typedapi-client-helpers 0.1.16 → 0.2.0

package/scripts/openapi-generator/controller-template.mjs

@@ -0,0 +1,246 @@
+import { getOperationTypes, generatedFileHeader } from "./schema.mjs";
+import { pascalCase, propertyKey, sanitizeIdentifier } from "./names.mjs";
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function createImport(names, from, typeOnly = false) {
+  const cleanNames = unique(names).sort((a, b) => a.localeCompare(b));
+  if (cleanNames.length === 0) return "";
+  const keyword = typeOnly ? "import type" : "import";
+  return `${keyword} { ${cleanNames.join(", ")} } from ${JSON.stringify(from)};`;
+}
+
+function pathExpression(routePath, pathParams) {
+  const parts = [];
+  let cursor = 0;
+  const regex = /\{([^}]+)\}/g;
+  let match;
+
+  while ((match = regex.exec(routePath))) {
+    const [placeholder, paramName] = match;
+    const before = routePath.slice(cursor, match.index);
+    if (before) parts.push(JSON.stringify(before));
+    parts.push(sanitizeIdentifier(paramName));
+    cursor = match.index + placeholder.length;
+  }
+
+  const after = routePath.slice(cursor);
+  if (after) parts.push(JSON.stringify(after));
+
+  if (parts.length === 0) {
+    return JSON.stringify(routePath);
+  }
+
+  return parts
+    .map((part) =>
+      /^"/.test(part) ? part.slice(1, -1).replace(/`/g, "\\`") : `\${${part}}`,
+    )
+    .join("")
+    .replace(/^/, "`")
+    .replace(/$/, "`");
+}
+
+function requestFormat(responseContentType, responseType) {
+  if (responseType === "void") return undefined;
+  if (!responseContentType) return undefined;
+  if (responseContentType.includes("json")) return "json";
+  if (responseContentType.startsWith("text/")) return "text";
+  if (
+    responseContentType === "application/octet-stream" ||
+    responseType === "Blob"
+  )
+    return "blob";
+  return undefined;
+}
+
+function contentTypeEnum(contentType) {
+  switch (contentType) {
+    case "application/json":
+      return "ContentType.Json";
+    case "application/vnd.api+json":
+      return "ContentType.JsonApi";
+    case "multipart/form-data":
+      return "ContentType.FormData";
+    case "application/x-www-form-urlencoded":
+      return "ContentType.UrlEncoded";
+    case "text/plain":
+      return "ContentType.Text";
+    default:
+      return contentType?.includes("json") ? "ContentType.Json" : undefined;
+  }
+}
+
+function destructuredParams(operationTypes) {
+  const parameters = [
+    ...operationTypes.pathParams,
+    ...operationTypes.queryParams,
+  ];
+  return parameters.map((parameter) => sanitizeIdentifier(parameter.name));
+}
+
+function queryExpression(operationTypes) {
+  if (!operationTypes.hasQueryParams) return undefined;
+
+  if (!operationTypes.hasPathParams) {
+    return "query";
+  }
+
+  const entries = operationTypes.queryParams.map((parameter) => {
+    const identifier = sanitizeIdentifier(parameter.name);
+    return `${JSON.stringify(parameter.name)}: ${identifier}`;
+  });
+
+  return `{ ${entries.join(", ")} }`;
+}
+
+function methodArguments(operationTypes) {
+  const args = [];
+
+  if (operationTypes.paramsTypeName) {
+    if (operationTypes.hasPathParams) {
+      args.push(
+        `{ ${destructuredParams(operationTypes).join(", ")} }: ${operationTypes.paramsTypeName}`,
+      );
+    } else {
+      args.push(`query: ${operationTypes.paramsTypeName} = {}`);
+    }
+  }
+
+  if (operationTypes.bodyType) {
+    args.push(`data: ${operationTypes.bodyType}`);
+  }
+
+  args.push("params: RequestParams = {}");
+  return args.join(", ");
+}
+
+function createMethod(operationInfo, operationTypes) {
+  const requestItems = [
+    `path: ${pathExpression(operationInfo.routePath, operationTypes.pathParams)}`,
+    `method: ${JSON.stringify(operationInfo.method)}`,
+  ];
+
+  const query = queryExpression(operationTypes);
+  if (query) requestItems.push(`query: ${query}`);
+
+  if (operationTypes.bodyType) {
+    requestItems.push("body: data");
+  }
+
+  const type = contentTypeEnum(operationTypes.contentType);
+  if (type) requestItems.push(`type: ${type}`);
+
+  const format = requestFormat(
+    operationTypes.responseContentType,
+    operationTypes.responseType,
+  );
+  if (format) requestItems.push(`format: ${JSON.stringify(format)}`);
+
+  requestItems.push("...params");
+
+  const description =
+    operationInfo.operation.description ||
+    operationInfo.operation.summary ||
+    "No description";
+  const tags = (operationInfo.operation.tags ?? []).join(", ");
+  const requestItemsText = requestItems
+    .map((item) => `      ${item},`)
+    .join("\n");
+
+  return `
+  /**
+   * ${description.replace(/\n/g, "\n   * ")}
+   *
+   * @tags ${tags}
+   * @name ${operationTypes.operationId}
+   * @request ${operationInfo.method}:${operationInfo.routePath}
+   */
+  ${operationTypes.methodName} = (${methodArguments(operationTypes)}): Promise<HttpResponse<${operationTypes.responseType}, any>> =>
+    this.request<${operationTypes.responseType}, any>({
+${requestItemsText}
+    });`.trimEnd();
+}
+
+export function generateController(
+  openApi,
+  controllerName,
+  operations,
+  options = {},
+) {
+  const dataContractImports = [];
+  const methods = [];
+  let needsContentType = false;
+
+  for (const operationInfo of operations) {
+    const operationTypes = getOperationTypes(openApi, operationInfo, options);
+    if (!operationTypes.operationId || !operationTypes.methodName) continue;
+
+    if (operationTypes.paramsTypeName)
+      dataContractImports.push(operationTypes.paramsTypeName);
+    if (
+      operationTypes.bodyType &&
+      operationTypes.bodyType !== "Blob" &&
+      operationTypes.bodyType !== "File"
+    ) {
+      dataContractImports.push(operationTypes.bodyType);
+    }
+    if (!isPrimitiveType(operationTypes.responseType)) {
+      dataContractImports.push(
+        ...extractTopLevelTypeNames(operationTypes.responseType),
+      );
+    }
+    if (contentTypeEnum(operationTypes.contentType)) needsContentType = true;
+
+    methods.push(createMethod(operationInfo, operationTypes));
+  }
+
+  const useTypeOnlyImports = options.useTypeOnlyImports !== false;
+  const imports = [
+    generatedFileHeader(),
+    createImport(
+      [...(needsContentType ? ["ContentType"] : []), "HttpClient"],
+      "../http-client",
+    ),
+    createImport(
+      ["HttpResponse", "RequestParams"],
+      "../http-client",
+      useTypeOnlyImports,
+    ),
+    createImport(dataContractImports, "../data-contracts", useTypeOnlyImports),
+  ].filter(Boolean);
+
+  return `${imports.join("\n")}\n\nexport class ${controllerName}<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {\n${methods.map((method) => `${method}\n`).join("\n")}\n}\n`;
+}
+
+function isPrimitiveType(type) {
+  return /^(void|any|unknown|string|number|boolean|Blob|File|Record<)/.test(
+    type,
+  );
+}
+
+function extractTopLevelTypeNames(type) {
+  const withoutLiterals = type.replace(/"(?:\\.|[^"])*"|'(?:\\.|[^'])*'/g, "");
+  const matches = withoutLiterals.match(/\b[A-Z][A-Za-z0-9_]*\b/g) ?? [];
+  return matches.filter(
+    (name) =>
+      !["Array", "Record", "Promise", "HttpResponse", "Blob", "File"].includes(
+        name,
+      ),
+  );
+}
+
+export function controllerNameForOperation(operationInfo, options = {}) {
+  if (options.moduleNameFirstTag !== false) {
+    const [tag] = operationInfo.operation.tags ?? [];
+    if (tag) return pascalCase(tag, "Default");
+  }
+
+  const firstPathPart =
+    operationInfo.routePath.split("/").filter(Boolean)[1] ??
+    operationInfo.routePath.split("/").filter(Boolean)[0] ??
+    "Default";
+
+  return pascalCase(firstPathPart, "Default");
+}

package/scripts/openapi-generator/http-client-template.mjs

@@ -0,0 +1,34 @@
+import { generatedFileHeader } from "./schema.mjs";
+
+export function generateHttpClient(openApi, options = {}) {
+  const baseUrl = options.baseUrl ?? openApi.servers?.[0]?.url ?? "";
+  const runtimePackageName =
+    options.runtimePackageName ?? "typedapi-client-helpers";
+
+  return `${generatedFileHeader()}
+
+import { createApiClient } from ${JSON.stringify(runtimePackageName)};
+
+export { ContentType } from ${JSON.stringify(runtimePackageName)};
+
+export type {
+  ApiConfig,
+  CancelToken,
+  FullRequestParams,
+  HttpResponse,
+  QueryParamsType,
+  RequestParams,
+  ResponseFormat,
+  RuntimeRequestParams,
+} from ${JSON.stringify(runtimePackageName)};
+
+const apiClient = createApiClient({
+  baseUrl: ${JSON.stringify(baseUrl)},
+});
+
+export const configureApiClient = apiClient.configureApiClient;
+export const setSecurityData = apiClient.setSecurityData;
+export const abortRequest = apiClient.abortRequest;
+export const request = apiClient.request;
+`;
+}

package/scripts/openapi-generator/index.mjs

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import { collectOperations } from "./openapi-utils.mjs";
+import { generateDataContracts } from "./schema.mjs";
+import { generateHttpClient } from "./http-client-template.mjs";
+import {
+  controllerNameForOperation,
+  generateMethodFile,
+  methodFileNameForController,
+} from "./method-template.mjs";
+
+export async function generateApi(options) {
+  const inputPath = path.resolve(options.input);
+  const output = path.resolve(options.output);
+  const openApi = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+
+  if (!openApi.paths || typeof openApi.paths !== "object") {
+    throw new Error(
+      "The OpenAPI document does not contain a valid paths object.",
+    );
+  }
+
+  const generatedDir = path.join(output, "generated");
+  const methodsDir = path.join(output, "methods");
+
+  if (options.cleanOutput !== false) {
+    cleanApiOutput(output);
+  }
+
+  fs.mkdirSync(generatedDir, { recursive: true });
+  fs.mkdirSync(methodsDir, { recursive: true });
+
+  const operations = collectOperations(openApi).filter(
+    (operationInfo) => operationInfo.operation?.operationId,
+  );
+
+  const normalizedOptions = {
+    moduleNameFirstTag: options.moduleNameFirstTag !== false,
+    defaultResponseAsSuccess: Boolean(options.defaultResponseAsSuccess),
+    generateUnionEnums: Boolean(options.generateUnionEnums),
+    enumNamesAsValues: Boolean(options.enumNamesAsValues),
+    useTypeOnlyImports: options.useTypeOnlyImports !== false,
+    useFilterFormValues: options.useFilterFormValues !== false,
+    baseUrl: options.baseUrl,
+    runtimePackageName: options.runtimePackageName,
+    defaultHandlers: options.defaultHandlers,
+  };
+
+  fs.writeFileSync(
+    path.join(generatedDir, "data-contracts.ts"),
+    generateDataContracts(openApi, operations, normalizedOptions),
+  );
+
+  fs.writeFileSync(
+    path.join(generatedDir, "http-client.ts"),
+    generateHttpClient(openApi, normalizedOptions),
+  );
+
+  const controllers = new Map();
+  for (const operationInfo of operations) {
+    const controllerName = controllerNameForOperation(
+      operationInfo,
+      normalizedOptions,
+    );
+    const controllerOperations = controllers.get(controllerName) ?? [];
+    controllerOperations.push(operationInfo);
+    controllers.set(controllerName, controllerOperations);
+  }
+
+  const controllerNames = [...controllers.keys()].sort((a, b) =>
+    a.localeCompare(b),
+  );
+
+  for (const controllerName of controllerNames) {
+    fs.writeFileSync(
+      path.join(methodsDir, methodFileNameForController(controllerName)),
+      generateMethodFile(
+        openApi,
+        controllerName,
+        controllers.get(controllerName),
+        normalizedOptions,
+      ),
+    );
+  }
+
+
+  return {
+    files: [
+      path.join(generatedDir, "data-contracts.ts"),
+      path.join(generatedDir, "http-client.ts"),
+      ...controllerNames.map((controllerName) =>
+        path.join(methodsDir, methodFileNameForController(controllerName)),
+      ),
+    ],
+  };
+}
+
+function cleanApiOutput(output) {
+  const removable = [
+    path.join(output, "controllers"),
+    path.join(output, "generated"),
+    path.join(output, "methods"),
+    path.join(output, "data-contracts.ts"),
+    path.join(output, "http-client.ts"),
+    path.join(output, "index.ts"),
+  ];
+
+  for (const item of removable) {
+    if (fs.existsSync(item)) {
+      fs.rmSync(item, { recursive: true, force: true });
+    }
+  }
+}