wormajs 0.3.1 → 1.0.0-beta.0

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

@@ -1,289 +0,0 @@
-"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',
-    'integer',
-]);
-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;
-        delete schema.enum;
-        delete schema.oneOf;
-        delete schema.anyOf;
-        delete schema.allOf;
-        delete schema.items;
-        delete schema.properties;
-        delete schema.required;
-        return schema;
-    };
-    // Native array type (elements are Schema)
-    if (Array.isArray(s)) {
-        const arr = s;
-        cleanType(result);
-        result.type = 'array';
-        const items = arr.map(item => toSchemaObject({}, item));
-        result.items = (items.length === 1 ? items[0] : items);
-        return result;
-    }
-    // Primitive types — validate against SchemaPrimitive set during conversion
-    if (typeof s === 'string') {
-        validatePrimitive(s);
-        result.type = s;
-        return result;
-    }
-    // Handle union keywords: overwrite arrays but preserve unrelated fields
-    if (s.oneOf) {
-        const spec = s;
-        const baseOneOf = base.oneOf || [];
-        cleanType(result);
-        result.oneOf = spec.oneOf.map((item, idx) => toSchemaObject(baseOneOf[idx] || {}, item));
-        return result;
-    }
-    if (s.anyOf) {
-        const spec = s;
-        const baseAnyOf = base.anyOf || [];
-        cleanType(result);
-        result.anyOf = spec.anyOf.map((item, idx) => toSchemaObject(baseAnyOf[idx] || {}, item));
-        return result;
-    }
-    if (s.allOf) {
-        const spec = s;
-        const baseAllOf = base.allOf || [];
-        cleanType(result);
-        result.allOf = spec.allOf.map((item, idx) => toSchemaObject(baseAllOf[idx] || {}, item));
-        return result;
-    }
-    // Enum: set enum and optional type
-    if (s.enum) {
-        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)
-    const ref = s;
-    if (ref && typeof ref === 'object') {
-        result.type = 'object';
-        const properties = {};
-        const requiredSet = new Set();
-        for (const key in ref) {
-            const val = ref[key];
-            if (!val) {
-                continue;
-            }
-            // 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(key);
-            }
-        }
-        result.properties = properties;
-        result.required = Array.from(requiredSet);
-        return result;
-    }
-    return result;
-}
-function schemaTypeToPrimitiveType(t) {
-    if (t === null) {
-        return 'null';
-    }
-    if (t === undefined) {
-        return 'undefined';
-    }
-    if (!t) {
-        return 'unknown';
-    }
-    if (t === 'integer') {
-        return 'number';
-    }
-    return t;
-}
-// Convert existing OpenAPI SchemaObject -> Schema (best-effort, for handler input)
-function toSchemaSpec(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return 'unknown';
-    }
-    // Union keywords
-    if (Array.isArray(obj.oneOf)) {
-        const arr = obj.oneOf;
-        return { oneOf: arr.map(item => toSchemaSpec(item)) };
-    }
-    if (Array.isArray(obj.anyOf)) {
-        const arr = obj.anyOf;
-        return { anyOf: arr.map(item => toSchemaSpec(item)) };
-    }
-    if (Array.isArray(obj.allOf)) {
-        const arr = obj.allOf;
-        return { allOf: arr.map(item => toSchemaSpec(item)) };
-    }
-    // Enum
-    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
-        const type = typeof obj.type === 'string' ? obj.type : undefined;
-        return { enum: obj.enum, type };
-    }
-    // Array -> native array
-    if (obj.type === 'array' || obj.items) {
-        const items = obj.items;
-        if (Array.isArray(items)) {
-            return items.map((it) => toSchemaSpec(it));
-        }
-        if (items) {
-            return [toSchemaSpec(items)];
-        }
-        return ['unknown'];
-    }
-    // Object
-    if (obj.type === 'object' || obj.properties) {
-        const properties = obj.properties || {};
-        const requiredSet = new Set(Array.isArray(obj.required) ? obj.required : []);
-        const result = {};
-        for (const key of Object.keys(properties)) {
-            const spec = toSchemaSpec(properties[key]);
-            // Required fields are written bare; optional fields wrapped with SchemaOptional
-            result[key] = requiredSet.has(key) ? spec : { required: false, type: spec };
-        }
-        return result;
-    }
-    // type union as array -> oneOf
-    if (Array.isArray(obj.type)) {
-        const typeArr = obj.type;
-        const mapped = typeArr.map(schemaTypeToPrimitiveType);
-        return { oneOf: mapped };
-    }
-    return schemaTypeToPrimitiveType(obj.type);
-}
-// Replace whole schema based on handler result (used for params/pathParams)
-function applyModifierSchema(schema, config, { required, key }) {
-    if (!schema || typeof schema !== 'object') {
-        return { required, schema: schema };
-    }
-    const cloned = { ...schema };
-    const currentSpec = toSchemaSpec(cloned);
-    // When the field is itself optional and is a primitive, wrap it as { required, type } before passing to handler
-    const handlerInput = (required === false && typeof currentSpec === 'string')
-        ? { required: false, type: currentSpec }
-        : currentSpec;
-    const ret = config.handler(handlerInput, key);
-    if (!ret) {
-        return {
-            required,
-            schema: null,
-        };
-    }
-    // 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: 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: true,
-        schema: r,
-    };
-}

package/dist/plugins/presets/platform/fastapi.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fastapi = void 0;
-const constant_1 = require("../../../constant");
-const shared_1 = require("./shared");
-/**
- * FastAPI platform plugin.
- *
- * Pass the base URL of your FastAPI app; the plugin will try `/openapi.json`
- * first, then fall back to the bare base URL.
- *
- * @param input - base URL string, or an array of base URLs
- *
- * @example
- * ```ts
- * plugins: [fastapi('http://fastapi-example.dokkuapp.com'), alovaGlobals()]
- * ```
- */
-exports.fastapi = (0, shared_1.defineUrlPlatformPlugin)(constant_1.PluginName.FASTAPI, base => [
-    `${base}/openapi.json`,
-    base,
-]);

package/dist/template/presets/alova/partials/dts-extra-config.handlebars

@@ -1,8 +0,0 @@
-{{#or pathParameters queryParameters requestBody}}
-type {{{name}}}ExtraConfig = {
-  {{#if pathParameters}}pathParams: {{addNamespace pathParameters @root.componentNames}};
-  {{/if}}{{#if queryParameters}}params: {{addNamespace queryParameters @root.componentNames}};
-  {{/if}}{{#if requestBody}}data: {{addNamespace requestBody @root.componentNames}};
-  {{/if}}
-};
-{{/or}}