@devbie/apits 0.0.0-stage → 1.0.0

package/dist/cjs/core/generator.js

@@ -0,0 +1,301 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  Generator: () => Generator
+});
+module.exports = __toCommonJS(generator_exports);
+var changeCase = __toESM(require("change-case"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_json5 = __toESM(require("json5"));
+var conso = __toESM(require("../utils/console.js"));
+var import_got = __toESM(require("got"));
+var import_openApiToInterfaces = require("../utils/openApiToInterfaces.js");
+var import_vtilsLite = require("../utils/vtilsLite.js");
+var import_types = require("../types.js");
+var import_utils = require("../utils/utils.js");
+var import_getOutputPath = require("../utils/getOutputPath.js");
+var import_writeRequestClient = __toESM(require("./writeRequestClient.js"));
+function defaultClientImportTemplate(config) {
+  return `import request from './request'`;
+}
+var getDataKeySetStr = (method) => {
+  if (["head", "option", "get"].includes(method.toLowerCase())) {
+    return "params: data";
+  }
+  return "data";
+};
+function handlePathParam(path2) {
+  if (path2.match(/\{(\w+)\}/)) {
+    return `\`${path2.replace(/\{(\w+)\}/g, "${data.$1}")}\``;
+  }
+  return JSON.stringify(path2);
+}
+function isDegradedRequestType(typeCode) {
+  const code = typeCode.replace(/\s+/g, " ").trim();
+  const match = code.match(/^export type \w+ = (.*?);?$/);
+  if (!match)
+    return false;
+  const body = match[1].trim();
+  if (/^(string|unknown|number|boolean|null)$/.test(body))
+    return true;
+  if (/^\{\s*\}$/.test(body))
+    return true;
+  if (/^\{\s*\[\s*\w+\s*:\s*string\s*\]\s*:\s*unknown\s*\}$/.test(body))
+    return true;
+  if (/&\s*(string|unknown)\b/.test(body))
+    return true;
+  return false;
+}
+var DEFAULT_CLIENT_CONFIG_TYPE = "AxiosRequestConfig";
+function defaultRequestFunctionTemplate(props, config) {
+  const { baseURL, requestFunctionName, requestDataTypeName, responseDataTypeName, extendedInterfaceInfo } = props;
+  const clientConfigType = (config == null ? void 0 : config.clientConfigType) || DEFAULT_CLIENT_CONFIG_TYPE;
+  const { req_params, req_query, req_body_type, req_body_multipart, req_body_form } = extendedInterfaceInfo;
+  const hasData = req_params.length || req_query.length || Array.isArray(req_body_form) && req_body_form.length;
+  const method = extendedInterfaceInfo.method.toLowerCase();
+  let finalBaseUrl = "";
+  if (baseURL == null ? void 0 : baseURL.match(/^\[code\]:/)) {
+    finalBaseUrl = baseURL.replace(/^\[code\]:/, "");
+  } else {
+    finalBaseUrl = `"${baseURL}"`;
+  }
+  const isForm = req_body_type === import_types.RequestBodyType.form;
+  const isMultipart = isForm && req_body_multipart === true;
+  const formBuilder = isForm ? `const form = new ${isMultipart ? "FormData" : "URLSearchParams"}();
+    Object.entries(data).forEach(([k, v]) => {
+      if (v == null) return;
+      if (Array.isArray(v)) v.forEach(i => form.append(k, ${isMultipart ? "i" : "String(i)"}));
+      else form.append(k, ${isMultipart ? "v" : "String(v)"});
+    });` : "";
+  const dataExpr = isForm ? "data: form" : getDataKeySetStr(method);
+  return `export const ${requestFunctionName} = (data${hasData ? "" : "?"}: ${requestDataTypeName}${`,extra?:${clientConfigType}`}) => {
+    ${formBuilder}
+    return request.${method}<${requestDataTypeName},${responseDataTypeName}>(${handlePathParam(
+    extendedInterfaceInfo.path
+  )}, {
+      ${dataExpr},
+      ${baseURL ? `baseURL: ${finalBaseUrl},` : ""}
+      ${`...extra`}
+    })
+  }`;
+}
+var Generator = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Whether an input points to a remote http(s) resource. */
+  static isHttpInput(input) {
+    return /^https?:\/\//i.test(input);
+  }
+  /**
+   * Derive a file base name from the input: hostname for URLs, file name
+   * without extension for local paths. Falls back to `api`.
+   */
+  static deriveName(input) {
+    let raw = "";
+    if (Generator.isHttpInput(input)) {
+      try {
+        raw = new URL(input).hostname.replace(/^www\./, "");
+      } catch {
+        raw = "";
+      }
+    } else {
+      raw = import_path.default.basename(input).replace(/\.(json5?|ya?ml)$/i, "");
+    }
+    return changeCase.camelCase(raw) || "api";
+  }
+  /** Parse a raw JSON / JSON5 / YAML document string. */
+  parseSpecDocument(raw) {
+    const head = raw.trimStart();
+    if (head.startsWith("{") || head.startsWith("[")) {
+      return import_json5.default.parse(raw);
+    }
+    return import_js_yaml.default.load(raw);
+  }
+  /**
+   * Load the OpenAPI document from a remote URL or a local file.
+   * Both JSON (.json/.json5) and YAML (.yaml/.yml) are supported.
+   */
+  async loadSpec(input) {
+    if (Generator.isHttpInput(input)) {
+      const res = await import_got.default.get(input, { responseType: "text" });
+      return this.parseSpecDocument(res.body);
+    }
+    const filePath = import_path.default.resolve(input);
+    const raw = await import_fs_extra.default.readFile(filePath, "utf-8");
+    return this.parseSpecDocument(raw);
+  }
+  /**
+   * Generate all code from the OpenAPI document.
+   * @returns map of output file path to file contents
+   */
+  async generate() {
+    var _a;
+    const outputFileList = /* @__PURE__ */ Object.create(null);
+    const { input, name } = this.config;
+    const typesName = name || Generator.deriveName(input);
+    const openApiV3Json = await this.loadSpec(input);
+    const componentsSchemas = ((_a = openApiV3Json.components) == null ? void 0 : _a.schemas) ?? {};
+    const componentsCode = [];
+    await Promise.all(
+      Object.keys(componentsSchemas).map(async (key) => {
+        const code = await (0, import_utils.jsonSchemaToTsCode)({ ...componentsSchemas[key], components: openApiV3Json.components }, key);
+        componentsCode.push(code);
+      })
+    );
+    const allApi = await (0, import_openApiToInterfaces.openApiToInterfaces)(openApiV3Json);
+    let interfaceList = allApi.interfaces;
+    const categoryCode = [...componentsCode];
+    for (let interfaceInfo of interfaceList) {
+      const code = await this.generateInterfaceCode(
+        {
+          ...this.config,
+          components: openApiV3Json.components
+        },
+        interfaceInfo
+      );
+      categoryCode.push(code);
+    }
+    const catOutputFilePath = (0, import_getOutputPath.getOutputFilePath)(this.config, `/${typesName}.ts`);
+    if (categoryCode.length > 0) {
+      outputFileList[catOutputFilePath] = {
+        projectId: typesName,
+        categoryId: typesName,
+        syntheticalConfig: this.config,
+        content: categoryCode
+      };
+    }
+    return outputFileList;
+  }
+  /**
+   * Write all generated files to disk.
+   * @param outputFileList generated files
+   */
+  async write(outputFileList) {
+    const config = this.config || {};
+    await (0, import_writeRequestClient.default)(config);
+    return Promise.all(
+      Object.keys(outputFileList).map(async (outputFilePath) => {
+        const { content, syntheticalConfig } = outputFileList[outputFilePath];
+        const resolvedPath = outputFilePath.replace(/\.js(x)?$/, ".ts$1");
+        const clientImportTemplate = syntheticalConfig.clientImportTemplate || defaultClientImportTemplate;
+        const clientConfigType = syntheticalConfig.clientConfigType || DEFAULT_CLIENT_CONFIG_TYPE;
+        const clientConfigImport = clientConfigType === DEFAULT_CLIENT_CONFIG_TYPE ? "import type { AxiosRequestConfig } from 'axios';" : "";
+        const rawOutputContent = import_vtilsLite.dedent`
+          ${(0, import_utils.topNotesContent)()}
+          ${clientImportTemplate(config)}
+          ${clientConfigImport}
+
+          ${content.join("\n\n").trim()}
+        `;
+        const outputContent = await (0, import_utils.formatContent)(import_vtilsLite.dedent`${rawOutputContent}`, resolvedPath);
+        await import_fs_extra.default.outputFile(resolvedPath, outputContent);
+      })
+    );
+  }
+  /** Generate a request function name from the extended interface info. */
+  requestFunctionNameGen(extendedInterfaceInfo) {
+    const path2 = extendedInterfaceInfo.parsedPath.dir;
+    const method = extendedInterfaceInfo.method;
+    const words = [method, ...path2.split("/"), extendedInterfaceInfo.parsedPath.name].join("_");
+    return changeCase.camelCase(words);
+  }
+  /** Generate TypeScript code (types + request function) for a single API. */
+  async generateInterfaceCode(syntheticalConfig, interfaceInfo) {
+    const extendedInterfaceInfo = {
+      ...interfaceInfo,
+      parsedPath: import_path.default.parse(interfaceInfo.path)
+    };
+    const requestFunctionName = this.requestFunctionNameGen(extendedInterfaceInfo);
+    const requestDataTypeName = changeCase.pascalCase(`${requestFunctionName}Request`);
+    const responseDataTypeName = changeCase.pascalCase(`${requestFunctionName}Response`);
+    const requestDataJsonSchema = (0, import_utils.getRequestDataJsonSchema)(extendedInterfaceInfo);
+    const requestDataType = await (0, import_utils.jsonSchemaToTsCode)(
+      { ...requestDataJsonSchema, components: syntheticalConfig.components },
+      requestDataTypeName
+    );
+    if (isDegradedRequestType(requestDataType)) {
+      conso.warn(
+        `[apits] Request type degraded for ${extendedInterfaceInfo.method.toUpperCase()} ${extendedInterfaceInfo.path} — check backend @Body()/@ApiBody decorator. Generated:
+${requestDataType}`
+      );
+    }
+    const responseDataJsonSchema = (0, import_utils.getResponseDataJsonSchema)(extendedInterfaceInfo);
+    const responseDataType = await (0, import_utils.jsonSchemaToTsCode)(
+      { ...responseDataJsonSchema, components: syntheticalConfig.components },
+      responseDataTypeName
+    );
+    const genComment = (genTitle) => {
+      const escapedTitle = String(extendedInterfaceInfo.title).replace(/\//g, "\\/");
+      return import_vtilsLite.dedent`
+        /**
+         * ${genTitle(escapedTitle)}
+         */
+      `;
+    };
+    const requestFunctionTemplate = defaultRequestFunctionTemplate;
+    const baseURL = syntheticalConfig.baseURL;
+    let baseUrl;
+    try {
+      baseUrl = typeof baseURL === "string" ? baseURL : typeof baseURL === "function" ? baseURL(extendedInterfaceInfo.path) : "";
+    } catch (e) {
+      conso.error(e);
+    }
+    const code = import_vtilsLite.dedent`
+      ${genComment((title) => `${title} request parameters`)}
+      ${requestDataType.trim()}
+
+      ${genComment((title) => `${title} response data`)}
+      ${responseDataType.trim()}
+
+      ${import_vtilsLite.dedent`
+          ${genComment((title) => `${title}`)}
+          ${requestFunctionTemplate(
+      {
+        baseURL: baseUrl,
+        requestFunctionName,
+        requestDataTypeName,
+        responseDataTypeName,
+        extendedInterfaceInfo
+      },
+      syntheticalConfig
+    )}
+        `}
+    `;
+    return code;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Generator
+});

package/dist/cjs/core/writeRequestClient.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "../types.js";
+export default function writeRequestClient(config: Config): Promise<void>;

package/dist/cjs/core/writeRequestClient.js

@@ -0,0 +1,93 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/writeRequestClient.ts
+var writeRequestClient_exports = {};
+__export(writeRequestClient_exports, {
+  default: () => writeRequestClient
+});
+module.exports = __toCommonJS(writeRequestClient_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_vtilsLite = require("../utils/vtilsLite.js");
+var import_getOutputPath = require("../utils/getOutputPath.js");
+var import_utils = require("../utils/utils.js");
+async function writeRequestClient(config) {
+  const { client } = config;
+  if (client === false)
+    return;
+  const rawRequestFunctionFilePath = (0, import_getOutputPath.getOutputFilePath)(config, "request.ts");
+  if (await import_fs_extra.default.pathExists(rawRequestFunctionFilePath)) {
+    return;
+  }
+  const content = `
+  ${(0, import_utils.topNotesContent)()}
+
+  import axios, { AxiosRequestConfig } from 'axios';
+
+  const instance = axios.create({
+    withCredentials: true,
+  });
+
+  // Custom request interceptor.
+  instance.interceptors.request.use((config) => {
+    return { ...config };
+  });
+
+  // Custom response interceptor — return res.data so the generated request
+  // functions receive the response payload directly, matching the RP type.
+  instance.interceptors.response.use((res) => {
+    const { status } = res;
+    if (status >= 200 && status < 300) {
+      return res.data;
+    }
+    return Promise.reject(res);
+  });
+
+  export default {
+    get: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.get<RP>(url, config) as Promise<RP>;
+    },
+    post: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.post<RP>(url, undefined, config) as Promise<RP>;
+    },
+    head: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.head<RP>(url, config) as Promise<RP>;
+    },
+    put: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.put<RP>(url, undefined, config) as Promise<RP>;
+    },
+    patch: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.patch<RP>(url, undefined, config) as Promise<RP>;
+    },
+    delete: <RQ, RP>(url: string, config?: AxiosRequestConfig) => {
+      return instance.delete<RP>(url, config) as Promise<RP>;
+    },
+  };
+`;
+  await import_fs_extra.default.outputFile(rawRequestFunctionFilePath, await (0, import_utils.formatContent)(import_vtilsLite.dedent`${content}`, rawRequestFunctionFilePath));
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./utils/helpers.js";

package/dist/cjs/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./types.js"), module.exports);
+__reExport(src_exports, require("./utils/helpers.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types.js"),
+  ...require("./utils/helpers.js")
+});