svelte-reflector 1.0.11 → 1.0.13

package/dist/helpers/helpers.d.ts

@@ -12,3 +12,4 @@ export declare function getEndpointAndModuleName(rawEndpoint: string): {
 };
 export declare function getEndpoint(rawEndpoint: string): string;
 export declare function testeEndpoint(rawEndpoint: string): string;
+export declare function treatenEnum(enums: string[]): string;

package/dist/helpers/helpers.js

@@ -84,3 +84,7 @@ export function testeEndpoint(rawEndpoint) {
     });
     return a.join("/");
 }
+export function treatenEnum(enums) {
+    const a = enums.map((e) => `"${e}"`);
+    return ` z.literal([${a}])`;
+}

package/dist/main.js

@@ -39,13 +39,7 @@ export class Reflector {
                 name: key,
                 requireds: object.required || [],
             };
-            schemas.push(new Schema({
-                ...schema,
-                isEmpty: false,
-            }), new Schema({
-                ...schema,
-                isEmpty: true,
-            }));
+            schemas.push(new Schema({ ...schema, isEmpty: false }), new Schema({ ...schema, isEmpty: true }));
         }
         console.log(`${schemas.length} schemas gerados com sucesso.`);
         return schemas;
@@ -86,7 +80,10 @@ export class Reflector {
         return modules;
     }
     build() {
-        this.schemaFile.changeData([`import z from 'zod';`, ...this.schemas.map((s) => `${s.schema} ${s.type}`)].join("\n\n"));
+        const treatedSchemas = this.schemas.map((s) => {
+            return `${s.schema} ${s.type}`;
+        });
+        this.schemaFile.changeData([`import z from 'zod';`, ...treatedSchemas].join("\n\n"));
         this.schemaFile.save();
         this.typesSrc.changeData("export class Behavior { onError?: (e) => void; onSuccess?: () => void }");
         this.typesSrc.save();

package/dist/method.d.ts

@@ -1,5 +1,5 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 import type { ReflectorOperation } from "./types/types.js";
 export declare class Method {
     name: string;

package/dist/method.js

@@ -1,5 +1,5 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 import { createDangerMessage, getEndpoint, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
 export class Method {
     name;
@@ -118,8 +118,6 @@ export class Method {
             return { outside, inside };
         }
         else if (this.request.apiType === "delete") {
-            // const props = this.zodProperties.map((x) => x.name).join(",");
-            // const propsString = props.length > 0 ? `const {${props}} = this.parameters` : "";
             const inside = `
         const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
           endpoint,

package/dist/module.d.ts

@@ -1,7 +1,7 @@
 import { Source } from "./file.js";
 import { Method } from "./method.js";
 import type { ReflectorOperation } from "./types/types.js";
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 export declare class Module {
     readonly name: string;
     readonly path: string;

package/dist/module.js

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import { Source } from "./file.js";
 import { capitalizeFirstLetter, createDangerMessage, treatByUppercase } from "./helpers/helpers.js";
 import { Method } from "./method.js";
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 export class Module {
     name;
     path;
@@ -71,7 +71,7 @@ export class Module {
             const capitalizedName = capitalizeFirstLetter(name);
             buildedModuleTypes.push(`const ${capitalizedName}Schema = ${this.buildZObject(objets)}`);
             moduleAttributes.add(`${name} = $state(repo.newForm(${capitalizedName}Schema))`);
-            moduleInit.add(`this.clear${capitalizedName}()`);
+            moduleInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
             moduleClear.add(`clear${capitalizedName}() { this.${name} = repo.newForm(${capitalizedName}Schema) }`);
         };
         if (this.querys.length > 0) {
@@ -98,8 +98,8 @@ export class Module {
             if (attributeType === "entity") {
                 const entityName = treatByUppercase(method.request.responseType);
                 moduleAttributes.add(`${entityName} = $state<${responseType} | undefined>()`);
-                moduleInit.add(`this.clear${entityName}()`);
-                moduleClear.add(`clear${entityName}() { this.${entityName} = undefined }`);
+                moduleInit.add(`this.clear${capitalizeFirstLetter(entityName)}()`);
+                moduleClear.add(`clear${capitalizeFirstLetter(entityName)}() { this.${entityName} = undefined }`);
             }
             else if (attributeType === "list") {
                 moduleAttributes.add(`list = $state<${responseType}['data']>([])`);

package/dist/property.d.ts

@@ -1,6 +1,7 @@
 import { type ParameterLocation, type SchemaObject } from "./types/open-api-spec.interface.js";
 import { type Example, type ReflectorParamType } from "./types/types.js";
 export declare class ZodProperty {
+    schemaName?: string;
     name: string;
     example: Example | undefined;
     type: ReflectorParamType;
@@ -9,6 +10,7 @@ export declare class ZodProperty {
     required: boolean;
     inParam: ParameterLocation;
     constructor(params: {
+        schemaName?: string;
         name: string;
         schemaObject: SchemaObject;
         type: ReflectorParamType;

package/dist/property.js

@@ -1,9 +1,10 @@
-import { sanitizeNumber } from "./helpers/helpers.js";
+import { sanitizeNumber, splitByUppercase } from "./helpers/helpers.js";
 import { ReflectorInput } from "./helpers/input.js";
 import {} from "./types/open-api-spec.interface.js";
 import {} from "./types/types.js";
 const inputs = new ReflectorInput();
 export class ZodProperty {
+    schemaName;
     name;
     example;
     type;
@@ -12,8 +13,11 @@ export class ZodProperty {
     required;
     inParam;
     constructor(params) {
-        const { name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
+        const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
         this.inParam = inParam;
+        if (schemaName) {
+            this.schemaName = schemaName;
+        }
         if (name.split("-").length > 1) {
             this.name = `['${name}']`;
         }
@@ -66,11 +70,15 @@ export class ZodProperty {
     treatName(name) {
         return name;
     }
-    build(value) {
+    build(schemaObject) {
         const name = this.treatName(this.name);
         const x = `${name}: z.${this.type}()${this.isNullable()}`;
         switch (this.type) {
             case "string": {
+                // if (name === "role") {
+                //   console.log(schemaObject.enum);
+                // }
+                console.log(schemaObject.enum);
                 const deepValidation = this.deepValidator();
                 return deepValidation ? `${name}: ${deepValidation}` : `${x}.default('${this.example}')`;
             }
@@ -81,10 +89,22 @@ export class ZodProperty {
                 return `${x}.default(${sanitizeNumber(number)})`;
             }
             case "array": {
-                if (!value.items || !("$ref" in value.items)) {
-                    return `${name}: z.${this.type}(z.${value.items?.type || "string"}())${this.isNullable()}.default([])`;
+                if (!schemaObject.items || !("$ref" in schemaObject.items)) {
+                    let zodType = "z.string()";
+                    if (schemaObject.items?.enum) {
+                        if (this.schemaName) {
+                            const teste = splitByUppercase(this.schemaName)
+                                .filter((name) => name !== "Empty")
+                                .join("");
+                            zodType = `${teste}EnumSchema`;
+                        }
+                    }
+                    else if (schemaObject.items?.type) {
+                        zodType = `z.${schemaObject.items.type}()`;
+                    }
+                    return `${name}: z.${this.type}(${zodType})${this.isNullable()}.default([])`;
                 }
-                const dto = this.getDtoName(value.items.$ref);
+                const dto = this.getDtoName(schemaObject.items.$ref);
                 return `${name}: z.array(${dto}Schema).default(new Array(10).fill(${dto}Schema.parse({})))`;
             }
             case "object":

package/dist/schema.d.ts

@@ -1,14 +1,17 @@
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 export declare class Schema {
     name: string;
     properties: ZodProperty[];
     type: string;
     schema: string;
+    enums: Set<string>;
+    objects: Map<string, string>;
     constructor(params: {
         properties: Record<string, SchemaObject | ReferenceObject>;
         name: string;
         requireds: string[];
         isEmpty: boolean;
     });
+    private getEnumConst;
 }

package/dist/schema.js

@@ -1,17 +1,33 @@
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 export class Schema {
     name;
     properties = [];
     type;
     schema;
+    enums = new Set();
+    objects = new Map();
     constructor(params) {
         const { name, properties, requireds, isEmpty } = params;
         this.name = `${isEmpty ? "Empty" : ""}${name}`;
         for (const [key, value] of Object.entries(properties)) {
-            if ("$ref" in value || !value?.type)
+            if ("$ref" in value || !value?.type) {
+                if ("$ref" in value) {
+                    const teste = value.$ref;
+                    const object = teste.split("/").at(-1);
+                    this.objects.set(key, `${object}Schema`);
+                }
                 continue;
+            }
             const required = requireds.includes(key);
+            const teste = value.items;
+            if (teste && !("$ref" in teste) && teste.enum) {
+                this.enums.add(this.getEnumConst({ enums: teste.enum, schemaName: key }));
+            }
+            else if (value.enum) {
+                this.enums.add(this.getEnumConst({ enums: value.enum, schemaName: key }));
+            }
             this.properties.push(new ZodProperty({
+                schemaName: this.name,
                 name: key,
                 schemaObject: value,
                 type: value.type,
@@ -26,6 +42,15 @@ export class Schema {
       ${this.properties.map((p) => {
             return p.buildedProp;
         })}
+      ${this.properties.length > 0 ? "," : ""}
+      ${Array.from(this.objects).map(([k, v]) => {
+            return `${k}: z.object(${v})`;
+        })}
     });`;
     }
+    getEnumConst(params) {
+        const { enums, schemaName } = params;
+        const enumList = enums.map((en) => `'${en}'`);
+        return `export const ${schemaName}EnumSchema = z.enum([${enumList}])`;
+    }
 }

package/dist/zodProperty.d.ts

@@ -0,0 +1,32 @@
+import { type ParameterLocation, type SchemaObject } from "./types/open-api-spec.interface.js";
+import { type Example, type ReflectorParamType } from "./types/types.js";
+export declare class ZodProperty {
+    schemaName?: string;
+    name: string;
+    example: Example | undefined;
+    type: ReflectorParamType;
+    buildedProp: string;
+    description?: string;
+    required: boolean;
+    inParam: ParameterLocation;
+    isEnum: boolean;
+    enums: string[];
+    constructor(params: {
+        schemaName?: string;
+        name: string;
+        schemaObject: SchemaObject;
+        type: ReflectorParamType;
+        example: Example | undefined;
+        required: boolean;
+        description?: string;
+        isEmpty: boolean;
+        inParam: ParameterLocation;
+    });
+    private getDtoName;
+    private getEmptyExample;
+    private getExample;
+    private deepValidator;
+    private isNullable;
+    private treatName;
+    private build;
+}

package/dist/zodProperty.js

@@ -0,0 +1,123 @@
+import { sanitizeNumber, treatenEnum } from "./helpers/helpers.js";
+import { ReflectorInput } from "./helpers/input.js";
+import {} from "./types/open-api-spec.interface.js";
+import {} from "./types/types.js";
+const inputs = new ReflectorInput();
+export class ZodProperty {
+    schemaName;
+    name;
+    example;
+    type;
+    buildedProp;
+    description;
+    required;
+    inParam;
+    isEnum = false;
+    enums = [];
+    constructor(params) {
+        const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
+        this.inParam = inParam;
+        this.isEnum = false;
+        const items = schemaObject.items;
+        if (items && !("$ref" in items) && items.enum) {
+            this.isEnum = true;
+            this.enums = items.enum;
+        }
+        else if (schemaObject.enum) {
+            this.isEnum = true;
+            this.enums = schemaObject.enum;
+        }
+        if (schemaName) {
+            this.schemaName = schemaName;
+        }
+        if (name.split("-").length > 1) {
+            this.name = `['${name}']`;
+        }
+        else {
+            this.name = name;
+        }
+        this.required = required;
+        this.type = type;
+        this.example = isEmpty ? this.getEmptyExample() : this.getExample(example);
+        this.buildedProp = this.build(schemaObject);
+        if (description)
+            this.description = description;
+    }
+    getDtoName(ref) {
+        const cavalos = ref.split("/");
+        const dto = cavalos[cavalos.length - 1];
+        return dto;
+    }
+    getEmptyExample() {
+        switch (this.type) {
+            case "number":
+                return 0;
+            case "boolean":
+                return false;
+            case "string":
+                return "";
+            default:
+                return "";
+        }
+    }
+    getExample(example) {
+        if (example)
+            return example;
+        return this.getEmptyExample();
+    }
+    deepValidator() {
+        if (this.name === "email") {
+            return `z.email().default('${this.example}')`;
+        }
+        else if (this.name === "password") {
+            return inputs.password;
+        }
+        else if (this.isEnum) {
+            return `${treatenEnum(this.enums)}.default('${this.enums[0]}')`;
+        }
+        else {
+            return false;
+        }
+    }
+    isNullable() {
+        return this.required ? "" : ".nullable()";
+    }
+    treatName(name) {
+        return name;
+    }
+    build(schemaObject) {
+        const name = this.treatName(this.name);
+        const x = `${name}: z.${this.type}()${this.isNullable()}`;
+        switch (this.type) {
+            case "string": {
+                // console.log(schemaObject.enum);
+                const deepValidation = this.deepValidator();
+                return deepValidation ? `${name}: ${deepValidation}` : `${x}.default('${this.example}')`;
+            }
+            case "boolean":
+                return `${x}.default(${this.example})`;
+            case "number": {
+                const number = JSON.stringify(this.example) ?? 0;
+                return `${x}.default(${sanitizeNumber(number)})`;
+            }
+            case "array": {
+                if (!schemaObject.items || !("$ref" in schemaObject.items)) {
+                    let zodType = "z.string()";
+                    if (schemaObject.items?.enum) {
+                        zodType = treatenEnum(schemaObject.items.enum);
+                    }
+                    else if (schemaObject.items?.type) {
+                        zodType = `z.${schemaObject.items.type}()`;
+                    }
+                    return `${name}: z.${this.type}(${zodType})${this.isNullable()}.default([])`;
+                }
+                const dto = this.getDtoName(schemaObject.items.$ref);
+                return `${name}: z.array(${dto}Schema).default(new Array(10).fill(${dto}Schema.parse({})))`;
+            }
+            case "object":
+                return `${name}: z.any()`;
+            default:
+                return `${name}: z.any()`;
+        }
+    }
+}

package/package.json

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