wormajs 0.0.1

package/dist/utils/openapi.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReferenceObject = isReferenceObject;
+exports.isMaybeArraySchemaObject = isMaybeArraySchemaObject;
+exports.findBy$ref = findBy$ref;
+exports.parseReference = parseReference;
+exports.dereference = dereference;
+exports.nextReference = nextReference;
+exports.setComponentsBy$ref = setComponentsBy$ref;
+exports.get$refName = get$refName;
+exports.removeAll$ref = removeAll$ref;
+exports.isEqualObject = isEqualObject;
+exports.next$ref = next$ref;
+exports.optimizeRefsMap = optimizeRefsMap;
+exports.mergeObject = mergeObject;
+exports.getResponseSuccessKey = getResponseSuccessKey;
+const lodash_1 = require("lodash");
+const config_1 = require("../config");
+const loader_1 = require("../core/loader");
+const utils_1 = require("../utils");
+/**
+ * Determine whether it is a $ref object
+ * @param obj Judgment object
+ * @returns Whether it is a $ref object
+ */
+function isReferenceObject(obj) {
+    return !!obj?.$ref;
+}
+function isBaseReferenceObject(obj) {
+    return !!obj?._$ref;
+}
+function isMaybeArraySchemaObject(obj) {
+    return !!obj?.items;
+}
+/**
+ *
+ * @param path $ref search path
+ * @param openApi openApi document object
+ * @param isDeep Whether to deep copy
+ * @returns SchemaObject found
+ */
+function findBy$ref(path, openApi, isDeep = false) {
+    const pathArr = path.split('/');
+    let find = {
+        '#': openApi,
+    };
+    pathArr.forEach((key) => {
+        const tryKeys = [key, decodeURIComponent(key)];
+        if (find) {
+            find = find[tryKeys.find(k => !!find[k]) ?? key];
+        }
+    });
+    if (!find) {
+        const DEFAULT_CONFIG = (0, config_1.getGlobalConfig)();
+        throw new DEFAULT_CONFIG.Error(`cannot find $ref '${path}'`);
+    }
+    return (isDeep ? (0, lodash_1.cloneDeep)(find) : find);
+}
+function parseReference(obj, document, isDeep = false) {
+    if (isReferenceObject(obj)) {
+        return findBy$ref(obj.$ref, document, isDeep);
+    }
+    return obj;
+}
+function dereference(obj, document, isDeep = false) {
+    if (isReferenceObject(obj)) {
+        const result = findBy$ref(obj.$ref, document, isDeep);
+        const description = obj.description || result.description;
+        return {
+            ...result,
+            description,
+        };
+    }
+    return obj;
+}
+function nextReference(schema) {
+    for (const keyStr of Object.keys(schema)) {
+        const key = keyStr;
+        if (schema[key] && typeof schema[key] === 'object' && isReferenceObject(schema[key])) {
+            return schema[key];
+        }
+    }
+    return null;
+}
+/**
+ *
+ * @param path $ref path
+ * @param data Reuse object
+ * @param openApi Inserted openapi document object
+ */
+function setComponentsBy$ref(path, data, openApi) {
+    const pathArr = path.split('/');
+    let find = {
+        '#': openApi,
+    };
+    pathArr.forEach((key, idx) => {
+        if (idx + 1 === pathArr.length) {
+            find[key] = data;
+            return;
+        }
+        if (find[key]) {
+            find = find[key];
+        }
+        else {
+            find = find[key] = {};
+        }
+    });
+}
+/**
+ *
+ * @param path $ref path
+ * @param toUpperCase Whether the initial letter size
+ * @returns Reference object name
+ */
+function get$refName(path, toUpperCase = true) {
+    const pathArr = path.split('/');
+    const name = pathArr[pathArr.length - 1];
+    if (!toUpperCase) {
+        return name;
+    }
+    return (0, utils_1.capitalizeFirstLetter)(name);
+}
+/**
+ *
+ * @param schemaOrigin Object with $ref
+ * @param openApi openApi document object
+ * @returns Removed $ref object
+ */
+/**
+ * M2-B1: $ref 解引用缓存优化 —— 命中 searchMap 时跳过 cloneDeep
+ */
+function removeAll$ref(schemaOrigin, openApi, optons) {
+    const { searchMap = new Map(), refNameMap = new Map() } = optons ?? {};
+    // 先检查缓存，命中则直接返回（避免 cloneDeep 开销）
+    if (isReferenceObject(schemaOrigin)) {
+        if (searchMap.has(schemaOrigin.$ref)) {
+            return searchMap.get(schemaOrigin.$ref);
+        }
+        const schema = findBy$ref(schemaOrigin.$ref, openApi, true);
+        refNameMap.set(schemaOrigin.$ref, loader_1.standardLoader.transformRefName(schemaOrigin.$ref));
+        // Mark for easy restoration
+        schema._$ref = schemaOrigin.$ref;
+        searchMap.set(schemaOrigin.$ref, schema);
+        for (const key of Object.keys(schema)) {
+            if (schema[key] && typeof schema[key] === 'object') {
+                schema[key] = removeAll$ref(schema[key], openApi, { searchMap, refNameMap });
+            }
+        }
+        return schema;
+    }
+    // 非 $ref 节点：仍需 cloneDeep 防止污染原始文档，但子节点走 searchMap 去重
+    const deepSchemaOrigin = (0, lodash_1.cloneDeep)(schemaOrigin);
+    for (const key of Object.keys(deepSchemaOrigin)) {
+        if (deepSchemaOrigin[key] && typeof deepSchemaOrigin[key] === 'object') {
+            deepSchemaOrigin[key] = removeAll$ref(deepSchemaOrigin[key], openApi, { searchMap, refNameMap });
+        }
+    }
+    return deepSchemaOrigin;
+}
+/**
+ *
+ * @param objValue object to be compared
+ * @param srcValue source object
+ * @param openApi openApi document object
+ * @returns Are they equal?
+ */
+function isEqualObject(objValue, srcValue, openApi) {
+    const visited = new WeakMap();
+    const ignoreKeyArr = ['_$ref'];
+    function customizer(objValueOrigin, otherValueOrigin) {
+        if (objValueOrigin === otherValueOrigin) {
+            return true;
+        }
+        let objValue = objValueOrigin;
+        let otherValue = otherValueOrigin;
+        if (isReferenceObject(objValueOrigin)) {
+            objValue = findBy$ref(objValueOrigin.$ref, openApi);
+        }
+        if (isReferenceObject(otherValueOrigin)) {
+            otherValue = findBy$ref(otherValueOrigin.$ref, openApi);
+        }
+        // Ignore the effect of array order
+        if ((0, lodash_1.isArray)(objValue) && (0, lodash_1.isArray)(otherValue)) {
+            const sortObjValue = (0, lodash_1.sortBy)(objValue);
+            const sortOtherValue = (0, lodash_1.sortBy)(otherValue);
+            const keys = [...new Set([...Object.keys(sortObjValue), ...Object.keys(sortOtherValue)])].filter(key => !ignoreKeyArr.includes(key));
+            return keys.every(key => (0, lodash_1.isEqualWith)(sortObjValue[key], sortOtherValue[key], customizer));
+        }
+        // If it is an object, compare recursively
+        if ((0, lodash_1.isObject)(objValue) && (0, lodash_1.isObject)(otherValue)) {
+            if (visited.has(objValue) && visited.get(objValue) === otherValue) {
+                return true;
+            }
+            visited.set(objValue, otherValue);
+            const keys = [...new Set([...Object.keys(objValue), ...Object.keys(otherValue)])].filter(key => !ignoreKeyArr.includes(key));
+            return keys.every(key => (0, lodash_1.isEqualWith)(objValue[key], otherValue[key], customizer));
+        }
+    }
+    return (0, lodash_1.isEqualWith)(objValue, srcValue, customizer);
+}
+function next$ref() {
+    function getNameVersion(path) {
+        const name = loader_1.standardLoader.transformRefName(path, {
+            toUpperCase: false,
+        });
+        const [, nameVersion = 0] = /(\d+)$/.exec(name) ?? [];
+        return Number(nameVersion);
+    }
+    function getOnlyName(path) {
+        const name = loader_1.standardLoader.transformRefName(path, {
+            toUpperCase: false,
+        });
+        return name.replace(/\d+$/, '');
+    }
+    function getOnlyPath(path) {
+        return path.split('/').slice(0, -1).join('/');
+    }
+    function getNext(path, map = []) {
+        const name = getOnlyName(path);
+        const basePath = getOnlyPath(path);
+        let nameVersion = getNameVersion(path);
+        map.forEach(([key]) => {
+            if (getOnlyName(key) === name && getOnlyPath(path) === basePath) {
+                nameVersion = Math.max(nameVersion, getNameVersion(key));
+            }
+        });
+        return `${basePath}/${name}${nameVersion + 1}`;
+    }
+    return {
+        getNameVersion,
+        getOnlyName,
+        getOnlyPath,
+        getNext,
+    };
+}
+/**
+ * 根据 usedRefs 优化 refsMap：
+ * 1) 移除未使用的 key；
+ * 2) 同组（相同 basePath+onlyName）内按版本升序将值左移，
+ *    即剩余键依次接收原始值的前 N 个（N 为剩余键数量）。
+ */
+function optimizeRefsMap(refsMap, usedRefs) {
+    const helper = next$ref();
+    const usedSet = new Set(usedRefs.map(v => (typeof v === 'string' ? v : v.$ref)));
+    const grouped = {};
+    for (const [key, value] of Object.entries(refsMap || {})) {
+        const groupId = `${helper.getOnlyPath(key)}::${helper.getOnlyName(key)}`;
+        const arr = grouped[groupId] || (grouped[groupId] = []);
+        arr.push({ key, value, version: helper.getNameVersion(key) });
+    }
+    const newRefsMap = {};
+    for (const groupId of Object.keys(grouped)) {
+        const list = grouped[groupId].sort((a, b) => a.version - b.version);
+        const remain = list.filter(item => usedSet.has(item.key));
+        if (remain.length === 0) {
+            continue;
+        }
+        const assignValues = list.map(item => item.value).slice(0, remain.length);
+        remain.forEach((item, idx) => {
+            newRefsMap[item.key] = assignValues[idx];
+        });
+    }
+    return newRefsMap;
+}
+function isCircular(obj) {
+    const seenObjects = new WeakSet();
+    function detect(obj) {
+        if (obj && typeof obj === 'object') {
+            if (seenObjects.has(obj)) {
+                return true;
+            }
+            seenObjects.add(obj);
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    if (detect(obj[key])) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    return detect(obj);
+}
+function hasBaseReferenceObject(obj) {
+    if (obj && typeof obj === 'object') {
+        if (isBaseReferenceObject(obj)) {
+            return true;
+        }
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                if (hasBaseReferenceObject(obj[key])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function removeBaseReference(obj, options) {
+    const { openApi, map = [], refNameMap = new Map() } = options;
+    if (isBaseReferenceObject(obj)) {
+        const refObj = { $ref: obj._$ref };
+        if (isEqualObject(obj, refObj, openApi)) {
+            return refObj;
+        }
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key) && hasBaseReferenceObject(obj[key])) {
+                obj[key] = removeBaseReference(obj[key], { openApi, map, refNameMap });
+            }
+        }
+        const [path] = map.find(([, item]) => isEqualObject(item, obj, openApi)) ?? [];
+        if (path) {
+            return {
+                $ref: path,
+            };
+        }
+        const refHelper = next$ref();
+        const nextPath = refHelper.getNext(refObj.$ref, map);
+        if (refNameMap.has(refObj.$ref)) {
+            refNameMap.set(nextPath, `${refNameMap.get(refObj.$ref) ?? ''}${refHelper.getNameVersion(nextPath)}`);
+        }
+        map.push([nextPath, obj]);
+        setComponentsBy$ref(nextPath, obj, openApi);
+        return {
+            $ref: nextPath,
+        };
+    }
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBaseReferenceObject(obj[key])) {
+            obj[key] = removeBaseReference(obj[key], { openApi, map, refNameMap });
+        }
+    }
+    return obj;
+}
+function unCircular(obj, options) {
+    const { openApi, map = [], objPath = '$', seen = new WeakMap(), refNameMap = new Map() } = options;
+    if (typeof obj !== 'object' || obj === null) {
+        return obj; // 原始值直接返回
+    }
+    if (seen.has(obj)) {
+        return seen.get(obj);
+    }
+    const setSeen = (obj, refOjec) => {
+        const oldRefObj = seen.get(obj) ?? refOjec;
+        oldRefObj.$ref = refOjec.$ref;
+        seen.set(obj, oldRefObj);
+    };
+    const $ref = `#/components/schemas/${loader_1.standardLoader.transform(loader_1.standardLoader.transformRadomVariable(objPath), {
+        style: 'camelCase',
+    })}`;
+    setSeen(obj, { $ref });
+    if (isBaseReferenceObject(obj)) {
+        const refObj = { $ref: obj._$ref };
+        if (isEqualObject(obj, refObj, openApi)) {
+            setSeen(obj, refObj);
+            return refObj;
+        }
+        const refHelper = next$ref();
+        const nextPath = refHelper.getNext(refObj.$ref, map);
+        if (refNameMap.has(refObj.$ref)) {
+            refNameMap.set(nextPath, `${refNameMap.get(refObj.$ref) ?? ''}${refHelper.getNameVersion(nextPath)}`);
+        }
+        seen.set(obj, { $ref: nextPath });
+        map.push([nextPath, obj]);
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                obj[key] = unCircular(obj[key], { openApi, map, objPath: `${objPath}.${key}`, seen, refNameMap });
+            }
+        }
+        setComponentsBy$ref(nextPath, obj, openApi);
+        return {
+            $ref: nextPath,
+        };
+    }
+    map.push([$ref, obj]);
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            obj[key] = unCircular(obj[key], { openApi, map, objPath: `${objPath}.${key}`, seen, refNameMap });
+        }
+    }
+    setComponentsBy$ref($ref, obj, openApi);
+    return obj;
+}
+function mergeObject(objValue, srcValue, options) {
+    const { openApi, map = [], refNameMap = new Map() } = options;
+    function customizer(objValue, srcValue) {
+        // If they are all arrays and the src value is an empty array, the src value will be returned directly.
+        if ((0, lodash_1.isArray)(objValue) && (0, lodash_1.isArray)(srcValue) && !srcValue.length) {
+            return srcValue;
+        }
+        if (isEqualObject(objValue, srcValue, openApi)) {
+            return objValue;
+        }
+        // Handle circular references
+        if (isCircular(srcValue)) {
+            srcValue = unCircular(srcValue, { openApi, map, objPath: loader_1.standardLoader.transformRadomVariable(JSON.stringify(objValue)), refNameMap });
+        }
+        // Is there also a $ref attribute?
+        if (hasBaseReferenceObject(srcValue)) {
+            return removeBaseReference(srcValue, { openApi, map, refNameMap });
+        }
+        return srcValue;
+    }
+    // M2-B1: mergeWith 自身不污染首参（返回新对象），去掉冗余 cloneDeep
+    return (0, lodash_1.mergeWith)(objValue, srcValue, customizer);
+}
+function getResponseSuccessKey(responsesObject) {
+    if (!responsesObject) {
+        return '200';
+    }
+    const successKeys = Object.keys(responsesObject)
+        .map(key => Number(key))
+        .filter(key => !Number.isNaN(key) && key >= 200 && key < 300)
+        .sort((a, b) => a - b);
+    return `${successKeys[0] ?? 'default'}`;
+}

package/dist/utils/readPackageJson.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJson = readPackageJson;
+exports.clearPackageJsonCache = clearPackageJsonCache;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+/** In-memory cache: projectPath → parsed package.json. Valid for the lifetime of one generate run. */
+const pkgCache = new Map();
+/**
+ * Read and cache package.json for a given project directory.
+ * Returns null if the file doesn't exist or can't be parsed.
+ */
+async function readPackageJson(projectPath) {
+    const cached = pkgCache.get(projectPath);
+    if (cached !== undefined)
+        return cached;
+    try {
+        const pkgPath = node_path_1.default.resolve(projectPath, 'package.json');
+        const content = await promises_1.default.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        pkgCache.set(projectPath, pkg);
+        return pkg;
+    }
+    catch {
+        pkgCache.set(projectPath, null);
+        return null;
+    }
+}
+/** Clear the in-memory cache (useful for testing). */
+function clearPackageJsonCache() {
+    pkgCache.clear();
+}

package/dist/utils/template.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPartials = registerPartials;
+exports.registerCommonHelpers = registerCommonHelpers;
+exports.generateFile = generateFile;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const glob_1 = require("glob");
+const handlebars_1 = __importDefault(require("handlebars"));
+const base_1 = require("./base");
+const format_1 = require("./format");
+// Register partials for template reuse, supports passing an hbs instance
+async function registerPartials(baseTemplatePath, hbs = handlebars_1.default) {
+    const partialsDir = node_path_1.default.resolve(baseTemplatePath, 'partials');
+    try {
+        const partialFiles = await (0, glob_1.glob)('**/*.handlebars', {
+            ignore: 'node_modules/**',
+            cwd: partialsDir,
+        });
+        for (const file of partialFiles) {
+            const partialName = file.replace('.handlebars', '').replace(/\\/g, '/');
+            const partialContent = await promises_1.default.readFile(node_path_1.default.join(partialsDir, file), 'utf-8');
+            hbs.registerPartial(partialName, partialContent);
+        }
+    }
+    catch {
+        // partials dir may not exist — that's fine
+    }
+}
+const getType = (obj) => Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
+/**
+ * Register the common set of Handlebars helpers onto the given instance.
+ * Call this on every newly created isolated Handlebars instance.
+ */
+function registerCommonHelpers(hbs) {
+    hbs.registerHelper('isType', function (value, type, options) {
+        if (getType(value) === type) {
+            return options.fn(this);
+        }
+        return options.inverse(this);
+    });
+    hbs.registerHelper('and', function (...rest) {
+        const args = Array.prototype.slice.call(rest, 0, -1);
+        const options = rest[rest.length - 1];
+        const result = args.every((arg) => {
+            if (Array.isArray(arg)) {
+                return arg.length === 0;
+            }
+            return Boolean(arg);
+        });
+        return result ? options.fn(this) : options.inverse(this);
+    });
+    hbs.registerHelper('or', function (...rest) {
+        const args = Array.prototype.slice.call(rest, 0, -1);
+        const options = rest[rest.length - 1];
+        const result = args.some((arg) => {
+            if (Array.isArray(arg)) {
+                return arg.length !== 0;
+            }
+            return Boolean(arg);
+        });
+        return result ? options.fn(this) : options.inverse(this);
+    });
+    hbs.registerHelper('eq', (a, b) => a === b);
+    hbs.registerHelper('not', (a, b) => a !== b);
+    hbs.registerHelper('join', (...rest) => {
+        const args = Array.prototype.slice.call(rest, 0, -1);
+        return args.join('');
+    });
+    hbs.registerHelper('raw', text => new hbs.SafeString(text));
+    hbs.registerHelper('stripStarPrefix', (text) => {
+        if (!text || typeof text !== 'string')
+            return text;
+        return text.split('\n').map(line => line.replace(/^\* ?/, '')).join('\n');
+    });
+}
+/**
+ * Pass in text content and generate a custom file in the specified directory
+ * @param distDir The directory where the file to be generated is located
+ * @param fileName File name to be generated
+ * @param content File content
+ */
+async function generateFile(distDir, fileName, content) {
+    if (!(await (0, base_1.existsPromise)(distDir))) {
+        await promises_1.default.mkdir(distDir, { recursive: true });
+    }
+    const filePath = node_path_1.default.join(distDir, fileName);
+    const formattedText = await (0, format_1.format)(content);
+    await promises_1.default.writeFile(filePath, formattedText);
+}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "wormajs",
+  "version": "0.0.1",
+  "description": "A modern OpenAPI code generator - Generate type-safe API clients from OpenAPI specs",
+  "author": "alova",
+  "license": "MIT",
+  "homepage": "https://github.com/alovajs/devtools",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alovajs/devtools.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alovajs/devtools/issues"
+  },
+  "keywords": [
+    "openapi",
+    "auto-generating",
+    "api",
+    "apis",
+    "fetch",
+    "axios",
+    "request",
+    "fetch-api",
+    "superagent",
+    "worma"
+  ],
+  "exports": {
+    ".": {
+      "types": "./typings/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./typings/plugins.d.ts",
+      "default": "./dist/plugins/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./typings/index.d.ts",
+  "bin": {
+    "worma": "dist/bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "typings"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "alova": "^3.3.4",
+    "chalk": "4.1.2",
+    "cli-truncate": "^4.0.0",
+    "commander": "^14.0.0",
+    "esbuild": "^0.25.6",
+    "glob": "^11.0.3",
+    "handlebars": "^4.7.8",
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21",
+    "log-update": "^6.1.0",
+    "openapi-types": "^12.1.3",
+    "ora": "5.4.1",
+    "prettier": "^3.6.2",
+    "skills": "^1.5.13",
+    "string-width": "^7.2.0",
+    "swagger2openapi": "^7.0.8",
+    "zod": "^3.25.68-alpha.11",
+    "zod-validation-error": "^3.5.3"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.24",
+    "@types/swagger2openapi": "^7.0.4",
+    "axios": "^1.17.0",
+    "fs-extra": "^11.3.1",
+    "ky": "^2.0.2",
+    "memfs": "^4.17.2",
+    "tsc-alias": "^1.8.16"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "run-s build:*",
+    "build:ts": "tsc --build tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "build:dts": "dts-bundle-generator -o typings/index.d.ts src/index.ts --no-check --no-banner --project tsconfig.dts.json",
+    "build:plugin-dts": "dts-bundle-generator -o typings/plugins.d.ts src/plugins/index.ts --no-check --no-banner --project tsconfig.dts.json",
+    "build:copy": "ncp ./src/template/presets ./dist/template/presets"
+  }
+}