svelte-reflector 2.1.4 → 2.1.6

package/dist/core/generators/queryOverride.d.ts

@@ -2,8 +2,7 @@ import type { AttributeProp } from "../../types/types.js";
 /** TS type literal for a single query override entry. Mirrors the
  *  shape produced by each Prop's bundle entry:
  *    PrimitiveProp / EnumProp     → `string | null`
- *    ArrayProp (enum)             → `${type}[]`
- *    ArrayProp (non-enum, raro)   → `string[]`
+ *    ArrayProp (enum or primitive) → `${type}[]`
  */
 export declare function queryOverrideEntryType(q: AttributeProp): string;
 /** Inline TS object type literal for the full queryOverride bag,

package/dist/core/generators/queryOverride.js

@@ -1,14 +1,11 @@
 /** TS type literal for a single query override entry. Mirrors the
  *  shape produced by each Prop's bundle entry:
  *    PrimitiveProp / EnumProp     → `string | null`
- *    ArrayProp (enum)             → `${type}[]`
- *    ArrayProp (non-enum, raro)   → `string[]`
+ *    ArrayProp (enum or primitive) → `${type}[]`
  */
 export function queryOverrideEntryType(q) {
-    if ("isEnum" in q && q.isEnum)
-        return `${q.type}[]`;
     if (!("rawType" in q) && !("enumName" in q))
-        return "string[]";
+        return `${q.type}[]`;
     return "string | null";
 }
 /** Inline TS object type literal for the full queryOverride bag,

package/dist/core/method/MethodRequestAnalyzer.js

@@ -1,7 +1,7 @@
 import { PrimitiveProp as PrimitivePropClass } from "../../props/primitive.property.js";
 import { ArrayProp as ArrayPropClass } from "../../props/array.property.js";
 import { EnumProp as EnumPropClass } from "../../props/enum.property.js";
-import { isReferenceObject } from "../../helpers/helpers.js";
+import { isReferenceObject, isPrimitiveEnumValues } from "../../helpers/helpers.js";
 export class MethodRequestAnalyzer {
     paths = [];
     headers = [];
@@ -49,8 +49,13 @@ export class MethodRequestAnalyzer {
             return;
         }
         if (schema.enum) {
-            this.querys.push(new EnumPropClass({ name, required: isRequired, enums: schema.enum, isParam: true, entityName: moduleName, context }));
-            return;
+            if (isPrimitiveEnumValues(schema.enum)) {
+                console.warn(`[reflector] Field '${moduleName}.${name}': enum=[${schema.enum.join(",")}] looks like a TS primitive type (string/number/boolean), not a real enum. Ignoring 'enum' and treating as plain primitive. Fix the @ApiProperty/@ApiQuery in the back.`);
+            }
+            else {
+                this.querys.push(new EnumPropClass({ name, required: isRequired, enums: schema.enum, isParam: true, entityName: moduleName, context }));
+                return;
+            }
         }
         this.querys.push(new PrimitivePropClass({ name, required: isRequired, schemaObject: schema, validator: undefined, isParam: true }));
     }

package/dist/core/module/ModuleClassBuilder.js

@@ -45,9 +45,12 @@ export class ModuleClassBuilder {
                     bundle.push(prop.bundleBuild());
                 }
                 else {
-                    // ArrayProp (não-enum)
+                    // ArrayProp (não-enum): emits EnumQueryBuilder<primitive>; só importa
+                    // enum quando o array é realmente de enum.
                     attributes.push(prop.queryBuild());
-                    this.imports.addEnumImport(prop.type);
+                    if ("isEnum" in prop && prop.isEnum) {
+                        this.imports.addEnumImport(prop.type);
+                    }
                     bundle.push(prop.queryBundleBuild());
                     this.imports.addReflectorImport("EnumQueryBuilder");
                 }

package/dist/core/openapi/InlineSchemaPromoter.d.ts

@@ -18,6 +18,35 @@ import type { ComponentsObject, PathsObject } from "../../types/open-api-spec.in
  */
 export declare class InlineSchemaPromoter {
     static promote(components: ComponentsObject, paths: PathsObject): void;
+    /**
+     * Recursively promotes inline object and array-of-object schemas nested
+     * inside named component schemas to their own named components, replacing
+     * them with a `$ref`.
+     *
+     * The rest of the pipeline already resolves `$ref` correctly (`ObjectProp`
+     * for object properties, `ArrayProp.getType` for array items), but it
+     * silently DROPS inline objects (`SchemaPropertyClassifier.classify` returns
+     * `null` for `type: "object"` without `$ref`) and DEGRADES inline
+     * arrays-of-object to `string[]` (`array.property.ts` fallback). Promoting
+     * them upfront routes both through the working `$ref` path, producing typed
+     * child classes instead of `string[]` / dropped fields.
+     *
+     * Runs after body/response promotion so it also covers the freshly promoted
+     * envelope schemas. Uses a worklist so newly created child schemas are
+     * themselves scanned for deeper nesting.
+     */
+    private static promoteNestedObjects;
+    /** Inline object with own `properties` (not a free-form `additionalProperties` map). */
+    private static extractableInlineObject;
+    /** `type: array` whose `items` is an inline object with `properties`. */
+    private static extractableInlineArrayItems;
+    private static reserveNestedName;
+    /**
+     * OpenAPI 3.0 forbids siblings next to `$ref`, so a nullable object property
+     * must wrap the ref in `allOf` + `nullable` — the form `classifyObject`
+     * already understands. Non-nullable properties use a bare `$ref`.
+     */
+    private static refForProperty;
     private static promoteBodies;
     private static promoteInlineBody;
     private static promoteResponses;

package/dist/core/openapi/InlineSchemaPromoter.js

@@ -1,4 +1,4 @@
-import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+import { capitalizeFirstLetter, isReferenceObject } from "../../helpers/helpers.js";
 const HTTP_METHODS = ["get", "put", "post", "delete", "patch", "options", "head", "trace"];
 /**
  * Promotes inline request-body and response `data` schemas to named
@@ -21,6 +21,92 @@ export class InlineSchemaPromoter {
     static promote(components, paths) {
         InlineSchemaPromoter.promoteBodies(components, paths);
         InlineSchemaPromoter.promoteResponses(components, paths);
+        InlineSchemaPromoter.promoteNestedObjects(components);
+    }
+    /**
+     * Recursively promotes inline object and array-of-object schemas nested
+     * inside named component schemas to their own named components, replacing
+     * them with a `$ref`.
+     *
+     * The rest of the pipeline already resolves `$ref` correctly (`ObjectProp`
+     * for object properties, `ArrayProp.getType` for array items), but it
+     * silently DROPS inline objects (`SchemaPropertyClassifier.classify` returns
+     * `null` for `type: "object"` without `$ref`) and DEGRADES inline
+     * arrays-of-object to `string[]` (`array.property.ts` fallback). Promoting
+     * them upfront routes both through the working `$ref` path, producing typed
+     * child classes instead of `string[]` / dropped fields.
+     *
+     * Runs after body/response promotion so it also covers the freshly promoted
+     * envelope schemas. Uses a worklist so newly created child schemas are
+     * themselves scanned for deeper nesting.
+     */
+    static promoteNestedObjects(components) {
+        const schemas = components.schemas;
+        if (!schemas)
+            return;
+        const usedNames = new Set(Object.keys(schemas));
+        const queue = Object.keys(schemas);
+        while (queue.length > 0) {
+            const schemaName = queue.shift();
+            const schema = schemas[schemaName];
+            if (!schema || "$ref" in schema || !schema.properties)
+                continue;
+            for (const [propKey, propValue] of Object.entries(schema.properties)) {
+                if (isReferenceObject(propValue))
+                    continue;
+                const inlineObject = InlineSchemaPromoter.extractableInlineObject(propValue);
+                if (inlineObject) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, propKey);
+                    schemas[name] = inlineObject;
+                    queue.push(name);
+                    schema.properties[propKey] = InlineSchemaPromoter.refForProperty(name, propValue.nullable);
+                    continue;
+                }
+                const inlineItems = InlineSchemaPromoter.extractableInlineArrayItems(propValue);
+                if (inlineItems) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, propKey);
+                    schemas[name] = inlineItems;
+                    queue.push(name);
+                    propValue.items = { $ref: `#/components/schemas/${name}` };
+                }
+            }
+        }
+    }
+    /** Inline object with own `properties` (not a free-form `additionalProperties` map). */
+    static extractableInlineObject(value) {
+        if (value.type !== "object" || value.additionalProperties || !value.properties)
+            return null;
+        return value;
+    }
+    /** `type: array` whose `items` is an inline object with `properties`. */
+    static extractableInlineArrayItems(value) {
+        if (value.type !== "array" || !value.items || isReferenceObject(value.items))
+            return null;
+        const items = value.items;
+        if (items.type !== "object" || items.additionalProperties || !items.properties)
+            return null;
+        return items;
+    }
+    static reserveNestedName(usedNames, parent, prop) {
+        const base = `${parent}${capitalizeFirstLetter(prop.replaceAll(/[^a-zA-Z0-9]/g, ""))}`;
+        let name = base;
+        let suffix = 2;
+        while (usedNames.has(name)) {
+            name = `${base}${suffix++}`;
+        }
+        usedNames.add(name);
+        return name;
+    }
+    /**
+     * OpenAPI 3.0 forbids siblings next to `$ref`, so a nullable object property
+     * must wrap the ref in `allOf` + `nullable` — the form `classifyObject`
+     * already understands. Non-nullable properties use a bare `$ref`.
+     */
+    static refForProperty(name, nullable) {
+        const ref = { $ref: `#/components/schemas/${name}` };
+        if (nullable)
+            return { allOf: [ref], nullable: true };
+        return ref;
     }
     static promoteBodies(components, paths) {
         components.schemas ??= {};

package/dist/core/schema/SchemaPropertyClassifier.js

@@ -2,7 +2,7 @@ import { ArrayProp } from "../../props/array.property.js";
 import { EnumProp } from "../../props/enum.property.js";
 import { ObjectProp } from "../../props/object.property.js";
 import { PrimitiveProp } from "../../props/primitive.property.js";
-import { isReferenceObject } from "../../helpers/helpers.js";
+import { isReferenceObject, isPrimitiveEnumValues } from "../../helpers/helpers.js";
 export class SchemaPropertyClassifier {
     static classify(params) {
         const { key, value, requireds, fieldConfigs, schemaName, context } = params;
@@ -37,14 +37,19 @@ export class SchemaPropertyClassifier {
             });
         }
         if (value.enum) {
-            return new EnumProp({
-                enums: value.enum,
-                name: key,
-                required,
-                isParam: undefined,
-                entityName: schemaName,
-                context,
-            });
+            if (isPrimitiveEnumValues(value.enum)) {
+                console.warn(`[reflector] Field '${schemaName}.${key}': enum=[${value.enum.join(",")}] looks like a TS primitive type (string/number/boolean), not a real enum. Ignoring 'enum' and treating as plain primitive. Fix the @ApiProperty/@ApiQuery in the back.`);
+            }
+            else {
+                return new EnumProp({
+                    enums: value.enum,
+                    name: key,
+                    required,
+                    isParam: undefined,
+                    entityName: schemaName,
+                    context,
+                });
+            }
         }
         const config = fieldConfigs.get(key);
         const validator = config?.validator;

package/dist/helpers/helpers.d.ts

@@ -15,5 +15,9 @@ export declare function getEndpointAndModuleName(rawEndpoint: string): {
 };
 export declare function getEndpoint(rawEndpoint: string): string;
 export declare function getFullEndpoint(rawEndpoint: string): string;
+/** True if every enum value is a TS-reserved primitive type name
+ *  (`"string"`, `"number"`, `"boolean"`) — a sign of misused
+ *  `@ApiProperty({ enum: String })` on the back. */
+export declare function isPrimitiveEnumValues(enums: unknown[] | undefined): boolean;
 export declare function isEnumSchema(schema: SchemaObject): boolean;
 export declare function isReferenceObject(obj: unknown): obj is ReferenceObject;

package/dist/helpers/helpers.js

@@ -88,6 +88,15 @@ export function getFullEndpoint(rawEndpoint) {
     })
         .join("/");
 }
+const TS_PRIMITIVE_RESERVED = new Set(["string", "number", "integer", "boolean"]);
+/** True if every enum value is a TS-reserved primitive type name
+ *  (`"string"`, `"number"`, `"boolean"`) — a sign of misused
+ *  `@ApiProperty({ enum: String })` on the back. */
+export function isPrimitiveEnumValues(enums) {
+    if (!enums || enums.length === 0)
+        return false;
+    return enums.every((e) => typeof e === "string" && TS_PRIMITIVE_RESERVED.has(e.toLowerCase()));
+}
 export function isEnumSchema(schema) {
     if (schema.enum)
         return true;

package/dist/props/array.property.js

@@ -47,6 +47,11 @@ export class ArrayProp {
             return theType;
         }
         this._isPrimitiveType = true;
+        const itemType = items.type;
+        if (itemType === "integer")
+            return "number";
+        if (itemType === "number" || itemType === "boolean")
+            return itemType;
         return "string";
     }
     constructorBuild() {
@@ -83,16 +88,13 @@ export class ArrayProp {
         return `${this.name}: this.${this.name}?.values`;
     }
     queryBuild() {
-        if (this.isEnum) {
-            if (this.defaultValues.length === 0) {
-                return `readonly ${this.name} = new EnumQueryBuilder<${this.type}>({ key: '${this.name}' })`;
-            }
-            const literal = `[${this.defaultValues
-                .map((v) => (typeof v === "string" ? `'${v}'` : String(v)))
-                .join(", ")}]`;
-            return `readonly ${this.name} = new EnumQueryBuilder<${this.type}>({ key: '${this.name}', defaultValues: ${literal} })`;
+        if (this.defaultValues.length === 0) {
+            return `readonly ${this.name} = new EnumQueryBuilder<${this.type}>({ key: '${this.name}', defaultValues: [] })`;
         }
-        return `readonly ${this.name} = new QueryBuilder({ key: '${this.name}' })`;
+        const literal = `[${this.defaultValues
+            .map((v) => (typeof v === "string" ? `'${v}'` : String(v)))
+            .join(", ")}]`;
+        return `readonly ${this.name} = new EnumQueryBuilder<${this.type}>({ key: '${this.name}', defaultValues: ${literal} })`;
     }
     staticBuild() {
         const result = this._isPrimitiveType ? "obj" : `new ${this.type}({ data: obj })`;

package/dist/props/primitive.property.js

@@ -69,7 +69,10 @@ export class PrimitiveProp {
             };
         if (type === "string")
             return {
-                example: `"${example}"`,
+                // JSON.stringify escapes embedded quotes/backslashes/newlines so a
+                // string example like `{"64":true}` doesn't emit invalid JS. For
+                // plain strings the output is identical to `"${example}"`.
+                example: JSON.stringify(String(example)),
                 emptyExample,
             };
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-reflector",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",