mobx-tanstack-query-api 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sergey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# mobx-tanstack-query-api  
+
+[![NPM version][npm-image]][npm-url] [![build status][github-build-actions-image]][github-actions-url] [![npm download][download-image]][download-url] [![bundle size][bundlephobia-image]][bundlephobia-url]
+
+
+[npm-image]: http://img.shields.io/npm/v/mobx-tanstack-query-api.svg
+[npm-url]: http://npmjs.org/package/mobx-tanstack-query-api
+[github-build-actions-image]: https://github.com/js2me/mobx-tanstack-query-api/workflows/Build/badge.svg
+[github-actions-url]: https://github.com/js2me/mobx-tanstack-query-api/actions
+[download-image]: https://img.shields.io/npm/dm/mobx-tanstack-query-api.svg
+[download-url]: https://npmjs.org/package/mobx-tanstack-query-api
+[bundlephobia-url]: https://bundlephobia.com/result?p=mobx-tanstack-query-api
+[bundlephobia-image]: https://badgen.net/bundlephobia/minzip/mobx-tanstack-query-api
+
+
+API codegen from swagger  

package/codegen/index.d.ts

@@ -0,0 +1,25 @@
+import { GenerateApiParams as GenerateApiParamsFromSwagger, ParsedRoute } from 'swagger-typescript-api';
+import { AnyObject } from 'yummies/utils/types';
+export interface QueryApiParams {
+    requestPathPrefix?: string;
+    requestPathSuffix?: string;
+    requestInfoPrefix?: string;
+    outputType: 'request-info-per-file';
+    getRequestInfoMeta?: (route: ParsedRoute) => {
+        typeName: string;
+        importTypePath: string;
+        tmplData: string;
+    };
+    getRequestMeta?: (route: ParsedRoute) => {
+        typeName: string;
+        importTypePath: string;
+        tmplData: string;
+    };
+}
+type GenerateApiParams = Omit<GenerateApiParamsFromSwagger, 'output' | 'moduleNameFirstTag' | 'moduleNameIndex' | 'url' | 'input' | 'spec'> & {
+    output: string;
+    input: string | AnyObject;
+} & QueryApiParams;
+export declare const generateApi: (inputParams: GenerateApiParams) => Promise<void>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/codegen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codegen/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,IAAI,4BAA4B,EACjD,WAAW,EAEZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAWhD,MAAM,WAAW,cAAc;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,uBAAuB,CAAC;IAEpC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK;QAC3C,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK;QACvC,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,KAAK,iBAAiB,GAAG,IAAI,CAC3B,4BAA4B,EAC5B,QAAQ,GAAG,oBAAoB,GAAG,iBAAiB,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAC/E,GAAG;IACF,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,GAAG,cAAc,CAAC;AAEnB,eAAO,MAAM,WAAW,gBAAuB,iBAAiB,kBAiH/D,CAAC"}

package/codegen/index.js

@@ -0,0 +1,89 @@
+import { generateApi as generateApiFromSwagger, } from 'swagger-typescript-api';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { requestInfoPerFileTmpl } from './templates/request-info-per-file.tmpl.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const generateApi = async (inputParams) => {
+    const { output, input, ...params } = inputParams;
+    const paths = {
+        templates: path.resolve(__dirname, 'templates'),
+        requestInfoClass: path.resolve(__dirname, 'templates/request-info-class.ejs'),
+        httpClient: path.resolve(__dirname, 'templates/http-client.ejs'),
+        createRequestInfoInstance: path.resolve(__dirname, 'templates/create-request-info-instance.ejs'),
+        outputRequestsDir: path.resolve(output, 'requests'),
+    };
+    const codegenParams = {
+        httpClientType: 'fetch',
+        cleanOutput: true,
+        modular: true,
+        patch: true,
+        typeSuffix: 'DC',
+        disableStrictSSL: false,
+        singleHttpClient: true,
+        extractRequestBody: true,
+        extractRequestParams: true,
+        extractResponseBody: true,
+        extractResponseError: true,
+        generateResponses: true,
+        generateClient: false,
+        addReadonly: true,
+        moduleNameFirstTag: true,
+        sortTypes: true,
+        templates: paths.templates.toString(),
+        primitiveTypeConstructs: (constructs) => {
+            return {
+                ...constructs,
+                object: () => `Record<string, any>`,
+                float: () => `number`,
+                ...params?.primitiveTypeConstructs?.(constructs),
+            };
+        },
+        ...params,
+    };
+    let codegenProcess;
+    const inputData = {};
+    if (typeof input === 'string') {
+        inputData.input = input;
+        inputData.url = input;
+    }
+    else {
+        inputData.spec = input;
+    }
+    const generated = await generateApiFromSwagger({
+        ...codegenParams,
+        ...inputData,
+        hooks: {
+            onInit: (configuration, codeGenProcessFromInit) => {
+                codegenProcess = codeGenProcessFromInit;
+                return codegenParams?.hooks?.onInit?.(configuration, codeGenProcessFromInit);
+            },
+            onPrepareConfig: (config) => {
+                config.routes.combined?.forEach((routeInfo) => {
+                    routeInfo.routes.sort((routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage));
+                });
+                return codegenParams?.hooks?.onPrepareConfig?.(config);
+            },
+        },
+    });
+    const codegenFs = codegenProcess.fileSystem;
+    codegenFs.cleanDir(output);
+    codegenFs.createDir(output);
+    codegenFs.createDir(paths.outputRequestsDir.toString());
+    const allRoutes = Object.values(generated.configuration.routes)
+        .flat()
+        .flatMap((routeGroup) => 'routes' in routeGroup ? routeGroup.routes : routeGroup);
+    for await (const route of allRoutes) {
+        const requestInfoPerFileContent = await requestInfoPerFileTmpl({
+            ...generated,
+            route,
+            apiParams: inputParams,
+        });
+        codegenFs.createFile({
+            path: paths.outputRequestsDir.toString(),
+            fileName: `${generated.configuration.utils._.kebabCase(route.routeName.usage)}.ts`,
+            withPrefix: false,
+            content: requestInfoPerFileContent,
+        });
+    }
+};

package/codegen/templates/new-request-info.tmpl.d.ts

@@ -0,0 +1,9 @@
+import { GenerateApiConfiguration, ParsedRoute } from 'swagger-typescript-api';
+import type { QueryApiParams } from '../index.js';
+export interface NewRequestInfoTmplParams {
+    route: ParsedRoute;
+    configuration: GenerateApiConfiguration;
+    apiParams: QueryApiParams;
+}
+export declare const newRequestInfoTmpl: ({ route, configuration, apiParams, }: NewRequestInfoTmplParams) => string;
+//# sourceMappingURL=new-request-info.tmpl.d.ts.map

package/codegen/templates/new-request-info.tmpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-request-info.tmpl.d.ts","sourceRoot":"","sources":["../../../src/codegen/templates/new-request-info.tmpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,wBAAwB,CAAC;IACxC,SAAS,EAAE,cAAc,CAAC;CAC3B;AAiBD,eAAO,MAAM,kBAAkB,yCAI5B,wBAAwB,WAyM1B,CAAC"}

package/codegen/templates/new-request-info.tmpl.js

@@ -0,0 +1,167 @@
+// RequestParams["type"]
+const requestContentKind = {
+    URL_ENCODED: 'application/x-www-form-urlencoded',
+    FORM_DATA: 'multipart/form-data',
+    TEXT: 'text/plain',
+    BINARY: 'application/octet-stream',
+};
+// RequestParams["format"]
+const responseContentKind = {
+    TEXT: '"text"',
+    IMAGE: '"blob"',
+    FORM_DATA: '"formData"',
+    BYTES: '"bytes"',
+};
+export const newRequestInfoTmpl = ({ route, configuration, apiParams, }) => {
+    const { utils } = configuration;
+    const { _ } = utils;
+    const positiveResponseTypes = route.raw.responsesTypes?.filter((it) => +it.status >= 200 && +it.status < 300);
+    const { requestBodyInfo, responseBodyInfo } = route;
+    const routeRequest = route.request;
+    const routeResponse = route.response;
+    const { parameters, path, method, payload, query, requestParams, security } = routeRequest;
+    const { raw } = route;
+    const queryName = query?.name || 'query';
+    const pathParams = _.values(parameters);
+    const pathParamsNames = _.map(pathParams, 'name');
+    const requestConfigParam = {
+        name: 'request',
+        optional: true,
+        type: 'RequestParams',
+        defaultValue: '{}',
+    };
+    const getArgs = ({ withPayload, withRequestConfigParam, withRequestParams, }) => {
+        return _.sortBy(_.compact([
+            ...(withRequestParams && requestParams
+                ? [
+                    {
+                        name: pathParams.length > 0
+                            ? `{ ${_.join(pathParamsNames, ', ')}, ...${queryName} }`
+                            : queryName,
+                        optional: false,
+                        type: utils.getInlineParseContent(requestParams),
+                    },
+                ]
+                : pathParams),
+            withPayload && payload,
+            withRequestConfigParam && requestConfigParam,
+        ]), [(o) => o.optional]);
+    };
+    const requestOutputDataType = positiveResponseTypes.map((it) => it.type).join('|') || 'any';
+    const requestOutputErrorType = routeResponse.errorType;
+    let requestInputCombinedType;
+    const requestInfoFnArgNames = getArgs({
+        withRequestParams: true,
+        withRequestConfigParam: true,
+        withPayload: true,
+    }).map(({ name }) => name);
+    const pathParamsToInline = path.split('/').slice(1);
+    let lastDynamicStructPos = 0;
+    const pathParamsStructs = pathParamsToInline.map((param, i) => {
+        if (param.includes('${')) {
+            const paramName = param.replace('${', '').replace('}', '');
+            return {
+                type: 'dynamic',
+                key: paramName,
+                i,
+                param: lastDynamicStructPos++,
+            };
+        }
+        return {
+            type: 'static',
+            value: param,
+            i,
+        };
+    });
+    const queryParamStruct = query == null
+        ? null
+        : {
+            type: 'dynamic',
+            key: 'params',
+            i: pathParamsToInline.length,
+            param: lastDynamicStructPos > 0 ? lastDynamicStructPos - 1 : 0,
+        };
+    if (queryParamStruct && !lastDynamicStructPos) {
+        lastDynamicStructPos++;
+    }
+    let requestInputType = `{
+  ${getArgs({
+        withRequestParams: true,
+        withRequestConfigParam: true,
+        withPayload: true,
+    })
+        .map(({ name, optional, type, defaultValue }) => {
+        const isCombinedType = name.includes('...') || name === 'query';
+        if (isCombinedType) {
+            requestInputCombinedType = { name, optional, type, defaultValue };
+            return;
+        }
+        return `${name}${optional ? '?' : ''}:${type}`;
+    })
+        .filter(Boolean)
+        .join(', ')}
+}`;
+    if (requestInputCombinedType) {
+        requestInputType = `${requestInputCombinedType.type} & ${requestInputType}`;
+    }
+    const requestKeyType = `[
+  ${getArgs({
+        withRequestParams: true,
+        withRequestConfigParam: true,
+        withPayload: true,
+    })
+        .map(({ name, optional, type }) => {
+        return `${name.includes('...') || name === 'query' ? 'params' : name}${optional ? '?' : ''}:${type}`;
+    })
+        .join(', ')}
+]`;
+    const requestInfoMeta = apiParams.getRequestInfoMeta?.(route);
+    const requestMeta = apiParams.getRequestMeta?.(route);
+    const resultPath = (apiParams.requestPathPrefix ?? '') +
+        path +
+        (apiParams.requestPathSuffix ?? '');
+    const bodyContentType = requestContentKind[requestBodyInfo.contentKind] || null;
+    const responseFormat = responseContentKind[responseBodyInfo.success?.schema?.contentKind] || null;
+    return `
+new RequestInfo<
+  ${requestOutputDataType},
+  ${requestOutputErrorType},
+  ${requestInputType},
+  ${requestKeyType},
+  ${requestInfoMeta?.typeName ?? 'any'}
+>(
+    {
+        params: (${requestInfoFnArgNames.join(', ')}) => ({
+            path: \`${resultPath}\`,
+            method: '${_.upperCase(method)}',
+            ${requestMeta?.tmplData ? `meta: ${requestMeta.tmplData},` : ''}
+            ${query == null ? '' : `query: ${query.name},`}
+            ${payload?.name ? `body: ${payload.name},` : ''}
+            ${security ? 'secure: true,' : ''}
+            ${bodyContentType ? `contentType: ${bodyContentType},` : ''}
+            ${responseFormat ? `format: ${responseFormat},` : ''}
+            ...${requestInfoFnArgNames.at(-1)},  
+        }),
+        operationId: "${raw.operationId}",
+        tags: [
+          ${raw.tags?.map((tag) => `"${tag}"`).join(',')}
+        ],
+        meta: ${requestInfoMeta?.tmplData ?? '{} as any'},
+        keys: [
+            ${_.compact([
+        ...pathParamsStructs.map((struct) => {
+            if (struct.type === 'dynamic') {
+                return `{ name: '${struct.key}', param: ${struct.param} }`;
+            }
+            return `"${struct.value}"`;
+        }),
+        queryParamStruct &&
+            `{ name: "${queryParamStruct.key}", rest: true }`,
+        requestConfigParam &&
+            `{ name: "${requestConfigParam.name}", param: ${lastDynamicStructPos} }`,
+    ]).join(',')}
+        ],
+    }
+)  
+`;
+};

package/codegen/templates/request-info-jsdoc.tmpl.d.ts

@@ -0,0 +1,10 @@
+import { ParsedRoute, GenerateApiConfiguration } from 'swagger-typescript-api';
+import { QueryApiParams } from '../index.js';
+export interface RequestInfoJSDocTmplParams {
+    route: ParsedRoute;
+    configuration: GenerateApiConfiguration;
+    apiParams: QueryApiParams;
+    offset?: number;
+}
+export declare const requestInfoJSDocTmpl: ({ route, configuration, offset, }: RequestInfoJSDocTmplParams) => string;
+//# sourceMappingURL=request-info-jsdoc.tmpl.d.ts.map

package/codegen/templates/request-info-jsdoc.tmpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-info-jsdoc.tmpl.d.ts","sourceRoot":"","sources":["../../../src/codegen/templates/request-info-jsdoc.tmpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAG/E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,wBAAwB,CAAC;IACxC,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,oBAAoB,sCAI9B,0BAA0B,WAkH5B,CAAC"}

package/codegen/templates/request-info-jsdoc.tmpl.js

@@ -0,0 +1,92 @@
+export const requestInfoJSDocTmpl = ({ route, configuration, offset = 0, }) => {
+    const { routeName } = route;
+    const rawRoute = route.raw;
+    const routeRequest = route.request;
+    const { utils } = configuration;
+    const { _, formatDescription } = utils;
+    const jsDocLines = [];
+    if (rawRoute.description) {
+        jsDocLines.push({
+            name: 'description',
+            content: formatDescription(rawRoute.description, true),
+        });
+    }
+    else {
+        jsDocLines.push({
+            content: 'No description',
+        });
+    }
+    if (rawRoute.operationId) {
+        jsDocLines.push({
+            name: 'operationId',
+            content: rawRoute.operationId,
+        });
+    }
+    if (_.size(rawRoute.tags)) {
+        jsDocLines.push({
+            name: 'tags',
+            content: rawRoute.tags.join(', '),
+        });
+    }
+    if (rawRoute.summary) {
+        jsDocLines.push({
+            name: 'summary',
+            content: rawRoute.summary,
+        });
+    }
+    jsDocLines.push({
+        name: 'request',
+        content: `${_.upperCase(routeRequest.method)}:${rawRoute.route}`,
+    });
+    if (rawRoute.deprecated) {
+        jsDocLines.push({
+            name: 'deprecated',
+        });
+    }
+    if (routeName.duplicate) {
+        jsDocLines.push({
+            name: 'duplicate',
+        }, {
+            name: 'originalName',
+            content: routeName.original,
+        });
+    }
+    if (routeRequest.security) {
+        jsDocLines.push({
+            name: 'secure',
+        });
+    }
+    if (rawRoute.responsesTypes.length > 0) {
+        jsDocLines.push({
+            name: 'responses',
+        });
+        rawRoute.responsesTypes.forEach((response) => {
+            jsDocLines.push({
+                name: `**${response.status}**`,
+                content: `${_.replace(_.replace(response.type, /\/\*/g, String.raw `\*`), /\*\//g, '*\\')} ${response.description}`,
+            });
+        });
+    }
+    const jsdocContent = jsDocLines.map((it) => {
+        let line = ' * ';
+        if (it.name) {
+            line += `@${it.name} `;
+        }
+        const content = (it.content ?? '').trimEnd();
+        if (content) {
+            line += content;
+        }
+        return line;
+    });
+    const result = `
+/**
+${jsdocContent.join('\n')}
+ */`;
+    if (offset > 0) {
+        return result
+            .split('\n')
+            .map((line) => line.padStart(offset))
+            .join('\n');
+    }
+    return result;
+};

package/codegen/templates/request-info-per-file.tmpl.d.ts

@@ -0,0 +1,9 @@
+import { ParsedRoute, GenerateApiConfiguration, GenerateApiOutput } from 'swagger-typescript-api';
+import type { QueryApiParams } from '../index.js';
+export interface RequestInfoPerFileTmplParams extends GenerateApiOutput {
+    route: ParsedRoute;
+    configuration: GenerateApiConfiguration;
+    apiParams: QueryApiParams;
+}
+export declare const requestInfoPerFileTmpl: ({ route, configuration, apiParams, formatTSContent, }: RequestInfoPerFileTmplParams) => Promise<string>;
+//# sourceMappingURL=request-info-per-file.tmpl.d.ts.map

package/codegen/templates/request-info-per-file.tmpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-info-per-file.tmpl.d.ts","sourceRoot":"","sources":["../../../src/codegen/templates/request-info-per-file.tmpl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,MAAM,WAAW,4BAA6B,SAAQ,iBAAiB;IACrE,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,wBAAwB,CAAC;IACxC,SAAS,EAAE,cAAc,CAAC;CAC3B;AAED,eAAO,MAAM,sBAAsB,0DAKhC,4BAA4B,oBA4B9B,CAAC"}

package/codegen/templates/request-info-per-file.tmpl.js

@@ -0,0 +1,28 @@
+import { newRequestInfoTmpl } from './new-request-info.tmpl.js';
+import { requestInfoJSDocTmpl } from './request-info-jsdoc.tmpl.js';
+export const requestInfoPerFileTmpl = async ({ route, configuration, apiParams, formatTSContent, }) => {
+    const dataContractNames = configuration.modelTypes.map((it) => it.name);
+    const { utils } = configuration;
+    const { _ } = utils;
+    return await formatTSContent(`
+/* eslint-disable */
+/* tslint:disable */
+import { RequestInfo, RequestParams } from "mobx-tanstack-query-api";
+${dataContractNames.length > 0
+        ? `
+import { ${dataContractNames.join(', ')} } from "./data-contracts.ts";
+`
+        : ''}
+
+${requestInfoJSDocTmpl({
+        route,
+        configuration,
+        apiParams,
+    })}
+export const ${_.camelCase(route.routeName.usage)} = ${newRequestInfoTmpl({
+        route,
+        configuration,
+        apiParams,
+    })}
+    `);
+};

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './runtime/index.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/index.js

@@ -0,0 +1 @@
+export * from './runtime/index.js';

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "mobx-tanstack-query-api",
+  "version": "0.0.1",
+  "keywords": [],
+  "author": "js2me",
+  "license": "MIT",
+  "description": "",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/js2me/mobx-tanstack-query-api/issues"
+  },
+  "homepage": "https://github.com/js2me/mobx-tanstack-query-api",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/js2me/mobx-tanstack-query-api"
+  },
+  "peerDependencies": {
+    "@tanstack/query-core": "^5.68.0",
+    "mobx": "^6.13.6",
+    "mobx-tanstack-query": "^4.2.5"
+  },
+  "dependencies": {
+    "swagger-typescript-api": "^13.0.23",
+    "yummies": "^3.0.36"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.11",
+    "eslint": "^8.57.1",
+    "js2me-eslint-config": "^1.0.7",
+    "js2me-exports-post-build-script": "^2.0.17",
+    "jsdom": "^26.0.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.2",
+    "unplugin-swc": "^1.5.1",
+    "vitest": "^3.0.5"
+  },
+  "exports": {
+    "./codegen": {
+      "import": "./codegen/index.js",
+      "default": "./codegen/index.js",
+      "types": "./codegen/index.d.ts"
+    },
+    "./codegen/templates/new-request-info.tmpl": {
+      "import": "./codegen/templates/new-request-info.tmpl.js",
+      "default": "./codegen/templates/new-request-info.tmpl.js",
+      "types": "./codegen/templates/new-request-info.tmpl.d.ts"
+    },
+    "./codegen/templates/request-info-jsdoc.tmpl": {
+      "import": "./codegen/templates/request-info-jsdoc.tmpl.js",
+      "default": "./codegen/templates/request-info-jsdoc.tmpl.js",
+      "types": "./codegen/templates/request-info-jsdoc.tmpl.d.ts"
+    },
+    "./codegen/templates/request-info-per-file.tmpl": {
+      "import": "./codegen/templates/request-info-per-file.tmpl.js",
+      "default": "./codegen/templates/request-info-per-file.tmpl.js",
+      "types": "./codegen/templates/request-info-per-file.tmpl.d.ts"
+    },
+    ".": {
+      "import": "./index.js",
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./runtime/http-client": {
+      "import": "./runtime/http-client.js",
+      "default": "./runtime/http-client.js",
+      "types": "./runtime/http-client.d.ts"
+    },
+    "./runtime": {
+      "import": "./runtime/index.js",
+      "default": "./runtime/index.js",
+      "types": "./runtime/index.d.ts"
+    },
+    "./runtime/request-info": {
+      "import": "./runtime/request-info.js",
+      "default": "./runtime/request-info.js",
+      "types": "./runtime/request-info.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "*"
+  ],
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist",
+    "lint:check": "eslint . --fix",
+    "ts:check": "tsc --noEmit",
+    "check": "npm run lint:check && npm run ts:check",
+    "prebuild": "npm run clean && npm run check",
+    "build": "tsc && node ./post-build.mjs",
+    "pub": "PUBLISH=true pnpm run build",
+    "pub:patch": "PUBLISH=true PUBLISH_VERSION=patch pnpm run build",
+    "pub:minor": "PUBLISH=true PUBLISH_VERSION=minor pnpm run build",
+    "pub:major": "PUBLISH=true PUBLISH_VERSION=major pnpm run build",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "dev": "pnpm test:watch",
+    "playground": "node ./playground/index.mjs"
+  }
+}

package/runtime/http-client.d.ts

@@ -0,0 +1,64 @@
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    contentType?: string;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** meta data */
+    meta?: Record<string, any>;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path' | 'serviceName'>;
+export interface HttpClientConfig<TMeta = unknown> {
+    baseUrl?: string;
+    meta?: TMeta;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    contentFormatters?: Record<string, (input: any) => any>;
+    toQueryString?: (query?: QueryParamsType) => string;
+    buildUrl?: (fullParams: FullRequestParams, formattedParts: {
+        baseUrl: string;
+        path: string;
+        query: string;
+    }) => string;
+    interceptor?: (requestParams: RequestParams, metadata: TMeta | null) => Promise<RequestParams | void> | RequestParams | void;
+    fetch?: typeof fetch;
+}
+export interface HttpResponse<D, E = unknown> extends Response {
+    data: D;
+    error: E;
+}
+export type AnyHttpResponse = HttpResponse<any, any>;
+export declare const isHttpResponse: (response: unknown, status?: number) => response is AnyHttpResponse;
+export declare class HttpClient<TMeta = unknown> {
+    baseUrl: string;
+    meta: TMeta | null;
+    private interceptor?;
+    private fetch;
+    private customBuildUrl;
+    private customToQueryString;
+    private baseApiParams;
+    badResponse: unknown;
+    constructor(config?: HttpClientConfig<TMeta>);
+    setMeta: (data: TMeta | null) => void;
+    setBadResponse: (response: unknown) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    private formatResponse;
+    buildUrl: (params: FullRequestParams) => string;
+    request: <T = any, E = any>(fullParams: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+//# sourceMappingURL=http-client.d.ts.map

package/runtime/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../../src/runtime/http-client.ts"],"names":[],"mappings":"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"}

package/runtime/http-client.js

@@ -0,0 +1,172 @@
+import { action, makeObservable, observable } from 'mobx';
+export const isHttpResponse = (response, status) => !!response &&
+    typeof response === 'object' &&
+    response instanceof Response &&
+    'data' in response &&
+    (!status || response.status === status);
+export class HttpClient {
+    baseUrl = '';
+    meta = null;
+    interceptor;
+    fetch;
+    customBuildUrl;
+    customToQueryString;
+    baseApiParams = {
+        credentials: 'same-origin',
+        headers: {},
+        redirect: 'follow',
+        referrerPolicy: 'no-referrer',
+    };
+    badResponse = null;
+    constructor(config) {
+        this.baseUrl = config?.baseUrl ?? '';
+        this.meta = config?.meta ?? null;
+        this.interceptor = config?.interceptor;
+        this.fetch = config?.fetch ?? fetch;
+        this.customBuildUrl = config?.buildUrl;
+        this.customToQueryString = config?.toQueryString;
+        Object.assign(this.contentFormatters, config?.contentFormatters ?? {});
+        observable.ref(this, 'badResponse');
+        observable.ref(this, 'meta');
+        action(this, 'setMeta');
+        action(this, 'setBadResponse');
+        makeObservable(this);
+    }
+    setMeta = (data) => {
+        this.meta = data;
+    };
+    setBadResponse = (response) => {
+        this.badResponse = response;
+    };
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === 'number' ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join('&');
+    }
+    toQueryString(rawQuery) {
+        if (this.customToQueryString) {
+            return this.customToQueryString(rawQuery);
+        }
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => 'undefined' !== typeof query[key]);
+        return keys
+            .map((key) => Array.isArray(query[key])
+            ? this.addArrayQueryParam(query, key)
+            : this.addQueryParam(query, key))
+            .join('&');
+    }
+    contentFormatters = {
+        'application/json': (input) => input !== null && (typeof input === 'object' || typeof input === 'string')
+            ? JSON.stringify(input)
+            : input,
+        'text/plain': (input) => input !== null && typeof input !== 'string'
+            ? JSON.stringify(input)
+            : input,
+        'multipart/form-data': (input) => Object.keys(input || {}).reduce((formData, key) => {
+            const property = input[key];
+            if (property instanceof Blob) {
+                formData.append(key, property);
+            }
+            else if (typeof property === 'object' && property !== null) {
+                formData.append(key, JSON.stringify(property));
+            }
+            else {
+                formData.append(key, `${property}`);
+            }
+            return formData;
+        }, new FormData()),
+        'application/x-www-form-urlencoded': (input) => this.toQueryString(input),
+        'application/octet-stream': (input) => input,
+    };
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...params2,
+            headers: {
+                ...this.baseApiParams.headers,
+                ...params1.headers,
+                ...params2?.headers,
+            },
+        };
+    }
+    async formatResponse(responseFormat, raw) {
+        const response = raw;
+        response.data = null;
+        response.error = null;
+        if (responseFormat) {
+            try {
+                const formatted = await response[responseFormat]();
+                if (response.ok) {
+                    response.data = formatted;
+                }
+                else {
+                    response.error = formatted;
+                }
+            }
+            catch (error) {
+                if (response.ok) {
+                    response.error = error;
+                }
+                else {
+                    response.error = null;
+                }
+            }
+        }
+        if (!response.ok) {
+            this.setBadResponse(response);
+            throw response;
+        }
+        return response;
+    }
+    buildUrl = (params) => {
+        const baseUrl = params.baseUrl ?? this.baseUrl ?? '';
+        const path = params.path;
+        const queryString = params.query && this.toQueryString(params.query);
+        const query = queryString ? `?${queryString}` : '';
+        if (this.customBuildUrl) {
+            return this.customBuildUrl(params, { baseUrl, path, query });
+        }
+        const url = baseUrl + path + query;
+        return url;
+    };
+    request = async (fullParams) => {
+        this.setBadResponse(null);
+        const { body, contentType = 'application/json', format = 'json', ...params } = fullParams;
+        let requestParams = this.mergeRequestParams(params);
+        if (this.interceptor) {
+            requestParams =
+                (await this.interceptor(requestParams, this.meta)) ?? requestParams;
+        }
+        const payloadFormatter = this.contentFormatters[contentType];
+        const responseFormat = format || requestParams.format;
+        const url = this.buildUrl(fullParams);
+        const responseFormatter = this.formatResponse.bind(this, responseFormat);
+        let headers;
+        if (requestParams.headers instanceof Headers) {
+            headers = requestParams.headers;
+        }
+        else if (Array.isArray(requestParams.headers)) {
+            headers = new Headers(requestParams.headers);
+        }
+        else {
+            headers = new Headers(requestParams.headers);
+        }
+        if (!headers.has('Content-Type')) {
+            headers.set('Content-Type', contentType);
+        }
+        return this.fetch(url, {
+            ...requestParams,
+            headers,
+            body: body == null ? null : payloadFormatter(body),
+        })
+            .then(responseFormatter)
+            .catch(responseFormatter);
+    };
+}

package/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export * from './request-info.js';
+export * from './http-client.js';
+//# sourceMappingURL=index.d.ts.map

package/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/runtime/index.js

@@ -0,0 +1,2 @@
+export * from './request-info.js';
+export * from './http-client.js';

package/runtime/request-info.d.ts

@@ -0,0 +1,57 @@
+import { InvalidateOptions, InvalidateQueryFilters, QueryClient, QueryFunctionContext } from '@tanstack/query-core';
+import { MobxQuery, MobxQueryConfig } from 'mobx-tanstack-query';
+import { AnyObject, MaybeFalsy } from 'yummies/utils/types';
+import type { FullRequestParams, HttpClient, HttpResponse } from './http-client.js';
+export interface RequestInfo<TData, TError, TInput extends AnyObject, TParams extends any[] = any[]> {
+    (...params: TParams): ReturnType<RequestInfo<TData, TError, TInput, TParams>['request']>;
+}
+export declare class RequestInfo<TData, TError, TInput extends AnyObject, TParams extends any[] = any[], TMetaData extends AnyObject = AnyObject> {
+    protected cfg: {
+        operationId: string;
+        meta?: TMetaData;
+        params: (...params: TParams) => FullRequestParams;
+        keys: (string | {
+            name: string;
+            param: number;
+        } | {
+            name: string;
+            rest: true;
+        })[];
+        tags: string[];
+    };
+    protected queryClient: QueryClient;
+    protected http: HttpClient;
+    meta: TMetaData;
+    constructor(cfg: {
+        operationId: string;
+        meta?: TMetaData;
+        params: (...params: TParams) => FullRequestParams;
+        keys: (string | {
+            name: string;
+            param: number;
+        } | {
+            name: string;
+            rest: true;
+        })[];
+        tags: string[];
+    }, queryClient: QueryClient, http: HttpClient);
+    private get hasRestParam();
+    protected buildParamsFromContext(ctx: QueryFunctionContext<any, any>): TParams;
+    protected buildParamsFromInput(input: TInput): TParams;
+    protected buildQueryKeyFromInput(input: TInput): any[];
+    protected buildInputFromQueryKey(queryKey: any[]): TInput;
+    getFullUrl(input: TInput): string;
+    getPath(input: TInput): string;
+    getTags(): string[];
+    request(...params: TParams): Promise<HttpResponse<TData, TError>>;
+    toQueryKey(input: TInput): any[];
+    invalidateByOperationId(filters?: Omit<InvalidateQueryFilters<HttpResponse<TData, TError>>, 'queryKey' | 'predicate'>, options?: InvalidateOptions): Promise<void>;
+    invalidateByTags(filters?: Omit<InvalidateQueryFilters<HttpResponse<TData, TError>>, 'queryKey' | 'predicate'>, options?: InvalidateOptions): Promise<void>;
+    invalidate(input: TInput, filters?: Omit<InvalidateQueryFilters<HttpResponse<TData, TError>>, 'queryKey' | 'predicate'> & {
+        queryKeyIndex?: number;
+    }, options?: InvalidateOptions): Promise<void>;
+    toQuery({ input: getInput, ...options }: Omit<MobxQueryConfig<HttpResponse<TData, TError>, TError>, 'options' | 'queryFn' | 'queryClient'> & {
+        input: () => MaybeFalsy<TInput>;
+    }): MobxQuery<HttpResponse<TData, TError>, TError, any>;
+}
+//# sourceMappingURL=request-info.d.ts.map

package/runtime/request-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-info.d.ts","sourceRoot":"","sources":["../../src/runtime/request-info.ts"],"names":[],"mappings":"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"}

package/runtime/request-info.js

@@ -0,0 +1,189 @@
+import { MobxQuery } from 'mobx-tanstack-query';
+export class RequestInfo {
+    cfg;
+    queryClient;
+    http;
+    meta;
+    constructor(cfg, queryClient, http) {
+        this.cfg = cfg;
+        this.queryClient = queryClient;
+        this.http = http;
+        this.meta = cfg.meta ?? {};
+        // Сохраняем оригинальный инстанс
+        const instance = this;
+        // Создаем функцию-обертку
+        const callable = function (...params) {
+            return instance.request.apply(instance, params);
+        };
+        // Копируем прототип
+        Object.setPrototypeOf(callable, new.target.prototype);
+        // Копируем методы из оригинального инстанса
+        Object.getOwnPropertyNames(instance)
+            .concat(Object.getOwnPropertyNames(new.target.prototype))
+            .forEach((key) => {
+            if (key === 'constructor')
+                return;
+            const desc = Object.getOwnPropertyDescriptor(instance, key) ||
+                Object.getOwnPropertyDescriptor(new.target.prototype, key);
+            if (desc)
+                Object.defineProperty(callable, key, desc);
+        });
+        return callable;
+    }
+    get hasRestParam() {
+        return this.cfg.keys.some((key) => {
+            if (typeof key !== 'string' && 'rest' in key) {
+                return true;
+            }
+        });
+    }
+    buildParamsFromContext(ctx) {
+        const input = this.buildInputFromQueryKey(ctx.queryKey);
+        return this.buildParamsFromInput(input);
+    }
+    buildParamsFromInput(input) {
+        const args = [];
+        const restParams = {};
+        if (this.hasRestParam) {
+            args[0] = restParams;
+        }
+        this.cfg.keys.forEach((key) => {
+            if (typeof key === 'object') {
+                if (key.name === 'request') {
+                    args.push(input[key.name]);
+                }
+                else if (this.hasRestParam) {
+                    if ('rest' in key) {
+                        Object.assign(restParams, input);
+                    }
+                }
+                else if ('param' in key) {
+                    args[key.param] = input[key.name];
+                }
+            }
+        });
+        return args;
+    }
+    buildQueryKeyFromInput(input) {
+        const restParams = this.hasRestParam ? { ...input } : {};
+        return this.cfg.keys.map((key) => {
+            if (typeof key === 'string') {
+                return key;
+            }
+            if (this.hasRestParam) {
+                if ('rest' in key) {
+                    return restParams;
+                }
+                else {
+                    const param = restParams[key.name];
+                    delete restParams[key.name];
+                    return param;
+                }
+            }
+            else {
+                return input[key.name];
+            }
+        });
+    }
+    buildInputFromQueryKey(queryKey) {
+        const input = {};
+        this.cfg.keys.forEach((key, index) => {
+            const keyPart = queryKey[index];
+            if (typeof key === 'string') {
+                return;
+            }
+            if (key.name === 'request') {
+                input[key.name] = keyPart;
+                return;
+            }
+            if ('rest' in key) {
+                Object.assign(input, keyPart);
+                return;
+            }
+            if ('param' in key) {
+                input[key.name] = keyPart;
+            }
+        });
+        return input;
+    }
+    getFullUrl(input) {
+        const params = this.cfg.params(...this.buildParamsFromInput(input));
+        return this.http.buildUrl(params);
+    }
+    getPath(input) {
+        return this.cfg.params(...this.buildParamsFromInput(input)).path;
+    }
+    getTags() {
+        return this.cfg.tags;
+    }
+    request(...params) {
+        return this.http.request(this.cfg.params(...params));
+    }
+    toQueryKey(input) {
+        return this.buildQueryKeyFromInput(input);
+    }
+    invalidateByOperationId(filters, options) {
+        return this.queryClient.invalidateQueries({
+            ...filters,
+            predicate: (query) => {
+                if (query.meta?.operationId) {
+                    return query.meta?.operationId === this.cfg.operationId;
+                }
+                return false;
+            },
+        }, options);
+    }
+    invalidateByTags(filters, options) {
+        const tags = this.getTags();
+        return this.queryClient.invalidateQueries({
+            ...filters,
+            predicate: (query) => {
+                if (Array.isArray(query.meta?.tags)) {
+                    return query.meta.tags.some((tag) => tags.includes(tag));
+                }
+                return false;
+            },
+        }, options);
+    }
+    invalidate(input, filters, options) {
+        return this.queryClient.invalidateQueries({
+            ...filters,
+            queryKey: this.toQueryKey(input).slice(0, filters?.queryKeyIndex),
+            exact: filters?.exact ?? false,
+        }, options);
+    }
+    toQuery({ input: getInput, ...options }) {
+        return new MobxQuery({
+            ...options,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            queryClient: this.queryClient,
+            options: () => {
+                const input = getInput();
+                return {
+                    meta: {
+                        tags: this.getTags(),
+                        operationId: this.cfg.operationId,
+                        ...options.meta,
+                    },
+                    enabled: !!input,
+                    queryKey: input ? this.toQueryKey(input) : '__SKIP__',
+                };
+            },
+            queryFn: async (ctx) => {
+                const args = this.buildParamsFromContext(ctx);
+                const requestParamsIndex = args.length - 1;
+                if (args[requestParamsIndex]) {
+                    if (!args[requestParamsIndex].signal) {
+                        args[requestParamsIndex].signal = ctx.signal;
+                    }
+                }
+                else {
+                    args[requestParamsIndex] = { signal: ctx.signal };
+                }
+                const response = await this.request(...args);
+                return response;
+            },
+        });
+    }
+}