wormajs 0.0.1

package/dist/plugins/presets/payloadModifier/index.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payloadModifier = payloadModifier;
+const constant_1 = require("../../../constant");
+const utils_1 = require("../utils");
+const hepler_1 = require("./hepler");
+// Apply modifications to object properties (for data/response scopes)
+function modifySchemaProperties(schema, config) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const targetSchema = { ...schema };
+    // union recursively
+    if (Array.isArray(targetSchema.oneOf)) {
+        targetSchema.oneOf = targetSchema.oneOf.map(item => modifySchemaProperties(item, config));
+    }
+    if (Array.isArray(targetSchema.anyOf)) {
+        targetSchema.anyOf = targetSchema.anyOf.map(item => modifySchemaProperties(item, config));
+    }
+    if (Array.isArray(targetSchema.allOf)) {
+        targetSchema.allOf = targetSchema.allOf.map(item => modifySchemaProperties(item, config));
+    }
+    // modify properties
+    if (targetSchema.properties) {
+        const props = { ...targetSchema.properties };
+        let required = Array.isArray(targetSchema.required) ? [...targetSchema.required] : [];
+        for (const key of Object.keys(props)) {
+            if (!(0, utils_1.isMatch)(key, config.match)) {
+                continue;
+            }
+            const { required: requiredOverride, value: valueSchema } = (0, hepler_1.applyModifierSchema)(props[key], config, { required: required.includes(key) });
+            required = required.filter(r => r !== key);
+            if (!valueSchema) {
+                delete props[key];
+                continue;
+            }
+            props[key] = valueSchema;
+            if (requiredOverride) {
+                required.push(key);
+            }
+        }
+        targetSchema.properties = props;
+        targetSchema.required = Array.from(new Set(required));
+    }
+    return targetSchema;
+}
+function modifyParameters(parameters, type, config) {
+    if (!parameters || !Array.isArray(parameters)) {
+        return parameters;
+    }
+    return parameters.map((param) => {
+        if (param.in === type) {
+            if (!(0, utils_1.isMatch)(param.name, config.match)) {
+                return param;
+            }
+            const { value: schema, required } = (0, hepler_1.applyModifierSchema)(param.schema, config, { required: !!param.required });
+            if (!schema) {
+                return null;
+            }
+            return {
+                ...param,
+                schema,
+                required,
+            };
+        }
+        return param;
+    }).filter(item => item !== null);
+}
+function payloadModifierApiDescriptor(apiDescriptor, config) {
+    if (!apiDescriptor) {
+        return null;
+    }
+    const newDescriptor = { ...apiDescriptor };
+    const { scope } = config;
+    switch (scope) {
+        case constant_1.ModifierScope.PARAMS:
+            if (newDescriptor.parameters) {
+                newDescriptor.parameters = modifyParameters(newDescriptor.parameters, constant_1.ParameterIn.QUERY, config);
+            }
+            break;
+        case constant_1.ModifierScope.PATH_PARAMS:
+            if (newDescriptor.parameters) {
+                newDescriptor.parameters = modifyParameters(newDescriptor.parameters, constant_1.ParameterIn.PATH, config);
+            }
+            break;
+        case constant_1.ModifierScope.DATA:
+            if (newDescriptor.requestBody) {
+                newDescriptor.requestBody = modifySchemaProperties(newDescriptor.requestBody, config);
+            }
+            break;
+        case constant_1.ModifierScope.RESPONSE:
+            if (newDescriptor.responses) {
+                newDescriptor.responses = modifySchemaProperties(newDescriptor.responses, config);
+            }
+            break;
+        default:
+            break;
+    }
+    return newDescriptor;
+}
+function payloadModifier(configs) {
+    return {
+        name: constant_1.PluginName.PAYLOAD_MODIFIER,
+        config({ config }) {
+            return (0, utils_1.extend)(config, {
+                handleApi: (apiDescriptor) => {
+                    if (!apiDescriptor) {
+                        return null;
+                    }
+                    // Apply each configuration in sequence
+                    return configs.reduce((desc, conf) => {
+                        if (!desc) {
+                            return null;
+                        }
+                        return payloadModifierApiDescriptor(desc, conf);
+                    }, apiDescriptor);
+                },
+            });
+        },
+    };
+}
+exports.default = payloadModifier;

package/dist/plugins/presets/payloadModifier/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/presets/platform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platform = platform;
+const constant_1 = require("../../constant");
+/**
+ * Generate OpenAPI file URLs based on platform type.
+ * For Swagger and Knife4j, generates multiple URLs covering both OAS3 and Swagger2 endpoints.
+ */
+function resolvePlatformUrls(baseUrl, platformType) {
+    // Normalize: remove trailing slash
+    const base = baseUrl.replace(/\/+$/, '');
+    switch (platformType) {
+        case 'swagger':
+            // Try OAS3 first, then Swagger2, then generic openapi.json
+            return [
+                `${base}/openapi.json`,
+                `${base}/v2/swagger.json`,
+                `${base}/api/v3/openapi.json`,
+                baseUrl,
+            ];
+        case 'knife4j':
+            // Try OAS3 first (springdoc), then Swagger2 (springfox)
+            return [
+                `${base}/v3/api-docs`,
+                `${base}/v2/api-docs`,
+                baseUrl,
+            ];
+        case 'fastapi':
+            return [`${base}/openapi.json`, baseUrl];
+        case 'yapi':
+            // YApi requires pid and token in URL, use input as-is
+            return [baseUrl];
+    }
+}
+/**
+ * Platform plugin for auto-resolving OpenAPI file URLs.
+ *
+ * Pass a platform type (e.g., `'swagger'`) and the plugin will use `config.input`
+ * as the base URL to generate candidate OpenAPI file URLs. The framework will try
+ * each URL in order and use the first successful response.
+ *
+ * @param platformType - The platform type: 'swagger' | 'knife4j' | 'fastapi' | 'yapi'
+ * @returns ApiPlugin
+ *
+ * @example
+ * ```ts
+ * import { platform, alovaGlobals } from 'worma/plugin';
+ *
+ * defineConfig({
+ *   generator: [{
+ *     input: 'https://petstore3.swagger.io',
+ *     plugins: [platform('swagger'), alovaGlobals()],
+ *     output: './src/api',
+ *   }]
+ * });
+ * ```
+ */
+function platform(platformType) {
+    return {
+        name: constant_1.PluginName.PLATFORM,
+        config({ config }) {
+            const raw = config.input;
+            if (!raw)
+                return config;
+            // Normalize to an array of base URLs, deduplicate
+            const inputs = Array.isArray(raw) ? [...new Set(raw)] : [raw];
+            // For each input, generate platform URLs, then flatten
+            config.input = inputs.flatMap(url => resolvePlatformUrls(url, platformType));
+            return config;
+        },
+    };
+}
+exports.default = platform;

package/dist/plugins/presets/rename.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rename = rename;
+const constant_1 = require("../../constant");
+const utils_1 = require("./utils");
+function toCamelCase(str) {
+    return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : '')).replace(/^(.)/, c => c.toLowerCase());
+}
+function toCase(str) {
+    return str
+        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1_$2')
+        .replace(/[-\s]+/g, '_')
+        .toLowerCase();
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z\d])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1-$2')
+        .replace(/[_\s]+/g, '-')
+        .toLowerCase();
+}
+function toPascalCase(str) {
+    return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : '')).replace(/^(.)/, c => c.toUpperCase());
+}
+/**
+ * Applies renaming rules to the specified value
+ * @returns The renamed value, or original value if not matched
+ */
+function applyRenameRule(value, config, apiDescriptor) {
+    if (!(0, utils_1.isMatch)(value, config.match)) {
+        return value;
+    }
+    if (config.transform) {
+        value = config.transform(apiDescriptor, value);
+    }
+    if (!config.style) {
+        return value;
+    }
+    if (config.style === 'kebabCase' && config.scope === 'refName') {
+        throw new Error(`Invalid rename style: ${config.style}、${config.scope}`);
+    }
+    switch (config.style) {
+        case 'camelCase':
+            return toCamelCase(value);
+        case 'snakeCase':
+            return toCase(value);
+        case 'kebabCase':
+            return toKebabCase(value);
+        case 'pascalCase':
+            return toPascalCase(value);
+        default:
+            throw new Error(`Invalid rename style: ${config.style}`);
+    }
+}
+/**
+ * renames URL path by processing each segment individually
+ * while keeping path parameter placeholders
+ */
+function renameUrl(url, config, apiDescriptor) {
+    const segments = url.split('/');
+    return segments
+        .map((segment) => {
+        // Skip parameter placeholders and empty segments
+        if ((segment.startsWith('{') && segment.endsWith('}')) || !segment) {
+            return segment;
+        }
+        return applyRenameRule(segment, config, apiDescriptor);
+    })
+        .join('/')
+        .replace(/^\/{2,}/g, '/');
+}
+/**
+ * Transforms object properties using the renaming rules
+ */
+function transformProperties(obj, config, apiDescriptor) {
+    if (!obj || typeof obj !== 'object' || !('properties' in obj)) {
+        return obj;
+    }
+    const properties = { ...obj.properties };
+    const newProperties = {};
+    for (const key in properties) {
+        const newKey = applyRenameRule(key, config, apiDescriptor);
+        newProperties[newKey] = properties[key];
+    }
+    return {
+        ...obj,
+        properties: newProperties,
+    };
+}
+/**
+ * Transforms parameters of specific type using the renaming rules
+ */
+function transformParameters(parameters, type, config, apiDescriptor) {
+    if (!parameters || !Array.isArray(parameters)) {
+        return parameters;
+    }
+    return parameters.map((param) => {
+        if (param.in === type) {
+            return {
+                ...param,
+                name: applyRenameRule(param.name, config, apiDescriptor),
+            };
+        }
+        return param;
+    });
+}
+function transformRefNameMap(refNameMap, config, apiDescriptor) {
+    if (!refNameMap || typeof refNameMap !== 'object') {
+        return refNameMap;
+    }
+    const newRefNameMap = {};
+    for (const key in refNameMap) {
+        const newValue = applyRenameRule(refNameMap[key], config, apiDescriptor);
+        newRefNameMap[key] = newValue;
+    }
+    return newRefNameMap;
+}
+/**
+ * Processes API descriptor based on renaming configuration
+ *
+ * Each scope targets different parts of the API descriptor:
+ * - url: Renames URL path segments
+ * - params: Renames query parameters
+ * - pathParams: Renames path parameters and their placeholders in URL
+ * - data: Renames request body properties
+ * - response: Renames response body properties
+ */
+function renameApiDescriptor(apiDescriptor, config) {
+    if (!apiDescriptor)
+        return apiDescriptor;
+    const newDescriptor = { ...apiDescriptor };
+    const scope = config.scope || constant_1.RenameScope.URL;
+    switch (scope) {
+        case constant_1.RenameScope.PARAMS:
+            if (newDescriptor.parameters) {
+                newDescriptor.parameters = transformParameters(newDescriptor.parameters, constant_1.ParameterIn.QUERY, config, apiDescriptor);
+            }
+            break;
+        case constant_1.RenameScope.PATH_PARAMS:
+            if (newDescriptor.parameters) {
+                newDescriptor.parameters = transformParameters(newDescriptor.parameters, constant_1.ParameterIn.PATH, config, apiDescriptor);
+            }
+            if (newDescriptor.url) {
+                newDescriptor.url = newDescriptor.url.replace(/\{([^}]+)\}/g, (match, paramName) => {
+                    const newName = applyRenameRule(paramName, config, apiDescriptor);
+                    return `{${newName}}`;
+                });
+            }
+            break;
+        case constant_1.RenameScope.DATA:
+            if (newDescriptor.requestBody) {
+                newDescriptor.requestBody = transformProperties(newDescriptor.requestBody, config, apiDescriptor);
+            }
+            break;
+        case constant_1.RenameScope.RESPONSE:
+            if (newDescriptor.responses) {
+                newDescriptor.responses = transformProperties(newDescriptor.responses, config, apiDescriptor);
+            }
+            break;
+        case constant_1.RenameScope.URL:
+            if (newDescriptor.url) {
+                newDescriptor.url = renameUrl(newDescriptor.url, config, apiDescriptor);
+            }
+            break;
+        case constant_1.RenameScope.REF_NAME:
+            if (newDescriptor.refNameMap) {
+                newDescriptor.refNameMap = transformRefNameMap(newDescriptor.refNameMap, config, apiDescriptor);
+            }
+            break;
+        default:
+            // No action needed, keep original descriptor
+            break;
+    }
+    return newDescriptor;
+}
+/**
+ * Creates a rename plugin that transforms API descriptors
+ * according to specified naming rules
+ */
+function rename(config) {
+    const configs = Array.isArray(config) ? config : [config];
+    for (const conf of configs) {
+        if (!conf.style && !conf.transform) {
+            throw new Error('at least one of `style` or `transform` is required');
+        }
+        if (conf.style === 'kebabCase' && conf.scope === 'refName') {
+            throw new Error(`Invalid rename style: ${conf.style}、${conf.scope}`);
+        }
+    }
+    return {
+        name: constant_1.PluginName.RENAME,
+        config({ config }) {
+            return (0, utils_1.extend)(config, {
+                handleApi: (apiDescriptor) => {
+                    if (!apiDescriptor)
+                        return null;
+                    // Apply each configuration in sequence
+                    return configs.reduce((desc, conf) => {
+                        if (!desc)
+                            return null;
+                        return renameApiDescriptor(desc, conf);
+                    }, apiDescriptor);
+                },
+            });
+        },
+    };
+}
+exports.default = rename;

package/dist/plugins/presets/tagModifier.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processApiTags = processApiTags;
+exports.tagModifier = tagModifier;
+const constant_1 = require("../../constant");
+const utils_1 = require("./utils");
+/**
+ * Validates if tag name follows naming conventions
+ * @param tag The tag name to validate
+ * @returns true if valid, false otherwise
+ */
+function isValidTagName(tag) {
+    if (!tag || typeof tag !== 'string') {
+        return false;
+    }
+    const trimmedTag = tag.trim();
+    if (!trimmedTag) {
+        return false;
+    }
+    // Basic naming convention: allow letters, numbers, hyphens, underscores and Chinese characters
+    const validPattern = /^[\u4E00-\u9FA5\w-]+$/;
+    return validPattern.test(trimmedTag);
+}
+/**
+ * Processes tags in the API descriptor
+ * @param apiDescriptor The API descriptor
+ * @param handler Tag modifier handler function
+ * @returns Modified API descriptor
+ */
+function processApiTags(apiDescriptor, handler) {
+    if (!apiDescriptor)
+        return apiDescriptor;
+    const newDescriptor = { ...apiDescriptor };
+    // Check if tags property exists and is an array
+    if (!newDescriptor.tags || !Array.isArray(newDescriptor.tags)) {
+        return newDescriptor;
+    }
+    // Process each tag and filter out null/undefined results
+    newDescriptor.tags = newDescriptor.tags
+        .map((tag) => {
+        try {
+            // Call user provided handler function
+            const modifiedTag = handler(tag);
+            // If handler returns null/undefined/void, remove this tag
+            if (!modifiedTag) {
+                return null;
+            }
+            // Validate if modified tag follows naming conventions
+            if (!isValidTagName(modifiedTag)) {
+                return tag; // Keep original tag if invalid
+            }
+            return modifiedTag.trim(); // Return trimmed modified tag
+        }
+        catch {
+            return tag; // Return original tag on error
+        }
+    })
+        .filter((tag) => tag != null); // Filter out null/undefined values
+    return newDescriptor;
+}
+/**
+ * Creates a tag modifier plugin
+ *
+ * @param handler Tag modifier handler function that receives a tag string and returns modified tag or null/undefined/void to remove the tag
+ * @returns API plugin instance
+ *
+ * @example
+ * ```ts
+ * // Convert all tags to uppercase
+ * const upperCasePlugin = tagModifier(tag => tag.toUpperCase());
+ *
+ * // Add prefix to tags
+ * const prefixPlugin = tagModifier(tag => `api-${tag}`);
+ *
+ * // Remove specific tags
+ * const filterPlugin = tagModifier(tag => tag === 'internal' ? null : tag);
+ *
+ * // Use the plugin
+ * export default {
+ *   generator: [{
+ *     // ...other config
+ *     plugins: [upperCasePlugin]
+ *   }]
+ * };
+ * ```
+ */
+function tagModifier(handler) {
+    if (!handler || typeof handler !== 'function') {
+        throw new Error('tagModifier requires a valid handler function');
+    }
+    return {
+        name: constant_1.PluginName.TAG_MODIFIER,
+        config({ config }) {
+            return (0, utils_1.extend)(config, {
+                handleApi: (apiDescriptor) => {
+                    if (!apiDescriptor)
+                        return null;
+                    return processApiTags(apiDescriptor, handler);
+                },
+            });
+        },
+    };
+}
+exports.default = tagModifier;

package/dist/plugins/presets/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extend = extend;
+exports.isMatch = isMatch;
+const prepareConfig_1 = require("../../functions/prepareConfig");
+/**
+ * 扩展生成器配置：
+ * 根据传入的 newConfig（对象或函数）与基础 config 生成合并后的配置。
+ * 当未提供 newConfig 时，直接回退到原始 config。
+ * @param config 基础配置
+ * @param newConfig 需要扩展的配置或用于生成扩展配置的函数
+ * @returns 合并且标准化后的配置
+ */
+function extend(config, newConfig) {
+    // 根据 newConfig 类型计算扩展配置：函数则调用生成配置，否则直接使用对象；未提供则回退到原始 config
+    const pluginExtendsConfig = typeof newConfig === 'function' ? newConfig(config) : (newConfig ?? config);
+    // 使用 extendsConfig 进行配置合并与标准化，确保最终结构满足生成器需求
+    return (0, prepareConfig_1.extendsConfig)(config, pluginExtendsConfig);
+}
+/**
+ * Tests if value matches the specified rule
+ */
+function isMatch(value, match) {
+    if (!match)
+        return true;
+    if (typeof match === 'string') {
+        return value.includes(match);
+    }
+    if (match instanceof RegExp) {
+        return match.test(value);
+    }
+    if (typeof match === 'function') {
+        return match(value);
+    }
+    return false;
+}

package/dist/readConfig.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfig = readConfig;
+exports.getApiDocs = getApiDocs;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const esbuild_1 = __importDefault(require("esbuild"));
+const wormaJson_1 = require("./functions/wormaJson");
+const helper_1 = require("./helper");
+const utils_1 = require("./utils");
+const readWormaRc_1 = require("./functions/readWormaRc");
+/**
+ * Read the worma.config configuration file and return the parsed configuration object.
+ * @param projectPath The project path where the configuration file is located. The default value is `process.cwd()`.
+ * @returns a promise instance that contains configuration object.
+ */
+async function readConfig(projectPath = process.cwd()) {
+    const configFile = await (0, utils_1.resolveConfigFile)(projectPath);
+    if (!configFile) {
+        throw helper_1.logger.throwError(`Cannot found config file from path ${projectPath}`, {
+            projectPath,
+            name: 'readConfig',
+        });
+    }
+    // Check if it's a .wormarc file
+    if (configFile.endsWith('.wormarc')) {
+        const config = await (0, readWormaRc_1.readWormaRc)(projectPath);
+        if (!config) {
+            throw helper_1.logger.throwError(`Failed to parse .wormarc file from path ${projectPath}`, {
+                projectPath,
+                name: 'readConfig',
+            });
+        }
+        await helper_1.configHelper.load(config, projectPath);
+        return config;
+    }
+    // 获取用户已安装的依赖
+    const userDependencies = await (0, utils_1.getUserInstalledDependencies)(projectPath);
+    // 始终将 worma 自身作为外部依赖，防止 esbuild 打包 worma 源码进入临时文件
+    // 否则 __dirname 会指向用户项目目录，导致预设模板路径解析失败
+    // monorepo 子包可能不直接依赖 worma，但 config 文件会 import from 'worma'
+    const allExternals = [...new Set([...userDependencies, 'worma', 'worma/plugin'])];
+    const configTmpFileName = `alova_tmp_${Date.now()}.cjs`;
+    // 使用绝对路径：esbuild 写入相对 outfile 时按 cwd 解析，
+    // 而 require() 解析相对路径时基于调用模块所在目录，二者不一致会导致 require 失败。
+    // 绝对路径可保证写入与 require 指向同一文件。
+    const outfile = node_path_1.default.resolve(projectPath, configTmpFileName);
+    await esbuild_1.default.build({
+        entryPoints: [configFile],
+        // 排除用户已安装的依赖，避免打包进最终文件
+        external: allExternals,
+        bundle: true,
+        format: 'cjs',
+        platform: 'node',
+        outfile,
+        logLevel: 'silent',
+    });
+    // try/finally 保证临时文件在任何情况下（require 抛错）都被清理
+    let module;
+    try {
+        // eslint-disable-next-line ts/no-require-imports
+        module = require(outfile);
+    }
+    finally {
+        await (0, promises_1.unlink)(outfile);
+    }
+    const config = await helper_1.configHelper.readUserConfig(module.default || module);
+    // Read the cache file and save it
+    await helper_1.configHelper.load(config, projectPath);
+    return helper_1.configHelper.getConfig();
+}
+/**
+ * Get cached API docs. Cache is self-describing — no config needed.
+ * In monorepo, pass ANY sub-package path; cache is always read from the unified cacheRoot.
+ * @param outputs Optional filter: only return entries matching these output paths.
+ *                If omitted, returns ALL cached entries (including all monorepo sub-projects).
+ * @param projectPath Project root, defaults to `process.cwd()`.
+ */
+async function getApiDocs(outputs, projectPath = process.cwd()) {
+    if (!projectPath) {
+        return [];
+    }
+    if (outputs && outputs.length > 0) {
+        const results = await Promise.all(outputs.map(o => (0, wormaJson_1.readCacheApis)(projectPath, o)));
+        return results.filter((r) => r !== null);
+    }
+    // No filter: return all (includes all monorepo sub-projects)
+    return (0, wormaJson_1.readAllCacheApis)(projectPath);
+}