mobx-tanstack-query-api 0.24.0 → 0.26.0

package/cli.js

@@ -0,0 +1,1278 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { cloneDeep } from "lodash-es";
+import { generateApi as generateApi$1 } from "swagger-typescript-api";
+import { splitTextByLines } from "yummies/text";
+import { Project, SyntaxKind, Node } from "ts-morph";
+const LINTERS_IGNORE = `/* eslint-disable */
+/* tslint:disable */`;
+const buildGenerics = (contract) => {
+  if (!contract.genericArgs?.length) return "";
+  return "<" + contract.genericArgs.map((arg) => {
+    const { name, default: defaultType, extends: extendsType } = arg;
+    return [
+      name,
+      extendsType && `extends ${extendsType}`,
+      defaultType && `= ${defaultType}`
+    ].filter(Boolean).join(" ");
+  }).join(", ") + ">";
+};
+const dataContractTmpl = async ({
+  contract,
+  configuration,
+  addExportKeyword
+}) => {
+  const { utils } = configuration;
+  const { formatDescription } = utils;
+  const dataContractTemplates = {
+    enum: (contract2) => {
+      return `enum ${contract2.name} {\r
+${contract2.content}\r
+}`;
+    },
+    interface: (contract2) => {
+      return `interface ${contract2.name}${buildGenerics(contract2)} {\r
+${contract2.content}}`;
+    },
+    type: (contract2) => {
+      return `type ${contract2.name}${buildGenerics(contract2)} = ${contract2.content === contract2.name ? "any" : contract2.content}`;
+    }
+  };
+  let result = "";
+  let jsdoc = "";
+  if (contract.description) {
+    jsdoc = `/**
+ * ${formatDescription(contract.description, true)}
+ */
+`;
+  }
+  if (jsdoc) {
+    result += jsdoc;
+  }
+  const templateFn = dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type;
+  const contractType = `${"export "}${templateFn(contract)}`;
+  return result + contractType;
+};
+const endpointJSDocTmpl = (params) => {
+  const { route, configuration, offset = 0 } = params;
+  const { routeName } = route;
+  const rawRoute = route.raw;
+  const routeRequest = route.request;
+  const { utils } = configuration;
+  const { _, formatDescription } = utils;
+  const jsDocLines = [];
+  if (rawRoute.summary) {
+    const summaryLines = splitTextByLines(rawRoute.summary, 60).filter(Boolean).map((line) => ({
+      content: `**${formatDescription(line, true)}**`
+    }));
+    if (summaryLines.length > 0) {
+      jsDocLines.push(...summaryLines, { content: "" });
+    }
+  }
+  if (rawRoute.description) {
+    const descriptionLines = splitTextByLines(rawRoute.description, 60).filter(Boolean).map((line) => ({
+      content: formatDescription(line, true)
+    }));
+    if (descriptionLines.length > 0) {
+      jsDocLines.push(...descriptionLines, { content: "" });
+    } else {
+      jsDocLines.push({
+        content: "No description"
+      });
+    }
+  } 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(", ")
+    });
+  }
+  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;
+};
+const createShortModelType = (shortModelType) => {
+  return {
+    ...shortModelType,
+    typeIdentifier: shortModelType.typeIdentifier || "type",
+    rawContent: shortModelType.rawContent || shortModelType.content,
+    description: shortModelType.description || ""
+  };
+};
+const formatGroupNameEnumKey = (groupName, { _ }) => _.upperFirst(_.camelCase(groupName));
+const formatTagNameEnumKey = (tagName, utils) => formatGroupNameEnumKey(tagName, utils);
+const metaInfoTmpl = async ({
+  metaInfo,
+  utils,
+  formatTSContent,
+  codegenParams,
+  ...other
+}) => {
+  const tagsMap = new Map(
+    other.configuration?.apiConfig?.tags?.map((it) => [
+      it.name,
+      it
+    ])
+  );
+  return await formatTSContent(`${LINTERS_IGNORE}
+  ${[
+    metaInfo?.namespace && `export const namespace = "${metaInfo?.namespace}";`,
+    metaInfo?.groupNames?.length && `
+export const enum Group {
+  ${metaInfo?.groupNames.map((groupName) => `${formatGroupNameEnumKey(groupName, utils)} = "${codegenParams.transforms?.groupEnumValue?.(groupName) ?? groupName}"`).join(",\n")}
+}
+`,
+    metaInfo?.tags?.length && `
+export const enum Tag {
+  ${metaInfo?.tags.map((tagName) => {
+      const tagData = tagsMap.get(tagName);
+      let description = tagData?.description;
+      if (!description) {
+        description = utils._.words(tagName).join(" ");
+      }
+      return [
+        description && `/** ${description} */`,
+        `${formatTagNameEnumKey(tagName, utils)} = "${codegenParams.transforms?.tagEnumValue?.(tagName) ?? tagName}"`
+      ].filter(Boolean).join("\n");
+    }).join(",\n")}
+}
+`
+  ].filter(Boolean).join("\n")}
+    `);
+};
+const requestContentKind = {
+  URL_ENCODED: '"application/x-www-form-urlencoded"',
+  FORM_DATA: '"multipart/form-data"',
+  TEXT: '"text/plain"',
+  BINARY: '"application/octet-stream"'
+};
+const responseContentKind = {
+  TEXT: '"text"',
+  IMAGE: '"blob"',
+  FORM_DATA: '"formData"',
+  BYTES: '"bytes"'
+};
+const newEndpointTmpl = ({
+  route,
+  codegenParams,
+  importFileParams,
+  utils,
+  groupName,
+  metaInfo,
+  filterTypes,
+  configuration
+}) => {
+  const { _ } = utils;
+  const positiveResponseTypes = route.raw.responsesTypes?.filter(
+    (it) => +it.status >= 200 && +it.status < 300 && (!it.typeData || filterTypes(it.typeData))
+  );
+  const { requestBodyInfo, responseBodyInfo } = route;
+  const routeRequest = route.request;
+  const routeResponse = route.response;
+  const { parameters, path: path2, 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: "requestParams",
+    optional: true,
+    type: "RequestParams",
+    defaultValue: "{}"
+  };
+  const inputParams = [
+    ...pathParams,
+    payload,
+    query,
+    requestConfigParam
+  ].filter(Boolean);
+  const getArgs = ({
+    withPayload,
+    withRequestConfigParam
+  }) => {
+    return _.sortBy(
+      _.compact([
+        ...requestParams ? [
+          {
+            name: pathParams.length > 0 ? `{ ${_.join(pathParamsNames, ", ")}, ...${queryName} }` : queryName,
+            optional: false,
+            type: utils.getInlineParseContent(requestParams)
+          }
+        ] : pathParams,
+        payload,
+        withRequestConfigParam && requestConfigParam
+      ]),
+      [(o) => o.optional]
+    );
+  };
+  const tags = (raw.tags || []).filter(Boolean);
+  const requestOutputDataTypes = positiveResponseTypes.map((it) => it.type);
+  const foundErrorModelType = routeResponse.errorType && configuration.modelTypes.find(
+    (it) => it.name === routeResponse.errorType
+  ) || null;
+  const requestOutputErrorType = foundErrorModelType ? routeResponse.errorType : "any";
+  const pathParamsToInline = path2.split("/").slice(1);
+  query == null ? null : {
+    i: pathParamsToInline.length
+  };
+  const requestInfoMeta = codegenParams.getEndpointMeta?.(route, utils);
+  const requestMeta = codegenParams.getRequestMeta?.(route, utils);
+  const resultPath = (codegenParams.requestPathPrefix ?? "") + path2 + (codegenParams.requestPathSuffix ?? "");
+  const bodyContentType = requestContentKind[requestBodyInfo.contentKind] || null;
+  const responseFormat = responseContentKind[responseBodyInfo.success?.schema?.contentKind] || null;
+  const reservedDataContractNames = _.uniq([
+    ...requestOutputDataTypes,
+    requestOutputErrorType || "any",
+    ...getArgs({
+      withPayload: true
+    }).map((it) => it.type)
+  ]);
+  const pathDeclaration = resultPath.replaceAll("$", "");
+  const getHttpRequestGenerics = () => {
+    const defaultOkResponse = positiveResponseTypes?.[0]?.type || "unknown";
+    const defaultBadResponse = requestOutputErrorType;
+    const responses = raw.responsesTypes?.filter(
+      (it) => it.status !== "default" && (!it.typeData || filterTypes(it.typeData))
+    ) || [];
+    if (!responses?.length) {
+      return `HttpResponse<unknown, ${requestOutputErrorType}>`;
+    }
+    if (responses.length === 1 && responses[0].isSuccess) {
+      return `HttpResponse<${responses[0].type}, ${requestOutputErrorType}>`;
+    }
+    return `HttpMultistatusResponse<{
+  ${responses.map((it) => {
+      return [
+        it.description && `/** ${it.description} */`,
+        `${it.status}: ${it.type};`
+      ].filter(Boolean).join("\n");
+    }).join("\n")}
+  },
+  ${defaultOkResponse},
+  ${defaultBadResponse}
+  >`;
+  };
+  const requestInputTypeDc = createShortModelType({
+    typeIdentifier: "type",
+    name: _.upperFirst(_.camelCase(`${route.routeName.usage}Params`)),
+    content: `{
+    ${inputParams.map(({ name, optional, type }) => {
+      return `${name}${optional ? "?" : ""}:${type}`;
+    }).filter(Boolean).join(", ")}
+  }`
+  });
+  const isAllowedInputType = filterTypes(requestInputTypeDc);
+  return {
+    reservedDataContractNames,
+    localModelTypes: isAllowedInputType ? [requestInputTypeDc] : [],
+    content: `
+new ${importFileParams.endpoint.exportName}<
+  ${getHttpRequestGenerics()},
+  ${isAllowedInputType ? requestInputTypeDc.name : "any"},
+  ${requestInfoMeta?.typeName ?? "any"}
+>(
+    {
+        params: ({
+  ${inputParams.map((it) => it.name)}
+}) => ({
+            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},` : ""}
+            ...${requestConfigParam.name},
+        }),
+        requiredParams: [${inputParams.filter((it) => !it.optional).map((it) => `"${it.name}"`)}],
+        operationId: "${raw.operationId || _.camelCase(route.routeName.usage)}",
+        path: [${pathDeclaration.split("/").filter(Boolean).map((it) => `"${it}"`)}],
+        tags: [${tags.map((tag) => {
+      if (metaInfo) {
+        return `Tag.${formatTagNameEnumKey(tag, utils)}`;
+      }
+      return `"${tag}"`;
+    })}],
+        ${groupName ? `group: ${metaInfo ? `Group.${formatGroupNameEnumKey(groupName, utils)}` : `"${groupName}"`},` : ""}
+        ${metaInfo?.namespace ? `namespace,` : ""}
+        meta: ${requestInfoMeta?.tmplData ?? "{} as any"},
+    },
+    ${importFileParams.queryClient.exportName},
+    ${importFileParams.httpClient.exportName},
+)  
+`.split("\n").map((it) => it.trim()).filter(Boolean).join("\n")
+  };
+};
+const allEndpointPerFileTmpl = async (params) => {
+  const {
+    routes,
+    configuration,
+    codegenParams,
+    formatTSContent,
+    importFileParams,
+    utils,
+    relativePathDataContracts,
+    groupName,
+    metaInfo
+  } = params;
+  const { _ } = utils;
+  const dataContractNamesInThisFile = [];
+  const newEndpointTemplates = routes.map((route) => {
+    const newEndpointTemplateData = newEndpointTmpl({
+      ...params,
+      route
+    });
+    const { reservedDataContractNames } = newEndpointTemplateData;
+    const dataContactNames = new Set(
+      Object.keys(
+        configuration.config.swaggerSchema?.components?.schemas
+      ).map((schemaName) => utils.formatModelName(schemaName))
+    );
+    reservedDataContractNames.forEach((reservedDataContractName) => {
+      if (!dataContactNames.has(reservedDataContractName)) {
+        dataContractNamesInThisFile.push(reservedDataContractName);
+      }
+    });
+    return { ...newEndpointTemplateData, route };
+  });
+  const extraImportLines = [];
+  const endpointTemplates = await Promise.all(
+    newEndpointTemplates.map(
+      async ({
+        content: requestInfoInstanceContent,
+        localModelTypes,
+        route
+      }) => {
+        const requestInfoMeta = codegenParams.getEndpointMeta?.(route, utils);
+        if (requestInfoMeta?.typeNameImportPath && requestInfoMeta.typeName) {
+          extraImportLines.push(
+            `import { ${requestInfoMeta.typeName} } from "${requestInfoMeta.typeNameImportPath}";`
+          );
+        }
+        return `
+      ${(await Promise.all(
+          localModelTypes.map(async (modelType) => {
+            const contractType = await dataContractTmpl({
+              ...params,
+              contract: modelType,
+              addExportKeyword: true
+            });
+            return contractType;
+          })
+        )).filter(Boolean).join("\n\n")}
+      
+      ${endpointJSDocTmpl({
+          ...params,
+          route
+        })}
+      export const ${_.camelCase(route.routeName.usage)} = ${requestInfoInstanceContent}               
+`;
+      }
+    )
+  );
+  if (metaInfo) {
+    extraImportLines.push(
+      `import { ${[groupName && "Group", metaInfo?.namespace && "namespace", "Tag"].filter(Boolean).join(",")} } from "${groupName ? "../" : "./"}meta-info";`
+    );
+  }
+  return {
+    reservedDataContractNames: dataContractNamesInThisFile,
+    content: await formatTSContent(`${LINTERS_IGNORE}
+      import {
+        RequestParams,
+        HttpResponse,
+        HttpMultistatusResponse,
+      } from "${codegenParams.libImports?.["mobx-tanstack-query-api"] ?? "mobx-tanstack-query-api"}";
+      import { ${importFileParams.endpoint.exportName} } from "${importFileParams.endpoint.path}";
+      import { ${importFileParams.httpClient.exportName} } from "${importFileParams.httpClient.path}";
+      import { ${importFileParams.queryClient.exportName} } from "${importFileParams.queryClient.path}";
+      ${extraImportLines.join("\n")}
+
+      ${configuration.modelTypes.length > 0 ? `
+      import { ${configuration.modelTypes.map((it) => it.name).filter(
+      (it) => !dataContractNamesInThisFile.includes(it)
+    )} } from "${relativePathDataContracts}";
+      ` : ""}
+
+      ${(await Promise.all(
+      dataContractNamesInThisFile.map(async (dataContractName) => {
+        const modelType = configuration.modelTypes.find(
+          (modelType2) => modelType2.name === dataContractName
+        );
+        if (!modelType) {
+          return "";
+        }
+        const contractType = await dataContractTmpl({
+          ...params,
+          contract: modelType,
+          addExportKeyword: true
+        });
+        return contractType;
+      })
+    )).filter(Boolean).join("\n\n")}
+
+      ${endpointTemplates.filter(Boolean).join("\n\n")}
+      `)
+  };
+};
+const allExportsTmpl = async ({
+  collectedExportFiles,
+  metaInfo,
+  formatTSContent
+}) => {
+  return await formatTSContent(`${LINTERS_IGNORE}
+  export * from './data-contracts';
+  ${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
+  ${metaInfo ? 'export * from "./meta-info";' : ""}
+    `);
+};
+const dataContractsFileTmpl = async (params) => {
+  const { config, modelTypes } = params.configuration;
+  const contractDefinitions = [];
+  if (config.internalTemplateOptions?.addUtilRequiredKeysType) {
+    contractDefinitions.push(
+      `type UtilRequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>`
+    );
+  }
+  for await (const contract of modelTypes) {
+    if (params.excludedDataContractNames?.includes(contract.name)) {
+      continue;
+    }
+    contractDefinitions.push(
+      await dataContractTmpl({
+        ...params,
+        contract,
+        addExportKeyword: true
+      })
+    );
+  }
+  return await params.formatTSContent(`${LINTERS_IGNORE}
+
+${contractDefinitions.length > 0 ? contractDefinitions.join("\n\n") : `export {}`}
+  `);
+};
+const endpointPerFileTmpl = async (params) => {
+  const {
+    route,
+    configuration,
+    codegenParams,
+    formatTSContent,
+    importFileParams,
+    utils,
+    relativePathDataContracts,
+    groupName,
+    metaInfo
+  } = params;
+  const { _ } = utils;
+  const {
+    content: requestInfoInstanceContent,
+    reservedDataContractNames,
+    localModelTypes
+  } = newEndpointTmpl({
+    ...params,
+    route,
+    groupName,
+    metaInfo
+  });
+  const dataContactNames = new Set(
+    Object.keys(
+      configuration.config.swaggerSchema?.components?.schemas
+    ).map((schemaName) => utils.formatModelName(schemaName))
+  );
+  const dataContractNamesInThisFile = [];
+  reservedDataContractNames.forEach((reservedDataContractName) => {
+    if (!dataContactNames.has(reservedDataContractName)) {
+      dataContractNamesInThisFile.push(reservedDataContractName);
+    }
+  });
+  const extraImportLines = [];
+  if (metaInfo) {
+    extraImportLines.push(
+      `import { ${[groupName && "Group", metaInfo?.namespace && "namespace", "Tag"].filter(Boolean).join(",")} } from "../${groupName ? "../" : ""}meta-info";`
+    );
+  }
+  const requestInfoMeta = codegenParams.getEndpointMeta?.(route, utils);
+  if (requestInfoMeta?.typeNameImportPath && requestInfoMeta.typeName) {
+    extraImportLines.push(
+      `import { ${requestInfoMeta.typeName} } from "${requestInfoMeta.typeNameImportPath}";`
+    );
+  }
+  return {
+    reservedDataContractNames: dataContractNamesInThisFile,
+    content: await formatTSContent(`${LINTERS_IGNORE}
+      import {
+        RequestParams,
+        HttpResponse,
+        HttpMultistatusResponse,
+      } from "${codegenParams.libImports?.["mobx-tanstack-query-api"] ?? "mobx-tanstack-query-api"}";
+      import { ${importFileParams.endpoint.exportName} } from "${importFileParams.endpoint.path}";
+      import { ${importFileParams.httpClient.exportName} } from "${importFileParams.httpClient.path}";
+      import { ${importFileParams.queryClient.exportName} } from "${importFileParams.queryClient.path}";
+      ${extraImportLines.join("\n")}
+
+      ${configuration.modelTypes.length > 0 ? `
+      import { ${configuration.modelTypes.map((it) => it.name).filter(
+      (it) => !dataContractNamesInThisFile.includes(it)
+    )} } from "${relativePathDataContracts}";
+      ` : ""}
+
+      ${(await Promise.all(
+      dataContractNamesInThisFile.map(async (dataContractName) => {
+        const modelType = configuration.modelTypes.find(
+          (modelType2) => modelType2.name === dataContractName
+        );
+        if (!modelType) {
+          return "";
+        }
+        const contractType = await dataContractTmpl({
+          ...params,
+          contract: modelType,
+          addExportKeyword: true
+        });
+        return contractType;
+      })
+    )).filter(Boolean).join("\n\n")}
+
+      ${(await Promise.all(
+      localModelTypes.map(async (modelType) => {
+        const contractType = await dataContractTmpl({
+          ...params,
+          contract: modelType,
+          addExportKeyword: true
+        });
+        return contractType;
+      })
+    )).filter(Boolean).join("\n\n")}
+      
+      ${endpointJSDocTmpl({
+      ...params,
+      route
+    })}
+      export const ${_.camelCase(route.routeName.usage)} = ${requestInfoInstanceContent}
+      `)
+  };
+};
+const indexTsForEndpointPerFileTmpl = async ({
+  generatedRequestFileNames
+}) => {
+  return `${LINTERS_IGNORE}
+${generatedRequestFileNames.map((fileName) => `export * from './${fileName.replace(".ts", "")}';`).join("\n")}
+`;
+};
+const unpackFilterOption = (option, argsToString, defaultReturnValue = true) => {
+  if (typeof option === "function") {
+    return option;
+  }
+  if (option == null) {
+    return () => defaultReturnValue;
+  }
+  const inputs = Array.isArray(option) ? option : [option];
+  return (...args) => inputs.some((input) => {
+    const str = argsToString(...args);
+    if (typeof input === "string") {
+      return input === str;
+    }
+    return input.test(str);
+  });
+};
+const removeUnusedTypesItteration = async ({
+  directory,
+  keepTypes
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+}) => {
+  const project = new Project();
+  project.addSourceFilesAtPaths([
+    path.join(directory, "**/*.ts"),
+    path.join(directory, "**/*.tsx")
+  ]);
+  const dataContractsSourceFile = project.getSourceFile(
+    (sourceFile) => sourceFile.getFilePath().includes(`${directory}/data-contracts.ts`)
+  );
+  if (!dataContractsSourceFile) return;
+  const exportedDeclarations = dataContractsSourceFile.getExportedDeclarations();
+  const candidateTypes = /* @__PURE__ */ new Map();
+  for (const [name, declarations] of exportedDeclarations) {
+    const validDeclarations = declarations.filter(
+      (decl) => decl.getKind() === SyntaxKind.InterfaceDeclaration || decl.getKind() === SyntaxKind.TypeAliasDeclaration || decl.getKind() === SyntaxKind.EnumDeclaration
+    );
+    if (validDeclarations.length > 0) {
+      candidateTypes.set(name, validDeclarations);
+    }
+  }
+  if (candidateTypes.size === 0) return;
+  const usedTypes = /* @__PURE__ */ new Set();
+  const externalFiles = project.getSourceFiles().filter((sf) => sf !== dataContractsSourceFile);
+  for (const file of externalFiles) {
+    const identifiers = file.getDescendantsOfKind(SyntaxKind.Identifier);
+    for (const identifier of identifiers) {
+      const name = identifier.getText();
+      if (candidateTypes.has(name)) {
+        usedTypes.add(name);
+      }
+    }
+    const memberAccessExpressions = file.getDescendantsOfKind(
+      SyntaxKind.PropertyAccessExpression
+    );
+    for (const expr of memberAccessExpressions) {
+      const expression = expr.getExpression();
+      if (Node.isIdentifier(expression)) {
+        const name = expression.getText();
+        if (candidateTypes.has(name)) {
+          usedTypes.add(name);
+        }
+      }
+    }
+  }
+  const dependencyGraph = /* @__PURE__ */ new Map();
+  for (const [name, declarations] of candidateTypes) {
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const decl of declarations) {
+      const typeReferences = decl.getDescendantsOfKind(
+        SyntaxKind.TypeReference
+      );
+      for (const ref of typeReferences) {
+        const typeName = ref.getTypeName().getText();
+        if (candidateTypes.has(typeName)) {
+          dependencies.add(typeName);
+        }
+      }
+      if (decl.getKind() === SyntaxKind.EnumDeclaration) {
+        const initializers = decl.getDescendantsOfKind(SyntaxKind.Identifier);
+        for (const init of initializers) {
+          const text = init.getText();
+          if (candidateTypes.has(text)) {
+            dependencies.add(text);
+          }
+        }
+      }
+    }
+    dependencyGraph.set(name, dependencies);
+  }
+  const queue = Array.from(usedTypes);
+  const visited = new Set(usedTypes);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (dependencyGraph.has(current)) {
+      for (const dep of dependencyGraph.get(current)) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          usedTypes.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  let removedCount = 0;
+  const isNeedToRemoveType = unpackFilterOption(
+    keepTypes,
+    (name) => name,
+    false
+  );
+  for (const [name, declarations] of candidateTypes) {
+    if (usedTypes.has(name)) continue;
+    for (const decl of declarations) {
+      if ("remove" in decl && isNeedToRemoveType(name)) {
+        decl.remove();
+        removedCount++;
+      }
+    }
+  }
+  if (removedCount > 0) {
+    await dataContractsSourceFile.save();
+  }
+  return removedCount;
+};
+const removeUnusedTypes = async (params) => {
+  while (true) {
+    const removedCount = await removeUnusedTypesItteration(params) ?? 0;
+    if (removedCount === 0) break;
+  }
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const __execdirname = process.cwd();
+const generateApi = async (params) => {
+  if (Array.isArray(params)) {
+    for await (const param of params) {
+      await generateApi(param);
+    }
+    return;
+  }
+  const tsconfigPath = params.tsconfigPath ? path.resolve(__execdirname, params.tsconfigPath) : path.resolve(__execdirname, "./tsconfig.json");
+  console.info("using tsconfig", tsconfigPath);
+  const importFileParams = {
+    queryClient: !params.queryClient || typeof params.queryClient === "string" ? {
+      exportName: "queryClient",
+      path: "mobx-tanstack-query-api/builtin"
+    } : params.queryClient,
+    endpoint: !params.endpoint || typeof params.endpoint === "string" ? {
+      exportName: "Endpoint",
+      path: "mobx-tanstack-query-api"
+    } : params.endpoint,
+    httpClient: !params.httpClient || typeof params.httpClient === "string" ? {
+      exportName: "http",
+      path: "mobx-tanstack-query-api/builtin"
+    } : params.httpClient
+  };
+  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"
+    ),
+    outputDir: path.resolve(process.cwd(), params.output)
+  };
+  const swaggerTypescriptApiCodegenBaseParams = {
+    httpClientType: "fetch",
+    cleanOutput: params.cleanOutput ?? true,
+    modular: true,
+    patch: true,
+    typeSuffix: "DC",
+    disableStrictSSL: false,
+    singleHttpClient: true,
+    extractRequestBody: true,
+    extractRequestParams: false,
+    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.otherCodegenParams?.primitiveTypeConstructs?.(constructs)
+      };
+    },
+    requestOptions: params.fetchSchemaRequestOptions,
+    ...params.otherCodegenParams
+  };
+  let codegenProcess;
+  if (!params.input) {
+    console.warn(
+      "[mobx-tanstack-query-api/codegen]",
+      "input is not specified",
+      "\nprocess will be skipped"
+    );
+    return;
+  }
+  const inputToCodegenInput = (input) => {
+    const inputData = {};
+    if (typeof input === "string") {
+      inputData.input = input;
+      inputData.url = input;
+    } else {
+      inputData.spec = input;
+    }
+    return inputData;
+  };
+  let mixinSwaggerSchema = null;
+  if (params.mixinInput) {
+    await generateApi$1({
+      ...swaggerTypescriptApiCodegenBaseParams,
+      ...inputToCodegenInput(params.mixinInput),
+      hooks: {
+        onInit: (configuration) => {
+          mixinSwaggerSchema = cloneDeep(configuration.swaggerSchema);
+        },
+        onPrepareConfig: (config) => {
+          config.routes.combined?.forEach((routeInfo) => {
+            routeInfo.routes.sort(
+              (routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage)
+            );
+          });
+        },
+        onFormatRouteName: (routeInfo, usageRouteName) => {
+          let formattedRouteName = usageRouteName;
+          if (params.addPathSegmentToRouteName === true || typeof params.addPathSegmentToRouteName === "number") {
+            const pathSegmentForSuffix = typeof params.addPathSegmentToRouteName === "number" ? params.addPathSegmentToRouteName : 0;
+            const pathSegments = routeInfo.route.split("/").filter(Boolean);
+            const { _: _2 } = codegenProcess.getRenderTemplateData().utils;
+            formattedRouteName = _2.camelCase(
+              `${pathSegments[pathSegmentForSuffix] || ""}_${formattedRouteName}`
+            );
+          }
+          const endpointName = formattedRouteName;
+          return params?.formatEndpointName?.(endpointName, routeInfo) ?? swaggerTypescriptApiCodegenBaseParams?.hooks?.onFormatRouteName?.(
+            routeInfo,
+            endpointName
+          ) ?? endpointName;
+        }
+      }
+    });
+  }
+  const generated = await generateApi$1({
+    ...swaggerTypescriptApiCodegenBaseParams,
+    ...inputToCodegenInput(params.input),
+    hooks: {
+      onInit: (configuration, codeGenProcessFromInit) => {
+        codegenProcess = codeGenProcessFromInit;
+        const resultSwaggerSchema = configuration.swaggerSchema;
+        resultSwaggerSchema.components = resultSwaggerSchema.components || {};
+        resultSwaggerSchema.components.schemas = resultSwaggerSchema.components.schemas || {};
+        resultSwaggerSchema.paths = {
+          ...resultSwaggerSchema.paths,
+          ...mixinSwaggerSchema?.paths
+        };
+        resultSwaggerSchema.components.schemas = {
+          ...resultSwaggerSchema.components.schemas,
+          ...mixinSwaggerSchema?.components?.schemas
+        };
+        return swaggerTypescriptApiCodegenBaseParams?.hooks?.onInit?.(
+          configuration,
+          codeGenProcessFromInit
+        );
+      },
+      onPrepareConfig: (config) => {
+        config.routes.combined?.forEach((routeInfo) => {
+          routeInfo.routes.sort(
+            (routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage)
+          );
+        });
+        return swaggerTypescriptApiCodegenBaseParams?.hooks?.onPrepareConfig?.(
+          config
+        );
+      },
+      onFormatRouteName: (routeInfo, usageRouteName) => {
+        let formattedRouteName = usageRouteName;
+        if (params.addPathSegmentToRouteName === true || typeof params.addPathSegmentToRouteName === "number") {
+          const pathSegmentForSuffix = typeof params.addPathSegmentToRouteName === "number" ? params.addPathSegmentToRouteName : 0;
+          const pathSegments = routeInfo.route.split("/").filter(Boolean);
+          const { _: _2 } = codegenProcess.getRenderTemplateData().utils;
+          formattedRouteName = _2.camelCase(
+            `${pathSegments[pathSegmentForSuffix] || ""}_${formattedRouteName}`
+          );
+        }
+        const endpointName = formattedRouteName;
+        return params?.formatEndpointName?.(endpointName, routeInfo) ?? swaggerTypescriptApiCodegenBaseParams?.hooks?.onFormatRouteName?.(
+          routeInfo,
+          endpointName
+        ) ?? endpointName;
+      }
+    }
+  });
+  const utils = codegenProcess.getRenderTemplateData().utils;
+  const { _ } = utils;
+  let namespace = null;
+  if (params.namespace) {
+    if (typeof params.namespace === "function") {
+      namespace = params.namespace(utils);
+    } else {
+      namespace = utils._.camelCase(params.namespace);
+    }
+  }
+  const codegenFs = codegenProcess.fileSystem;
+  codegenFs.cleanDir(params.output);
+  codegenFs.createDir(params.output);
+  const filterTypes = unpackFilterOption(
+    params.filterTypes,
+    (modelType) => modelType.name
+  );
+  generated.configuration.modelTypes = generated.configuration.modelTypes.filter(
+    (modelType) => filterTypes(modelType)
+  );
+  const allRoutes = Object.values(generated.configuration.routes).flat().flatMap(
+    (routeGroup) => "routes" in routeGroup ? routeGroup.routes : routeGroup
+  );
+  const filterEndpoint = unpackFilterOption(
+    params.filterEndpoints,
+    (route) => route.raw?.operationId || ""
+  );
+  const baseTmplParams = {
+    ...generated,
+    codegenParams: params,
+    configuration: generated.configuration,
+    formatTSContent: generated.formatTSContent,
+    codegenProcess,
+    importFileParams,
+    utils,
+    filterTypes
+  };
+  const reservedDataContractNamesMap = /* @__PURE__ */ new Map();
+  const collectedExportFilesFromIndexFile = [];
+  const groupsMap = /* @__PURE__ */ new Map();
+  const nonEmptyGroups = /* @__PURE__ */ new Set();
+  const tagsSet = /* @__PURE__ */ new Set();
+  if (params.groupBy == null) {
+    collectedExportFilesFromIndexFile.push("endpoints");
+    if (params.outputType === "one-endpoint-per-file") {
+      codegenFs.createDir(path.resolve(params.output, "endpoints"));
+      const fileNamesWithRequestInfo = [];
+      for await (const route of allRoutes) {
+        const {
+          content: requestInfoPerFileContent,
+          reservedDataContractNames
+        } = await endpointPerFileTmpl({
+          ...baseTmplParams,
+          route,
+          relativePathDataContracts: "../data-contracts",
+          groupName: null,
+          metaInfo: params.noMetaInfo ? null : {
+            groupNames: [],
+            namespace
+          }
+        });
+        if (Array.isArray(route.raw.tags)) {
+          route.raw.tags.forEach((tag) => {
+            tagsSet.add(tag);
+          });
+        }
+        reservedDataContractNames.forEach((name) => {
+          reservedDataContractNamesMap.set(
+            name,
+            (reservedDataContractNamesMap.get(name) ?? 0) + 1
+          );
+        });
+        if (!filterEndpoint(route)) {
+          continue;
+        }
+        const fileName = `${_.kebabCase(route.routeName.usage)}.ts`;
+        fileNamesWithRequestInfo.push(fileName);
+        codegenFs.createFile({
+          path: path.resolve(params.output, "endpoints"),
+          fileName,
+          withPrefix: false,
+          content: requestInfoPerFileContent
+        });
+      }
+      codegenFs.createFile({
+        path: path.resolve(params.output, "endpoints"),
+        fileName: "index.ts",
+        withPrefix: false,
+        content: await indexTsForEndpointPerFileTmpl({
+          generatedRequestFileNames: fileNamesWithRequestInfo
+        })
+      });
+    } else {
+      const { content: requestInfoPerFileContent, reservedDataContractNames } = await allEndpointPerFileTmpl({
+        ...baseTmplParams,
+        routes: allRoutes,
+        relativePathDataContracts: "./data-contracts",
+        groupName: null,
+        metaInfo: params.noMetaInfo ? null : {
+          namespace,
+          groupNames: []
+        }
+      });
+      reservedDataContractNames.forEach((name) => {
+        reservedDataContractNamesMap.set(
+          name,
+          (reservedDataContractNamesMap.get(name) ?? 0) + 1
+        );
+      });
+      const filteredRoutes = allRoutes.filter(filterEndpoint);
+      const hasFilteredRoutes = filteredRoutes.length > 0;
+      if (hasFilteredRoutes) {
+        filteredRoutes.forEach((route) => {
+          if (Array.isArray(route.raw.tags)) {
+            route.raw.tags.forEach((tag) => {
+              tagsSet.add(tag);
+            });
+          }
+        });
+        const fileName = "endpoints.ts";
+        collectedExportFilesFromIndexFile.push("endpoints");
+        codegenFs.createFile({
+          path: params.output,
+          fileName,
+          withPrefix: false,
+          content: requestInfoPerFileContent
+        });
+      }
+    }
+  } else {
+    allRoutes.forEach((route) => {
+      let group;
+      if (typeof params.groupBy === "function") {
+        group = params.groupBy(route);
+      } else if (params.groupBy?.includes("path-segment")) {
+        const segmentIndex = +params.groupBy.replaceAll(/path-segment-?/g, "") || 0;
+        group = route.request.path?.split("/")?.filter(Boolean)?.[segmentIndex] || void 0;
+      } else if (params.groupBy?.includes("tag")) {
+        const tagIndex = +params.groupBy.replaceAll(/tag-?/g, "") || 0;
+        group = route.raw?.tags?.[tagIndex] ?? void 0;
+      }
+      if (group == null) {
+        group = "other";
+      }
+      if (!groupsMap.has(group)) {
+        groupsMap.set(group, []);
+      }
+      groupsMap.get(group)?.push(route);
+    });
+    const filterGroups = unpackFilterOption(
+      params.filterGroups,
+      (groupName) => groupName
+    );
+    for await (const [groupName, routes] of groupsMap) {
+      if (!filterGroups(groupName)) {
+        continue;
+      }
+      const fileNamesWithRequestInfo = [];
+      const groupDirectory = path.resolve(
+        params.output,
+        _.kebabCase(groupName)
+      );
+      codegenFs.createDir(groupDirectory);
+      let hasFilteredRoutes = false;
+      if (params.outputType === "one-endpoint-per-file") {
+        codegenFs.createDir(path.resolve(groupDirectory, "endpoints"));
+        for await (const route of routes) {
+          const {
+            content: requestInfoPerFileContent,
+            reservedDataContractNames
+          } = await endpointPerFileTmpl({
+            ...baseTmplParams,
+            route,
+            relativePathDataContracts: "../../data-contracts",
+            groupName,
+            metaInfo: params.noMetaInfo ? null : {
+              namespace,
+              groupNames: []
+            }
+          });
+          reservedDataContractNames.forEach((name) => {
+            reservedDataContractNamesMap.set(
+              name,
+              (reservedDataContractNamesMap.get(name) ?? 0) + 1
+            );
+          });
+          if (!filterEndpoint(route)) {
+            continue;
+          }
+          hasFilteredRoutes = true;
+          if (Array.isArray(route.raw.tags)) {
+            route.raw.tags.forEach((tag) => {
+              tagsSet.add(tag);
+            });
+          }
+          const fileName = `${_.kebabCase(route.routeName.usage)}.ts`;
+          fileNamesWithRequestInfo.push(fileName);
+          codegenFs.createFile({
+            path: path.resolve(
+              params.output,
+              _.kebabCase(groupName),
+              "endpoints"
+            ),
+            fileName,
+            withPrefix: false,
+            content: requestInfoPerFileContent
+          });
+        }
+      } else {
+        const {
+          content: requestInfoPerFileContent,
+          reservedDataContractNames
+        } = await allEndpointPerFileTmpl({
+          ...baseTmplParams,
+          routes,
+          relativePathDataContracts: "../data-contracts",
+          groupName,
+          metaInfo: params.noMetaInfo ? null : {
+            namespace,
+            groupNames: []
+          }
+        });
+        reservedDataContractNames.forEach((name) => {
+          reservedDataContractNamesMap.set(
+            name,
+            (reservedDataContractNamesMap.get(name) ?? 0) + 1
+          );
+        });
+        const filteredRoutes = routes.filter(filterEndpoint);
+        hasFilteredRoutes = filteredRoutes.length > 0;
+        if (hasFilteredRoutes) {
+          filteredRoutes.forEach((route) => {
+            if (Array.isArray(route.raw.tags)) {
+              route.raw.tags.forEach((tag) => {
+                tagsSet.add(tag);
+              });
+            }
+          });
+          const fileName = "endpoints.ts";
+          fileNamesWithRequestInfo.push(fileName);
+          codegenFs.createFile({
+            path: groupDirectory,
+            fileName,
+            withPrefix: false,
+            content: requestInfoPerFileContent
+          });
+        }
+      }
+      if (hasFilteredRoutes) {
+        nonEmptyGroups.add(groupName);
+        const exportGroupName = params.formatExportGroupName ? params.formatExportGroupName(_.camelCase(groupName), utils) : _.camelCase(groupName);
+        codegenFs.createFile({
+          path: groupDirectory,
+          fileName: "index.ts",
+          withPrefix: false,
+          content: `${LINTERS_IGNORE}
+export * as ${exportGroupName} from './endpoints';
+`
+        });
+        if (params.outputType === "one-endpoint-per-file") {
+          codegenFs.createFile({
+            path: path.resolve(groupDirectory, "endpoints"),
+            fileName: "index.ts",
+            withPrefix: false,
+            content: await indexTsForEndpointPerFileTmpl({
+              generatedRequestFileNames: fileNamesWithRequestInfo
+            })
+          });
+        }
+        collectedExportFilesFromIndexFile.push(_.kebabCase(groupName));
+      } else {
+        codegenFs.removeDir(
+          path.resolve(params.output, _.kebabCase(groupName))
+        );
+      }
+    }
+  }
+  const metaInfo = !params.noMetaInfo && (namespace ?? (nonEmptyGroups.size > 0 || tagsSet.size > 0)) ? {
+    namespace,
+    groupNames: [...nonEmptyGroups.values()],
+    tags: [...tagsSet.values()]
+  } : null;
+  const excludedDataContractNames = Array.from(
+    reservedDataContractNamesMap.entries()
+  ).filter(([_2, count]) => count === 1).map(([name]) => name);
+  const dataContractsContent = await dataContractsFileTmpl({
+    ...baseTmplParams,
+    excludedDataContractNames
+  });
+  codegenFs.createFile({
+    path: paths.outputDir,
+    fileName: "data-contracts.ts",
+    withPrefix: false,
+    content: dataContractsContent
+  });
+  if (metaInfo) {
+    codegenFs.createFile({
+      path: paths.outputDir,
+      fileName: "meta-info.ts",
+      withPrefix: false,
+      content: await metaInfoTmpl({
+        ...baseTmplParams,
+        metaInfo
+      })
+    });
+  }
+  if (namespace) {
+    codegenFs.createFile({
+      path: paths.outputDir,
+      fileName: "__exports.ts",
+      withPrefix: false,
+      content: await allExportsTmpl({
+        ...baseTmplParams,
+        collectedExportFiles: collectedExportFilesFromIndexFile,
+        metaInfo
+      })
+    });
+    codegenFs.createFile({
+      path: paths.outputDir,
+      fileName: "index.ts",
+      withPrefix: false,
+      content: `${LINTERS_IGNORE}
+export * as ${namespace} from './__exports';
+`
+    });
+  } else {
+    codegenFs.createFile({
+      path: paths.outputDir,
+      fileName: "index.ts",
+      withPrefix: false,
+      content: await allExportsTmpl({
+        ...baseTmplParams,
+        collectedExportFiles: collectedExportFilesFromIndexFile,
+        metaInfo
+      })
+    });
+  }
+  if (params.removeUnusedTypes) {
+    removeUnusedTypes({
+      directory: params.output,
+      keepTypes: params.removeUnusedTypes === true ? void 0 : params.removeUnusedTypes.keepTypes
+    });
+  }
+};
+const defineConfig = (...configs) => {
+  return configs.flat().filter((config) => !!config);
+};
+export {
+  defineConfig,
+  generateApi
+};
+//# sourceMappingURL=cli.js.map