Write the contract.
Generate the rest.

// Code generated by `mctl api ts` from a `.api` spec. DO NOT EDIT.

export class UserApiClient {
  readonly baseUrl: string;
  token?: string;

  constructor(baseUrl: string, fetchImpl?: Fetch, token?: string) {
    this.baseUrl = baseUrl.replace(/\/+$/, "");
    this.fetchImpl = fetchImpl ?? ((url, init) => fetch(url, init));
    this.token = token;
  }

  async login(body: LoginReq): Promise<LoginResp> {
    const path = `/api/v1/login`;
    const url = this.baseUrl + path;
    const headers: Record<string, string> = { accept: "application/json" };
    if (this.token !== undefined) {
      headers["authorization"] = "Bearer " + this.token;
    }
    const res = await this.fetchImpl(url, {
      method: "POST",
      headers,
      body: JSON.stringify(loginReqToJson(body)),
    });
    if (!res.ok) {
      throw new ApiError(res.status, await res.text());
    }
    return loginRespFromJson(JSON.parse(await res.text()));
  }
}

// Code generated by `mctl api dart` from a `.api` spec. DO NOT EDIT.

import 'dart:convert';

class UserApiClient {
  UserApiClient({required String baseUrl, required this.send, this.token})
      : baseUrl = baseUrl.replaceAll(RegExp(r'/+$'), '');

  final String baseUrl;
  final Send send;
  final String? token;

  Future<LoginResp> login(LoginReq body) async {
    final path = '/api/v1/login';
    final url = Uri.parse('$baseUrl$path');
    final headers = <String, String>{'accept': 'application/json'};
    if (token != null) {
      headers['authorization'] = 'Bearer $token';
    }
    final res = await send('POST', url, headers, jsonEncode(body.toJson()));
    if (!res.ok) {
      throw ApiException(res.status, res.body);
    }
    return LoginResp.fromJson(jsonDecode(res.body) as Map<String, dynamic>);
  }
}

// Code generated by `mctl api kt` from a `.api` spec. DO NOT EDIT.

class UserApiClient(
    private val baseUrl: String,
    private val transport: Transport,
    private val codec: Codec,
    private var token: String? = null,
) {
    fun login(body: LoginReq): LoginResp {
        val path = "/api/v1/login"
        val url = baseUrl + path
        val headers = linkedMapOf("accept" to "application/json")
        token?.let { headers["authorization"] = "Bearer " + it }
        val res = transport.send("POST", url, headers, codec.encode(body))
        if (!res.ok) {
            throw ApiException(res.status, res.body)
        }
        return LoginResp.fromWire(codec.decode(res.body))
    }

    fun getProfile(id: String): Profile {
        val path = "/api/v1/profile/" + enc(id)
        val res = transport.send("GET", baseUrl + path, linkedMapOf("accept" to "application/json"), null)
        if (!res.ok) {
            throw ApiException(res.status, res.body)
        }
        return Profile.fromWire(codec.decode(res.body))
    }
}

// Code generated by `mctl api java` from a `.api` spec. DO NOT EDIT.

public final class UserApiClient {
    public Profile getProfile(String id) {
        String path = "/api/v1/profile/" + enc(id);
        String url = baseUrl + path;
        Map<String, String> headers = new LinkedHashMap<>();
        headers.put("accept", "application/json");
        if (token != null) {
            headers.put("authorization", "Bearer " + token);
        }
        RawResponse res = transport.send("GET", url, headers, null);
        if (!res.ok()) {
            throw new ApiException(res.status, res.body);
        }
        return Profile.fromWire(codec.decode(res.body));
    }
}

# user-api

A MoonAPI service with 2 route(s) and 3 type(s).

## Routes

| Method | Path | Handler | Request | Response | Description |
| --- | --- | --- | --- | --- | --- |
| POST | `/api/v1/login` | `Login` | `LoginReq` | `LoginResp` | log a user in |
| GET | `/api/v1/profile/:id` | `GetProfile` | — | `Profile` | — |

### Groups

| Group | Prefix | JWT | Middleware | Max body | Timeout |
| --- | --- | --- | --- | --- | --- |
| `user` | `/api/v1` | — | — | — | — |

### Profile

| Field | Type | In | Required | Constraints |
| --- | --- | --- | --- | --- |
| `id` | `Int64` | path | yes |  |
| `name` | `String` | body | yes |  |

-- One table per `type` block of the spec. A spec says what a value looks
-- like, not what the database should enforce: indexes, uniqueness and foreign
-- keys are yours to add.

CREATE TABLE IF NOT EXISTS `profiles` (
  `id` BIGINT NOT NULL,
  `name` VARCHAR(191) NOT NULL,
  PRIMARY KEY (`id`)
);

CREATE TABLE IF NOT EXISTS `login_reqs` (
  `username` VARCHAR(191) NOT NULL,
  `password` VARCHAR(191) NOT NULL
);