@mittwald/api-client-commons 0.0.0-development-04b7288-20240610 → 0.0.0-development-7c0a25b-20240611

package/dist/esm/axios.js

@@ -0,0 +1 @@
+export * from "axios";

package/dist/esm/core/ApiClientBase.js

@@ -0,0 +1,13 @@
+import axios, { Axios } from "axios";
+import Request from "./Request.js";
+export class ApiClientBase {
+    axios;
+    constructor(axiosConfig = axios) {
+        this.axios =
+            axiosConfig instanceof Axios ? axiosConfig : axios.create(axiosConfig);
+    }
+    requestFunctionFactory(operation) {
+        return (conf) => new Request(operation, conf).execute(this.axios);
+    }
+}
+export default ApiClientBase;

package/dist/esm/core/ApiClientError.js

@@ -0,0 +1,12 @@
+import { AxiosError } from "axios";
+export class ApiClientError extends AxiosError {
+    constructor(message, code, config, request, response) {
+        super(message, code, config, request, response);
+        Object.setPrototypeOf(this, ApiClientError.prototype);
+        this.name = "ApiClientError";
+    }
+    static fromResponse(message, response) {
+        return new ApiClientError(message, undefined, response.config, response.request, response);
+    }
+}
+export default ApiClientError;

package/dist/esm/core/OpenAPIPath.js

@@ -0,0 +1,20 @@
+export class OpenAPIPath {
+    rawPath;
+    params;
+    constructor(rawPath, params) {
+        this.rawPath = rawPath;
+        this.params = params;
+    }
+    buildUrl() {
+        return OpenAPIPath.setPathParams(this.rawPath, this.params);
+    }
+    static setPathParams(path, params) {
+        const asEntries = Object.entries(params ?? {});
+        const finalPath = asEntries.reduce((path, entry) => {
+            const [key, value] = entry;
+            return path.replace(`{${key}}`, encodeURIComponent(value));
+        }, path);
+        return finalPath.startsWith("/") ? finalPath.substring(1) : finalPath;
+    }
+}
+export default OpenAPIPath;

package/dist/esm/core/Request.js

@@ -0,0 +1,76 @@
+import OpenAPIPath from "./OpenAPIPath.js";
+export class Request {
+    operationDescriptor;
+    requestObject;
+    requestConfig;
+    constructor(operationDescriptor, requestObject) {
+        this.operationDescriptor = operationDescriptor;
+        this.requestObject = requestObject;
+        this.requestConfig = Object.freeze(this.buildAxiosConfig());
+    }
+    execute(axios) {
+        return axios.request(this.requestConfig);
+    }
+    buildAxiosConfig() {
+        const { method, path } = this.operationDescriptor;
+        const pathParameters = this.requestObject;
+        const openApiPath = new OpenAPIPath(path, pathParameters);
+        const url = openApiPath.buildUrl();
+        const data = this.requestObject && "data" in this.requestObject
+            ? this.requestObject.data
+            : undefined;
+        const headersConfig = this.requestObject && "headers" in this.requestObject
+            ? this.requestObject.headers
+            : undefined;
+        const headers = headersConfig
+            ? this.makeAxiosHeaders(headersConfig)
+            : undefined;
+        const queryParametersConfig = this.requestObject && "queryParameters" in this.requestObject
+            ? this.requestObject.queryParameters
+            : undefined;
+        const params = this.convertQueryToUrlSearchParams(queryParametersConfig);
+        return {
+            url,
+            method,
+            headers,
+            // Must be a plain object or an URLSearchParams object
+            params,
+            data,
+            validateStatus: () => true,
+        };
+    }
+    makeAxiosHeaders(headers) {
+        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, value?.toString()]));
+    }
+    convertQueryToUrlSearchParams(query) {
+        if (query === undefined || query === null) {
+            return undefined;
+        }
+        if (query instanceof URLSearchParams) {
+            return query;
+        }
+        if (typeof query === "string") {
+            return new URLSearchParams(query);
+        }
+        if (typeof query === "object") {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (Array.isArray(value)) {
+                    for (const arrayItem of value) {
+                        searchParams.append(key, arrayItem);
+                    }
+                }
+                else {
+                    searchParams.append(key, typeof value === "string" ||
+                        typeof value === "number" ||
+                        typeof value === "boolean"
+                        ? value.toString()
+                        : JSON.stringify(value));
+                }
+            }
+            return searchParams;
+        }
+        throw new Error(`Unexpected query parameter type (${typeof query})`);
+    }
+}
+export default Request;

package/dist/esm/core/Request.test.js

@@ -0,0 +1,53 @@
+import Request from "./Request.js";
+import { jest } from "@jest/globals";
+const requestFn = jest.fn();
+const mockedAxios = {
+    request: requestFn,
+};
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+describe("query parameters", () => {
+    const op = {
+        path: "/",
+        operationId: "test",
+        method: "GET",
+    };
+    const executeRequest = (query) => {
+        const request = new Request(op, { queryParameters: query });
+        request.execute(mockedAxios);
+        const requestConfig = requestFn.mock.calls[0][0];
+        return requestConfig.params.toString();
+    };
+    test("Empty query", () => {
+        const query = executeRequest({});
+        expect(query).toBe("");
+    });
+    test("Simple parameter", () => {
+        const query = executeRequest({
+            foo: "bar",
+        });
+        expect(query).toBe("foo=bar");
+    });
+    test("Two parameters", () => {
+        const query = executeRequest({
+            foo: "bar",
+            bam: "baz",
+        });
+        expect(query).toBe("foo=bar&bam=baz");
+    });
+    test("Array parameters", () => {
+        const query = executeRequest({
+            foo: ["bar", "bam"],
+        });
+        expect(query).toBe("foo=bar&foo=bam");
+    });
+    test("Number, boolean, JSON", () => {
+        const query = executeRequest({
+            foo: 1,
+            bar: true,
+            baz: { some: "value" },
+        });
+        expect(query).toBe("foo=1&bar=true&baz=%7B%22some%22%3A%22value%22%7D");
+    });
+});

package/dist/esm/core/index.js

@@ -0,0 +1,4 @@
+export * from "./ApiClientBase.js";
+export * from "./ApiClientError.js";
+export * from "./OpenAPIPath.js";
+export * from "./Request.js";

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./core/index.js";
+export * from "./types/index.js";
+export * from "./axios.js";
+export * from "./interceptors/index.js";

package/dist/esm/interceptors/accessToken.js

@@ -0,0 +1,19 @@
+import ApiClientBase from "../core/ApiClientBase.js";
+function configureAccessTokenInterceptor(axios, token, headerName = "x-access-token") {
+    axios.interceptors.request.use((conf) => {
+        if (!conf.headers.has(headerName)) {
+            conf.headers.set(headerName, token);
+        }
+        return conf;
+    });
+}
+export function withAccessToken(clientOrAxiosInstance, token, headerName = "x-access-token") {
+    if (token) {
+        const axiosInstance = clientOrAxiosInstance instanceof ApiClientBase
+            ? clientOrAxiosInstance.axios
+            : clientOrAxiosInstance;
+        configureAccessTokenInterceptor(axiosInstance, token, headerName);
+    }
+    return clientOrAxiosInstance;
+}
+export default withAccessToken;

package/dist/esm/interceptors/consistencyHandling.js

@@ -0,0 +1,27 @@
+import ApiClientBase from "../core/ApiClientBase.js";
+function isMutatingRequest(request) {
+    return ["post", "put", "delete", "patch"].includes(request.method?.toLowerCase() ?? "");
+}
+function configureConsistencyHandlingInterceptor(axios) {
+    let lastEventId = undefined;
+    axios.interceptors.request.use((config) => {
+        if (lastEventId !== undefined && !isMutatingRequest(config)) {
+            config.headers["if-event-reached"] = lastEventId;
+        }
+        return config;
+    });
+    axios.interceptors.response.use((response) => {
+        const headers = response.headers;
+        if (headers.has("etag") && isMutatingRequest(response.config)) {
+            lastEventId = headers.get("etag");
+        }
+        return response;
+    });
+}
+export function withEventConsistencyHandling(clientOrAxiosInstance) {
+    const axiosInstance = clientOrAxiosInstance instanceof ApiClientBase
+        ? clientOrAxiosInstance.axios
+        : clientOrAxiosInstance;
+    configureConsistencyHandlingInterceptor(axiosInstance);
+    return clientOrAxiosInstance;
+}

package/dist/esm/interceptors/index.js

@@ -0,0 +1,2 @@
+export * from "./accessToken.js";
+export * from "./consistencyHandling.js";

package/dist/esm/react/ApiCallAsyncResourceFactory.js

@@ -0,0 +1,35 @@
+import { getAsyncResource } from "@mittwald/react-use-promise";
+import { assertStatus, } from "../types/index.js";
+import Request from "../core/Request.js";
+export class ApiCallAsyncResourceFactory {
+    static namespace = "@mittwald/api-client";
+    operation;
+    requestFn;
+    constructor(operation, requestFn) {
+        this.operation = operation;
+        this.requestFn = requestFn;
+    }
+    getAsyncResourceId() {
+        return `${ApiCallAsyncResourceFactory.namespace}/${this.operation.operationId}`;
+    }
+    getAsyncResourceTags(request) {
+        const url = request.requestConfig.url ?? "";
+        return [
+            this.getAsyncResourceId(),
+            `${ApiCallAsyncResourceFactory.namespace}/${this.operation.method}`,
+            `${ApiCallAsyncResourceFactory.namespace}/${url}`,
+        ];
+    }
+    async executeRequest(requestObj) {
+        const response = await this.requestFn(requestObj);
+        assertStatus(response, 200);
+        return response.data;
+    }
+    getApiResource = ((requestObj) => {
+        const request = new Request(this.operation, requestObj);
+        return getAsyncResource((requestObj) => this.executeRequest(requestObj), [requestObj], {
+            tags: this.getAsyncResourceTags(request),
+            loaderId: this.getAsyncResourceId(),
+        });
+    });
+}

package/dist/esm/react/ApiCallAsyncResourceFactory.test-types.js

@@ -0,0 +1,36 @@
+import { ApiCallAsyncResourceFactory } from "./ApiCallAsyncResourceFactory.js";
+const getStuff = new ApiCallAsyncResourceFactory({
+    operationId: "getStuff",
+    path: "/stuff",
+    method: "GET",
+}, {});
+function ignoredCheckRequestType() {
+    getStuff.getApiResource({
+        data: {
+            // @ts-expect-error Not matching request type
+            foo: "",
+        },
+    });
+    getStuff.getApiResource({
+        data: {
+            requestString: "",
+        },
+    });
+}
+function ignoredCheckResponseType() {
+    const stuff = getStuff
+        .getApiResource({
+        data: {
+            requestString: "",
+        },
+    })
+        .use();
+    // @ts-expect-error Accessing unknown prop
+    stuff.foo;
+    (function (ignored) {
+        // @ts-expect-error is a number
+    })(stuff.responseData);
+    (function (ignored) {
+        // is number
+    })(stuff.responseData);
+}

package/dist/esm/react/ApiCallAsyncResourceFactory.test.js

@@ -0,0 +1,46 @@
+import { beforeEach, expect, jest } from "@jest/globals";
+import { ApiCallAsyncResourceFactory } from "./ApiCallAsyncResourceFactory.js";
+import { refresh } from "@mittwald/react-use-promise";
+beforeEach(() => {
+    refresh();
+    jest.resetAllMocks();
+});
+const requestMock = jest.fn();
+const getStuff = new ApiCallAsyncResourceFactory({
+    operationId: "getStuff",
+    path: "/stuff",
+    method: "GET",
+}, requestMock);
+const testRequest1 = {
+    data: {
+        foo: "bar",
+    },
+};
+const testRequest2 = {
+    data: {
+        foo: "baz",
+    },
+};
+test("Resource loader executes request", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    const firstRequestParams = requestMock.mock.calls[0][0];
+    expect(firstRequestParams).toMatchObject(testRequest1);
+});
+test("Resource is cached under URL", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    refresh({
+        tag: "@mittwald/api-client/stuff",
+    });
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(2);
+});
+test("Resources are different when request object changes", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    await getStuff.getApiResource(testRequest2).load();
+    expect(requestMock).toHaveBeenCalledTimes(2);
+});

package/dist/esm/react/index.js

@@ -0,0 +1 @@
+export * from "./ApiCallAsyncResourceFactory.js";

package/dist/esm/react/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/testing/expectStatus.js

@@ -0,0 +1,7 @@
+import { expect } from "@jest/globals";
+import assertStatus from "../types/assertStatus.js";
+export function expectStatus(response, status) {
+    expect(response.status).toBe(status);
+    assertStatus(response, status);
+}
+export default expectStatus;

package/dist/esm/testing/index.js

@@ -0,0 +1 @@
+export * from "./expectStatus.js";

package/dist/esm/types/NullableOnNoRequiredKeysDeep.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/OpenAPIOperation.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/RequestFunction.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/RequestFunction.test-types.js

@@ -0,0 +1,29 @@
+function ignoredTestEmptyRequestTypes() {
+    const f = {};
+    void f();
+    void f({
+        headers: {},
+    });
+    void f({
+        headers: { extra: true },
+    });
+}
+function ignoredTestOptionalHeadersRequestTypes() {
+    const f = {};
+    void f();
+    void f({
+        headers: {},
+    });
+    void f({
+        headers: { extra: true },
+    });
+}
+function ignoredTestPathParametersAreInRootOfRequestConfig() {
+    const f = {};
+    void f({
+        foo: "",
+    });
+    // @ts-expect-error Missing parameter
+    void f({});
+}
+export {};

package/dist/esm/types/RequestType.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/RequestType.test-types.js

@@ -0,0 +1,146 @@
+import { expectAssignable } from "tsd";
+function ignoredTestEmptyRequestTypes() {
+    expectAssignable({});
+    // @ts-expect-error Not assignable
+    expectAssignable({ extra: true });
+    // @ts-expect-error Not assignable
+    expectAssignable({ data: {} });
+    // @ts-expect-error Not assignable
+    expectAssignable({ data: null });
+    // @ts-expect-error Not assignable
+    expectAssignable({ pathParameters: {} });
+}
+function ignoredTestRequestTypesWithDataType() {
+    expectAssignable({ data: { foo: "" } });
+    // @ts-expect-error Not assignable
+    expectAssignable({});
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        data: { foo: "", extra: "" },
+    });
+    // @ts-expect-error Not assignable
+    expectAssignable({ data: { noFoo: "" } });
+}
+function ignoredTestRequestTypesWithPathParameters() {
+    expectAssignable({
+        data: { foo: "" },
+        pathParameters: { bar: "" },
+    });
+    expectAssignable({
+        pathParameters: { bar: "" },
+    });
+    // @ts-expect-error Not assignable
+    expectAssignable({});
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        pathParameters: {},
+    });
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        pathParameters: { foo: "", extra: "" },
+    });
+}
+function ignoredTestRequestTypesWithHeader() {
+    expectAssignable({
+        data: {
+            foo: "",
+        },
+        pathParameters: { bar: "" },
+        headers: { baz: "" },
+    });
+    expectAssignable({
+        pathParameters: { bar: "" },
+        headers: { baz: "" },
+    });
+    expectAssignable({
+        headers: { baz: "" },
+    });
+    // @ts-expect-error Not assignable
+    expectAssignable({});
+    expectAssignable({
+        headers: {
+            // @ts-expect-error Not assignable
+            baz: 42,
+        },
+    });
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        headers: {},
+    });
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        data: {},
+        headers: {
+            baz: "",
+        },
+    });
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        pathParameters: {},
+        headers: {
+            baz: "",
+        },
+    });
+}
+function ignoredTestRequestTypesWithQuery() {
+    expectAssignable({
+        data: {
+            foo: "",
+        },
+        pathParameters: { bar: "" },
+        headers: { baz: "" },
+        queryParameters: {
+            whut: "",
+        },
+    });
+    expectAssignable({
+        pathParameters: { bar: "" },
+        headers: { baz: "" },
+        queryParameters: {
+            whut: "",
+        },
+    });
+    expectAssignable({
+        queryParameters: {
+            whut: "",
+        },
+    });
+    // @ts-expect-error Not assignable
+    expectAssignable({});
+    expectAssignable({
+        queryParameters: {
+            // @ts-expect-error Not assignable
+            whut: 42,
+        },
+    });
+    expectAssignable({
+        // @ts-expect-error Not assignable
+        queryParameters: {},
+    });
+}
+function ignoredTestAdditionalHeadersCanAlwaysBeSet() {
+    expectAssignable({
+        headers: { extra: true },
+    });
+    expectAssignable({
+        headers: { extra: true },
+    });
+    expectAssignable({
+        headers: { extra: true },
+    });
+    expectAssignable({
+        data: {
+            foo: "",
+        },
+        headers: { extra: true },
+    });
+    expectAssignable({
+        pathParameters: {
+            bar: "",
+        },
+        headers: { extra: true },
+    });
+    expectAssignable({
+        headers: { extra: true, baz: "" },
+    });
+}

package/dist/esm/types/Response.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/Response.test-types.js

@@ -0,0 +1,70 @@
+import { expectAssignable, expectNotAssignable, expectType } from "tsd";
+const additionalAxiosResponseData = {
+    statusText: "",
+    headers: {},
+    config: {},
+    mediaType: "application/json",
+};
+expectAssignable({
+    data: { a: "" },
+    status: 200,
+    ...additionalAxiosResponseData,
+});
+expectNotAssignable({
+    data: { a: "", extra: "!" },
+    status: 200,
+    ...additionalAxiosResponseData,
+});
+expectAssignable({
+    data: {
+        b: "",
+    },
+    status: 201,
+    ...additionalAxiosResponseData,
+});
+expectAssignable({
+    data: null,
+    status: 400,
+    ...additionalAxiosResponseData,
+});
+expectNotAssignable({
+    data: null,
+    status: 42,
+    ...additionalAxiosResponseData,
+});
+expectNotAssignable({
+    data: null,
+    status: 42,
+    extra: "!",
+    ...additionalAxiosResponseData,
+});
+expectNotAssignable({
+    data: { extraContent: "" },
+    status: 400,
+    ...additionalAxiosResponseData,
+});
+function ignoredTestRequestTypesWithDataPathParameters() {
+    const someResponse = {};
+    expectType(someResponse.status);
+    if (someResponse.status === 200) {
+        // @ts-expect-error > a is not in data
+        someResponse.data.a;
+        // @ts-expect-error > b is not in data
+        someResponse.data.b;
+        if (someResponse.mediaType === "text/plain") {
+            // @ts-expect-error > a is not in data
+            someResponse.data.a;
+            expectType(someResponse.data.text);
+        }
+        else {
+            // @ts-expect-error > text is not in data
+            someResponse.data.text;
+            expectType(someResponse.data.a);
+        }
+    }
+    else if (someResponse.status === 201) {
+        expectType(someResponse.data.b);
+        // @ts-expect-error > a is not in data
+        someResponse.data.a;
+    }
+}

package/dist/esm/types/assertOneOfStatus.js

@@ -0,0 +1,7 @@
+import ApiClientError from "../core/ApiClientError.js";
+export function assertOneOfStatus(response, expectedStatus) {
+    if (!expectedStatus.includes(response.status)) {
+        throw ApiClientError.fromResponse(`Unexpected response status (expected ${expectedStatus}, got: ${response.status})`, response);
+    }
+}
+export default assertOneOfStatus;

package/dist/esm/types/assertStatus.js

@@ -0,0 +1,5 @@
+import assertOneOfStatus from "./assertOneOfStatus.js";
+export function assertStatus(response, expectedStatus) {
+    assertOneOfStatus(response, [expectedStatus]);
+}
+export default assertStatus;

package/dist/esm/types/assertStatus.test-types.js

@@ -0,0 +1,8 @@
+import { expectAssignable } from "tsd";
+import assertStatus from "./assertStatus.js";
+function ignoredTestAssertStatusAssertsAlsoTheCorrectResponseType() {
+    assertStatus(someResponse, 200);
+    expectAssignable(someResponse);
+    // @ts-expect-error Not assignable
+    expectAssignable(someResponse);
+}

package/dist/esm/types/http.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/index.js

@@ -0,0 +1,8 @@
+export * from "./RequestType.js";
+export * from "./RequestFunction.js";
+export * from "./Response.js";
+export * from "./OpenAPIOperation.js";
+export * from "./http.js";
+export * from "./simplify.js";
+export * from "./assertStatus.js";
+export * from "./assertOneOfStatus.js";

package/dist/esm/types/simplify.js

@@ -0,0 +1 @@
+export {};

package/dist/types/axios.d.ts

@@ -0,0 +1 @@
+export * from "axios";

package/dist/types/core/ApiClientBase.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance, CreateAxiosDefaults } from "axios";
+import { RequestFunction } from "../types/index.js";
+import { OpenAPIOperation } from "../types/index.js";
+export declare abstract class ApiClientBase {
+    axios: AxiosInstance;
+    constructor(axiosConfig?: AxiosInstance | CreateAxiosDefaults);
+    protected requestFunctionFactory<TOp extends OpenAPIOperation>(operation: TOp): RequestFunction<TOp>;
+}
+export default ApiClientBase;

package/dist/types/core/ApiClientError.d.ts

@@ -0,0 +1,7 @@
+import { AxiosError, AxiosResponse, InternalAxiosRequestConfig } from "axios";
+import { AnyResponse } from "../types/Response.js";
+export declare class ApiClientError<T = unknown, D = unknown> extends AxiosError<T, D> {
+    constructor(message?: string, code?: string, config?: InternalAxiosRequestConfig<D>, request?: unknown, response?: AxiosResponse<T, D>);
+    static fromResponse(message: string, response: AnyResponse): ApiClientError;
+}
+export default ApiClientError;

package/dist/types/core/OpenAPIPath.d.ts

@@ -0,0 +1,9 @@
+import { PathParameters } from "../types/http.js";
+export declare class OpenAPIPath {
+    private readonly rawPath;
+    private readonly params?;
+    constructor(rawPath: string, params?: PathParameters);
+    buildUrl(): string;
+    private static setPathParams;
+}
+export default OpenAPIPath;

package/dist/types/core/Request.d.ts

@@ -0,0 +1,13 @@
+import { OpenAPIOperation, RequestObject, ResponsePromise } from "../types/index.js";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+export declare class Request<TOp extends OpenAPIOperation> {
+    private readonly operationDescriptor;
+    private readonly requestObject?;
+    readonly requestConfig: AxiosRequestConfig;
+    constructor(operationDescriptor: TOp, requestObject?: RequestObject<TOp>);
+    execute(axios: AxiosInstance): ResponsePromise<TOp>;
+    private buildAxiosConfig;
+    private makeAxiosHeaders;
+    private convertQueryToUrlSearchParams;
+}
+export default Request;

package/dist/types/core/Request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ApiClientBase.js";
+export * from "./ApiClientError.js";
+export * from "./OpenAPIPath.js";
+export * from "./Request.js";

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./core/index.js";
+export * from "./types/index.js";
+export * from "./axios.js";
+export * from "./interceptors/index.js";

package/dist/types/interceptors/accessToken.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance } from "axios";
+import ApiClientBase from "../core/ApiClientBase.js";
+export declare function withAccessToken<T extends ApiClientBase | AxiosInstance>(clientOrAxiosInstance: T, token: string | undefined, headerName?: string): T;
+export default withAccessToken;

package/dist/types/interceptors/consistencyHandling.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from "axios";
+import ApiClientBase from "../core/ApiClientBase.js";
+export declare function withEventConsistencyHandling<T extends ApiClientBase | AxiosInstance>(clientOrAxiosInstance: T): T;

package/dist/types/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./accessToken.js";
+export * from "./consistencyHandling.js";

package/dist/types/react/ApiCallAsyncResourceFactory.d.ts

@@ -0,0 +1,12 @@
+import { OpenAPIOperation, RequestFunction } from "../types/index.js";
+import { GetApiResourceFn } from "./types.js";
+export declare class ApiCallAsyncResourceFactory<TOp extends OpenAPIOperation> {
+    private static namespace;
+    private readonly operation;
+    private readonly requestFn;
+    constructor(operation: TOp, requestFn: RequestFunction<TOp>);
+    private getAsyncResourceId;
+    private getAsyncResourceTags;
+    private executeRequest;
+    getApiResource: GetApiResourceFn<TOp>;
+}

package/dist/types/react/ApiCallAsyncResourceFactory.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react/ApiCallAsyncResourceFactory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./ApiCallAsyncResourceFactory.js";

package/dist/types/react/types.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIOperation, RequestObject, InferredResponseData } from "../types/index.js";
+import { AsyncResource } from "@mittwald/react-use-promise";
+export type GetApiResourceFn<TOp extends OpenAPIOperation> = null extends RequestObject<TOp> ? (conf?: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>> : (conf: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>>;

package/dist/types/testing/expectStatus.d.ts

@@ -0,0 +1,5 @@
+import { Response } from "../types/Response.js";
+export declare function expectStatus<T extends Response, S extends T["status"]>(response: T, status: S): asserts response is T & {
+    status: S;
+};
+export default expectStatus;

package/dist/types/testing/index.d.ts

@@ -0,0 +1 @@
+export * from "./expectStatus.js";

package/dist/types/types/NullableOnNoRequiredKeysDeep.d.ts

@@ -0,0 +1,6 @@
+import { HasRequiredKeys, OmitIndexSignature, PartialOnUndefinedDeep } from "type-fest";
+type PartialOnNoRequiredKeysDeep<T> = PartialOnUndefinedDeep<OmitIndexSignature<{
+    [TKey in keyof T]: HasRequiredKeys<PartialOnNoRequiredKeysDeep<T[TKey]>> extends true ? T[TKey] : T[TKey] | undefined;
+}>>;
+export type NullableOnNoRequiredKeysDeep<T> = HasRequiredKeys<PartialOnNoRequiredKeysDeep<T>> extends true ? PartialOnNoRequiredKeysDeep<T> : PartialOnNoRequiredKeysDeep<T> | null;
+export {};

package/dist/types/types/OpenAPIOperation.d.ts

@@ -0,0 +1,20 @@
+import { AnyResponse, Response } from "./Response.js";
+import { AnyRequest, RequestType } from "./RequestType.js";
+import { HttpMethod, HttpStatus } from "./http.js";
+export interface OpenAPIOperation<TIgnoredRequest extends AnyRequest = RequestType, IgnoredResponse extends AnyResponse = Response> {
+    operationId: string;
+    path: string;
+    method: HttpMethod;
+}
+export type InferredRequestType<TOp> = TOp extends OpenAPIOperation<infer TReq> ? TReq : never;
+export type InferredResponseType<TOp> = TOp extends OpenAPIOperation<RequestType, infer TRes> ? TRes : never;
+export type InferredResponseData<TOp, TStatus extends HttpStatus = 200> = Extract<InferredResponseType<TOp>, {
+    status: TStatus;
+}>["data"];
+export type InferredRequestData<TOp> = TOp extends OpenAPIOperation ? InferredRequestType<TOp> extends {
+    data: infer TData;
+} ? TData : never : never;
+/** @deprecated Use InferredResponseData */
+export type ResponseData<TOp> = InferredResponseData<TOp>;
+/** @deprecated Use InferredRequestData */
+export type RequestData<TOp> = InferredRequestData<TOp>;

package/dist/types/types/RequestFunction.d.ts

@@ -0,0 +1,11 @@
+import { InferredRequestType, InferredResponseType, OpenAPIOperation } from "./OpenAPIOperation.js";
+import { NullableOnNoRequiredKeysDeep } from "./NullableOnNoRequiredKeysDeep.js";
+type UnboxPathParameters<T> = T extends {
+    pathParameters: infer TPath;
+} ? Omit<T, "pathParameters"> & TPath : T;
+export type RequestObject<TOp extends OpenAPIOperation> = NullableOnNoRequiredKeysDeep<UnboxPathParameters<InferredRequestType<TOp>>>;
+export type ResponsePromise<TOp extends OpenAPIOperation> = Promise<InferredResponseType<TOp>>;
+type RequestFunctionWithOptionalRequest<TOp extends OpenAPIOperation> = (request?: RequestObject<TOp>) => ResponsePromise<TOp>;
+type RequestFunctionWithRequiredRequest<TOp extends OpenAPIOperation> = (request: RequestObject<TOp>) => ResponsePromise<TOp>;
+export type RequestFunction<TOp extends OpenAPIOperation> = null extends RequestObject<TOp> ? RequestFunctionWithOptionalRequest<TOp> : RequestFunctionWithRequiredRequest<TOp>;
+export {};

package/dist/types/types/RequestFunction.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/RequestType.d.ts

@@ -0,0 +1,21 @@
+import { HttpHeaders, HttpPayload, PathParameters, QueryParameters } from "./http.js";
+type EmptyObject = Record<string, never>;
+type EmptyRequestComponent = EmptyObject | null;
+type RequestWithOptionalHeaders = {
+    headers?: HttpHeaders;
+};
+type RequestWithData<TData> = TData extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    data: TData;
+};
+type RequestWithPathParameters<TPathParameters> = TPathParameters extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    pathParameters: TPathParameters;
+};
+type RequestWithHeaders<THeaders> = THeaders extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    headers: THeaders & HttpHeaders;
+};
+type RequestWithQueryParameters<TQuery> = TQuery extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    queryParameters: TQuery & HttpHeaders;
+};
+export type RequestType<TData extends HttpPayload = EmptyRequestComponent, TPathParameters extends PathParameters | EmptyRequestComponent = EmptyRequestComponent, TQueryParameters extends QueryParameters | EmptyRequestComponent = EmptyRequestComponent, THeader extends HttpHeaders | EmptyRequestComponent = EmptyRequestComponent> = TData | TPathParameters | THeader | TQueryParameters extends EmptyRequestComponent ? RequestWithOptionalHeaders : RequestWithData<TData> & RequestWithPathParameters<TPathParameters> & RequestWithQueryParameters<TQueryParameters> & RequestWithHeaders<THeader>;
+export type AnyRequest = RequestType<any, any, any, any>;
+export {};

package/dist/types/types/RequestType.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/Response.d.ts

@@ -0,0 +1,7 @@
+import { HttpMediaType, HttpPayload, HttpStatus } from "./http.js";
+import { AxiosResponse } from "axios";
+export type Response<TContent extends HttpPayload = HttpPayload, TStatus extends HttpStatus = HttpStatus, TMediaType extends HttpMediaType | null = HttpMediaType> = AxiosResponse<TContent> & {
+    status: TStatus;
+    mediaType: TMediaType;
+};
+export type AnyResponse = Response<any, any, any>;

package/dist/types/types/Response.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/assertOneOfStatus.d.ts

@@ -0,0 +1,5 @@
+import { Response } from "./Response.js";
+export declare function assertOneOfStatus<T extends Response, S extends T["status"]>(response: T, expectedStatus: S[]): asserts response is T & {
+    status: S;
+};
+export default assertOneOfStatus;

package/dist/types/types/assertStatus.d.ts

@@ -0,0 +1,5 @@
+import { Response } from "./Response.js";
+export declare function assertStatus<T extends Response, S extends T["status"]>(response: T, expectedStatus: S): asserts response is T & {
+    status: S;
+};
+export default assertStatus;

package/dist/types/types/assertStatus.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/http.d.ts

@@ -0,0 +1,13 @@
+export type HttpPayload = unknown;
+export type HttpStatus = number | "default";
+export type HttpMediaType = string;
+type SafeHttpMethod = "GET" | "HEAD" | "OPTIONS";
+type UnsafeHttpMethod = "PUT" | "DELETE" | "POST" | "PATCH";
+export type HttpMethod = SafeHttpMethod | UnsafeHttpMethod;
+type HeaderValue = string | number | boolean;
+export type HttpHeaders = Partial<{
+    [TKey: string]: HeaderValue | HeaderValue[];
+}>;
+export type PathParameters = Record<string, string | number>;
+export type QueryParameters = Record<string, unknown>;
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./RequestType.js";
+export * from "./RequestFunction.js";
+export * from "./Response.js";
+export * from "./OpenAPIOperation.js";
+export * from "./http.js";
+export * from "./simplify.js";
+export * from "./assertStatus.js";
+export * from "./assertOneOfStatus.js";

package/dist/types/types/simplify.d.ts

@@ -0,0 +1,3 @@
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/api-client-commons",
-  "version": "0.0.0-development-04b7288-20240610",
+  "version": "0.0.0-development-7c0a25b-20240611",
   "author": "Mittwald CM Service GmbH & Co. KG <opensource@mittwald.de>",
   "type": "module",
   "description": "Common types and utilities for mittwald API clients",
@@ -78,5 +78,5 @@
       "optional": true
     }
   },
-  "gitHead": "97660b1fee614cc23b778573ba3e8ae75a961517"
+  "gitHead": "6e1f85a8f705547fa14be6279e7380b9fd7d4aa9"
 }