typedapi-client-helpers 0.1.1

package/scripts/generate-api-minimal.mjs

@@ -0,0 +1,740 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import prettier from "prettier";
+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 ??
+  "https://localhost:7000/swagger/v1/swagger.json";
+
+const swaggerInput = swaggerFile ? path.resolve(cwd, swaggerFile) : swaggerUrl;
+
+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 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) {
+  const formatted = await prettier.format(content, {
+    parser: "typescript",
+  });
+
+  fs.writeFileSync(filePath, formatted);
+}
+
+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);
+}
+
+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}";`;
+}
+
+async function createTypesFile() {
+  const httpClientImport = useTypeOnlyImports
+    ? `import type { HttpResponse, RequestParams } from "../generated/http-client";`
+    : `import { HttpResponse, RequestParams } from "../generated/http-client";`;
+
+  const content = `
+${httpClientImport}
+
+export type ExtractResponse<T> =
+  T extends Promise<HttpResponse<infer R, any>> ? R : never;
+
+export type UnwrapArray<T> = T extends (infer U)[] ? U : T;
+
+export type ExtractDataIfPaginated<T> =
+  T extends { data?: (infer U)[] | null } ? U : T;
+
+export type SortableKeys<T> = keyof UnwrapArray<ExtractDataIfPaginated<T>>;
+
+export type WithoutRequestParams<T extends any[]> =
+  T extends [infer First, ...infer Rest]
+    ? First extends RequestParams
+      ? Rest
+      : [First, ...WithoutRequestParams<Rest>]
+    : [];
+`.trim();
+
+  await writeFormattedFile(path.join(methodsDir, "Types.ts"), content);
+}
+
+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;
+}
+
+async function convertGeneratedUploadMethods(apiDir) {
+  const tsFiles = getAllTsFiles(apiDir);
+  let changedMethods = 0;
+
+  console.log(
+    `Checking ${tsFiles.length} generated TypeScript files for multipart methods...`,
+  );
+
+  for (const filePath of tsFiles) {
+    if (
+      filePath.endsWith("data-contracts.ts") ||
+      filePath.endsWith("http-client.ts")
+    ) {
+      continue;
+    }
+
+    const originalContent = fs.readFileSync(filePath, "utf8");
+
+    const methodRegex =
+      /(\b\w+\s*=\s*\(\s*data\s*:\s*)([^,\n]+)(,\s*params\s*:\s*RequestParams\s*=\s*\{\}\s*,?\s*\)\s*=>\s*this\.request<[\s\S]*?type:\s*ContentType\.FormData,[\s\S]*?\}\);)/g;
+
+    let fileChanges = 0;
+
+    const updatedContent = originalContent.replace(
+      methodRegex,
+      (_match, start, currentType, rest) => {
+        console.log(
+          `  Replacing multipart payload type "${currentType.trim()}" with FormData`,
+        );
+
+        fileChanges++;
+        changedMethods++;
+
+        return `${start}FormData${rest}`;
+      },
+    );
+
+    if (fileChanges > 0) {
+      await writeFormattedFile(filePath, updatedContent);
+
+      console.log(
+        `Updated ${fileChanges} multipart method(s) in ${path.relative(
+          process.cwd(),
+          filePath,
+        )}`,
+      );
+    }
+  }
+
+  if (changedMethods === 0) {
+    throw new Error(
+      "No multipart methods were converted. Check the generated method format and output directory.",
+    );
+  }
+
+  console.log(`Converted ${changedMethods} multipart method(s) to FormData.`);
+}
+
+function isMultipartMethod(source, methodName) {
+  const startPattern = new RegExp(`\\b${methodName}\\s*=\\s*\\(`);
+
+  const startMatch = startPattern.exec(source);
+
+  if (!startMatch) {
+    return false;
+  }
+
+  const nextMethodPattern = /^\s*\w+\s*=\s*\(/gm;
+  nextMethodPattern.lastIndex = startMatch.index + startMatch[0].length;
+
+  const nextMatch = nextMethodPattern.exec(source);
+  const endIndex = nextMatch?.index ?? source.length;
+
+  const methodSource = source.slice(startMatch.index, endIndex);
+
+  return methodSource.includes("type: ContentType.FormData");
+}
+
+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"),
+    };
+  });
+}
+
+async function createMethodFiles() {
+  const generatedFiles = fs
+    .readdirSync(generatedDir)
+    .filter(
+      (file) =>
+        file.endsWith(".ts") &&
+        file !== "http-client.ts" &&
+        file !== "data-contracts.ts" &&
+        !file.endsWith("Route.ts") &&
+        !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 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,
+      });
+    }
+
+    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 hasNonQueryMethods = nonQueryMethods.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,
+  toastOptions?: ToastOptions
+): Promise<ApiResult<ExtractResponse<ReturnType<${className}["${methodName}"]>>>> {
+  return handleApiResponse(
+    () =>
+      ${instanceName}.${methodName}(
+        buildQuery<
+          ${toQueryName(methodName)},
+          UnwrapArray<
+            ExtractDataIfPaginated<
+              ExtractResponse<ReturnType<${className}["${methodName}"]>>
+            >
+          >
+        >(filters, page, pageSize, sortBy, sortDirection)
+      ),
+    toastOptions
+  );
+}
+`.trim();
+        }
+
+        return `
+export async function ${methodName}(
+  query?: ${toQueryName(methodName)},
+  toastOptions?: ToastOptions
+): Promise<ApiResult<ExtractResponse<ReturnType<${className}["${methodName}"]>>>> {
+  return handleApiResponse(
+    () => ${instanceName}.${methodName}(query),
+    toastOptions
+  );
+}
+`.trim();
+      })
+      .join("\n\n");
+
+    const simpleQueryMethodWrappers = simpleQueryMethods
+      .map((methodName) =>
+        `
+export async function ${methodName}(
+  query?: ${toQueryName(methodName)},
+  toastOptions?: ToastOptions
+): Promise<
+  ApiResult<
+    ExtractResponse<
+      ReturnType<
+        ${className}["${methodName}"]
+      >
+    >
+  >
+> {
+  return handleApiResponse(
+    () =>
+      ${instanceName}.${methodName}(query),
+    toastOptions
+  );
+}
+`.trim(),
+      )
+      .join("\n\n");
+
+    const nonQueryMethodWrappers = nonQueryMethods
+      .map(({ methodName, isFormData }) => {
+        if (isFormData) {
+          return `
+export async function ${methodName}(
+  data: Parameters<
+    ${className}["${methodName}"]
+  >[0],
+  toastOptions?: ToastOptions,
+  params?: RequestParams
+): Promise<
+  ApiResult<
+    ExtractResponse<
+      ReturnType<
+        ${className}["${methodName}"]
+      >
+    >
+  >
+> {
+  const formData = toFormData(data);
+
+  return handleApiResponse(
+    () =>
+      ${instanceName}.${methodName}(
+        formData as unknown as Parameters<
+          ${className}["${methodName}"]
+        >[0],
+        params ?? {}
+      ),
+    toastOptions
+  );
+}
+`.trim();
+        }
+
+        return `
+export async function ${methodName}(
+  ...argsWithToast: [
+    ...WithoutRequestParams<
+      Parameters<
+        ${className}["${methodName}"]
+      >
+    >,
+    ToastOptions?,
+    RequestParams?
+  ]
+): Promise<
+  ApiResult<
+    ExtractResponse<
+      ReturnType<
+        ${className}["${methodName}"]
+      >
+    >
+  >
+> {
+  const {
+    args,
+    toastOptions,
+    params
+  } = extractArgsToastsAndParams<
+    WithoutRequestParams<
+      Parameters<
+        ${className}["${methodName}"]
+      >
+    >
+  >(argsWithToast);
+
+  const requestArgs = [
+    ...args,
+    params ?? {}
+  ] as unknown as Parameters<
+    ${className}["${methodName}"]
+  >;
+
+  return handleApiResponse(
+    () =>
+      ${instanceName}.${methodName}(
+        ...requestArgs
+      ),
+    toastOptions
+  );
+}
+`.trim();
+      })
+      .join("\n\n");
+
+    const runtimeValueImportNames = [
+      ...(hasPaginatedMethods && useFilterFormValues ? ["buildQuery"] : []),
+      ...(hasRegularNonQueryMethods ? ["extractArgsToastsAndParams"] : []),
+      ...(hasFormDataMethods ? ["toFormData"] : []),
+      "handleApiResponse",
+    ];
+
+    const runtimeTypeImportNames = [
+      "ApiResult",
+      ...(hasPaginatedMethods && useFilterFormValues
+        ? ["FilterFormValues", "SortDirection"]
+        : []),
+      "ToastOptions",
+    ];
+
+    const localTypeImportNames = [
+      ...(hasPaginatedMethods && useFilterFormValues
+        ? ["ExtractDataIfPaginated", "SortableKeys", "UnwrapArray"]
+        : []),
+      "ExtractResponse",
+      ...(hasRegularNonQueryMethods ? ["WithoutRequestParams"] : []),
+    ];
+
+    const runtimeValueImports = createImportStatement({
+      names: runtimeValueImportNames,
+      from: runtimePackageName,
+    });
+
+    const runtimeTypeImports = createImportStatement({
+      names: runtimeTypeImportNames,
+      from: runtimePackageName,
+      typeOnly: useTypeOnlyImports,
+    });
+
+    const generatedValueImports = createImportStatement({
+      names: [className],
+      from: `../generated/${baseName}`,
+    });
+
+    const generatedTypeImports = hasNonQueryMethods
+      ? createImportStatement({
+          names: ["RequestParams"],
+          from: "../generated/http-client",
+          typeOnly: useTypeOnlyImports,
+        })
+      : "";
+
+    const localTypeImports = createImportStatement({
+      names: localTypeImportNames,
+      from: "./Types",
+      typeOnly: useTypeOnlyImports,
+    });
+
+    const content = `
+${runtimeValueImports}
+
+${runtimeTypeImports}
+
+${generatedValueImports}
+
+${generatedTypeImports}
+
+${localTypeImports}
+
+/* =======================
+   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";
+export * from "./methods/Types";
+
+${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;
+
+    /*
+     * Converts:
+     *
+     * import { ContentType, HttpClient, RequestParams }
+     *   from "./http-client";
+     *
+     * into separate runtime and type imports.
+     */
+    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");
+      },
+    );
+
+    /*
+     * Everything imported from data-contracts by generated API classes
+     * is normally used as a TypeScript type.
+     */
+    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 createTypesFile();
+  await createMethodFiles();
+
+  console.log("API generation completed.");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});