svelte-reflector 1.0.13 → 1.0.14

package/dist/constructor.d.ts

@@ -0,0 +1,2 @@
+export declare class SchemaConstructor {
+}

package/dist/constructor.js

@@ -0,0 +1,2 @@
+export class SchemaConstructor {
+}

package/dist/main.js

@@ -1,9 +1,10 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpoint, splitByUppercase, testeEndpoint } from "./helpers/helpers.js";
+import { getEndpoint, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
+// import { Module } from "./module.js";
 export class Reflector {
     components;
     paths;
@@ -12,7 +13,7 @@ export class Reflector {
     localDoc = new Source({ path: path.resolve(process.cwd(), `${this.dir}/backup.json`) });
     src = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/controllers`) });
     typesSrc = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/reflector.types.ts`) });
-    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/schemas.ts`) });
+    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/schemas.svelte.ts`) });
     files;
     schemas;
     modules;
@@ -39,7 +40,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 }));
         }
         console.log(`${schemas.length} schemas gerados com sucesso.`);
         return schemas;
@@ -81,9 +82,21 @@ export class Reflector {
     }
     build() {
         const treatedSchemas = this.schemas.map((s) => {
-            return `${s.schema} ${s.type}`;
+            return s.schema;
         });
-        this.schemaFile.changeData([`import z from 'zod';`, ...treatedSchemas].join("\n\n"));
+        const teste = `
+      function build<T>(params: { key?: T; example: T; required: boolean }) {
+        const { example, required, key } = params;
+
+        return {
+          value: key ?? example,
+          display: key ?? example,
+          required,
+          placeholder: example,
+        } as FieldSetup<T>
+      }
+    `;
+        this.schemaFile.changeData(["import type { FieldSetup } from '$repository/types';", teste, ...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,15 +1,15 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./zodProperty.js";
 import type { ReflectorOperation } from "./types/types.js";
+import { SchemaProp } from "./property.js";
 export declare class Method {
     name: string;
     description: string | undefined;
     endpoint: string;
     request: Request;
-    paths: ZodProperty[];
-    headers: ZodProperty[];
-    querys: ZodProperty[];
-    cookies: ZodProperty[];
+    paths: SchemaProp[];
+    headers: SchemaProp[];
+    querys: SchemaProp[];
+    cookies: SchemaProp[];
     constructor(params: {
         operation: ReflectorOperation;
         moduleName: string;

package/dist/method.js

@@ -1,9 +1,9 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./zodProperty.js";
-import { createDangerMessage, getEndpoint, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
+import { createDangerMessage, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
+import { SchemaProp } from "./property.js";
 export class Method {
     name;
-    // zodProperties: ZodProperty[];
+    // zodProperties: Property[];
     description;
     endpoint;
     request;
@@ -42,16 +42,16 @@ export class Method {
                 inParam,
             };
             if (inParam === "query") {
-                this.querys.push(new ZodProperty(zodPropertie));
+                this.querys.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "header") {
-                this.headers.push(new ZodProperty(zodPropertie));
+                this.headers.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "path") {
-                this.paths.push(new ZodProperty(zodPropertie));
+                this.paths.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "cookie") {
-                this.paths.push(new ZodProperty(zodPropertie));
+                this.paths.push(new SchemaProp(zodPropertie));
             }
         }
     }

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 "./zodProperty.js";
+import type { SchemaProp } from "./property.js";
 export declare class Module {
     readonly name: string;
     readonly path: string;
@@ -9,10 +9,10 @@ export declare class Module {
     readonly src: Source;
     imports: Set<string>;
     methods: Method[];
-    querys: ZodProperty[];
-    paths: ZodProperty[];
-    headers: ZodProperty[];
-    cookies: ZodProperty[];
+    querys: SchemaProp[];
+    paths: SchemaProp[];
+    headers: SchemaProp[];
+    cookies: SchemaProp[];
     moduleConstructor: string;
     constructor(params: {
         name: string;
@@ -21,7 +21,6 @@ export declare class Module {
         path: string;
         dir: string;
     });
-    private buildZObject;
     private creator;
     private getPath;
     private getAdditionalMethod;

package/dist/module.js

@@ -3,7 +3,6 @@ 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 "./zodProperty.js";
 export class Module {
     name;
     path;
@@ -24,7 +23,6 @@ export class Module {
             'import repo from "$repository/main"',
             'import { Behavior } from "$reflector/reflector.types";',
             'import { PUBLIC_ENVIRONMENT } from "$env/static/public";',
-            'import z from "zod";',
         ]);
         this.name = capitalizeFirstLetter(name);
         this.path = path;
@@ -57,10 +55,10 @@ export class Module {
             data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
         });
     }
-    buildZObject(props) {
-        const teste = `z.object({${props.map((p) => p.buildedProp)}})`;
-        return teste;
-    }
+    // private buildZObject(props: SchemaProp[]) {
+    //   const teste = `z.object({${props.map((p) => p.buildedProp)}})`;
+    //   return teste;
+    // }
     creator() {
         const buildedModuleTypes = [];
         const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
@@ -69,10 +67,10 @@ export class Module {
         const getXablau = (params) => {
             const { name, objets } = params;
             const capitalizedName = capitalizeFirstLetter(name);
-            buildedModuleTypes.push(`const ${capitalizedName}Schema = ${this.buildZObject(objets)}`);
+            // buildedModuleTypes.push(`const ${capitalizedName}Schema = ${this.buildZObject(objets)}`);
             moduleAttributes.add(`${name} = $state(repo.newForm(${capitalizedName}Schema))`);
             moduleInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
-            moduleClear.add(`clear${capitalizedName}() { this.${name} = repo.newForm(${capitalizedName}Schema) }`);
+            moduleClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}Schema() }`);
         };
         if (this.querys.length > 0) {
             getXablau({ name: "querys", objets: this.querys });
@@ -106,13 +104,10 @@ export class Module {
                 moduleInit.add("this.clearList()");
                 moduleClear.add(`clearList() { this.list = [] }`);
             }
-            if (attributeType === "list" || this.querys.length > 0 || this.headers.length > 0) {
-                this.imports.add(`import z from "zod";`);
-            }
         }
         const formSet = new Set();
         for (const f of form) {
-            formSet.add(`${f.name}: repo.newForm(Empty${f.type}Schema)`);
+            formSet.add(`${f.name}: new ${f.type}()`);
         }
         if (formSet.size > 0) {
             moduleAttributes.add(`
@@ -194,12 +189,11 @@ export class Module {
         for (const method of this.methods) {
             const { bodyType, responseType, apiType } = method.request;
             if (bodyType) {
-                entries.add(`${bodyType}Schema`);
-                entries.add(`Empty${bodyType}Schema`);
+                entries.add(`${bodyType}`);
             }
             if (responseType) {
                 if (apiType === "delete") {
-                    entries.add(`${responseType}Schema`);
+                    entries.add(`${responseType}`);
                 }
                 entries.add(`type ${responseType}`);
             }
@@ -207,7 +201,7 @@ export class Module {
         const cleanEntries = Array.from(entries).filter((x) => x != "type any");
         if (cleanEntries.length === 0)
             return "";
-        return `import { ${cleanEntries} } from '$reflector/schemas';`;
+        return `import { ${cleanEntries} } from '$reflector/schemas.svelte';`;
     }
     buildClass(params) {
         const { moduleInit, moduleAttributes, moduleClear } = params;
@@ -220,7 +214,7 @@ export class Module {
         ${this.buildMethods().join("\n")}
 
         ${moduleClear.join("\n\n")}
-        
+
         reset() {
           ${moduleInit.join(";")}
         }
@@ -230,7 +224,7 @@ export class Module {
     buildConstructor(form) {
         if (form.length === 0)
             return "";
-        const teste = `        
+        const teste = `
       constructor(params?: { empty: boolean }) {
         const isEmpty = params?.empty || PUBLIC_ENVIRONMENT != 'DEV'
 
@@ -241,7 +235,7 @@ export class Module {
         if(isEmpty) return this.forms
 
         return {
-          ${form.map((f) => `${f.name}: repo.newForm(${f.type}Schema)`)}
+          ${form.map((f) => `${f.name}: new ${f.type}()`)}
         }
       }
     `;

package/dist/property.d.ts

@@ -1,14 +1,13 @@
 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;
+export declare class SchemaProp {
+    example: string;
+    emptyExample: string;
     name: string;
-    example: Example | undefined;
-    type: ReflectorParamType;
-    buildedProp: string;
-    description?: string;
-    required: boolean;
-    inParam: ParameterLocation;
+    bType: string;
+    isRequired: boolean;
+    paramType: ReflectorParamType;
+    buildedValue: string;
     constructor(params: {
         schemaName?: string;
         name: string;
@@ -20,11 +19,11 @@ export declare class ZodProperty {
         isEmpty: boolean;
         inParam: ParameterLocation;
     });
-    private getDtoName;
-    private getEmptyExample;
+    private getBuildedValue;
+    getEmptyExample(type: ReflectorParamType): false | 0 | "''";
     private getExample;
     private deepValidator;
     private isNullable;
     private treatName;
-    private build;
+    private getType;
 }

package/dist/property.js

@@ -1,116 +1,114 @@
-import { sanitizeNumber, splitByUppercase } from "./helpers/helpers.js";
+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;
+export class SchemaProp {
+    // schemaName?: string;
+    // name: string;
+    // example: Example | undefined;
+    // type: ReflectorParamType;
+    // buildedProp: string;
+    // description?: string;
+    // required: boolean;
+    // inParam: ParameterLocation;
+    // isEnum: boolean = false;
+    // enums: string[] = [];
     example;
-    type;
-    buildedProp;
-    description;
-    required;
-    inParam;
+    emptyExample;
+    name;
+    bType;
+    isRequired;
+    paramType;
+    buildedValue;
     constructor(params) {
         const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
-        this.inParam = inParam;
-        if (schemaName) {
-            this.schemaName = schemaName;
+        // this.inParam = inParam;
+        // this.isEnum = false;
+        this.paramType = type;
+        this.isRequired = required;
+        this.name = this.treatName(name);
+        this.bType = this.getType({ type, schemaName });
+        this.example = `${this.getExample({ example, type })}`;
+        this.emptyExample = `${this.getEmptyExample(type)}`;
+        this.buildedValue = this.getBuildedValue({
+            example: this.example,
+            isRequired: this.isRequired,
+            name: this.name,
+            type,
+            bType: this.bType,
+        });
+    }
+    getBuildedValue(params) {
+        const { example, isRequired, name, type, bType } = params;
+        let content = "";
+        // let emptyContent: string = "";
+        if (type === "number" || type === "string" || type === "boolean") {
+            content = `build({key: ${this.getEmptyExample(type)}, example: ${example}, required: ${isRequired}})`;
         }
-        if (name.split("-").length > 1) {
-            this.name = `['${name}']`;
+        else if (type === "object") {
+            content = `new ${bType}()`;
+            // emptyContent = `new ${bType}()`;
         }
-        else {
-            this.name = name;
+        else if (type === "array") {
+            content = "[]";
+            // emptyContent = "[]";
         }
-        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;
+        return content;
     }
-    getEmptyExample() {
-        switch (this.type) {
-            case "number":
-                return 0;
-            case "boolean":
-                return false;
-            case "string":
-                return "";
-            default:
-                return "";
+    // private getDtoName(ref: string) {
+    //   const splittedRef = ref.split("/");
+    //   const dto = splittedRef[splittedRef.length - 1];
+    //   return dto;
+    // }
+    getEmptyExample(type) {
+        if (type === "number") {
+            return 0;
+        }
+        else if (type === "boolean") {
+            return false;
+        }
+        else {
+            return "''";
         }
     }
-    getExample(example) {
-        if (example)
-            return example;
-        return this.getEmptyExample();
+    getExample(params) {
+        const { example, type } = params;
+        const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
+        return example ? sanitizedExample : this.getEmptyExample(type);
     }
-    deepValidator() {
-        if (this.name === "email") {
-            return `z.email().default('${this.example}')`;
+    deepValidator(params) {
+        const { name } = params;
+        if (name === "email") {
+            // return `z.email().default('${this.example}')`;
+            return "Email";
         }
-        else if (this.name === "password") {
-            return inputs.password;
+        else if (name === "password") {
+            return "Password";
         }
+        // else if (this.isEnum) {
+        //   return `${treatenEnum(this.enums)}.default('${this.enums[0]}')`;
+        // }
         else {
             return false;
         }
     }
-    isNullable() {
-        return this.required ? "" : ".nullable()";
+    isNullable(isRequired) {
+        return isRequired ? "" : " | null";
     }
     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": {
-                // if (name === "role") {
-                //   console.log(schemaObject.enum);
-                // }
-                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) {
-                        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(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()`;
+    getType(params) {
+        const { type, schemaName } = params;
+        if (type === "object") {
+            return `${schemaName}`;
+        }
+        else if (type === "array") {
+            return `${schemaName}[]`;
+        }
+        else {
+            return type;
         }
     }
 }

package/dist/schema.d.ts

@@ -1,9 +1,8 @@
-import { ZodProperty } from "./zodProperty.js";
+import { SchemaProp } from "./property.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 export declare class Schema {
     name: string;
-    properties: ZodProperty[];
-    type: string;
+    properties: SchemaProp[];
     schema: string;
     enums: Set<string>;
     objects: Map<string, string>;

package/dist/schema.js

@@ -1,8 +1,8 @@
-import { ZodProperty } from "./zodProperty.js";
+import { SchemaProp } from "./property.js";
 export class Schema {
     name;
     properties = [];
-    type;
+    // type: string;
     schema;
     enums = new Set();
     objects = new Map();
@@ -14,7 +14,7 @@ export class Schema {
                 if ("$ref" in value) {
                     const teste = value.$ref;
                     const object = teste.split("/").at(-1);
-                    this.objects.set(key, `${object}Schema`);
+                    this.objects.set(key, `${object}`);
                 }
                 continue;
             }
@@ -26,7 +26,7 @@ export class Schema {
             else if (value.enum) {
                 this.enums.add(this.getEnumConst({ enums: value.enum, schemaName: key }));
             }
-            this.properties.push(new ZodProperty({
+            this.properties.push(new SchemaProp({
                 schemaName: this.name,
                 name: key,
                 schemaObject: value,
@@ -37,16 +37,36 @@ export class Schema {
                 inParam: "path",
             }));
         }
-        this.type = `export type ${this.name} = z.infer<typeof ${this.name}Schema>;`;
-        this.schema = `export const ${this.name}Schema = z.object({
-      ${this.properties.map((p) => {
-            return p.buildedProp;
-        })}
-      ${this.properties.length > 0 ? "," : ""}
-      ${Array.from(this.objects).map(([k, v]) => {
-            return `${k}: z.object(${v})`;
-        })}
-    });`;
+        const keys = this.properties
+            .map((p) => {
+            const keyName = `${p.name}${p.isRequired ? "" : "?"}`;
+            let state;
+            if (p.paramType === "object") {
+                state = `$state<${p.bType}>()`;
+            }
+            else if (p.paramType === "array") {
+                state = `$state<${p.bType}>([])`;
+            }
+            else {
+                state = `$state(${p.buildedValue})`;
+            }
+            return `${keyName} = ${state}`;
+        })
+            .join(";\n");
+        const buildedObjects = Array.from(this.objects)
+            .map(([k, v]) => {
+            return `${k} = $state(new ${v}())`;
+        })
+            .join(";\n");
+        // const builded = this.properties.map((p) => ).join(";\n\n\n");
+        if (this.name === "OwnerFinishSignUpDataDto") {
+            console.log(properties);
+        }
+        this.schema = `export class ${this.name} {
+      ${keys}
+      ${this.properties.length > 0 ? ";" : ""}
+      ${buildedObjects}
+    };`;
     }
     getEnumConst(params) {
         const { enums, schemaName } = params;

package/package.json

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