typedapi-client-helpers 0.1.15 → 0.2.0

package/scripts/generate-api-minimal.mjs

@@ -1,959 +1,476 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { generateApi } from "swagger-typescript-api";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const runtimePackageJsonPath = path.resolve(__dirname, "../package.json");
-const runtimePackageJson = JSON.parse(
-  fs.readFileSync(runtimePackageJsonPath, "utf8"),
-);
-
-const consumerPackageJsonPath = path.resolve(process.cwd(), "package.json");
-const consumerPackageJson = fs.existsSync(consumerPackageJsonPath)
-  ? JSON.parse(fs.readFileSync(consumerPackageJsonPath, "utf8"))
-  : {};
-
-const isRunningInsidePackage =
-  path.resolve(process.cwd()) === path.resolve(__dirname, "..");
-
-const runtimePackageName = isRunningInsidePackage
-  ? "../.."
-  : runtimePackageJson.name;
-
-const cwd = process.cwd();
-
-const config = {
-  ...(runtimePackageJson.config ?? {}),
-  ...(consumerPackageJson.config ?? {}),
-};
-
-const swaggerFile =
-  process.env.SWAGGER_FILE ??
-  process.env.npm_config_swagger_file ??
-  config.swaggerFile;
-
-const swaggerUrl =
-  process.env.SWAGGER_URL ??
-  process.env.npm_config_swagger_url ??
-  config.swaggerUrl;
-
-const swaggerInput = swaggerFile
-  ? path.resolve(cwd, swaggerFile)
-  : (swaggerUrl ?? path.resolve(cwd, "swagger/swagger.json"));
-
-const apiRoot = path.resolve(
-  cwd,
-  process.env.API_OUTPUT ??
-    process.env.npm_config_api_output ??
-    config.apiOutput ??
-    "src/api",
-);
-
-const generatedDir = path.join(apiRoot, "generated");
-const methodsDir = path.join(apiRoot, "methods");
-
-const useTypeOnlyImports =
-  process.env.TYPED_API_USE_TYPE_ONLY_IMPORTS === "true" ||
-  process.env.npm_config_typed_api_use_type_only_imports === "true" ||
-  config.typedApiUseTypeOnlyImports === true;
-
-const useFilterFormValues =
-  process.env.TYPED_API_USE_FILTER_FORM_VALUES === "true" ||
-  process.env.npm_config_typed_api_use_filter_form_values === "true" ||
-  config.typedApiUseFilterFormValues === true;
-
-function getStringSetting(...values) {
-  for (const value of values) {
-    if (typeof value === "string" && value.trim() !== "") {
-      return value.trim();
-    }
-  }
-
-  return undefined;
-}
-
-const fallbackDefaultFunctionsPath = "defaultApiFunctions";
-
-const defaultFunctionsPathSetting = getStringSetting(
-  process.env.TYPED_API_DEFAULT_FUNCTIONS_PATH,
-  process.env.npm_config_typed_api_default_functions_path,
-  config.typedApiDefaultFunctionsPath,
-  fallbackDefaultFunctionsPath,
-);
-
-const defaultFunctionsFilePath = path.resolve(cwd, defaultFunctionsPathSetting);
-
-const defaultSuccessHandlerName = getStringSetting(
-  process.env.TYPED_API_DEFAULT_SUCCESS_HANDLER,
-  process.env.npm_config_typed_api_default_success_handler,
-  config.typedApiDefaultSuccessHandler,
-  "handleGoodResult",
-);
-
-const defaultErrorHandlerName = getStringSetting(
-  process.env.TYPED_API_DEFAULT_ERROR_HANDLER,
-  process.env.npm_config_typed_api_default_error_handler,
-  config.typedApiDefaultErrorHandler,
-  "handleErrors",
-);
-
-function pascalCase(value) {
-  return value
-    .split(/[-_]/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}
-
-function toQueryName(methodName) {
-  return `${pascalCase(methodName)}Query`;
-}
-
-function cleanDirectory(directory) {
-  if (fs.existsSync(directory)) {
-    fs.rmSync(directory, { recursive: true, force: true });
-  }
-
-  fs.mkdirSync(directory, { recursive: true });
-}
-
-async function writeFormattedFile(filePath, content) {
-  fs.writeFileSync(filePath, content);
-}
-
-function removeGeneratedRouteFiles() {
-  const files = fs.readdirSync(generatedDir);
-
-  for (const file of files) {
-    if (/route\.ts$/i.test(file)) {
-      fs.rmSync(path.join(generatedDir, file), { force: true });
-    }
-  }
-}
-
-async function generateOpenApiClient() {
-  cleanDirectory(generatedDir);
-  cleanDirectory(methodsDir);
-  fs.mkdirSync(methodsDir, { recursive: true });
-
-  const generateOptions = {
-    name: "Api.ts",
-    output: generatedDir,
-    httpClientType: "fetch",
-    modular: true,
-    cleanOutput: true,
-    generateClient: true,
-    generateRouteTypes: true,
-    extractRequestParams: true,
-    extractRequestBody: true,
-    moduleNameFirstTag: true,
-  };
-
-  if (swaggerFile) {
-    generateOptions.input = swaggerInput;
-  } else {
-    generateOptions.url = swaggerInput;
-  }
-
-  await generateApi(generateOptions);
-
-  removeGeneratedRouteFiles();
-}
-
-function createImportStatement({ names, from, typeOnly = false }) {
-  if (!names || names.length === 0) {
-    return "";
-  }
-
-  const importKeyword = typeOnly ? "import type" : "import";
-
-  return `${importKeyword} {
-${names.map((name) => `  ${name},`).join("\n")}
-} from "${from}";`;
-}
-
-function createAliasedImportStatement({ imports, from }) {
-  if (!imports || imports.length === 0) {
-    return "";
-  }
-
-  return `import {
-${imports
-  .map(({ name, alias }) =>
-    alias && alias !== name ? `  ${name} as ${alias},` : `  ${name},`,
-  )
-  .join("\n")}
-} from "${from}";`;
-}
-
-function resolveImportFilePath(fromDirectory, importPath) {
-  if (!importPath.startsWith(".")) {
-    return undefined;
-  }
-
-  const basePath = path.resolve(fromDirectory, importPath);
-  const candidates = [
-    basePath,
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    `${basePath}.js`,
-    `${basePath}.jsx`,
-    path.join(basePath, "index.ts"),
-    path.join(basePath, "index.tsx"),
-    path.join(basePath, "index.js"),
-    path.join(basePath, "index.jsx"),
-  ];
-
-  return candidates.find((candidate) => fs.existsSync(candidate));
-}
-
-function createDefaultFunctionsFileIfMissing(filePath) {
-  const extension = path.extname(filePath);
-  const resolvedFilePath = extension ? filePath : `${filePath}.ts`;
-
-  if (fs.existsSync(resolvedFilePath)) {
-    return resolvedFilePath;
-  }
-
-  fs.mkdirSync(path.dirname(resolvedFilePath), { recursive: true });
-
-  fs.writeFileSync(
-    resolvedFilePath,
-    `
-${createImportStatement({
-  names: ["ApiErrorResult", "ApiSuccessResult"],
-  from: "typedapi-client-helpers",
-  typeOnly: true,
-})}
-
-export function ${defaultSuccessHandlerName}<T>(
-  _response: ApiSuccessResult<T>,
-): void | Promise<void> {
-  // Add your default success handling here.
-}
-
-export function ${defaultErrorHandlerName}<T>(
-  _error: ApiErrorResult<T>,
-): void | Promise<void> {
-  // Add your default error handling here.
-}
-`,
-  );
-
-  console.log(
-    `Created default API handler file: ${path.relative(process.cwd(), resolvedFilePath)}`,
-  );
-
-  return resolvedFilePath;
-}
-
-function toRelativeImportPath(fromDirectory, filePath) {
-  let relativePath = path.relative(fromDirectory, filePath);
-
-  if (!relativePath.startsWith(".")) {
-    relativePath = `./${relativePath}`;
-  }
-
-  relativePath = relativePath.replaceAll(path.sep, "/");
-
-  return relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
-}
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function fileExportsName(source, exportName) {
-  const escapedName = escapeRegExp(exportName);
-
-  const directExportPattern = new RegExp(
-    `export\\s+(?:async\\s+)?(?:function|const|let|var|class)\\s+${escapedName}\\b`,
-    "m",
-  );
-
-  if (directExportPattern.test(source)) {
-    return true;
-  }
-
-  const namedExportBlocks = source.matchAll(/export\s*\{([\s\S]*?)\}/g);
-
-  for (const match of namedExportBlocks) {
-    const exportedNames = match[1]
-      .split(",")
-      .map((part) => part.trim())
-      .filter(Boolean);
-
-    if (
-      exportedNames.some((part) => {
-        const [localName, aliasName] = part
-          .split(/\s+as\s+/)
-          .map((name) => name.trim());
-
-        return (
-          aliasName === exportName || (!aliasName && localName === exportName)
-        );
-      })
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function resolveDefaultHandlers(importFromDirectory) {
-  const defaultFunctionsFile =
-    resolveImportFilePath(importFromDirectory, defaultFunctionsFilePath) ??
-    createDefaultFunctionsFileIfMissing(defaultFunctionsFilePath);
-
-  const source = fs.readFileSync(defaultFunctionsFile, "utf8");
-  const hasSuccessHandler = fileExportsName(source, defaultSuccessHandlerName);
-  const hasErrorHandler = fileExportsName(source, defaultErrorHandlerName);
-
-  if (!hasSuccessHandler || !hasErrorHandler) {
-    const missingNames = [
-      ...(!hasSuccessHandler ? [defaultSuccessHandlerName] : []),
-      ...(!hasErrorHandler ? [defaultErrorHandlerName] : []),
-    ];
-
-    console.warn(
-      `Default API handlers were not imported because ${path.relative(
-        process.cwd(),
-        defaultFunctionsFile,
-      )} does not export: ${missingNames.join(", ")}.`,
-    );
-
-    return undefined;
-  }
-
-  return {
-    defaultFunctionsPath: toRelativeImportPath(
-      importFromDirectory,
-      defaultFunctionsFile,
-    ),
-    defaultSuccessHandlerName,
-    defaultErrorHandlerName,
-  };
-}
-
-function callbackOptionsExpression(defaultHandlers) {
-  if (defaultHandlers) {
-    return `{
-      onSuccess: onSuccess ?? typedApiDefaultSuccessHandler,
-      onError: onError ?? typedApiDefaultErrorHandler
-    }`;
-  }
-
-  return `{
-      onSuccess,
-      onError
-    }`;
-}
-
-function getAllTsFiles(dir) {
-  let results = [];
-
-  if (!fs.existsSync(dir)) {
-    return results;
-  }
-
-  const list = fs.readdirSync(dir);
-
-  for (const file of list) {
-    const filePath = path.join(dir, file);
-    const stat = fs.statSync(filePath);
-
-    if (stat.isDirectory()) {
-      results = results.concat(getAllTsFiles(filePath));
-    } else if (filePath.endsWith(".ts")) {
-      results.push(filePath);
-    }
-  }
-
-  return results;
-}
-
-function getGeneratedMethods(source) {
-  const methodRegex = /^\s*(\w+)\s*=\s*\(/gm;
-  const matches = [...source.matchAll(methodRegex)];
-
-  return matches.map((match, index) => {
-    const methodName = match[1];
-    const startIndex = match.index ?? 0;
-    const endIndex =
-      index + 1 < matches.length ? matches[index + 1].index : source.length;
-
-    const methodSource = source.slice(startIndex, endIndex);
-
-    return {
-      methodName,
-      methodSource,
-      isFormData: methodSource.includes("type: ContentType.FormData"),
-    };
-  });
-}
-
-function splitTopLevelArguments(value) {
-  const args = [];
-  let current = "";
-  let depth = 0;
-  let quote = "";
-
-  for (let index = 0; index < value.length; index++) {
-    const char = value[index];
-    const previousChar = value[index - 1];
-
-    if (quote) {
-      current += char;
-
-      if (char === quote && previousChar !== "\\") {
-        quote = "";
-      }
-
-      continue;
-    }
-
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      current += char;
-      continue;
-    }
-
-    if (char === "(" || char === "{" || char === "[" || char === "<") {
-      depth++;
-      current += char;
-      continue;
-    }
-
-    if (char === ")" || char === "}" || char === "]" || char === ">") {
-      depth--;
-      current += char;
-      continue;
-    }
-
-    if (char === "," && depth === 0) {
-      if (current.trim()) {
-        args.push(current.trim());
-      }
-
-      current = "";
-      continue;
-    }
-
-    current += char;
-  }
-
-  if (current.trim()) {
-    args.push(current.trim());
-  }
-
-  return args;
-}
-
-function getGeneratedMethodArgumentCount(signatureParams) {
-  const args = splitTopLevelArguments(signatureParams);
-
-  if (args.length === 0) {
-    return 0;
-  }
-
-  const lastArg = args[args.length - 1];
-
-  if (/\bparams\s*:\s*RequestParams\b/.test(lastArg)) {
-    return args.length - 1;
-  }
-
-  return args.length;
-}
-
-async function createMethodFiles() {
-  const defaultHandlers = resolveDefaultHandlers(methodsDir);
-
-  const generatedFiles = fs
-    .readdirSync(generatedDir)
-    .filter(
-      (file) =>
-        file.endsWith(".ts") &&
-        file !== "http-client.ts" &&
-        file !== "data-contracts.ts" &&
-        !/route\.ts$/i.test(file) &&
-        !file.includes(".api"),
-    );
-
-  const methodExports = [];
-
-  for (const file of generatedFiles) {
-    const filePath = path.join(generatedDir, file);
-    const source = fs.readFileSync(filePath, "utf8");
-
-    const baseName = file.replace(".ts", "");
-    const className = baseName.split("-").map(pascalCase).join("");
-
-    const instanceName = `${className.charAt(0).toLowerCase()}${className.slice(1)}Api`;
-
-    const paginatedMethods = [];
-    const simpleQueryMethods = [];
-    const nonQueryMethods = [];
-
-    const generatedMethods = getGeneratedMethods(source);
-
-    for (const generatedMethod of generatedMethods) {
-      const { methodName, methodSource, isFormData } = generatedMethod;
-
-      const signatureRegex = new RegExp(
-        `${methodName}\\s*=\\s*\\(([^)]*)\\)\\s*=>`,
-        "m",
-      );
-
-      const signatureMatch = methodSource.match(signatureRegex);
-
-      if (!signatureMatch) {
-        continue;
-      }
-
-      const params = signatureMatch[1].trim();
-      const methodArgumentCount = getGeneratedMethodArgumentCount(params);
-
-      const returnTypeMatch = methodSource.match(/this\.request<([^,>]+)/m);
-      const returnType = returnTypeMatch?.[1] ?? "";
-
-      const isPaginated =
-        returnType.includes("ApiPaginationResponse") ||
-        returnType.trim().endsWith("[]");
-
-      if (params.startsWith("query")) {
-        if (isPaginated) {
-          paginatedMethods.push(methodName);
-        } else {
-          simpleQueryMethods.push(methodName);
-        }
-
-        continue;
-      }
-
-      nonQueryMethods.push({
-        methodName,
-        isFormData,
-        methodArgumentCount,
-      });
-    }
-
-    const queryTypes = [...paginatedMethods, ...simpleQueryMethods]
-      .map((methodName) =>
-        `
-export type ${toQueryName(methodName)} =
-  NonNullable<
-    Parameters<${className}["${methodName}"]>[0]
-  >;
-`.trim(),
-      )
-      .join("\n\n");
-
-    const hasPaginatedMethods = paginatedMethods.length > 0;
-
-    const hasFormDataMethods = nonQueryMethods.some(
-      ({ isFormData }) => isFormData,
-    );
-
-    const hasRegularNonQueryMethods = nonQueryMethods.some(
-      ({ isFormData }) => !isFormData,
-    );
-
-    const paginatedMethodWrappers = paginatedMethods
-      .map((methodName) => {
-        if (useFilterFormValues) {
-          return `
-export async function ${methodName}(
-  filters: FilterFormValues<${toQueryName(methodName)}>[] = [],
-  page = 1,
-  pageSize = 100,
-  sortBy: SortableKeys<
-    ExtractResponse<ReturnType<${className}["${methodName}"]>>
-  > | null = null,
-  sortDirection?: SortDirection,
-  options: ApiMethodOptions<
-    ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-    ExtractError<ReturnType<${className}["${methodName}"]>>,
-    RequestParams
-  > = {}
-): Promise<ApiResult<ExtractResponse<ReturnType<${className}["${methodName}"]>>>> {
-  const { onSuccess, onError, params } = options;
-
-  return handleApiResponse(
-    () =>
-      ${instanceName}.${methodName}(
-        buildQuery<
-          ${toQueryName(methodName)},
-          UnwrapArray<
-            ExtractDataIfPaginated<
-              ExtractResponse<ReturnType<${className}["${methodName}"]>>
-            >
-          >
-        >(filters, page, pageSize, sortBy, sortDirection),
-        params ?? {}
-      ),
-    ${callbackOptionsExpression(defaultHandlers)}
-  );
-}
-`.trim();
-        }
-
-        return `
-export async function ${methodName}(
-  query?: ${toQueryName(methodName)},
-  options: ApiMethodOptions<
-    ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-    ExtractError<ReturnType<${className}["${methodName}"]>>,
-    RequestParams
-  > = {}
-): Promise<ApiResult<ExtractResponse<ReturnType<${className}["${methodName}"]>>>> {
-  const { onSuccess, onError, params } = options;
-
-  return handleApiResponse(
-    () =>
-      ${instanceName}.${methodName}(
-        (query ?? {}) as ${toQueryName(methodName)},
-        params ?? {}
-      ),
-    ${callbackOptionsExpression(defaultHandlers)}
-  );
-}
-`.trim();
-      })
-      .join("\n\n");
-
-    const simpleQueryMethodWrappers = simpleQueryMethods
-      .map((methodName) =>
-        `
-export async function ${methodName}(
-  query?: ${toQueryName(methodName)},
-  options: ApiMethodOptions<
-    ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-    ExtractError<ReturnType<${className}["${methodName}"]>>,
-    RequestParams
-  > = {}
-): Promise<
-  ApiResult<
-    ExtractResponse<
-      ReturnType<
-        ${className}["${methodName}"]
-      >
-    >
-  >
-> {
-  const { onSuccess, onError, params } = options;
-
-  return handleApiResponse(
-    () =>
-      ${instanceName}.${methodName}(
-        (query ?? {}) as ${toQueryName(methodName)},
-        params ?? {}
-      ),
-    ${callbackOptionsExpression(defaultHandlers)}
-  );
-}
-`.trim(),
-      )
-      .join("\n\n");
-
-    const nonQueryMethodWrappers = nonQueryMethods
-      .map(({ methodName, isFormData, methodArgumentCount }) => {
-        if (isFormData) {
-          return `
-export async function ${methodName}(
-  data: Parameters<
-    ${className}["${methodName}"]
-  >[0],
-  options: ApiMethodOptions<
-    ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-    ExtractError<ReturnType<${className}["${methodName}"]>>,
-    RequestParams
-  > = {}
-): Promise<
-  ApiResult<
-    ExtractResponse<
-      ReturnType<
-        ${className}["${methodName}"]
-      >
-    >
-  >
-> {
-  const { onSuccess, onError, params } = options;
-  const formData = toFormData(data);
-
-  return handleApiResponse(
-    () =>
-      ${instanceName}.${methodName}(
-        formData as unknown as Parameters<
-          ${className}["${methodName}"]
-        >[0],
-        params ?? {}
-      ),
-    ${callbackOptionsExpression(defaultHandlers)}
-  );
-}
-`.trim();
-        }
-
-        return `
-export async function ${methodName}(
-  ...argsWithOptions: [
-    ...ApiMethodArguments<
-      ${className}["${methodName}"],
-      RequestParams
-    >,
-    ApiMethodOptions<
-      ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-      ExtractError<ReturnType<${className}["${methodName}"]>>,
-      RequestParams
-    >?
-  ]
-): Promise<
-  ApiResult<
-    ExtractResponse<
-      ReturnType<
-        ${className}["${methodName}"]
-      >
-    >
-  >
-> {
-  const args = [...argsWithOptions] as unknown[];
-
-  const options =
-    args.length > ${methodArgumentCount}
-      ? (args.pop() as ApiMethodOptions<
-            ExtractResponse<ReturnType<${className}["${methodName}"]>>,
-            ExtractError<ReturnType<${className}["${methodName}"]>>,
-            RequestParams
-          >)
-      : {};
-
-  const { onSuccess, onError, params } = options ?? {};
-
-  const requestArgs = [
-    ...args,
-    params ?? {}
-  ] as unknown as Parameters<
-    ${className}["${methodName}"]
-  >;
-
-  return handleApiResponse(
-    () =>
-      ${instanceName}.${methodName}(
-        ...requestArgs
-      ),
-    ${callbackOptionsExpression(defaultHandlers)}
-  );
-}
-`.trim();
-      })
-      .join("\n\n");
-
-    const runtimeValueImportNames = [
-      ...(hasPaginatedMethods && useFilterFormValues ? ["buildQuery"] : []),
-      ...(hasFormDataMethods ? ["toFormData"] : []),
-      "handleApiResponse",
-    ];
-
-    const runtimeTypeImportNames = [
-      "ApiResult",
-      "ApiMethodOptions",
-      ...(hasRegularNonQueryMethods ? ["ApiMethodArguments"] : []),
-      "ExtractResponse",
-      "ExtractError",
-
-      ...(hasPaginatedMethods && useFilterFormValues
-        ? [
-            "ExtractDataIfPaginated",
-            "FilterFormValues",
-            "SortableKeys",
-            "SortDirection",
-            "UnwrapArray",
-          ]
-        : []),
-    ];
-
-    const runtimeValueImports = createImportStatement({
-      names: runtimeValueImportNames,
-      from: runtimePackageName,
-    });
-
-    const defaultFunctionImports = defaultHandlers
-      ? createAliasedImportStatement({
-          imports: [
-            {
-              name: defaultHandlers.defaultSuccessHandlerName,
-              alias: "typedApiDefaultSuccessHandler",
-            },
-            {
-              name: defaultHandlers.defaultErrorHandlerName,
-              alias: "typedApiDefaultErrorHandler",
-            },
-          ],
-          from: defaultHandlers.defaultFunctionsPath,
-        })
-      : "";
-
-    const runtimeTypeImports = createImportStatement({
-      names: runtimeTypeImportNames,
-      from: runtimePackageName,
-      typeOnly: useTypeOnlyImports,
-    });
-
-    const generatedValueImports = createImportStatement({
-      names: [className],
-      from: `../generated/${baseName}`,
-    });
-
-    const generatedTypeImports =
-      generatedMethods.length > 0
-        ? createImportStatement({
-            names: ["RequestParams"],
-            from: "../generated/http-client",
-            typeOnly: useTypeOnlyImports,
-          })
-        : "";
-
-    const content = `
-${runtimeValueImports}
-
-${defaultFunctionImports}
-
-${runtimeTypeImports}
-
-${generatedValueImports}
-
-${generatedTypeImports}
-
-/* =======================
-   Query Types
-   ======================= */
-${queryTypes}
-
-/* =======================
-   API Instance
-   ======================= */
-const ${instanceName} = new ${className}();
-
-/* =======================
-   Paginated Query Methods
-   ======================= */
-${paginatedMethodWrappers}
-
-/* =======================
-   Simple Query Methods
-   ======================= */
-${simpleQueryMethodWrappers}
-
-/* =======================
-   Non-Query Methods
-   ======================= */
-${nonQueryMethodWrappers}
-`.trim();
-
-    const outputFile = path.join(methodsDir, `${className}.api.ts`);
-
-    await writeFormattedFile(outputFile, content);
-
-    methodExports.push(`export * from "./methods/${className}.api";`);
-  }
-
-  const apiIndexContent = `
-export * from "./generated/data-contracts";
-export * from "./generated/http-client";
-${methodExports.join("\n")}
-`.trim();
-
-  await writeFormattedFile(path.join(apiRoot, "index.ts"), apiIndexContent);
-}
-
-async function fixGeneratedMixedImports(apiDir) {
-  const tsFiles = getAllTsFiles(apiDir);
-
-  for (const filePath of tsFiles) {
-    if (
-      filePath.endsWith("http-client.ts") ||
-      filePath.endsWith("data-contracts.ts")
-    ) {
-      continue;
-    }
-
-    const originalContent = fs.readFileSync(filePath, "utf8");
-    let content = originalContent;
-
-    content = content.replace(
-      /import\s*\{([\s\S]*?)\}\s*from\s*["']\.\/http-client["'];/g,
-      (_match, importsText) => {
-        const importedNames = importsText
-          .split(",")
-          .map((name) => name.trim())
-          .filter(Boolean);
-
-        const typeNames = importedNames.filter(
-          (name) => name === "RequestParams",
-        );
-
-        const valueNames = importedNames.filter(
-          (name) => name !== "RequestParams",
-        );
-
-        const statements = [];
-
-        if (valueNames.length > 0) {
-          statements.push(
-            `import { ${valueNames.join(", ")} } from "./http-client";`,
-          );
-        }
-
-        if (typeNames.length > 0 && useTypeOnlyImports) {
-          statements.push(
-            `import type { ${typeNames.join(", ")} } from "./http-client";`,
-          );
-        } else if (typeNames.length > 0) {
-          statements.push(
-            `import { ${typeNames.join(", ")} } from "./http-client";`,
-          );
-        }
-
-        return statements.join("\n");
-      },
-    );
-
-    if (useTypeOnlyImports) {
-      content = content.replace(
-        /import\s*\{([\s\S]*?)\}\s*from\s*["']\.\/data-contracts["'];/g,
-        (_match, importsText) =>
-          `import type {${importsText}} from "./data-contracts";`,
-      );
-    }
-
-    if (content !== originalContent) {
-      await writeFormattedFile(filePath, content);
-
-      console.log(
-        `Fixed mixed imports in ${path.relative(process.cwd(), filePath)}`,
-      );
-    }
-  }
-}
-
-async function main() {
-  console.log(`Generating API from: ${swaggerInput}`);
-  console.log(`Output folder: ${apiRoot}`);
-
-  await generateOpenApiClient();
-
-  await fixGeneratedMixedImports(generatedDir);
-
-  await createMethodFiles();
-
-  console.log("API generation completed.");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { generateApi } from "./openapi-generator/index.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const packageRoot = path.resolve(__dirname, "..");
+const runtimePackageJsonPath = path.join(packageRoot, "package.json");
+const runtimePackageJson = JSON.parse(
+  fs.readFileSync(runtimePackageJsonPath, "utf8"),
+);
+
+const consumerPackageJsonPath = path.resolve(process.cwd(), "package.json");
+const consumerPackageJson = fs.existsSync(consumerPackageJsonPath)
+  ? JSON.parse(fs.readFileSync(consumerPackageJsonPath, "utf8"))
+  : {};
+
+const cwd = process.cwd();
+const config = {
+  ...(runtimePackageJson.config ?? {}),
+  ...(consumerPackageJson.config ?? {}),
+};
+
+const runtimePackageName =
+  path.resolve(cwd) === packageRoot ? "../.." : runtimePackageJson.name;
+
+const swaggerFile = getStringSetting(
+  process.env.SWAGGER_FILE,
+  process.env.npm_config_swagger_file,
+  config.swaggerFile,
+  config.input,
+);
+
+const swaggerUrl = getStringSetting(
+  process.env.SWAGGER_URL,
+  process.env.npm_config_swagger_url,
+  config.swaggerUrl,
+  config.url,
+);
+
+const defaultSwaggerUrl = getStringSetting(
+  config.defaultSwaggerUrl,
+  "https://localhost:7000/swagger/v1/swagger.json",
+);
+
+const swaggerBackupPath = path.resolve(
+  cwd,
+  getStringSetting(
+    process.env.TYPED_API_SWAGGER_BACKUP_FILE,
+    process.env.npm_config_typed_api_swagger_backup_file,
+    config.typedApiSwaggerBackupFile,
+    "swagger/swagger.backup.json",
+  ),
+);
+
+const apiRoot = path.resolve(
+  cwd,
+  getStringSetting(
+    process.env.API_OUTPUT,
+    process.env.npm_config_api_output,
+    config.apiOutput,
+    config.output,
+    "src/api",
+  ),
+);
+
+const methodsDir = path.join(apiRoot, "methods");
+
+const defaultFunctionsPathSetting = getStringSetting(
+  process.env.TYPED_API_DEFAULT_FUNCTIONS_PATH,
+  process.env.npm_config_typed_api_default_functions_path,
+  config.typedApiDefaultFunctionsPath,
+  "src/defaultApiFunctions",
+);
+
+const defaultFunctionsFilePath = path.resolve(cwd, defaultFunctionsPathSetting);
+
+const defaultSuccessHandlerName = getStringSetting(
+  process.env.TYPED_API_DEFAULT_SUCCESS_HANDLER,
+  process.env.npm_config_typed_api_default_success_handler,
+  config.typedApiDefaultSuccessHandler,
+  "handleGoodResult",
+);
+
+const defaultErrorHandlerName = getStringSetting(
+  process.env.TYPED_API_DEFAULT_ERROR_HANDLER,
+  process.env.npm_config_typed_api_default_error_handler,
+  config.typedApiDefaultErrorHandler,
+  "handleErrors",
+);
+
+const generatorOptions = {
+  cleanOutput: getBooleanSetting(
+    process.env.TYPED_API_CLEAN_OUTPUT,
+    process.env.npm_config_typed_api_clean_output,
+    process.env.npm_config_clean_output,
+    config.typedApiCleanOutput,
+    config.cleanOutput,
+    true,
+  ),
+  moduleNameFirstTag: getBooleanSetting(
+    process.env.TYPED_API_MODULE_NAME_FIRST_TAG,
+    process.env.npm_config_typed_api_module_name_first_tag,
+    process.env.npm_config_module_name_first_tag,
+    config.typedApiModuleNameFirstTag,
+    config.moduleNameFirstTag,
+    true,
+  ),
+  defaultResponseAsSuccess: getBooleanSetting(
+    process.env.TYPED_API_DEFAULT_RESPONSE_AS_SUCCESS,
+    process.env.npm_config_typed_api_default_response_as_success,
+    process.env.npm_config_default_response_as_success,
+    config.typedApiDefaultResponseAsSuccess,
+    config.defaultResponseAsSuccess,
+    false,
+  ),
+  generateUnionEnums: getBooleanSetting(
+    process.env.TYPED_API_GENERATE_UNION_ENUMS,
+    process.env.npm_config_typed_api_generate_union_enums,
+    process.env.npm_config_generate_union_enums,
+    config.typedApiGenerateUnionEnums,
+    config.generateUnionEnums,
+    false,
+  ),
+  enumNamesAsValues: getBooleanSetting(
+    process.env.TYPED_API_ENUM_NAMES_AS_VALUES,
+    process.env.npm_config_typed_api_enum_names_as_values,
+    process.env.npm_config_enum_names_as_values,
+    config.typedApiEnumNamesAsValues,
+    config.enumNamesAsValues,
+    false,
+  ),
+  useTypeOnlyImports: getBooleanSetting(
+    process.env.TYPED_API_USE_TYPE_ONLY_IMPORTS,
+    process.env.npm_config_typed_api_use_type_only_imports,
+    process.env.npm_config_use_type_only_imports,
+    config.typedApiUseTypeOnlyImports,
+    config.useTypeOnlyImports,
+    true,
+  ),
+  useFilterFormValues: getBooleanSetting(
+    process.env.TYPED_API_USE_FILTER_FORM_VALUES,
+    process.env.npm_config_typed_api_use_filter_form_values,
+    config.typedApiUseFilterFormValues,
+    true,
+  ),
+  baseUrl: getStringSetting(
+    process.env.TYPED_API_BASE_URL,
+    process.env.npm_config_typed_api_base_url,
+    config.typedApiBaseUrl,
+  ),
+  runtimePackageName,
+};
+
+function getStringSetting(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
+    }
+  }
+
+  return undefined;
+}
+
+function getBooleanSetting(...values) {
+  const fallback = values[values.length - 1];
+
+  for (const value of values.slice(0, -1)) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string" && value.trim() !== "") {
+      const normalized = value.trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) return true;
+      if (["0", "false", "no", "off"].includes(normalized)) return false;
+    }
+  }
+
+  return Boolean(fallback);
+}
+
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function displayPath(filePath) {
+  return path.relative(cwd, filePath) || ".";
+}
+
+function writeSwaggerBackup(content, sourceLabel) {
+  fs.mkdirSync(path.dirname(swaggerBackupPath), { recursive: true });
+  fs.writeFileSync(swaggerBackupPath, content);
+
+  console.log(
+    `Updated Swagger backup from ${sourceLabel}: ${displayPath(swaggerBackupPath)}`,
+  );
+}
+
+function copySwaggerBackupFromFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  JSON.parse(content);
+  writeSwaggerBackup(content, path.relative(cwd, filePath));
+}
+
+async function downloadSwaggerBackupFromUrl(url) {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(
+      `Swagger URL returned ${response.status} ${response.statusText}: ${url}`,
+    );
+  }
+
+  const content = await response.text();
+  JSON.parse(content);
+  writeSwaggerBackup(content, url);
+}
+
+function useBackupSwaggerInput(reason) {
+  if (!fileExists(swaggerBackupPath)) {
+    return undefined;
+  }
+
+  console.warn(
+    `${reason} Using Swagger backup: ${displayPath(swaggerBackupPath)}`,
+  );
+
+  return {
+    input: swaggerBackupPath,
+    label: swaggerBackupPath,
+  };
+}
+
+async function resolveSwaggerInput() {
+  if (swaggerFile) {
+    const swaggerFilePath = path.resolve(cwd, swaggerFile);
+
+    if (fileExists(swaggerFilePath)) {
+      copySwaggerBackupFromFile(swaggerFilePath);
+
+      return {
+        input: swaggerFilePath,
+        label: swaggerFilePath,
+      };
+    }
+
+    const backupInput = useBackupSwaggerInput(
+      `Swagger file was not found: ${swaggerFilePath}.`,
+    );
+
+    if (backupInput) {
+      return backupInput;
+    }
+
+    throw new Error(
+      `Swagger file was not found and no backup exists: ${swaggerFilePath}`,
+    );
+  }
+
+  if (swaggerUrl) {
+    try {
+      await downloadSwaggerBackupFromUrl(swaggerUrl);
+
+      return {
+        input: swaggerBackupPath,
+        label: swaggerUrl,
+      };
+    } catch (error) {
+      const backupInput = useBackupSwaggerInput(
+        `Swagger URL is not available: ${swaggerUrl}.`,
+      );
+
+      if (backupInput) {
+        return backupInput;
+      }
+
+      throw error;
+    }
+  }
+
+  const defaultSwaggerFile = path.resolve(cwd, "swagger/swagger.json");
+
+  if (fileExists(defaultSwaggerFile)) {
+    copySwaggerBackupFromFile(defaultSwaggerFile);
+
+    return {
+      input: defaultSwaggerFile,
+      label: defaultSwaggerFile,
+    };
+  }
+
+  try {
+    await downloadSwaggerBackupFromUrl(defaultSwaggerUrl);
+
+    return {
+      input: swaggerBackupPath,
+      label: defaultSwaggerUrl,
+    };
+  } catch {
+    const backupInput = useBackupSwaggerInput(
+      "Default Swagger file was not found and default Swagger URL is not available.",
+    );
+
+    if (backupInput) {
+      return backupInput;
+    }
+
+    throw new Error(
+      `No Swagger input found. Add swagger/swagger.json, configure swaggerFile, or configure swaggerUrl.`,
+    );
+  }
+}
+
+function createImportStatement({ names, from, typeOnly = false }) {
+  const cleanNames = [...new Set(names.filter(Boolean))];
+  if (cleanNames.length === 0) return "";
+  const importKeyword = typeOnly ? "import type" : "import";
+  return `${importKeyword} { ${cleanNames.join(", ")} } from ${JSON.stringify(from)};`;
+}
+
+function createDefaultFunctionsFileIfMissing(filePath) {
+  const extension = path.extname(filePath);
+  const resolvedFilePath = extension ? filePath : `${filePath}.ts`;
+
+  if (fs.existsSync(resolvedFilePath)) {
+    return resolvedFilePath;
+  }
+
+  fs.mkdirSync(path.dirname(resolvedFilePath), { recursive: true });
+
+  fs.writeFileSync(
+    resolvedFilePath,
+    `${createImportStatement({
+      names: ["ApiErrorResult", "ApiSuccessResult"],
+      from: runtimePackageName,
+      typeOnly: generatorOptions.useTypeOnlyImports !== false,
+    })}
+
+export function ${defaultSuccessHandlerName}<T>(
+  _response: ApiSuccessResult<T>,
+): void | Promise<void> {
+  // Add your default success handling here.
+}
+
+export function ${defaultErrorHandlerName}<T>(
+  _error: ApiErrorResult<T>,
+): void | Promise<void> {
+  // Add your default error handling here.
+}
+`,
+  );
+
+  console.log(
+    `Created default API handler file: ${path.relative(process.cwd(), resolvedFilePath)}`,
+  );
+
+  return resolvedFilePath;
+}
+
+function toRelativeImportPath(fromDirectory, filePath) {
+  let relativePath = path.relative(fromDirectory, filePath);
+
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+
+  return relativePath
+    .replaceAll(path.sep, "/")
+    .replace(/\.(ts|tsx|js|jsx)$/, "");
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function fileExportsName(source, exportName) {
+  const escapedName = escapeRegExp(exportName);
+
+  const directExportPattern = new RegExp(
+    `export\\s+(?:async\\s+)?(?:function|const|let|var|class)\\s+${escapedName}\\b`,
+    "m",
+  );
+
+  if (directExportPattern.test(source)) {
+    return true;
+  }
+
+  const namedExportBlocks = source.matchAll(/export\s*\{([\s\S]*?)\}/g);
+
+  for (const match of namedExportBlocks) {
+    const exportedNames = match[1]
+      .split(",")
+      .map((part) => part.trim())
+      .filter(Boolean);
+
+    if (
+      exportedNames.some((part) => {
+        const [localName, aliasName] = part
+          .split(/\s+as\s+/)
+          .map((name) => name.trim());
+
+        return (
+          aliasName === exportName || (!aliasName && localName === exportName)
+        );
+      })
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function resolveDefaultHandlers() {
+  const defaultFunctionsFile = createDefaultFunctionsFileIfMissing(
+    defaultFunctionsFilePath,
+  );
+  const source = fs.readFileSync(defaultFunctionsFile, "utf8");
+  const hasSuccessHandler = fileExportsName(source, defaultSuccessHandlerName);
+  const hasErrorHandler = fileExportsName(source, defaultErrorHandlerName);
+
+  if (!hasSuccessHandler || !hasErrorHandler) {
+    const missingNames = [
+      ...(!hasSuccessHandler ? [defaultSuccessHandlerName] : []),
+      ...(!hasErrorHandler ? [defaultErrorHandlerName] : []),
+    ];
+
+    console.warn(
+      `Default API handlers were not imported because ${path.relative(
+        process.cwd(),
+        defaultFunctionsFile,
+      )} does not export: ${missingNames.join(", ")}.`,
+    );
+
+    return undefined;
+  }
+
+  return {
+    path: toRelativeImportPath(methodsDir, defaultFunctionsFile),
+    success: defaultSuccessHandlerName,
+    error: defaultErrorHandlerName,
+  };
+}
+
+async function main() {
+  const swaggerInput = await resolveSwaggerInput();
+
+  console.log(`Generating API from: ${swaggerInput.label}`);
+  console.log(`Output folder: ${apiRoot}`);
+  console.log(
+    "Generator: local typedapi OpenAPI generator, function-only methods",
+  );
+
+  const result = await generateApi({
+    input: swaggerInput.input,
+    output: apiRoot,
+    ...generatorOptions,
+    defaultHandlers: resolveDefaultHandlers(),
+  });
+
+  for (const file of result.files) {
+    console.log(`Generated ${path.relative(cwd, file)}`);
+  }
+
+  console.log("API generation completed.");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});