svelte-reflector 2.1.3 → 2.1.5

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/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/runtime/reflector.svelte.ts

@@ -158,10 +158,18 @@ export function genericArrayBundler<T extends { bundle: () => BundleResult<T> }>
   return (data as T[]).map((item) => item.bundle());
 }
 
+/**
+ * Atualiza um query param na URL.
+ * - `""` (string vazia) → remove o param.
+ * - qualquer outro valor → `searchParams.set(key, String(event))`.
+ */
 export function changeParam({ event, key }: QueryContract) {
-  const newValue = event;
   const url = new SvelteURL(page.url);
-  url.searchParams.set(key, String(newValue));
+  if (event === "") {
+    url.searchParams.delete(key);
+  } else {
+    url.searchParams.set(key, String(event));
+  }
   goto(url, { replaceState: true, keepFocus: true });
 }
 
@@ -190,12 +198,24 @@ export class QueryBuilder {
     return fromUrl !== null ? fromUrl : this.defaultValue;
   }
 
+  /**
+   * Aplica o valor recebido ao query param.
+   * - `null` / `undefined` → no-op (não chama `goto`).
+   * - `""` (string vazia) → delega pra `changeParam`, que remove o param.
+   * - número / string não-vazia → `set(key, String(event))`.
+   */
   update(event: string | number | null) {
     if (event === null || event === undefined) return;
     return changeParam({ key: this.key, event: String(event) });
   }
 }
 
+/**
+ * Atualiza vários query params de uma vez.
+ * - array → `delete(key)` seguido de `append` para cada item.
+ * - `""` → remove o param.
+ * - outros valores → `set(key, String(value))`.
+ */
 export function setQueryGroup(group: QueryWithArrayType[]) {
   if (!browser) return;
 
@@ -210,6 +230,11 @@ export function setQueryGroup(group: QueryWithArrayType[]) {
       continue;
     }
 
+    if (value === "") {
+      url.searchParams.delete(key);
+      continue;
+    }
+
     url.searchParams.set(key, String(value));
   }
 

package/package.json

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