svelte-reflector 1.0.21 → 1.0.22

package/dist/helpers/helpers.d.ts

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

package/dist/helpers/helpers.js

@@ -90,7 +90,7 @@ export function getEndpoint(rawEndpoint) {
     const filteredEntitys = getFilteredEntities(rawEndpoint);
     return filteredEntitys.join("/");
 }
-export function testeEndpoint(rawEndpoint) {
+export function getFullEndpoint(rawEndpoint) {
     const teste = rawEndpoint.split("/");
     const a = teste
         .filter((t) => t !== "")

package/dist/interface.d.ts

@@ -0,0 +1,11 @@
+import type { PrimitiveProp } from "./primitive-property.js";
+import type { ArrayProp, ObjectProp } from "./property.js";
+export declare class ReflectorInterface {
+    builded: string;
+    constructor(params: {
+        primitiveProps: PrimitiveProp[];
+        arrayProps: ArrayProp[];
+        name: string;
+        objectProps: ObjectProp[];
+    });
+}

package/dist/interface.js

@@ -0,0 +1,21 @@
+export class ReflectorInterface {
+    builded;
+    constructor(params) {
+        const { name, arrayProps, primitiveProps, objectProps } = params;
+        const buildedProps = [];
+        arrayProps.forEach((prop) => {
+            buildedProps.push(prop.interfaceBuild());
+        });
+        primitiveProps.forEach((prop) => {
+            buildedProps.push(prop.interfaceBuild());
+        });
+        objectProps.forEach((prop) => {
+            buildedProps.push(prop.interfaceBuild());
+        });
+        this.builded = `
+      export interface ${name}Interface {
+        ${buildedProps}
+      }
+    `;
+    }
+}

package/dist/main.js

@@ -93,10 +93,14 @@ export class Reflector {
         const enums = new Set();
         const treatedSchemas = this.schemas.map((s) => {
             s.enums.forEach((en) => enums.add(en));
-            return s.schema;
+            return `
+        ${s.interface};
+
+        ${s.schema};
+      `;
         });
         this.schemaFile.changeData([
-            'import { build  } from "$reflector/reflector.svelte";',
+            'import { build, BuildedInput } from "$reflector/reflector.svelte";',
             'import { validateInputs } from "$lib/sanitizers/validateFormats";',
             // ...Array.from(enums),
             ...treatedSchemas,

package/dist/method.d.ts

@@ -1,15 +1,15 @@
 import { Request } from "./request.js";
 import type { ReflectorOperation } from "./types/types.js";
-import { SchemaProp } from "./property.js";
+import { PrimitiveProp } from "./primitive-property.js";
 export declare class Method {
     name: string;
     description: string | undefined;
     endpoint: string;
     request: Request;
-    paths: SchemaProp[];
-    headers: SchemaProp[];
-    querys: SchemaProp[];
-    cookies: SchemaProp[];
+    paths: PrimitiveProp[];
+    headers: PrimitiveProp[];
+    querys: PrimitiveProp[];
+    cookies: PrimitiveProp[];
     constructor(params: {
         operation: ReflectorOperation;
         moduleName: string;

package/dist/method.js

@@ -1,6 +1,6 @@
 import { Request } from "./request.js";
-import { createDangerMessage, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
-import { SchemaProp } from "./property.js";
+import { createDangerMessage, getFullEndpoint, treatByUppercase } from "./helpers/helpers.js";
+import { PrimitiveProp } from "./primitive-property.js";
 export class Method {
     name;
     // zodProperties: Property[];
@@ -31,27 +31,18 @@ export class Method {
             const { required, name, description, schema, in: inParam } = object;
             if ("$ref" in schema)
                 continue;
-            const zodPropertie = {
-                name,
-                example: schema.default,
-                schemaObject: schema,
-                type: schema.type,
-                description: description ?? "",
-                required: required || true,
-                isEmpty: false,
-                inParam,
-            };
+            const properties = { name, required: !!required, schemaObject: schema, validator: undefined };
             if (inParam === "query") {
-                this.querys.push(new SchemaProp(zodPropertie));
+                this.querys.push(new PrimitiveProp(properties));
             }
             else if (inParam === "header") {
-                this.headers.push(new SchemaProp(zodPropertie));
+                this.headers.push(new PrimitiveProp(properties));
             }
             else if (inParam === "path") {
-                this.paths.push(new SchemaProp(zodPropertie));
+                this.paths.push(new PrimitiveProp(properties));
             }
             else if (inParam === "cookie") {
-                this.paths.push(new SchemaProp(zodPropertie));
+                this.paths.push(new PrimitiveProp(properties));
             }
         }
     }
@@ -76,7 +67,7 @@ export class Method {
             if (this.request.attributeType === "list") {
                 beforeResponse.push(`const {data: { data }} = response`, "\n\n", `this.list = data`);
                 const inside = `
-          const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
+          const response = await repo.api.get<{data: ${this.request.responseType}Interface}, unknown>({
             endpoint,
             queryData: { ${this.gee(this.querys)} }
           })
@@ -86,9 +77,9 @@ export class Method {
             }
             else if (this.request.attributeType === "entity") {
                 const entityName = treatByUppercase(this.request.responseType);
-                beforeResponse.push(`this.${entityName} = response`);
+                beforeResponse.push(`this.${entityName} = new ${this.request.responseType}(response)`);
                 const inside = `
-          const response = await repo.api.get<${this.request.responseType}, unknown>({
+          const response = await repo.api.get<${this.request.responseType}Interface, unknown>({
             endpoint,
           })
           ${beforeResponse.join(";")}
@@ -109,7 +100,7 @@ export class Method {
             }
             const outside = ["this.loading = true", data, headers].join("\n");
             const inside = `
-        const response = await repo.api.${this.request.apiType}<${this.request.responseType}>({
+        const response = await repo.api.${this.request.apiType}<${this.request.responseType}Interface>({
           endpoint,
           ${hasData ? "data," : ""}
           ${hasHeaders ? "headers," : ""}
@@ -118,8 +109,9 @@ export class Method {
             return { outside, inside };
         }
         else if (this.request.apiType === "delete") {
+            const diamond = this.request.responseType ? `${this.request.responseType}Interface` : "null";
             const inside = `
-        const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
+        const response = await repo.api.delete<${diamond}, unknown>({
           endpoint,
         })
       `;
@@ -143,7 +135,7 @@ export class Method {
       async ${this.name}(behavior: Behavior = new Behavior()) {
         const {onError, onSuccess} = behavior
         ${this.getProps()}
-        const endpoint = ${a}${testeEndpoint(this.endpoint)}${a}
+        const endpoint = ${a}${getFullEndpoint(this.endpoint)}${a}
 
         ${outside}
 
@@ -151,7 +143,7 @@ export class Method {
           ${inside}
           onSuccess?.()
 
-          return response
+          return new ${this.request.responseType}(response)
         } catch(e) {
           onError?.(e)
         } finally {

package/dist/module.d.ts

@@ -15,7 +15,7 @@ export declare class Module {
         operations: ReflectorOperation[];
         path: string;
     });
-    private buildZObject;
+    private buildClassProps;
     private creator;
     private getPath;
     private getAdditionalMethod;

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 { baseDir, generatedDir } from "./vars.global.js";
+import { generatedDir } from "./vars.global.js";
 export class Module {
     name;
     path;
@@ -11,10 +11,6 @@ export class Module {
     src;
     imports;
     methods;
-    // querys: SchemaProp[] = [];
-    // paths: SchemaProp[] = [];
-    // headers: SchemaProp[] = [];
-    // cookies: SchemaProp[] = [];
     moduleConstructor;
     constructor(params) {
         const { name, operations, moduleName, path } = params;
@@ -22,7 +18,7 @@ export class Module {
         this.imports = new Set([
             "// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n",
             'import repo from "$repository/main"',
-            'import { Behavior, build } from "$reflector/reflector.svelte";',
+            'import { Behavior, build, BuildedInput } from "$reflector/reflector.svelte";',
             'import { PUBLIC_ENVIRONMENT } from "$env/static/public";',
         ]);
         this.name = capitalizeFirstLetter(name);
@@ -52,19 +48,38 @@ export class Module {
             data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
         });
     }
-    buildZObject(props) {
-        const bundle = new Set();
-        const teste = props
-            .map((prop) => {
-            bundle.add(`${prop.name}: this${prop.isSpecial ? "" : "."}${prop.name}.value`);
-            return `${prop.name} = ${prop.buildedValue}`;
-        })
-            .join(";");
-        return `
-      ${teste};
-      
-      bundle() { return { ${Array.from(bundle)} } }
+    buildClassProps(params) {
+        const { name, props } = params;
+        const bundle = [];
+        const attributes = [];
+        const constructorThis = [];
+        const interfaceBuild = [];
+        props.forEach((prop) => {
+            constructorThis.push(prop.constructorBuild());
+            bundle.push(prop.bundleBuild());
+            attributes.push(prop.classBuild());
+            interfaceBuild.push(prop.interfaceBuild());
+        });
+        const buildedInterface = `
+      interface ${name}Interface {
+        ${interfaceBuild.join(";")}
+      }
+    `;
+        const buildedClass = `
+      class ${name} {
+        ${attributes.join(";")}
+
+        constructor(params?: ${name}Interface){
+          ${constructorThis.join(";")}
+        }
+
+        bundle(){
+          return { ${bundle.join(",")} }
+        }
+      }
+
     `;
+        return [buildedInterface, buildedClass].join(";");
     }
     creator(params) {
         const { cookies, headers, paths, querys } = params;
@@ -73,24 +88,24 @@ export class Module {
         const moduleInit = new Set([]);
         const moduleClear = new Set([]);
         const getParams = (params) => {
-            const { name, objets } = params;
+            const { name, props } = params;
             const capitalizedName = capitalizeFirstLetter(name);
-            buildedModuleTypes.push(`class ${capitalizedName}Schema { ${this.buildZObject(objets)} }`);
-            moduleAttributes.add(`${name} = $state(new ${capitalizedName}Schema())`);
+            buildedModuleTypes.push(this.buildClassProps({ props, name: capitalizedName }));
+            moduleAttributes.add(`${name} = $state(new ${capitalizedName}())`);
             moduleInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
-            moduleClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}Schema() }`);
+            moduleClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}() }`);
         };
         if (querys.length > 0) {
-            getParams({ name: "querys", objets: querys });
+            getParams({ name: "querys", props: querys });
         }
         if (headers.length > 0) {
-            getParams({ name: "headers", objets: headers });
+            getParams({ name: "headers", props: headers });
         }
         if (paths.length > 0) {
-            getParams({ name: "paths", objets: paths });
+            getParams({ name: "paths", props: paths });
         }
         if (cookies.length > 0) {
-            getParams({ name: "cookies", objets: cookies });
+            getParams({ name: "cookies", props: cookies });
         }
         const form = [];
         for (const method of this.methods) {
@@ -200,6 +215,7 @@ export class Module {
                 entries.add(`${bodyType}`);
             }
             if (responseType) {
+                entries.add(`type ${responseType}Interface`);
                 entries.add(`${responseType}`);
             }
         }

package/dist/primitive-property.d.ts

@@ -0,0 +1,21 @@
+import type { SchemaObject } from "./types/open-api-spec.interface.js";
+export declare class PrimitiveProp {
+    name: string;
+    type: string;
+    isSpecial: boolean;
+    private readonly required;
+    private readonly rawType;
+    private readonly buildedConst;
+    constructor(params: {
+        name: string;
+        schemaObject: SchemaObject;
+        required: boolean;
+        validator: string | undefined;
+    });
+    private treatName;
+    private buildConst;
+    constructorBuild(): string;
+    classBuild(): string;
+    interfaceBuild(): string;
+    bundleBuild(): string;
+}

package/dist/primitive-property.js

@@ -0,0 +1,46 @@
+export class PrimitiveProp {
+    name;
+    type;
+    isSpecial = false;
+    required;
+    rawType;
+    buildedConst;
+    constructor(params) {
+        const { name, schemaObject, required } = params;
+        const { example, type } = schemaObject;
+        this.name = this.treatName(name);
+        this.rawType = type ?? "any";
+        this.type = `BuildedInput<${type}>`;
+        this.required = required;
+        this.buildedConst = this.buildConst({ example, name, required, type });
+    }
+    treatName(name) {
+        let newName = name;
+        if (name.split("-").length > 1) {
+            this.isSpecial = true;
+            newName = `['${name}']`;
+        }
+        return newName;
+    }
+    buildConst(params) {
+        const { example, name, required, type } = params;
+        const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
+        return `
+      build({ key: params?.${name}, example: ${sanitizedExample}, required: ${required}})
+    `;
+    }
+    constructorBuild() {
+        return `this.${this.name} = ${this.buildedConst}`;
+    }
+    classBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.type}`;
+    }
+    interfaceBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.rawType}`;
+    }
+    bundleBuild() {
+        return `${this.name}: this.${this.name}?.value`;
+    }
+}

package/dist/property.d.ts

@@ -1,35 +1,28 @@
-import { type ParameterLocation, type SchemaObject } from "./types/open-api-spec.interface.js";
-import { type Example, type ReflectorParamType } from "./types/types.js";
-export declare class SchemaProp {
-    inParam: ParameterLocation;
-    isSpecial: boolean;
-    example: string;
-    emptyExample: string;
+import { type ReferenceObject, type SchemaObject } from "./types/open-api-spec.interface.js";
+export declare class ArrayProp {
     name: string;
-    bType: string;
-    isRequired: boolean;
-    reflectorType: ReflectorParamType;
-    buildedValue: string;
-    enums?: string;
+    type: string;
     constructor(params: {
-        schemaName?: string;
         name: string;
         schemaObject: SchemaObject;
-        type: ReflectorParamType;
-        example: Example | undefined;
-        required: boolean;
-        description?: string;
-        isEmpty: boolean;
-        inParam: ParameterLocation;
-        validator?: string | undefined;
+        schemaName: string;
     });
-    private getBuildedValue;
-    getEmptyExample(params: {
-        type: ReflectorParamType;
-        schemaObject: SchemaObject;
-    }): string | false | 0;
-    private getExample;
-    private deepValidator;
     private treatName;
     private getType;
+    constructorBuild(): string;
+    classBuild(): string;
+    interfaceBuild(): string;
+    bundleBuild(): string;
+}
+export declare class ObjectProp {
+    name: string;
+    type: string;
+    private readonly required;
+    constructor(params: {
+        referenceObject: ReferenceObject;
+        name: string;
+    });
+    constructorBuild(): string;
+    classBuild(): string;
+    interfaceBuild(): string;
 }

package/dist/property.js

@@ -1,113 +1,175 @@
-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 SchemaProp {
-    inParam;
-    isSpecial = false;
-    example;
-    emptyExample;
+// export class SchemaProp {
+//   inParam?: ParameterLocation | undefined;
+//   reflectorType: ReflectorParamType;
+//   example: string;
+//   emptyExample: string;
+//   name: string;
+//   buildedValue: string;
+//   buildedType: string;
+//   enums?: string;
+//   isRequired: boolean;
+//   isSpecial: boolean = false;
+//   constructor(params: {
+//     schemaName?: string;
+//     name: string;
+//     schemaObject: SchemaObject;
+//     type: ReflectorParamType;
+//     example: Example | undefined;
+//     required: boolean;
+//     description?: string;
+//     isEmpty: boolean;
+//     inParam?: ParameterLocation;
+//     validator?: string | undefined;
+//   }) {
+//     const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam, validator } = params;
+//     if (schemaObject.enum) {
+//       this.enums = schemaObject.enum.map((e) => `'${e}'`).join("|");
+//     }
+//     this.inParam = inParam;
+//     this.reflectorType = schemaObject.enum ? "enum" : type;
+//     this.isRequired = required;
+//     this.name = this.treatName(name);
+//     this.buildedType = this.getType({ type, schemaName, schemaObject });
+//     this.example = `${this.getExample({ example, type, schemaObject })}`;
+//     this.emptyExample = `${this.getEmptyExample({ schemaObject, type: this.reflectorType })}`;
+//     this.buildedValue = this.getBuildedValue({
+//       example: this.example,
+//       isRequired: this.isRequired,
+//       type,
+//       bType: this.buildedType,
+//       enums: this.enums,
+//       schemaObject,
+//       validator,
+//       inParam,
+//     });
+//   }
+//   private getBuildedValue(params: {
+//     type: ReflectorParamType;
+//     isRequired: boolean;
+//     example: string;
+//     bType: string;
+//     enums: string | undefined;
+//     schemaObject: SchemaObject;
+//     validator: string | undefined;
+//     inParam?: ParameterLocation | undefined;
+//   }) {
+//     const { example, isRequired, type, bType, schemaObject, validator, inParam } = params;
+//     let content: string = "";
+//     const buildedValidator = validator ? `validator: ${validator}` : "";
+//     const buildedKey = () => {
+//       const example = this.getEmptyExample({ type, schemaObject });
+//       return inParam ? example : `params?.${this.name} ?? ${example}`;
+//     };
+//     if (type === "number" || type === "string" || type === "boolean") {
+//       content = `build({key: ${buildedKey()}, example: ${example}, required: ${isRequired}, ${buildedValidator}})`;
+//     } else if (type === "object") {
+//       content = `new ${bType}()`;
+//     } else if (type === "array") {
+//       content = `${this.name}Interface[]`;
+//     }
+//     return content;
+//   }
+//   private getExample(params: { example: Example | undefined; type: ReflectorParamType; schemaObject: SchemaObject }) {
+//     const { example, type, schemaObject } = params;
+//     const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
+//     return example ? sanitizedExample : this.getEmptyExample({ schemaObject, type });
+//   }
+//   private treatName(name: string) {
+//     let newName = name;
+//     if (name.split("-").length > 1) {
+//       this.isSpecial = true;
+//       newName = `['${name}']`;
+//     }
+//     return newName;
+//   }
+//   private getType(params: { type: ReflectorParamType; schemaName: string | undefined; schemaObject: SchemaObject }) {
+//     const { type, schemaName, schemaObject } = params;
+//     if (type === "object") {
+//       return `${schemaName}`;
+//     } else if (type === "array") {
+//       let name = schemaName;
+//       const teste = schemaObject.items;
+//       if (teste && "$ref" in teste) {
+//         const a = teste.$ref;
+//         name = a.split("/").at(-1);
+//       }
+//       return `${name}[]`;
+//     } else {
+//       return type as string;
+//     }
+//   }
+//   getEmptyExample(params: { type: ReflectorParamType; schemaObject: SchemaObject }) {
+//     const { schemaObject, type } = params;
+//     if (type === "number") {
+//       return 0;
+//     } else if (type === "boolean") {
+//       return false;
+//     } else if (schemaObject.enum) {
+//       return `'${schemaObject.enum[0]}'`;
+//     } else {
+//       return "''";
+//     }
+//   }
+// }
+export class ArrayProp {
     name;
-    bType;
-    isRequired;
-    reflectorType;
-    buildedValue;
-    enums;
+    type;
     constructor(params) {
-        const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam, validator } = params;
-        if (schemaObject.enum) {
-            this.enums = schemaObject.enum.map((e) => `'${e}'`).join("|");
-        }
-        this.inParam = inParam;
-        this.reflectorType = schemaObject.enum ? "enum" : type;
-        this.isRequired = required;
+        const { name, schemaObject, schemaName } = params;
         this.name = this.treatName(name);
-        this.bType = this.getType({ type, schemaName, schemaObject });
-        this.example = `${this.getExample({ example, type, schemaObject })}`;
-        this.emptyExample = `${this.getEmptyExample({ schemaObject, type: this.reflectorType })}`;
-        this.buildedValue = this.getBuildedValue({
-            example: this.example,
-            isRequired: this.isRequired,
-            type,
-            bType: this.bType,
-            enums: this.enums,
-            schemaObject,
-            validator,
-        });
-    }
-    getBuildedValue(params) {
-        const { example, isRequired, type, bType, enums, schemaObject, validator } = params;
-        let content = "";
-        const diamondType = enums ? `<${enums}>` : "";
-        const buildedValidator = validator ? `validator: ${validator}` : "";
-        if (type === "number" || type === "string" || type === "boolean") {
-            content = `build${diamondType}({key: ${this.getEmptyExample({ type, schemaObject })}, example: ${example}, required: ${isRequired}, ${buildedValidator}})`;
-        }
-        else if (type === "object") {
-            content = `new ${bType}()`;
-        }
-        else if (type === "array") {
-            content = "[]";
-        }
-        return content;
-    }
-    getEmptyExample(params) {
-        const { schemaObject, type } = params;
-        if (type === "number") {
-            return 0;
-        }
-        else if (type === "boolean") {
-            return false;
-        }
-        else if (schemaObject.enum) {
-            return `'${schemaObject.enum[0]}'`;
-        }
-        else {
-            return "''";
-        }
-    }
-    getExample(params) {
-        const { example, type, schemaObject } = params;
-        const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
-        return example ? sanitizedExample : this.getEmptyExample({ schemaObject, type });
-    }
-    deepValidator(params) {
-        const { name } = params;
-        if (name === "email") {
-            // return `z.email().default('${this.example}')`;
-            return "Email";
-        }
-        else if (name === "password") {
-            return "Password";
-        }
-        else {
-            return false;
-        }
+        this.type = this.getType({ schemaObject, schemaName });
     }
     treatName(name) {
         let newName = name;
         if (name.split("-").length > 1) {
-            this.isSpecial = true;
             newName = `['${name}']`;
         }
         return newName;
     }
     getType(params) {
-        const { type, schemaName, schemaObject } = params;
-        if (type === "object") {
-            return `${schemaName}`;
-        }
-        else if (type === "array") {
-            let name = schemaName;
-            const teste = schemaObject.items;
-            if (teste && "$ref" in teste) {
-                const a = teste.$ref;
-                name = a.split("/").at(-1);
-            }
-            return `${name}[]`;
-        }
-        else {
-            return type;
+        const { schemaObject, schemaName } = params;
+        let name = schemaName;
+        const teste = schemaObject.items;
+        if (teste && "$ref" in teste) {
+            const a = teste.$ref;
+            name = a.split("/").at(-1);
         }
+        return name;
+    }
+    constructorBuild() {
+        return `this.${this.name} = params?.${this.name}.map((param) => new ${this.type}(param)) ?? []`;
+    }
+    classBuild() {
+        return `${this.name}: ${this.type}[]`;
+    }
+    interfaceBuild() {
+        return `${this.name}: ${this.type}Interface[]`;
+    }
+    bundleBuild() {
+        return `${this.name}: this.${this.name}.map((obj) => obj.bundle())`;
+    }
+}
+export class ObjectProp {
+    name;
+    type;
+    required;
+    constructor(params) {
+        const { referenceObject, name } = params;
+        this.name = name;
+        this.type = referenceObject.$ref.split("/").at(-1) ?? "";
+        this.required = true; // tem que ver isso daí
+    }
+    constructorBuild() {
+        return `this.${this.name} = new ${this.type}(params?.${this.name})`;
+    }
+    classBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.type}`;
+    }
+    interfaceBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.type}Interface`;
     }
 }

package/dist/schema.d.ts

@@ -1,12 +1,16 @@
-import { SchemaProp } from "./property.js";
+import { PrimitiveProp } from "./primitive-property.js";
+import { ArrayProp, ObjectProp } from "./property.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 import type { FieldValidators } from "./types/types.js";
 export declare class Schema {
     name: string;
-    properties: SchemaProp[];
+    primitiveProps: PrimitiveProp[];
+    arrayProps: ArrayProp[];
+    objectProps: ObjectProp[];
     schema: string;
     enums: Set<string>;
     objects: Map<string, string>;
+    interface: string;
     constructor(params: {
         properties: Record<string, SchemaObject | ReferenceObject>;
         name: string;

package/dist/schema.js

@@ -1,23 +1,23 @@
-import { capitalizeFirstLetter, splitByUppercase, treatAndUpper, treatByUppercase } from "./helpers/helpers.js";
-import { SchemaProp } from "./property.js";
+import { capitalizeFirstLetter } from "./helpers/helpers.js";
+import { ReflectorInterface } from "./interface.js";
+import { PrimitiveProp } from "./primitive-property.js";
+import { ArrayProp, ObjectProp } from "./property.js";
 export class Schema {
     name;
-    properties = [];
-    // type: string;
+    primitiveProps = [];
+    arrayProps = [];
+    objectProps = [];
     schema;
     enums = new Set();
     objects = new Map();
+    interface;
     constructor(params) {
         const { name, properties, requireds, isEmpty, validators } = params;
         this.name = `${isEmpty ? "Empty" : ""}${name}`;
-        const bundleParams = new Set();
         for (const [key, value] of Object.entries(properties)) {
             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}`);
-                    bundleParams.add(`${key}: this.${key}?.bundle()`);
+                    this.objectProps.push(new ObjectProp({ name: key, referenceObject: value }));
                 }
                 continue;
             }
@@ -31,46 +31,51 @@ export class Schema {
                 this.enums.add(this.getEnumConst({ enums: value.enum, schemaName: key }));
             }
             const validator = validators.get(key);
-            bundleParams.add(`${key}: this.${key}?.value`);
-            this.properties.push(new SchemaProp({
-                schemaName: this.name,
-                name: key,
-                schemaObject: value,
-                type: value.type,
-                example: value.example,
-                required,
-                isEmpty,
-                inParam: "path",
-                validator,
-            }));
-        }
-        const keys = this.properties
-            .map((p) => {
-            const keyName = `${p.name}${p.isRequired ? "" : "?"}`;
-            let state;
-            if (p.reflectorType === "object") {
-                state = `$state<${p.bType}>()`;
-            }
-            else if (p.reflectorType === "array") {
-                state = `$state<${p.bType}>([])`;
+            const type = value.type;
+            if (type === "object")
+                continue;
+            if (type === "array") {
+                this.arrayProps.push(new ArrayProp({ schemaObject: value, schemaName: this.name, name: key }));
             }
             else {
-                state = `$state(${p.buildedValue})`;
+                this.primitiveProps.push(new PrimitiveProp({ name: key, schemaObject: value, required, validator }));
             }
-            return `${keyName} = ${state}`;
-        })
-            .join(";\n");
-        const buildedObjects = Array.from(this.objects)
-            .map(([k, v]) => {
-            return `${k} = $state(new ${v}())`;
-        })
-            .join(";\n");
-        this.schema = `export class ${this.name} {
-      ${keys}
-      ${this.properties.length > 0 ? ";" : ""}
-      ${buildedObjects}
+        }
+        const reflectorInterface = new ReflectorInterface({
+            name: this.name,
+            arrayProps: this.arrayProps,
+            primitiveProps: this.primitiveProps,
+            objectProps: this.objectProps,
+        });
+        this.interface = reflectorInterface.builded;
+        const constructorThis = [];
+        const keys = [];
+        const bundleParams = [];
+        this.primitiveProps.forEach((prop) => {
+            constructorThis.push(prop.constructorBuild());
+            bundleParams.push(prop.bundleBuild());
+            keys.push(prop.classBuild());
+        });
+        this.arrayProps.forEach((prop) => {
+            constructorThis.push(prop.constructorBuild());
+            keys.push(prop.classBuild());
+            bundleParams.push(prop.bundleBuild());
+        });
+        this.objectProps.forEach((prop) => {
+            constructorThis.push(prop.constructorBuild());
+            keys.push(prop.classBuild());
+            // bundleParams.push(prop.bundleBuild());
+        });
+        this.schema = `
+    export class ${this.name} {
+      ${keys.join(";")}
+
+      constructor(params?: ${this.name}Interface) { 
+        ${constructorThis.join(";\n")}
+      }
+
       bundle(){
-        return { ${Array.from(bundleParams).join(",")} }
+        return { ${bundleParams.join(",")} }
       }
     };`;
     }

package/package.json

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