wormajs 0.2.0 → 0.2.1

package/dist/functions/prepareConfig.js

@@ -12,6 +12,10 @@ function extendsConfig(config, newConfig) {
         }
         // handleApi is a special case, we need to merge the functions
         if (typeof newValue === 'function' && typeof srcValue === 'function') {
+            // Avoid chaining the same function reference with itself (idempotency guard).
+            if (newValue === srcValue) {
+                return newValue;
+            }
             // chain the functions
             return (...args) => {
                 const result = srcValue(...args);

package/dist/generate.js

@@ -19,12 +19,11 @@ async function generate(config, options) {
         return [];
     const projectPath = options?.projectPath ?? process.cwd();
     const emit = options?.onProgress;
-    // Load phase (shared, no per-gen events during load) — plugins may modify generator configs
-    helper_1.logger.debug('Loading config', { projectPath });
-    await helper_1.configHelper.load(config, projectPath);
-    // Use the processed generators from ConfigManager (after plugin hooks have run)
-    const generators = helper_1.configHelper.getConfig().generator;
-    helper_1.logger.debug('Config loaded', { generatorCount: generators.length });
+    // Each generate() call creates its own ConfigHelper / ConfigManager,
+    // so multiple concurrent calls never share mutable config state.
+    const helper = new helper_1.ConfigHelper();
+    await helper.load(config, projectPath);
+    const generators = helper.getConfig().generator;
     // Run all generators in parallel, each with its own ProgressTracker
     const results = await Promise.all(generators.map(async (gen, i) => {
         const generatorName = gen.input || `generator-${i}`;

package/dist/helper/config/ConfigHelper.js

@@ -1,30 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configHelper = exports.ConfigHelper = void 0;
+exports.ConfigHelper = void 0;
 const lodash_1 = require("lodash");
 const helper_1 = require("../../helper");
-const logger_1 = require("../../helper/logger");
 const ConfigManager_1 = require("./ConfigManager");
 const GeneratorHelper_1 = require("./GeneratorHelper");
 class ConfigHelper {
     constructor() {
-        this.configManager = ConfigManager_1.ConfigManager.getInstance();
-    }
-    static getInstance() {
-        if (!ConfigHelper.instance) {
-            ConfigHelper.instance = new ConfigHelper();
-        }
-        return ConfigHelper.instance;
+        this.configManager = new ConfigManager_1.ConfigManager();
     }
     async load(config, projectPath = process.cwd(), tracker) {
         this.projectPath = projectPath;
-        logger_1.logger.debug('ConfigHelper.load — loading config manager', { projectPath, generatorCount: config.generator?.length ?? 0 });
         await this.configManager.load(config, projectPath, tracker);
-        logger_1.logger.debug('ConfigHelper.load — reading cache data');
         await this.readAlovaJson();
-        logger_1.logger.debug('ConfigHelper.load — complete');
     }
-    async readUserConfig(userConfig) {
+    static async readUserConfig(userConfig) {
         if (typeof userConfig === 'function') {
             return await userConfig();
         }
@@ -76,4 +66,3 @@ class ConfigHelper {
     }
 }
 exports.ConfigHelper = ConfigHelper;
-exports.configHelper = ConfigHelper.getInstance();

package/dist/helper/config/ConfigManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configManager = exports.ConfigManager = void 0;
+exports.ConfigManager = void 0;
 const zod_validation_error_1 = require("zod-validation-error");
 const prepareConfig_1 = __importDefault(require("../../functions/prepareConfig"));
 const GeneratorHelper_1 = require("../../helper/config/GeneratorHelper");
@@ -17,12 +17,6 @@ class ConfigManager {
         this.defaultGeneratorConfig = GeneratorHelper_1.generatorHelper.getDefaultConfig();
         this.config = this.defaultConfig;
     }
-    static getInstance() {
-        if (!ConfigManager.instance) {
-            ConfigManager.instance = new ConfigManager();
-        }
-        return ConfigManager.instance;
-    }
     /**
      * 加载并验证配置
      */
@@ -84,5 +78,3 @@ class ConfigManager {
     }
 }
 exports.ConfigManager = ConfigManager;
-// 导出单例实例
-exports.configManager = ConfigManager.getInstance();

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

@@ -1,8 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyModifierSchema = applyModifierSchema;
+// Detect a `SchemaOptional` wrapper: { required: boolean, type: Schema }.
+// The `required` must be a literal boolean so a plain SchemaReference whose
+// property happens to be named "required" (e.g. { required: 'boolean' }) is not misread.
+function isSchemaOptional(val) {
+    return !!val
+        && typeof val === 'object'
+        && !Array.isArray(val)
+        && typeof val.required === 'boolean'
+        && 'type' in val;
+}
+// Collapse (possibly nested) `SchemaOptional` wrappers.
+// - The OUTERMOST `required` wins; inner `required` fields are ignored.
+// - A non-wrapped value defaults to required (required: true).
+function unwrapOptional(s) {
+    if (!isSchemaOptional(s)) {
+        return { required: true, type: s };
+    }
+    const required = s.required;
+    let type = s.type;
+    while (isSchemaOptional(type)) {
+        type = type.type;
+    }
+    return { required, type };
+}
+// Remove the internal `_$ref` marker that `removeAll$ref` stamps onto dereferenced
+// component schemas. When a handler replaces a schema, the result must NOT inherit the
+// original component's `_$ref` — otherwise `mergeObject`/`removeBaseReference` downstream
+// treats the replacement as a reference to the original component and discards the change.
+function stripInternalRef(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(stripInternalRef);
+    }
+    const out = {};
+    for (const key of Object.keys(schema)) {
+        if (key === '_$ref') {
+            continue;
+        }
+        out[key] = stripInternalRef(schema[key]);
+    }
+    return out;
+}
+// Set of valid SchemaPrimitive values for O(1) validation lookup
+const VALID_PRIMITIVES = new Set([
+    'number',
+    'string',
+    'boolean',
+    'undefined',
+    'null',
+    'unknown',
+    'any',
+    'never',
+]);
+function validatePrimitive(val) {
+    if (!VALID_PRIMITIVES.has(val)) {
+        throw new Error(`[payloadModifier] Invalid schema type "${val}". Must be one of: ${[...VALID_PRIMITIVES].join(', ')}`);
+    }
+}
 // Convert Schema (custom spec) -> OpenAPI SchemaObject
 function toSchemaObject(base, s) {
+    // A `SchemaOptional` wrapper only affects requiredness (handled by the caller);
+    // here we care about the type shape, so fully unwrap nested wrappers first.
+    if (isSchemaOptional(s)) {
+        s = unwrapOptional(s).type;
+    }
     const result = { ...base };
     const cleanType = (schema) => {
         delete schema.type;
@@ -24,8 +89,9 @@ function toSchemaObject(base, s) {
         result.items = (items.length === 1 ? items[0] : items);
         return result;
     }
-    // Primitive types and no-op primitives
+    // Primitive types — validate against SchemaPrimitive set during conversion
     if (typeof s === 'string') {
+        validatePrimitive(s);
         result.type = s;
         return result;
     }
@@ -56,12 +122,16 @@ function toSchemaObject(base, s) {
         const spec = s;
         result.enum = spec.enum;
         if (spec.type) {
+            if (typeof spec.type === 'string') {
+                validatePrimitive(spec.type);
+            }
             result.type = spec.type;
         }
         return result;
     }
     // Object (reference-like map): replace properties and required with handler's spec
-    // (the SchemaReference returned by the handler fully replaces this field, only keeping scalar fields like description from base)
+    // (the SchemaReference returned by the handler fully replaces this field, only keeping
+    // scalar fields like description from base)
     const ref = s;
     if (ref && typeof ref === 'object') {
         result.type = 'object';
@@ -72,15 +142,27 @@ function toSchemaObject(base, s) {
             if (!val) {
                 continue;
             }
-            const optional = key.endsWith('?');
-            const cleanKey = optional ? key.slice(0, -1) : key;
-            const baseProp = properties[cleanKey];
-            properties[cleanKey] = toSchemaObject(baseProp || {}, val);
-            if (optional) {
-                requiredSet.delete(cleanKey);
+            // SchemaOptional wrapper: optionality expressed via { required, type };
+            // bare value defaults to required. Nested wrappers are collapsed — outermost
+            // `required` wins, inner ones are ignored.
+            let isOptional;
+            let effectiveVal;
+            if (isSchemaOptional(val)) {
+                const { required, type } = unwrapOptional(val);
+                isOptional = !required;
+                effectiveVal = type;
+            }
+            else {
+                isOptional = false;
+                effectiveVal = val;
+            }
+            const baseProp = properties[key];
+            properties[key] = toSchemaObject(baseProp || {}, effectiveVal);
+            if (isOptional) {
+                requiredSet.delete(key);
             }
             else {
-                requiredSet.add(cleanKey);
+                requiredSet.add(key);
             }
         }
         result.properties = properties;
@@ -145,8 +227,8 @@ function toSchemaSpec(obj) {
         const result = {};
         for (const key of Object.keys(properties)) {
             const spec = toSchemaSpec(properties[key]);
-            const finalKey = requiredSet.has(key) ? key : `${key}?`;
-            result[finalKey] = spec;
+            // Required fields are written bare; optional fields wrapped with SchemaOptional
+            result[key] = requiredSet.has(key) ? spec : { required: false, type: spec };
         }
         return result;
     }
@@ -159,9 +241,9 @@ function toSchemaSpec(obj) {
     return schemaTypeToPrimitiveType(obj.type);
 }
 // Replace whole schema based on handler result (used for params/pathParams)
-function applyModifierSchema(schema, config, { required }) {
+function applyModifierSchema(schema, config, { required, key }) {
     if (!schema || typeof schema !== 'object') {
-        return schema;
+        return { required, schema: schema };
     }
     const cloned = { ...schema };
     const currentSpec = toSchemaSpec(cloned);
@@ -169,23 +251,38 @@ function applyModifierSchema(schema, config, { required }) {
     const handlerInput = (required === false && typeof currentSpec === 'string')
         ? { required: false, type: currentSpec }
         : currentSpec;
-    const ret = config.handler(handlerInput);
+    const ret = config.handler(handlerInput, key);
     if (!ret) {
         return {
             required,
             schema: null,
         };
     }
-    // A returned { required, type } means changing requiredness (driven by the `type` field)
-    if (typeof ret === 'object' && !Array.isArray(ret) && 'required' in ret && 'type' in ret) {
-        const opt = ret;
+    // A returned SchemaOptional means changing requiredness (driven by the `type` field).
+    // Nested wrappers are collapsed: the outermost `required` wins, inner ones are ignored;
+    // `type` may be any Schema expression (primitive, object, array, union, ...).
+    if (isSchemaOptional(ret)) {
+        const { required: nextRequired, type } = unwrapOptional(ret);
+        let r = stripInternalRef(toSchemaObject(cloned, type));
+        // When handler explicitly sets required=false, propagate to object-level required array
+        // so all properties become nullable as semantically expected
+        if (!nextRequired && r && typeof r === 'object' && !Array.isArray(r)) {
+            const robj = r;
+            if (robj.type === 'object' && Array.isArray(robj.required) && robj.required.length > 0) {
+                r = { ...r, required: [] };
+            }
+        }
         return {
-            required: !!(opt.required ?? required),
-            schema: toSchemaObject(cloned, opt.type),
+            required: nextRequired,
+            schema: r,
         };
     }
+    // Non-SchemaOptional return: handler explicitly provides a type value,
+    // so default to required=true (the handler had the chance to wrap with
+    // { required: false, type: ... } if it wanted to keep it optional).
+    const r = stripInternalRef(toSchemaObject(cloned, ret));
     return {
-        required,
-        schema: toSchemaObject(cloned, ret),
+        required: true,
+        schema: r,
     };
 }

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

@@ -4,13 +4,58 @@ 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)
+// Convert parameters of a specific type (query/path) into an object schema
+function parametersToSchema(parameters, type) {
+    if (!parameters || !Array.isArray(parameters)) {
+        return { type: 'object', properties: {}, required: [] };
+    }
+    const schema = { type: 'object', properties: {}, required: [] };
+    for (const param of parameters) {
+        if (param.in === type) {
+            ;
+            schema.properties[param.name] = param.schema;
+            if (param.required) {
+                ;
+                schema.required.push(param.name);
+            }
+        }
+    }
+    return schema;
+}
+// Convert an object schema back to parameters, keeping other types untouched
+function schemaToParameters(parameters, schema, type) {
+    if (!parameters || !Array.isArray(parameters)) {
+        return parameters;
+    }
+    if (!schema || typeof schema !== 'object' || !schema.properties) {
+        return parameters.filter(param => param.in !== type);
+    }
+    const requiredSet = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const newParameters = [];
+    for (const param of parameters) {
+        if (param.in !== type) {
+            newParameters.push(param);
+            continue;
+        }
+        const propSchema = schema.properties[param.name];
+        if (!propSchema) {
+            continue;
+        }
+        newParameters.push({
+            ...param,
+            schema: propSchema,
+            required: requiredSet.has(param.name),
+        });
+    }
+    return newParameters;
+}
+// Apply modifications to properties of an object schema (used when `match` is set)
 function modifySchemaProperties(schema, config) {
     if (!schema || typeof schema !== 'object') {
         return schema;
     }
     const targetSchema = { ...schema };
-    // union recursively
+    // recurse into union keywords
     if (Array.isArray(targetSchema.oneOf)) {
         targetSchema.oneOf = targetSchema.oneOf.map(item => modifySchemaProperties(item, config));
     }
@@ -20,7 +65,7 @@ function modifySchemaProperties(schema, config) {
     if (Array.isArray(targetSchema.allOf)) {
         targetSchema.allOf = targetSchema.allOf.map(item => modifySchemaProperties(item, config));
     }
-    // modify properties
+    // modify matched properties
     if (targetSchema.properties) {
         const props = { ...targetSchema.properties };
         let required = Array.isArray(targetSchema.required) ? [...targetSchema.required] : [];
@@ -28,7 +73,7 @@ function modifySchemaProperties(schema, config) {
             if (!(0, utils_1.isMatch)(key, config.match)) {
                 continue;
             }
-            const { required: requiredOverride, schema: schemaValue } = (0, hepler_1.applyModifierSchema)(props[key], config, { required: required.includes(key) });
+            const { required: requiredOverride, schema: schemaValue } = (0, hepler_1.applyModifierSchema)(props[key], config, { required: required.includes(key), key });
             required = required.filter(r => r !== key);
             if (!schemaValue) {
                 delete props[key];
@@ -44,56 +89,59 @@ function modifySchemaProperties(schema, config) {
     }
     return targetSchema;
 }
+// Apply modifications to matched parameters (used when `match` is set for params/pathParams)
 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 { schema, required } = (0, hepler_1.applyModifierSchema)(param.schema, config, { required: !!param.required });
-            if (!schema) {
-                return null;
-            }
-            return {
-                ...param,
-                schema,
-                required,
-            };
+        if (param.in !== type || !(0, utils_1.isMatch)(param.name, config.match)) {
+            return param;
+        }
+        const { schema, required } = (0, hepler_1.applyModifierSchema)(param.schema, config, { required: !!param.required, key: param.name });
+        if (!schema) {
+            return null;
         }
-        return param;
+        return { ...param, schema, required };
     }).filter(item => item !== null);
 }
+// Apply config to a parameter scope (params or pathParams)
+function applyToParameters(parameters, type, config) {
+    if (!parameters)
+        return undefined;
+    if (config.match) {
+        return modifyParameters(parameters, type, config);
+    }
+    const schema = parametersToSchema(parameters, type);
+    const result = (0, hepler_1.applyModifierSchema)(schema, config, { required: false });
+    return schemaToParameters(parameters, result.schema, type);
+}
+// Apply config to a schema scope (data or response)
+function applyToSchemaField(schema, config) {
+    if (!schema)
+        return undefined;
+    if (config.match) {
+        return modifySchemaProperties(schema, config);
+    }
+    return (0, hepler_1.applyModifierSchema)(schema, config, { required: false }).schema ?? undefined;
+}
 function payloadModifierApiDescriptor(apiDescriptor, config) {
-    if (!apiDescriptor) {
+    if (!apiDescriptor)
         return null;
-    }
     const newDescriptor = { ...apiDescriptor };
     const { scope } = config;
     switch (scope) {
         case 'params':
-            if (newDescriptor.parameters) {
-                newDescriptor.parameters = modifyParameters(newDescriptor.parameters, constant_1.ParameterIn.QUERY, config);
-            }
+            newDescriptor.parameters = applyToParameters(newDescriptor.parameters, constant_1.ParameterIn.QUERY, config);
             break;
         case 'pathParams':
-            if (newDescriptor.parameters) {
-                newDescriptor.parameters = modifyParameters(newDescriptor.parameters, constant_1.ParameterIn.PATH, config);
-            }
+            newDescriptor.parameters = applyToParameters(newDescriptor.parameters, constant_1.ParameterIn.PATH, config);
             break;
         case 'data':
-            if (newDescriptor.requestBody) {
-                newDescriptor.requestBody = modifySchemaProperties(newDescriptor.requestBody, config);
-            }
+            newDescriptor.requestBody = applyToSchemaField(newDescriptor.requestBody, config);
             break;
         case 'response':
-            if (newDescriptor.responses) {
-                newDescriptor.responses = modifySchemaProperties(newDescriptor.responses, config);
-            }
-            break;
-        default:
+            newDescriptor.responses = applyToSchemaField(newDescriptor.responses, config);
             break;
     }
     return newDescriptor;

package/dist/readConfig.js

@@ -34,7 +34,6 @@ async function readConfig(projectPath = process.cwd()) {
                 name: 'readConfig',
             });
         }
-        await helper_1.configHelper.load(config, projectPath);
         return config;
     }
     // 获取用户已安装的依赖
@@ -67,10 +66,8 @@ async function readConfig(projectPath = process.cwd()) {
     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();
+    const config = await helper_1.ConfigHelper.readUserConfig(module.default || module);
+    return config;
 }
 /**
  * Get cached API docs. Cache is self-describing — no config needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wormajs",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A modern OpenAPI code generator - Generate type-safe API clients from OpenAPI specs",
   "author": "worma",
   "license": "MIT",

package/typings/index.d.ts

@@ -497,7 +497,7 @@ export declare const logger: Logger$1;
  * @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.
  */
-export declare function readConfig(projectPath?: string): Promise<Readonly<Config>>;
+export declare function readConfig(projectPath?: string): Promise<Config>;
 /**
  * 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.

package/typings/plugins.d.ts

@@ -542,7 +542,9 @@ export type SchemaPrimitive = "number" | "string" | "boolean" | "undefined" | "n
 export type SchemaArray = Schema[];
 /**
  * Object/reference type.
- * Append '?' to the end of a key to mark it optional.
+ * Required properties are written directly; optional properties are wrapped
+ * with the `SchemaOptional` form `{ required: false, type: Schema }`
+ * (consistent with how a standalone optional primitive is represented).
  */
 export interface SchemaReference {
 	[attr: string]: Schema;
@@ -578,8 +580,8 @@ export interface SchemaOptional {
  * The data Schema.
  * - SchemaArray is a native array (elements are Schemas)
  * - composite types use { oneOf | anyOf | allOf: Schema[] }
- * - optional object properties use a trailing '?' on the key;
- *   a standalone optional primitive uses the SchemaOptional wrapper
+ * - optional object properties are wrapped with `SchemaOptional` ({ required: false, type: Schema });
+ *   a standalone optional primitive uses the same SchemaOptional wrapper
  */
 export type Schema = SchemaPrimitive | SchemaReference | SchemaArray | SchemaEnum | SchemaOneOf | SchemaAnyOf | SchemaAllOf | SchemaOptional;
 export interface ModifierConfig {
@@ -599,10 +601,12 @@ export interface ModifierConfig {
 	 * @param schema the original field type, already converted to the user-facing Schema representation.
 	 *               When the field itself is optional and is a primitive, it is passed as { required: false, type: 'string' }.
 	 *               Narrow the type inside handler if needed (e.g. with a cast).
+	 * @param key the matched field key. When `match` is omitted, the whole scope object is passed to the handler
+	 *            once and `key` is `undefined`; when `match` is set, `key` is the matched field name for each call.
 	 * @returns Schema to change the type; { required: boolean, type: Schema } to change requiredness (driven by `type`);
 	 *          void | null | undefined to remove the field.
 	 */
-	handler: (schema: Schema) => Schema | {
+	handler: (schema: Schema, key?: string) => Schema | {
 		required: boolean;
 		type: Schema;
 	} | void | null | undefined;