@devbie/apits 0.0.0-stage → 1.0.1

package/dist/cjs/utils/helpers.js

@@ -0,0 +1,166 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  FileData: () => FileData,
+  asyncFnArrayOrderRun: () => asyncFnArrayOrderRun,
+  defineConfig: () => defineConfig,
+  parseRequestData: () => parseRequestData,
+  prepare: () => prepare
+});
+module.exports = __toCommonJS(helpers_exports);
+function defineConfig(config) {
+  const configs = config instanceof Array ? config : [config];
+  const final = configs.map((item) => {
+    const client = "client" in item ? item.client : item.clientImportTemplate ? false : true;
+    return {
+      output: "src/api",
+      client,
+      ...item
+    };
+  });
+  return final;
+}
+var FileData = class {
+  /**
+   * File data helper class, unified file upload for web, mini-program and other platforms.
+   *
+   * @param originalFileData Original file data
+   * @param options If using internal getFormData, options will be used by it
+   */
+  constructor(originalFileData, options) {
+    this.originalFileData = originalFileData;
+    this.options = options;
+  }
+  /**
+   * Get original file data.
+   *
+   * @returns Original file data
+   */
+  getOriginalFileData() {
+    return this.originalFileData;
+  }
+  /**
+   * Get options.
+   */
+  getOptions() {
+    return this.options;
+  }
+};
+function parseRequestData(requestData) {
+  const result = {
+    data: {},
+    fileData: {}
+  };
+  if (requestData != null) {
+    if (typeof requestData === "object" && !Array.isArray(requestData)) {
+      Object.keys(requestData).forEach((key) => {
+        if (requestData[key] && requestData[key] instanceof FileData) {
+          result.fileData[key] = requestData[key].getOriginalFileData();
+        } else {
+          result.data[key] = requestData[key];
+        }
+      });
+    } else {
+      result.data = requestData;
+    }
+  }
+  return result;
+}
+function prepare(requestConfig, requestData) {
+  let requestPath = requestConfig.path;
+  const { data, fileData } = parseRequestData(requestData);
+  const dataIsObject = data != null && typeof data === "object" && !Array.isArray(data);
+  if (dataIsObject) {
+    if (Array.isArray(requestConfig.paramNames) && requestConfig.paramNames.length > 0) {
+      Object.keys(data).forEach((key) => {
+        if (requestConfig.paramNames.indexOf(key) >= 0) {
+          requestPath = requestPath.replace(new RegExp(`\\{${key}\\}`, "g"), data[key]).replace(new RegExp(`/:${key}(?=/|$)`, "g"), `/${data[key]}`);
+          delete data[key];
+        }
+      });
+    }
+    let queryString = "";
+    if (Array.isArray(requestConfig.queryNames) && requestConfig.queryNames.length > 0) {
+      Object.keys(data).forEach((key) => {
+        if (requestConfig.queryNames.indexOf(key) >= 0) {
+          if (data[key] != null) {
+            queryString += `${queryString ? "&" : ""}${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`;
+          }
+          delete data[key];
+        }
+      });
+    }
+    if (queryString) {
+      requestPath += `${requestPath.indexOf("?") > -1 ? "&" : "?"}${queryString}`;
+    }
+  }
+  const allData = {
+    ...dataIsObject ? data : {},
+    ...fileData
+  };
+  const getFormData = () => {
+    const useNativeFormData = typeof FormData !== "undefined";
+    const useNodeFormData = !useNativeFormData && // https://github.com/fjc0k/vtils/blob/master/src/utils/inNodeJS.ts
+    typeof global === "object" && typeof global.process === "object" && typeof global.process.versions === "object" && global.process.versions.node != null;
+    const UniFormData = useNativeFormData ? FormData : useNodeFormData ? (
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require("form-data")
+    ) : void 0;
+    if (!UniFormData) {
+      throw new Error("FormData is not supported in the current environment");
+    }
+    const formData = new UniFormData();
+    Object.keys(data).forEach((key) => {
+      formData.append(key, data[key]);
+    });
+    Object.keys(fileData).forEach((key) => {
+      const options = requestData[key].getOptions();
+      formData.append(key, fileData[key], useNativeFormData ? options == null ? void 0 : options.filename : options);
+    });
+    return formData;
+  };
+  return {
+    ...requestConfig,
+    path: requestPath,
+    rawData: requestData,
+    data,
+    hasFileData: fileData && Object.keys(fileData).length > 0,
+    fileData,
+    allData,
+    getFormData
+  };
+}
+var asyncFnArrayOrderRun = async (fns, results) => {
+  if (fns.length) {
+    const res = await fns[0]();
+    const res1 = await asyncFnArrayOrderRun(fns.slice(1), [...results || [], res]);
+    return res1;
+  }
+  return results || [];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileData,
+  asyncFnArrayOrderRun,
+  defineConfig,
+  parseRequestData,
+  prepare
+});

package/dist/cjs/utils/openApiToInterfaces.js

@@ -0,0 +1,229 @@
+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/utils/openApiToInterfaces.ts
+var openApiToInterfaces_exports = {};
+__export(openApiToInterfaces_exports, {
+  openApiToInterfaces: () => openApiToInterfaces
+});
+module.exports = __toCommonJS(openApiToInterfaces_exports);
+var import_types = require("../types.js");
+var import_vtilsLite = require("./vtilsLite.js");
+var conso = __toESM(require("./console.js"));
+function handlePath(p) {
+  if (p === "/")
+    return p;
+  if (p.charAt(0) !== "/")
+    p = `/${p}`;
+  if (p.charAt(p.length - 1) === "/")
+    p = p.slice(0, -1);
+  return p;
+}
+function resolveRef(ref, root) {
+  if (!ref || typeof ref !== "string" || !ref.startsWith("#/") || ref.length <= 2)
+    return null;
+  const parts = ref.slice(2).split("/").filter(Boolean);
+  let node = root;
+  for (const part of parts) {
+    if (node == null)
+      return null;
+    node = node[part];
+  }
+  return node ?? null;
+}
+function isRef(obj) {
+  return obj != null && typeof obj === "object" && "$ref" in obj;
+}
+function handleRequestBody(requestBody, api) {
+  if (!requestBody || typeof requestBody !== "object")
+    return;
+  const content = requestBody.content || {};
+  const jsonContent = content["application/json"];
+  if (jsonContent && jsonContent.schema) {
+    api.req_body_other = JSON.stringify(jsonContent.schema, null, 2);
+    api.req_body_type = import_types.RequestBodyType.json;
+    api.req_body_is_json_schema = true;
+    return;
+  }
+  const multipartContent = content["multipart/form-data"];
+  const formContent = multipartContent || content["application/x-www-form-urlencoded"];
+  if (formContent && formContent.schema) {
+    const schema = formContent.schema;
+    if (isRef(schema))
+      return;
+    const required = schema.required || [];
+    const props = schema.properties || {};
+    for (const name of Object.keys(props)) {
+      const prop = props[name] || {};
+      const arrayItems = Array.isArray(prop.items) ? prop.items[0] : prop.items;
+      const isFileArray = prop.type === "array" && arrayItems && arrayItems.format === "binary";
+      const isFile = prop.format === "binary" || isFileArray;
+      api.req_body_form.push({
+        name,
+        type: isFile ? import_types.RequestFormItemType.file : import_types.RequestFormItemType.text,
+        desc: prop.description || "",
+        example: "",
+        required: required.indexOf(name) > -1 ? import_types.Required.true : import_types.Required.false,
+        ...isFileArray ? { isArray: true } : {},
+        ...Array.isArray(prop.enum) && prop.enum.length ? { enum: prop.enum } : {}
+      });
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      api.req_body_additional = schema.additionalProperties;
+    }
+    api.req_body_type = import_types.RequestBodyType.form;
+    api.req_body_multipart = !!multipartContent;
+  }
+}
+function handleResponse(responses) {
+  if (!responses || typeof responses !== "object")
+    return { body: "", hasSchema: false };
+  const codes = Object.keys(responses);
+  if (codes.length === 0)
+    return { body: "", hasSchema: false };
+  const curCode = codes.indexOf("200") > -1 ? "200" : codes[0];
+  const res = responses[curCode];
+  if (!res || typeof res !== "object") {
+    return { body: "", hasSchema: false };
+  }
+  if (isRef(res))
+    return { body: "", hasSchema: false };
+  const content = res.content;
+  if (content && typeof content === "object") {
+    const mediaType = content["application/json"] || content["application/hal+json"] || content["*/*"];
+    if (mediaType && mediaType.schema) {
+      return {
+        body: JSON.stringify(mediaType.schema, null, 2),
+        hasSchema: true
+      };
+    }
+  }
+  if (res.description)
+    return { body: res.description, hasSchema: false };
+  return { body: "", hasSchema: false };
+}
+function handleOpenApiOperation(operation, path, method, originTags, root) {
+  const api = {
+    title: operation.summary || path,
+    path: handlePath(path),
+    method: method.toUpperCase(),
+    req_params: [],
+    req_body_form: [],
+    req_query: [],
+    req_body_type: import_types.RequestBodyType.raw,
+    req_body_is_json_schema: false,
+    req_body_other: "",
+    res_body_type: import_types.ResponseBodyType.raw,
+    res_body_is_json_schema: false,
+    res_body: ""
+  };
+  api.catname = null;
+  if (Array.isArray(operation.tags)) {
+    for (const tag of operation.tags) {
+      if (/v[0-9.]+/.test(tag))
+        continue;
+      if (originTags.length > 0 && (0, import_vtilsLite.find)(originTags, (item) => item.name === tag)) {
+        api.catname = tag;
+        break;
+      }
+      if (originTags.length === 0) {
+        api.catname = tag;
+        break;
+      }
+    }
+  }
+  if (Array.isArray(operation.parameters)) {
+    for (let param of operation.parameters) {
+      if (isRef(param)) {
+        param = resolveRef(param.$ref, root);
+      }
+      if (!param || typeof param !== "object")
+        continue;
+      const p = param;
+      const paramObj = {
+        name: p.name,
+        desc: p.description || "",
+        type: p.schema ? p.schema.type : p.type,
+        required: p.required ? import_types.Required.true : import_types.Required.false,
+        example: ""
+      };
+      switch (p.in) {
+        case "path":
+          api.req_params.push(paramObj);
+          break;
+        case "query":
+          api.req_query.push(paramObj);
+          break;
+        case "header":
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  const reqBody = operation.requestBody;
+  handleRequestBody(isRef(reqBody) ? void 0 : reqBody, api);
+  const { body: resBody, hasSchema } = handleResponse(operation.responses);
+  api.res_body = resBody;
+  if (hasSchema) {
+    api.res_body_type = import_types.ResponseBodyType.json;
+    api.res_body_is_json_schema = true;
+  } else if (resBody) {
+    api.res_body_type = import_types.ResponseBodyType.raw;
+  }
+  return api;
+}
+async function openApiToInterfaces(data) {
+  if (typeof data === "string" && data) {
+    try {
+      data = JSON.parse(data);
+    } catch (e) {
+      conso.error(`Failed to parse JSON: ${e.message}`);
+    }
+  }
+  const doc = data;
+  const tags = Array.isArray(doc.tags) ? doc.tags : [];
+  const interfaces = [];
+  (0, import_vtilsLite.each)(doc.paths || {}, (pathItem, path) => {
+    delete pathItem.parameters;
+    (0, import_vtilsLite.each)(pathItem, (operation, method) => {
+      if (!operation || typeof operation !== "object")
+        return;
+      try {
+        const iface = handleOpenApiOperation(operation, path, method, tags, doc);
+        interfaces.push(iface);
+      } catch {
+      }
+    });
+  });
+  return { interfaces };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openApiToInterfaces
+});

package/dist/cjs/utils/spinner.js

@@ -0,0 +1,69 @@
+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/utils/spinner.ts
+var spinner_exports = {};
+__export(spinner_exports, {
+  spinnerInstance: () => spinnerInstance
+});
+module.exports = __toCommonJS(spinner_exports);
+var import_ora = __toESM(require("ora"));
+var Spin = class {
+  constructor() {
+    this.spinnerInstance = (0, import_ora.default)();
+  }
+  clear() {
+    this.spinnerInstance.clear();
+  }
+  start(text) {
+    this.spinnerInstance.start(text);
+  }
+  succeed(text) {
+    this.spinnerInstance.succeed(text);
+  }
+  fail(text) {
+    this.spinnerInstance.fail(text);
+  }
+  render() {
+    this.spinnerInstance.render();
+  }
+  frame() {
+    this.spinnerInstance.frame();
+  }
+  info(text) {
+    this.spinnerInstance.info(text);
+  }
+  stop() {
+    this.spinnerInstance.stop();
+  }
+};
+var spinnerInstance = new Spin();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  spinnerInstance
+});

package/dist/cjs/utils/utils.d.ts

@@ -0,0 +1,56 @@
+import { Interface } from "../types.js";
+import { JSONSchema4 } from "json-schema";
+/**
+ * Process a JSON Schema in place.
+ *
+ * @param jsonSchema JSON Schema to process
+ * @returns the processed JSON Schema
+ */
+export declare function processJsonSchema<T extends JSONSchema4>(jsonSchema: T): T;
+/**
+ * Pre-process a schema before compiling it to TypeScript.
+ *
+ * Handles edge cases such as empty enums and normalizes OpenAPI 3.x
+ * `nullable: true` into the JSON Schema union-null form
+ * (`type: [T, 'null']`) so json-schema-to-typescript emits `T | null`.
+ * Component schemas reach the compiler through this preprocessor instead of
+ * `processJsonSchema`, and jstt silently ignores the OpenAPI `nullable`
+ * keyword. Every node here is a fresh copy, so the source document is never
+ * mutated.
+ *
+ * @param schema input JSON Schema
+ * @returns normalized JSON Schema (fresh copy, source is not mutated)
+ */
+export declare function preprocessSchema(schema: JSONSchema4): JSONSchema4;
+/**
+ * Generate a TypeScript type definition from a JSON Schema object.
+ *
+ * @param jsonSchema JSON Schema object
+ * @param typeName type name
+ * @returns TypeScript type definition
+ */
+export declare function jsonSchemaToTsCode(jsonSchema: JSONSchema4, typeName: string): Promise<string>;
+export declare function getRequestDataJsonSchema(interfaceInfo: Interface): JSONSchema4;
+export declare function getResponseDataJsonSchema(interfaceInfo: Interface): JSONSchema4;
+/**
+ * Format generated code with prettier.
+ *
+ * When the output file path is known, the consumer project's own prettier
+ * config is resolved from it (resolveConfig walks up from the file location),
+ * so generated code lands clean under the consumer's `prettier --check`. When
+ * the consumer has no config, pure prettier defaults are used, mirroring what
+ * the consumer's own prettier would produce. `filepath` is always set so
+ * prettier infers the parser from the extension and applies any matching
+ * `overrides` from the consumer config.
+ *
+ * @param content code to format
+ * @param filePath output file path used to resolve the consumer config
+ * @returns formatted code
+ * @see https://prettier.io/docs/en/options.html
+ */
+export declare function formatContent(content: string, filePath?: string): Promise<string>;
+/**
+ * Generate the banner comment placed at the top of every generated file.
+ * @returns banner comment
+ */
+export declare function topNotesContent(): string;