@devbie/apits 0.0.0-stage → 1.0.0

package/dist/cjs/utils/utils.js

@@ -0,0 +1,355 @@
+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/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  formatContent: () => formatContent,
+  getRequestDataJsonSchema: () => getRequestDataJsonSchema,
+  getResponseDataJsonSchema: () => getResponseDataJsonSchema,
+  jsonSchemaToTsCode: () => jsonSchemaToTsCode,
+  preprocessSchema: () => preprocessSchema,
+  processJsonSchema: () => processJsonSchema,
+  topNotesContent: () => topNotesContent
+});
+module.exports = __toCommonJS(utils_exports);
+var import_vtilsLite = require("./vtilsLite.js");
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var import_prettier = require("prettier");
+var import_types = require("../types.js");
+function upperFirst(value) {
+  return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
+}
+function processJsonSchema(jsonSchema) {
+  if (!(0, import_vtilsLite.isObject)(jsonSchema))
+    return jsonSchema;
+  delete jsonSchema.title;
+  delete jsonSchema.id;
+  delete jsonSchema.minItems;
+  delete jsonSchema.maxItems;
+  delete jsonSchema.default;
+  if (jsonSchema.nullable === true) {
+    if (jsonSchema.type) {
+      const types = (0, import_vtilsLite.castArray)(jsonSchema.type).filter((t) => t !== "null");
+      if (!types.includes("null"))
+        types.push("null");
+      jsonSchema.type = types.length === 1 ? types[0] : types;
+    } else if (jsonSchema.enum && Array.isArray(jsonSchema.enum)) {
+      if (!jsonSchema.enum.includes(null)) {
+        jsonSchema.enum = [...jsonSchema.enum, null];
+      }
+    }
+    delete jsonSchema.nullable;
+  }
+  if (jsonSchema.type) {
+    const isMultiple = Array.isArray(jsonSchema.type);
+    const types = (0, import_vtilsLite.castArray)(jsonSchema.type).map((type) => {
+      type = type.toLowerCase();
+      type = {
+        int: "integer"
+      }[type] || type;
+      return type;
+    });
+    jsonSchema.type = isMultiple ? types : types[0];
+  }
+  if ((0, import_vtilsLite.isArray)(jsonSchema.properties)) {
+    jsonSchema.properties = jsonSchema.properties.reduce(
+      (props, js) => {
+        props[js.name] = js;
+        return props;
+      },
+      {}
+    );
+  }
+  if (jsonSchema.properties) {
+    (0, import_vtilsLite.forOwn)(jsonSchema.properties, (_, prop) => {
+      const propDef = jsonSchema.properties[prop];
+      delete jsonSchema.properties[prop];
+      jsonSchema.properties[prop.trim()] = propDef;
+    });
+    jsonSchema.required = jsonSchema.required && jsonSchema.required.map((prop) => prop.trim());
+  }
+  if (jsonSchema.properties) {
+    (0, import_vtilsLite.forOwn)(jsonSchema.properties, processJsonSchema);
+  }
+  if (jsonSchema.items) {
+    (0, import_vtilsLite.castArray)(jsonSchema.items).forEach(processJsonSchema);
+  }
+  if (jsonSchema.oneOf) {
+    jsonSchema.oneOf.forEach(processJsonSchema);
+  }
+  if (jsonSchema.anyOf) {
+    jsonSchema.anyOf.forEach(processJsonSchema);
+  }
+  if (jsonSchema.allOf) {
+    jsonSchema.allOf.forEach(processJsonSchema);
+  }
+  return jsonSchema;
+}
+function jsonSchemaStringToJsonSchema(str) {
+  return processJsonSchema(JSON.parse(str));
+}
+function propDefinitionsToJsonSchema(propDefinitions) {
+  return processJsonSchema({
+    type: "object",
+    required: propDefinitions.reduce((res, prop) => {
+      if (prop.required) {
+        res.push(prop.name);
+      }
+      return res;
+    }, []),
+    properties: propDefinitions.reduce((res, prop) => {
+      res[prop.name] = {
+        type: prop.type,
+        description: prop.comment,
+        // File fields emit the native DOM `File` type (or `File[]` for
+        // multi-file arrays) so generated code has no dangling reference
+        // to the generator-internal `FileData` class. Non-file fields with
+        // an enum constraint emit a literal union.
+        ...prop.type === "file" ? { tsType: prop.isArray ? "File[]" : "File" } : Array.isArray(prop.enum) && prop.enum.length ? { enum: prop.enum } : {}
+      };
+      return res;
+    }, {})
+  });
+}
+function preprocessSchema(schema) {
+  if (!(0, import_vtilsLite.isObject)(schema)) {
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map(preprocessSchema);
+  }
+  const processed = { ...schema };
+  if (processed.enum && Array.isArray(processed.enum) && processed.enum.length === 0) {
+    delete processed.enum;
+  }
+  if (processed.nullable === true) {
+    if (processed.type) {
+      const typeList = (0, import_vtilsLite.castArray)(processed.type).filter((typeName) => typeName !== "null");
+      typeList.push("null");
+      processed.type = typeList.length === 1 ? typeList[0] : typeList;
+    } else if (Array.isArray(processed.enum)) {
+      if (!processed.enum.includes(null))
+        processed.enum = [...processed.enum, null];
+    }
+    delete processed.nullable;
+  }
+  for (const key in processed) {
+    if (processed.hasOwnProperty(key)) {
+      processed[key] = preprocessSchema(processed[key]);
+    }
+  }
+  return processed;
+}
+function jsonSchemaTypeToTs(propSchema) {
+  if (!propSchema || typeof propSchema !== "object") {
+    return "unknown";
+  }
+  if (propSchema.tsType) {
+    return propSchema.tsType;
+  }
+  if (propSchema.enum && Array.isArray(propSchema.enum) && propSchema.enum.length) {
+    return propSchema.enum.map((v) => v === null ? "null" : `'${String(v).replace(/'/g, "\\'")}'`).join(" | ");
+  }
+  switch (propSchema.type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "null":
+      return "null";
+    case "array": {
+      const itemSchema = Array.isArray(propSchema.items) ? propSchema.items[0] : propSchema.items;
+      const itemTs = itemSchema && (itemSchema.tsType || jsonSchemaTypeToTs(itemSchema));
+      return itemTs ? `${itemTs}[]` : "any[]";
+    }
+    case "object":
+    case void 0:
+    default:
+      return "unknown";
+  }
+}
+async function jsonSchemaToTsCode(jsonSchema, typeName) {
+  jsonSchema = preprocessSchema(jsonSchema);
+  typeName = upperFirst(typeName);
+  if ((0, import_vtilsLite.isEmpty)(jsonSchema)) {
+    return `export interface ${typeName} {}`;
+  }
+  if (jsonSchema.__is_any__) {
+    delete jsonSchema.__is_any__;
+    return `export type ${typeName} = any`;
+  }
+  function rewriteRefs(obj) {
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        if (key === "$ref" && typeof obj[key] === "string") {
+          let refValue = obj[key];
+          if (refValue.startsWith("#components")) {
+            refValue = refValue.replace("#components", "#/components");
+          }
+          if (refValue.startsWith("#/components/schemas/")) {
+            const interfaceName = refValue.replace("#/components/schemas/", "");
+            obj["tsType"] = upperFirst(interfaceName);
+            if (obj.properties) {
+              const requiredArr = Array.isArray(obj.required) ? obj.required : [];
+              const propParts = [];
+              Object.keys(obj.properties).forEach((key2) => {
+                const propSchema = obj.properties[key2];
+                const tsType = propSchema.tsType || jsonSchemaTypeToTs(propSchema);
+                const optional = requiredArr.includes(key2) ? "" : "?";
+                propParts.push(`${key2}${optional}: ${tsType}`);
+              });
+              obj["tsType"] += ` & { ${propParts.join("; ")} }`;
+            }
+            delete obj["$ref"];
+          }
+        } else if (typeof obj[key] === "object" && obj[key] !== null) {
+          rewriteRefs(obj[key]);
+        }
+      }
+    }
+  }
+  rewriteRefs(jsonSchema);
+  const fakeTypeName = "THISISAFAKETYPENAME";
+  const code = await (0, import_json_schema_to_typescript.compile)(jsonSchema, fakeTypeName, {
+    bannerComment: "",
+    additionalProperties: false,
+    declareExternallyReferenced: false
+  });
+  delete jsonSchema.id;
+  return code.replace(fakeTypeName, typeName).trim();
+}
+function getRequestDataJsonSchema(interfaceInfo) {
+  let jsonSchema;
+  switch (interfaceInfo.req_body_type) {
+    case import_types.RequestBodyType.form:
+      jsonSchema = propDefinitionsToJsonSchema(
+        interfaceInfo.req_body_form.map((item) => ({
+          name: item.name,
+          required: item.required === import_types.Required.true,
+          type: item.type === import_types.RequestFormItemType.file ? "file" : "string",
+          comment: item.desc,
+          // Carry multi-file and enum markers from the OAS3 multipart schema
+          // expansion so propDefinitionsToJsonSchema can emit `File[]` and
+          // literal unions instead of collapsing every field to `string`.
+          ...item.isArray ? { isArray: true } : {},
+          ...Array.isArray(item.enum) && item.enum.length ? { enum: item.enum } : {}
+        }))
+      );
+      break;
+    case import_types.RequestBodyType.json:
+      if (interfaceInfo.req_body_other) {
+        jsonSchema = jsonSchemaStringToJsonSchema(interfaceInfo.req_body_other);
+      }
+      break;
+    default:
+      break;
+  }
+  if (jsonSchema && jsonSchema.type && jsonSchema.type !== "object" && !jsonSchema.properties && !jsonSchema.$ref && !jsonSchema.oneOf && !jsonSchema.anyOf && !jsonSchema.allOf) {
+    delete jsonSchema.type;
+    delete jsonSchema.tsType;
+  }
+  if ((0, import_vtilsLite.isArray)(interfaceInfo.req_query) && interfaceInfo.req_query.length) {
+    const queryJsonSchema = propDefinitionsToJsonSchema(
+      interfaceInfo.req_query.map((item) => ({
+        name: item.name,
+        required: item.required === import_types.Required.true,
+        type: item.type || "any",
+        // `object` resolves to `{}`, which causes declaration issues, so strip it for now
+        comment: item.desc
+      }))
+    );
+    if (jsonSchema) {
+      jsonSchema.properties = {
+        ...jsonSchema.properties,
+        ...queryJsonSchema.properties
+      };
+      jsonSchema.required = [
+        ...jsonSchema.required || [],
+        ...queryJsonSchema.required || []
+      ];
+    } else {
+      jsonSchema = queryJsonSchema;
+    }
+  }
+  if ((0, import_vtilsLite.isArray)(interfaceInfo.req_params) && interfaceInfo.req_params.length) {
+    const paramsJsonSchema = propDefinitionsToJsonSchema(
+      interfaceInfo.req_params.map((item) => ({
+        name: item.name,
+        required: true,
+        type: item.type || "string",
+        comment: item.desc
+      }))
+    );
+    if (jsonSchema) {
+      jsonSchema.properties = {
+        ...jsonSchema.properties,
+        ...paramsJsonSchema.properties
+      };
+      jsonSchema.required = [
+        ...jsonSchema.required || [],
+        ...paramsJsonSchema.required || []
+      ];
+    } else {
+      jsonSchema = paramsJsonSchema;
+    }
+  }
+  return jsonSchema;
+}
+function getResponseDataJsonSchema(interfaceInfo) {
+  let jsonSchema = {};
+  switch (interfaceInfo.res_body_type) {
+    case import_types.ResponseBodyType.json:
+      if (interfaceInfo.res_body) {
+        jsonSchema = jsonSchemaStringToJsonSchema(interfaceInfo.res_body);
+      }
+      break;
+    default:
+      jsonSchema = { __is_any__: true };
+      break;
+  }
+  return jsonSchema;
+}
+async function formatContent(content, filePath) {
+  if (!filePath) {
+    return (0, import_prettier.format)(content, { parser: "babel-ts" });
+  }
+  const consumerConfig = await (0, import_prettier.resolveConfig)(filePath) ?? {};
+  return (0, import_prettier.format)(content, { ...consumerConfig, filepath: filePath });
+}
+function topNotesContent() {
+  return `
+  /**
+   * Created By apits-gen
+   */
+
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatContent,
+  getRequestDataJsonSchema,
+  getResponseDataJsonSchema,
+  jsonSchemaToTsCode,
+  preprocessSchema,
+  processJsonSchema,
+  topNotesContent
+});

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

@@ -0,0 +1,55 @@
+/**
+ * Local replacements for the small subset of `vtils` helpers used by this
+ * project. `vtils` pulls in several deprecated dependencies (cuid, uuid,
+ * tough-cookie@0.12.1 with a ReDoS advisory) and is otherwise unmaintained,
+ * so these minimal local implementations keep the dependency tree clean.
+ *
+ * Behavior matches the upstream vtils functions for the call sites in this
+ * repository only; no attempt is made to be a drop-in replacement for the
+ * full vtils API.
+ */
+/**
+ * Remove `undefined` from a type. Equivalent to vtils's `Defined<T>`.
+ */
+export type Defined<T> = Exclude<T, undefined>;
+/**
+ * Wrap a value in an array unless it is already an array.
+ */
+export declare function castArray<T>(value: T | T[]): T[];
+/**
+ * `Array.isArray` alias, kept for import symmetry with the other helpers.
+ */
+export declare const isArray: (arg: any) => arg is any[];
+/**
+ * Check whether a value is a plain object (not null, not an array, not a
+ * function, not a primitive). Matches vtils `isObject` for the JSON-Schema
+ * values used in this project.
+ */
+export declare function isObject(value: any): value is Record<string, any>;
+/**
+ * Check whether a value is "empty": null/undefined, empty string, empty
+ * array, or an object with no own enumerable string-keyed properties.
+ */
+export declare function isEmpty(value: any): boolean;
+/**
+ * Iterate over the own enumerable string-keyed properties of an object,
+ * invoking `callback(value, key)` for each.
+ */
+export declare function forOwn<T extends object>(obj: T, callback: (value: T[keyof T], key: keyof T) => void): void;
+/**
+ * Iterate over a collection (array or object), invoking `callback(value, key)`
+ * for each item. For arrays `key` is the numeric index. Types are intentionally
+ * loose (matching vtils) because call sites pass heterogeneous OpenAPI data.
+ */
+export declare function each(collection: any, callback: (value: any, key: any) => void): void;
+/**
+ * Return the first item in a collection for which `predicate` returns a
+ * truthy value, or `undefined` if none matches.
+ */
+export declare function find(collection: any, predicate: (value: any, key: any) => boolean): any;
+/**
+ * Tagged-template helper that strips the common leading whitespace from every
+ * line. Multi-line interpolations keep the indentation of the line they are
+ * embedded on (mirrors vtils `dedent`, which first runs `indent`).
+ */
+export declare function dedent(literals: TemplateStringsArray, ...interpolations: any[]): string;

package/dist/cjs/utils/vtilsLite.js

@@ -0,0 +1,123 @@
+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/vtilsLite.ts
+var vtilsLite_exports = {};
+__export(vtilsLite_exports, {
+  castArray: () => castArray,
+  dedent: () => dedent,
+  each: () => each,
+  find: () => find,
+  forOwn: () => forOwn,
+  isArray: () => isArray,
+  isEmpty: () => isEmpty,
+  isObject: () => isObject
+});
+module.exports = __toCommonJS(vtilsLite_exports);
+function castArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+var isArray = Array.isArray;
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isEmpty(value) {
+  if (value == null)
+    return true;
+  if (typeof value === "string" || Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return true;
+}
+function forOwn(obj, callback) {
+  if (obj == null)
+    return;
+  Object.keys(obj).forEach((key) => {
+    callback(obj[key], key);
+  });
+}
+function each(collection, callback) {
+  if (collection == null)
+    return;
+  if (Array.isArray(collection)) {
+    collection.forEach((value, index) => callback(value, index));
+  } else if (typeof collection === "object") {
+    Object.keys(collection).forEach((key) => {
+      callback(collection[key], key);
+    });
+  }
+}
+function find(collection, predicate) {
+  if (collection == null)
+    return void 0;
+  if (Array.isArray(collection)) {
+    return collection.find((value, index) => predicate(value, index));
+  }
+  if (typeof collection === "object") {
+    for (const key of Object.keys(collection)) {
+      const value = collection[key];
+      if (predicate(value, key))
+        return value;
+    }
+  }
+  return void 0;
+}
+function dedent(literals, ...interpolations) {
+  let text = "";
+  for (let i = 0; i < interpolations.length; i++) {
+    const literal = literals[i];
+    const interpolation = String(interpolations[i]);
+    const match = literal.match(/(?:^|[\r\n]+)([^\S\r\n]*)$/);
+    if (match && match[1]) {
+      text += literal + interpolation.replace(/([\r\n]+)(?=[^\r\n])/g, `$1${match[1]}`);
+    } else {
+      text += literal + interpolation;
+    }
+  }
+  text += literals[literals.length - 1];
+  const lines = text.split(/[\r\n]/g);
+  let commonLeadingWhitespace = null;
+  let firstLineIndex = null;
+  let lastLineIndex = null;
+  for (let i = 0; i < lines.length; i++) {
+    const leadingWhitespace = lines[i].match(/^\s*/)[0];
+    if (leadingWhitespace.length !== lines[i].length) {
+      lastLineIndex = i;
+      if (firstLineIndex == null)
+        firstLineIndex = i;
+      if (commonLeadingWhitespace == null || leadingWhitespace.length < commonLeadingWhitespace.length) {
+        commonLeadingWhitespace = leadingWhitespace;
+      }
+    }
+  }
+  if (commonLeadingWhitespace == null)
+    return text;
+  return lines.slice(firstLineIndex, lastLineIndex + 1).map((line) => line.slice(commonLeadingWhitespace.length)).join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  castArray,
+  dedent,
+  each,
+  find,
+  forOwn,
+  isArray,
+  isEmpty,
+  isObject
+});

package/dist/esm/core/cli.d.mts

@@ -0,0 +1,29 @@
+import yargs from "yargs";
+/** Flags accepted by the `gen` command. */
+interface GenFlags {
+    /** OpenAPI document URL or local file path. */
+    input?: string;
+    /** Output directory. */
+    output?: string;
+    /** File base name (CLI mode) or name filter (config-file mode). */
+    name?: string;
+    /** Runtime baseURL (string; `[code]:` prefix supported). */
+    baseUrl?: string;
+    /** Whether to scaffold the default request.ts client. */
+    client?: boolean;
+    /** Watch local input files and regenerate on change. */
+    watch?: boolean;
+}
+/** Scaffold an optional apits.config.ts template. */
+export declare function genConfig(prefill?: {
+    input?: string;
+}): Promise<void>;
+export declare function start(flags?: GenFlags): Promise<void>;
+export default class CLI {
+    run(args: string[]): {
+        [x: string]: any;
+    };
+    private genBuilder;
+    init(): yargs.Argv<any>;
+}
+export {};