typedapi-client-helpers 0.1.16 → 0.2.0

package/scripts/generate-api-minimal.mjs

@@ -1,7 +1,8 @@
+#!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { generateApi } from "swagger-typescript-api";
+import { generateApi } from "./openapi-generator/index.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -17,79 +18,62 @@ 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 runtimePackageName =
+  path.resolve(cwd) === packageRoot ? "../.." : runtimePackageJson.name;
 
-const swaggerUrl =
-  process.env.SWAGGER_URL ??
-  process.env.npm_config_swagger_url ??
-  config.swaggerUrl;
+const swaggerFile = getStringSetting(
+  process.env.SWAGGER_FILE,
+  process.env.npm_config_swagger_file,
+  config.swaggerFile,
+  config.input,
+);
 
-const defaultSwaggerUrl = "https://localhost:7000/swagger/v1/swagger.json";
+const swaggerUrl = getStringSetting(
+  process.env.SWAGGER_URL,
+  process.env.npm_config_swagger_url,
+  config.swaggerUrl,
+  config.url,
+);
 
-const swaggerBackupFileSetting = getStringSetting(
-  process.env.TYPED_API_SWAGGER_BACKUP_FILE,
-  process.env.npm_config_typed_api_swagger_backup_file,
-  config.typedApiSwaggerBackupFile,
-  "swagger/swagger.backup.json",
+const defaultSwaggerUrl = getStringSetting(
+  config.defaultSwaggerUrl,
+  "https://localhost:7000/swagger/v1/swagger.json",
 );
 
-const swaggerBackupPath = path.resolve(packageRoot, swaggerBackupFileSetting);
+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,
-  process.env.API_OUTPUT ??
-    process.env.npm_config_api_output ??
-    config.apiOutput ??
+  getStringSetting(
+    process.env.API_OUTPUT,
+    process.env.npm_config_api_output,
+    config.apiOutput,
+    config.output,
     "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,
+  "src/defaultApiFunctions",
 );
 
 const defaultFunctionsFilePath = path.resolve(cwd, defaultFunctionsPathSetting);
@@ -108,27 +92,94 @@ const defaultErrorHandlerName = getStringSetting(
   "handleErrors",
 );
 
-function pascalCase(value) {
-  return value
-    .split(/[-_]/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}
+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 toQueryName(methodName) {
-  return `${pascalCase(methodName)}Query`;
+function getStringSetting(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
+    }
+  }
+
+  return undefined;
 }
 
-function cleanDirectory(directory) {
-  if (fs.existsSync(directory)) {
-    fs.rmSync(directory, { recursive: true, force: true });
+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;
+    }
   }
 
-  fs.mkdirSync(directory, { recursive: true });
+  return Boolean(fallback);
 }
 
-
 function fileExists(filePath) {
   try {
     return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
@@ -137,22 +188,22 @@ function fileExists(filePath) {
   }
 }
 
+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}: ${path.relative(packageRoot, swaggerBackupPath)}`,
+    `Updated Swagger backup from ${sourceLabel}: ${displayPath(swaggerBackupPath)}`,
   );
 }
 
 function copySwaggerBackupFromFile(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
-
-  // Validate that the backup is at least JSON. This prevents overwriting a good
-  // backup with an invalid or empty file by accident.
   JSON.parse(content);
-
   writeSwaggerBackup(content, path.relative(cwd, filePath));
 }
 
@@ -166,10 +217,7 @@ async function downloadSwaggerBackupFromUrl(url) {
   }
 
   const content = await response.text();
-
-  // Validate before saving, so a server error page is never stored as backup.
   JSON.parse(content);
-
   writeSwaggerBackup(content, url);
 }
 
@@ -179,7 +227,7 @@ function useBackupSwaggerInput(reason) {
   }
 
   console.warn(
-    `${reason} Using Swagger backup: ${path.relative(packageRoot, swaggerBackupPath)}`,
+    `${reason} Using Swagger backup: ${displayPath(swaggerBackupPath)}`,
   );
 
   return {
@@ -253,103 +301,26 @@ async function resolveSwaggerInput() {
       input: swaggerBackupPath,
       label: defaultSwaggerUrl,
     };
-  } catch (error) {
+  } catch {
     const backupInput = useBackupSwaggerInput(
-      `Default Swagger file was not found and default Swagger URL is not available.`,
+      "Default Swagger file was not found and default Swagger URL is not available.",
     );
 
     if (backupInput) {
       return backupInput;
     }
 
-    throw error;
-  }
-}
-
-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 });
-    }
+    throw new Error(
+      `No Swagger input found. Add swagger/swagger.json, configure swaggerFile, or configure swaggerUrl.`,
+    );
   }
 }
 
-async function generateOpenApiClient(swaggerInput) {
-  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,
-  };
-
-  generateOptions.input = swaggerInput;
-
-  await generateApi(generateOptions);
-
-  removeGeneratedRouteFiles();
-}
-
 function createImportStatement({ names, from, typeOnly = false }) {
-  if (!names || names.length === 0) {
-    return "";
-  }
-
+  const cleanNames = [...new Set(names.filter(Boolean))];
+  if (cleanNames.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));
+  return `${importKeyword} { ${cleanNames.join(", ")} } from ${JSON.stringify(from)};`;
 }
 
 function createDefaultFunctionsFileIfMissing(filePath) {
@@ -364,12 +335,11 @@ function createDefaultFunctionsFileIfMissing(filePath) {
 
   fs.writeFileSync(
     resolvedFilePath,
-    `
-${createImportStatement({
-  names: ["ApiErrorResult", "ApiSuccessResult"],
-  from: "typedapi-client-helpers",
-  typeOnly: true,
-})}
+    `${createImportStatement({
+      names: ["ApiErrorResult", "ApiSuccessResult"],
+      from: runtimePackageName,
+      typeOnly: generatorOptions.useTypeOnlyImports !== false,
+    })}
 
 export function ${defaultSuccessHandlerName}<T>(
   _response: ApiSuccessResult<T>,
@@ -399,13 +369,13 @@ function toRelativeImportPath(fromDirectory, filePath) {
     relativePath = `./${relativePath}`;
   }
 
-  relativePath = relativePath.replaceAll(path.sep, "/");
-
-  return relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+  return relativePath
+    .replaceAll(path.sep, "/")
+    .replace(/\.(ts|tsx|js|jsx)$/, "");
 }
 
 function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 function fileExportsName(source, exportName) {
@@ -446,11 +416,10 @@ function fileExportsName(source, exportName) {
   return false;
 }
 
-function resolveDefaultHandlers(importFromDirectory) {
-  const defaultFunctionsFile =
-    resolveImportFilePath(importFromDirectory, defaultFunctionsFilePath) ??
-    createDefaultFunctionsFileIfMissing(defaultFunctionsFilePath);
-
+function resolveDefaultHandlers() {
+  const defaultFunctionsFile = createDefaultFunctionsFileIfMissing(
+    defaultFunctionsFilePath,
+  );
   const source = fs.readFileSync(defaultFunctionsFile, "utf8");
   const hasSuccessHandler = fileExportsName(source, defaultSuccessHandlerName);
   const hasErrorHandler = fileExportsName(source, defaultErrorHandlerName);
@@ -472,627 +441,31 @@ function resolveDefaultHandlers(importFromDirectory) {
   }
 
   return {
-    defaultFunctionsPath: toRelativeImportPath(
-      importFromDirectory,
-      defaultFunctionsFile,
-    ),
-    defaultSuccessHandlerName,
-    defaultErrorHandlerName,
+    path: toRelativeImportPath(methodsDir, defaultFunctionsFile),
+    success: defaultSuccessHandlerName,
+    error: 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() {
   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",
+  );
 
-  await generateOpenApiClient(swaggerInput.input);
-
-  await fixGeneratedMixedImports(generatedDir);
+  const result = await generateApi({
+    input: swaggerInput.input,
+    output: apiRoot,
+    ...generatorOptions,
+    defaultHandlers: resolveDefaultHandlers(),
+  });
 
-  await createMethodFiles();
+  for (const file of result.files) {
+    console.log(`Generated ${path.relative(cwd, file)}`);
+  }
 
   console.log("API generation completed.");
 }