Unable to get the response from URL using combine with SwiftUI

First of all, your error comes from the fact you want to return AnyPublisher<LoginModel, Error> but you map your response as .decode(type: LoginResponse.self, decoder: JSONDecoder()) which doesn't match your json response.

In the second time, I would use a Basic Authorization as a body of your URL request as it is to send user credentials with a password, which must be protected. Do you have access to the server side? How is the backend handling this post request? Is it with Authorization or Content-Type? I would put the two solutions, try to find the one that is set in the server side.

Your LoginModel must match your json response. I noticed their was expertToken missing:

struct LoginModel: Codable {

  let success: Bool
  let token: String
  let expertToken: String
  let message: String

  enum CodingKeys: String, CodingKey {
    case success
    case token
    case expertToken = "expert-token"
    case message
  }
}

So I would create the LoginService class this way:

final class LoginService {

  /// The request your use when the button is pressed.
  func logIn(username: String, password: String) -> AnyPublisher<LoginModel, Error> {

    let url = URL(string: "http://your.api.endpoints/")!
    let body = logInBody(username: username, password: password)
    let urlRequest = basicAuthRequestSetup(url: url, body: body)

    return URLSession.shared
      .dataTaskPublisher(for: urlRequest)
      .receive(on: DispatchQueue.main)
      .tryMap { try self.validate($0.data, $0.response) }
      .decode(
        type: LoginModel.self,
        decoder: JSONDecoder())
      .eraseToAnyPublisher()
  }

  /// The body for a basic authorization with encoded credentials.
  func logInBody(username: String, password: String) -> String {

    let body = String(format: "%@:%@",
                      username,
                      password)

    guard let bodyData = body.data(using: .utf8) else { return String() }

    let encodedBody = bodyData.base64EncodedString()
    return encodedBody
  }

  /// The authorization setup
  func basicAuthRequestSetup(url: URL, body: String) -> URLRequest {

    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "POST"
    urlRequest.setValue("Basic \(body)",
                        forHTTPHeaderField: "Authorization")

    return urlRequest
  }

  /// Validation of the Data and the response.
  /// You can handle response with status code for more precision.
  func validate(_ data: Data, _ response: URLResponse) throws -> Data {
    guard let httpResponse = response as? HTTPURLResponse else {
      throw NetworkError.unknown
    }
    guard (200..<300).contains(httpResponse.statusCode) else {
      throw networkRequestError(from: httpResponse.statusCode)
    }
    return data
  }

  /// Handle the status code errors to populate to user.
  func networkRequestError(from statusCode: Int) -> Error {
    switch statusCode {
    case 401:
      return NetworkError.unauthorized
    default:
      return NetworkError.unknown
    }
  }

  /// Define your different Error here that can come back from
  /// your backend.
  enum NetworkError: Error, Equatable {

    case unauthorized
    case unknown
  }
}

So if you use a simple Content-Type, your body would be this one below. Replace from the code above logInBody(username:password:) -> String and basicAuthRequestSetup(url:body:) -> URLRequest

/// Classic body for content type.
/// Keys must match the one in your server side.
func contentTypeBody(username: String, password: String) -> [String: Any] {
  [
    "username": username,
    "password": password
  ] as [String: Any]
}

/// Classic Content-Type but not secure. To avoid when having
/// passwords.
func contentTypeRequestSetup(url: URL,
                      body: [String: Any]) -> URLRequest {

  var urlRequest = URLRequest(url: url)
  urlRequest.httpMethod = "POST"
  urlRequest.setValue("application/json",
                      forHTTPHeaderField: "Content-Type")
  urlRequest.httpBody = try? JSONSerialization.data(withJSONObject: body)

  return urlRequest
}

I would then create a ViewModel to handle the logic that will be passed in your View.

final class OnboardingViewModel: ObservableObject {

  var logInService = LoginService()

  var subscriptions = Set<AnyCancellable>()

  func logIn() {
    logInService.logIn(username: "Shubhank", password: "1234")
      .sink(receiveCompletion: { completion in
              print(completion) },
            receiveValue: { data in
              print(data.expertToken) })  // This is your response
      .store(in: &subscriptions)
  }
}

And now, in your ContentView, you can pass the view model login action inside the button:

struct ContentView: View {

  @ObservedObject var viewModel = OnboardingViewModel()

  var body: some View {
    Button(action: { viewModel.logIn() }) {
      Text("Log In")
    }
  }
}