wormajs 0.0.1

package/dist/core/loader/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./astLoader"), exports);
+__exportStar(require("./callingCodeLoader"), exports);
+__exportStar(require("./schemaLoader"), exports);
+__exportStar(require("./standardLoader"), exports);

package/dist/core/loader/schemaLoader/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaLoader = exports.SchemaLoader = void 0;
+const astLoader_1 = require("../astLoader");
+const generates_1 = require("../astLoader/generates");
+const normalize_1 = __importDefault(require("../astLoader/normalize"));
+const parsers_1 = require("../astLoader/parsers");
+/**
+ * P0: WeakMap cache for normalized schema.
+ *  The normalizer clones + transforms the schema (expensive), but the result
+ *  is independent of commentType/onReference. Caching by schema identity avoids
+ *  repeated normalization of shared schemas across APIs.
+ */
+const normalizeCache = new WeakMap();
+class SchemaLoader {
+    constructor() {
+        this.name = 'schemaLoader';
+    }
+    /** Normalize schema once, with WeakMap caching for repeated identical objects. */
+    normalizeSchema(schemaOrigin) {
+        const key = schemaOrigin;
+        if (normalizeCache.has(key)) {
+            return normalizeCache.get(key);
+        }
+        const normalized = normalize_1.default.normalize(schemaOrigin);
+        normalizeCache.set(key, normalized);
+        return normalized;
+    }
+    /** Parse schema to AST: normalize + parse. Uses normalization cache internally. */
+    parseSchema(schemaOrigin, parserOptions) {
+        const normalized = this.normalizeSchema(schemaOrigin);
+        return (0, parsers_1.astParse)(normalized, parserOptions);
+    }
+    async transform(schemaOrigin, typeOptionsOrOptions, commentOptions) {
+        // Dual-output path: third argument present
+        if (commentOptions !== undefined) {
+            const typeOptions = typeOptionsOrOptions;
+            // Normalize once to save the clone+transform cost
+            const normalized = this.normalizeSchema(schemaOrigin);
+            // Parse for type: respects typeOptions.commentType (default 'doc' for marker transforms)
+            const typeAst = (0, parsers_1.astParse)(normalized, {
+                document: typeOptions.document,
+                commentType: typeOptions.commentType ?? 'doc',
+                defaultRequire: typeOptions.defaultRequire,
+                refNameMap: typeOptions.refNameMap,
+                onReference(ast) {
+                    typeOptions.onReference?.(ast);
+                },
+            });
+            // Generate type output
+            const typeOutput = await this.generateCode(typeAst, typeOptions);
+            // Parse for comment: 'line' preserves raw markers, no onReference needed
+            let commentOutput;
+            if (commentOptions) {
+                const commentAst = (0, parsers_1.astParse)(normalized, {
+                    document: typeOptions.document,
+                    commentType: 'line',
+                    defaultRequire: typeOptions.defaultRequire,
+                });
+                commentOutput = await this.generateCode(commentAst, commentOptions);
+            }
+            return { type: typeOutput, comment: commentOutput };
+        }
+        // Single-output path: original behavior
+        const options = typeOptionsOrOptions;
+        const ast = this.parseSchema(schemaOrigin, {
+            document: options.document,
+            commentType: options.commentType ?? 'line',
+            defaultRequire: options.defaultRequire,
+            refNameMap: options.refNameMap,
+            onReference(ast) {
+                options.onReference?.(ast);
+            },
+        });
+        return this.generateCode(ast, options);
+    }
+    /** Generate TS code string from an AST node + options. */
+    async generateCode(ast, options) {
+        const genOptions = {
+            deep: options.deep,
+            shallowDeep: options.shallowDeep,
+            commentType: options.commentType ?? 'line',
+            noEnum: options.noEnum,
+        };
+        const result = await astLoader_1.astLoader.transform(ast, {
+            ...genOptions,
+            format: true,
+        });
+        const tsStrArr = (0, generates_1.getValue)(result, {
+            ...genOptions,
+        })
+            .trim()
+            .split('\n');
+        return tsStrArr.map((line, idx) => (idx ? options.preText : '') + line).join('\n');
+    }
+}
+exports.SchemaLoader = SchemaLoader;
+exports.schemaLoader = new SchemaLoader();

package/dist/core/loader/standardLoader/helper.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIdentifier = makeIdentifier;
+exports.isValidJSIdentifier = isValidJSIdentifier;
+const reservedWords = new Set([
+    'abstract',
+    'arguments',
+    'await',
+    'boolean',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'float',
+    'for',
+    'function',
+    'goto',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'int',
+    'interface',
+    'let',
+    'long',
+    'native',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'synchronized',
+    'this',
+    'throw',
+    'throws',
+    'transient',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'volatile',
+    'while',
+    'with',
+    'yield',
+]);
+function splitIntoWords(str) {
+    const words = [];
+    const UPPERCASE_REGEX = /^[A-Z]$/;
+    const LOWERCASE_OR_DIGIT_REGEX = /^[a-z\d]$/;
+    const LETTER_REGEX = /[a-z]/i;
+    const DIGIT_REGEX = /^\d$/;
+    let currentWord = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const lastChar = str[i - 1] ?? '';
+        const nextChar = str[i + 1] ?? '';
+        // 如果遇到非单词字符，结束当前单词
+        if (/[^\w$]/.test(char) || ['_'].includes(char)) {
+            if (currentWord) {
+                words.push(currentWord);
+            }
+            currentWord = '';
+            continue;
+        }
+        const isStartOfCamelCase = !UPPERCASE_REGEX.test(lastChar) && UPPERCASE_REGEX.test(char);
+        const isUppercaseFollowedByLowercase = UPPERCASE_REGEX.test(char) && LOWERCASE_OR_DIGIT_REGEX.test(nextChar);
+        const isTransitionFromDigitToNonDigit = LETTER_REGEX.test(currentWord) && DIGIT_REGEX.test(lastChar) && !DIGIT_REGEX.test(char);
+        if (isStartOfCamelCase || isUppercaseFollowedByLowercase || isTransitionFromDigitToNonDigit) {
+            if (currentWord) {
+                words.push(currentWord);
+            }
+            currentWord = char;
+        }
+        else {
+            currentWord += char;
+        }
+    }
+    if (currentWord) {
+        words.push(currentWord);
+    }
+    return words;
+}
+function makeIdentifier(str, style) {
+    // Removes all characters that are not letters, numbers, underscores, and dollar signs while splitting words
+    const words = splitIntoWords(str).filter(Boolean);
+    // Convert words to camelCase form
+    let identifier = '';
+    switch (style) {
+        case 'camelCase':
+            identifier = words
+                .map((word, index) => {
+                if (index === 0) {
+                    return word.toLowerCase();
+                }
+                return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+            })
+                .join('');
+            break;
+        case 'snakeCase':
+            identifier = words.join('_').toLowerCase();
+            break;
+        default:
+            identifier = words.join('');
+            break;
+    }
+    // If the string starts with a number, replace it with an underscore
+    if (/^\d/.test(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    // If it is a reserved word, add a suffix
+    if (reservedWords.has(identifier)) {
+        identifier += '_';
+    }
+    return identifier;
+}
+function isValidJSIdentifier(str) {
+    return !!str && /^[a-z_$][\w$]*$/i.test(str) && !reservedWords.has(str);
+}

package/dist/core/loader/standardLoader/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardLoader = exports.StandardLoader = void 0;
+const helper_1 = require("./helper");
+const standards_1 = require("./standards");
+class StandardLoader {
+    constructor() {
+        this.name = 'standardLoader';
+    }
+    transform(input, options) {
+        return (0, helper_1.makeIdentifier)(input, options?.style ?? 'camelCase');
+    }
+    validate(input) {
+        return (0, helper_1.isValidJSIdentifier)(input);
+    }
+    transformRefName(refPath, options) {
+        return (0, standards_1.getStandardRefName)(refPath, {
+            ...options,
+            standardLoader: this,
+        });
+    }
+    transformTags(tags) {
+        return (0, standards_1.getStandardTags)(tags, {
+            standardLoader: this,
+        });
+    }
+    transformOperationId(pathObject, options) {
+        return (0, standards_1.getStandardOperationId)(pathObject, {
+            ...options,
+            standardLoader: this,
+        });
+    }
+    transformRadomVariable(value) {
+        return (0, standards_1.getRandomVariable)(value);
+    }
+}
+exports.StandardLoader = StandardLoader;
+exports.standardLoader = new StandardLoader();

package/dist/core/loader/standardLoader/standards.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStandardOperationId = getStandardOperationId;
+exports.getStandardTags = getStandardTags;
+exports.getRandomVariable = getRandomVariable;
+exports.getStandardRefName = getStandardRefName;
+const utils_1 = require("../../../utils");
+function getStandardOperationId(pathObject, options) {
+    const { url, method, map, standardLoader } = options;
+    if (standardLoader.validate(pathObject.operationId)) {
+        return pathObject.operationId;
+    }
+    let operationId = '';
+    if (pathObject.operationId) {
+        operationId = standardLoader.transform(pathObject.operationId, {
+            style: 'camelCase',
+        });
+    }
+    if (!operationId) {
+        operationId = standardLoader.transform(`${method}/${url}`, {
+            style: 'snakeCase',
+        });
+    }
+    if (map.has(operationId)) {
+        let num = 1;
+        while (map.has(`${operationId}${num}`)) {
+            num += 1;
+        }
+        operationId = `${operationId}${num}`;
+    }
+    map.add(operationId);
+    return operationId;
+}
+function getStandardTags(tags, options) {
+    const { standardLoader } = options;
+    const tagsSet = new Set();
+    if (!tags || !tags.length) {
+        return ['general'];
+    }
+    return tags.map((tag) => {
+        tag = tag.trim();
+        if (standardLoader.validate(tag)) {
+            tagsSet.add(tag);
+            return tag;
+        }
+        let newTag = '';
+        if (tag) {
+            newTag = standardLoader.transform(tag, {
+                style: 'camelCase',
+            });
+        }
+        if (tagsSet.has(newTag)) {
+            let num = 1;
+            while (tagsSet.has(`${newTag}${num}`)) {
+                num += 1;
+            }
+            newTag = `${newTag}${num}`;
+        }
+        if (!newTag) {
+            newTag = 'general';
+        }
+        tagsSet.add(newTag);
+        return newTag;
+    });
+}
+function getRandomVariable(value) {
+    return `${(0, utils_1.strHashCode)(value)}`
+        .split('')
+        .map((code) => {
+        let numberCode = Number(code);
+        numberCode = Number.isNaN(numberCode) ? 10 : numberCode;
+        return String.fromCharCode(numberCode + 97);
+    })
+        .join('');
+}
+const refPathMap = new Map();
+const refNameSet = new Set();
+function getStandardRefName(refPath, options) {
+    const { toUpperCase = true, standardLoader } = options;
+    if (refPathMap.has(refPath)) {
+        return refPathMap.get(refPath) ?? '';
+    }
+    const refName = (0, utils_1.get$refName)(refPath, toUpperCase);
+    if (standardLoader.validate(refName)) {
+        refNameSet.add(refName);
+        refPathMap.set(refPath, refName);
+        return refName;
+    }
+    let newRefName = standardLoader.transform(refName, {
+        style: 'snakeCase',
+    }) || getRandomVariable(refName);
+    if (toUpperCase) {
+        newRefName = (0, utils_1.capitalizeFirstLetter)(newRefName);
+    }
+    if (refNameSet.has(newRefName)) {
+        let num = 1;
+        while (refNameSet.has(`${newRefName}${num}`)) {
+            num += 1;
+        }
+        newRefName = `${newRefName}${num}`;
+    }
+    refNameSet.add(newRefName);
+    refPathMap.set(refPath, newRefName);
+    return newRefName;
+}

package/dist/core/parser/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openApiParser"), exports);
+__exportStar(require("./templateParser"), exports);

package/dist/core/parser/openApiParser/helper.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenApiDataWithUrl = getOpenApiDataWithUrl;
+exports.getOpenApiData = getOpenApiData;
+const node_fs_1 = require("node:fs");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const poolManager_1 = require("../../../core/workerPool/poolManager");
+const helper_1 = require("../../../helper");
+const utils_1 = require("../../../utils");
+const supportedExtname = ['json', 'yaml'];
+function isSwagger2(data) {
+    return !!data?.swagger;
+}
+/** 9.3.4: Run CPU-heavy Swagger2→OpenAPI3 conversion via PoolManager */
+function convertSwagger2Async(data) {
+    return new Promise((resolve, reject) => {
+        // Resolve worker path: .js for production, .ts for vitest/dev
+        // In mocked filesystem envs, existsSync may return false — fall back to trying both paths
+        const jsPath = node_path_1.default.resolve(__dirname, '../../workerPool/swagger2Worker.js');
+        const tsPath = node_path_1.default.resolve(__dirname, '../../workerPool/swagger2Worker.ts');
+        const workerScript = (0, node_fs_1.existsSync)(jsPath) ? jsPath : tsPath;
+        const pool = poolManager_1.PoolManager.getInstance().get({
+            key: 'swagger2Worker',
+            workerScript,
+            sharedContext: {},
+            poolSize: 1,
+        });
+        pool.processBatch([data]).then((results) => {
+            if (results.length > 0 && results[0].openapi) {
+                resolve(results[0].openapi);
+            }
+            else {
+                reject(new Error('Empty result from swagger2 conversion'));
+            }
+        }).catch(reject);
+    });
+}
+// Parse local openapi files
+async function parseLocalFile(url, projectPath = process.cwd()) {
+    const [, extname] = /\.([^.]+)$/.exec(url) ?? [];
+    if (!supportedExtname.includes(extname)) {
+        throw helper_1.logger.throwError(`Unsupported file type: ${extname}`, {
+            url,
+            projectPath,
+        });
+    }
+    const filePath = node_path_1.default.resolve(projectPath, url);
+    if (extname === 'yaml') {
+        return js_yaml_1.default.load(await promises_1.default.readFile(filePath, 'utf-8'));
+    }
+    // M6-C3: prefer async read, fallback to require() for environments where
+    // fs is mocked (e.g. memfs in tests) but the real file exists on disk
+    try {
+        return JSON.parse(await promises_1.default.readFile(filePath, 'utf-8'));
+    }
+    catch {
+        // Fallback: use require() which bypasses fs mocks to reach real disk
+        // eslint-disable-next-line ts/no-require-imports
+        return require(filePath);
+    }
+}
+// Parse remote openapi files
+async function parseRemoteFile(url, fetchOptions) {
+    const dataText = (await (0, utils_1.fetchData)(url, fetchOptions)) ?? '';
+    let data;
+    try {
+        // 尝试解析为 JSON 格式
+        data = JSON.parse(dataText);
+    }
+    catch (jsonError) {
+        try {
+            // 若 JSON 解析失败，尝试解析为 YAML 格式
+            data = js_yaml_1.default.load(dataText);
+        }
+        catch (yamlError) {
+            throw helper_1.logger.throwError(`Only JSON and YAML formats are supported. Parsing failed:
+        ${jsonError instanceof Error ? jsonError.message : String(jsonError)}
+        ${yamlError instanceof Error ? yamlError.message : String(yamlError)}`, {
+                url,
+            });
+        }
+    }
+    // Validate if the data is valid (prevent server from returning error responses)
+    if (!isValidOpenApiData(data)) {
+        throw new Error(`Data retrieved from URL ${url} is not a valid OpenAPI document`);
+    }
+    return data;
+}
+// Validate OpenAPI data
+function isValidOpenApiData(data) {
+    if (!data || typeof data !== 'object') {
+        return false;
+    }
+    // Check if it's an error response format (e.g., {"code": -1, "msg": "URL does not exist", "data": null})
+    if (data.code !== undefined && data.msg !== undefined) {
+        return false;
+    }
+    // Check if it contains required OpenAPI/Swagger structure
+    return !!(data.openapi || data.swagger || data.info || data.paths);
+}
+const isRemoteUrl = (u) => /^https?:\/\//.test(u);
+/**
+ * Try all URLs in parallel (local & remote) — first successful one wins.
+ * Returns the parsed data together with the resolved URL; throws if all URLs fail.
+ */
+async function tryUrls(urls, options) {
+    if (urls.length === 0) {
+        throw helper_1.logger.throwError('No URLs provided to fetch OpenAPI document');
+    }
+    const { projectPath, fetchOptions } = options;
+    // All URLs race in parallel: local files are fast, remote ones use network
+    const tasks = urls.map((u) => {
+        if (isRemoteUrl(u)) {
+            return parseRemoteFile(u, fetchOptions).then(data => ({ data, url: u }), (err) => {
+                throw new Error(`${u}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+        return parseLocalFile(u, projectPath).then(data => ({ data, url: u }));
+    });
+    try {
+        return await Promise.any(tasks);
+    }
+    catch (err) {
+        const errors = (err instanceof AggregateError)
+            ? err.errors.map((e) => e.message)
+            : [err.message];
+        throw helper_1.logger.throwError(`Unable to retrieve valid OpenAPI document from any URL:\n${errors.join('\n')}`);
+    }
+}
+/**
+ * Parse OpenAPI document and return the resolved URL alongside the data.
+ * Use this when you need to know which URL actually provided the document.
+ */
+async function getOpenApiDataWithUrl(url, options) {
+    const { projectPath, fetchOptions } = options ?? {};
+    // Normalize to array — single string or array both handled uniformly
+    const urls = Array.isArray(url) ? url : [url];
+    const { data, url: resolvedUrl } = await tryUrls(urls, { projectPath, fetchOptions });
+    let result = data;
+    // If it is a swagger2 file — convert via worker to avoid main-thread blocking
+    if (isSwagger2(result)) {
+        result = await convertSwagger2Async(result);
+    }
+    if (!result) {
+        throw helper_1.logger.throwError(`Cannot read file from ${urls.join(', ')}`, {
+            projectPath,
+            url,
+            fetchOptions,
+        });
+    }
+    return { data: result, resolvedUrl };
+}
+/**
+ * Parse OpenAPI document from config input.
+ * Backward-compatible: wraps {@link getOpenApiDataWithUrl}, returning only the document.
+ */
+async function getOpenApiData(url, options) {
+    const { data } = await getOpenApiDataWithUrl(url, options);
+    return data;
+}

package/dist/core/parser/openApiParser/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiParser = exports.OpenApiParser = void 0;
+const helper_1 = require("./helper");
+class OpenApiParser {
+    constructor() {
+        this.name = 'openapiParser';
+    }
+    async parse(input, options) {
+        return (0, helper_1.getOpenApiData)(input, options);
+    }
+}
+exports.OpenApiParser = OpenApiParser;
+exports.openApiParser = new OpenApiParser();