svelte-reflector 1.0.32 → 1.0.34

package/dist/array.property.js

@@ -16,26 +16,29 @@ export class ArrayProp {
     }
     getType(params) {
         const { schemaObject, schemaName } = params;
-        let name = schemaName;
         const teste = schemaObject.items;
         if (!teste)
-            return name;
+            return schemaName;
+        this.isSpecial = true;
         if ("$ref" in teste) {
             return teste.$ref.split("/").at(-1);
         }
-        this.isSpecial = true;
-        return teste.type || "string";
+        if (teste.enum && teste.type === "string") {
+            return "string";
+        }
+        return teste.type ?? "string";
     }
     constructorBuild() {
         const result = this.isSpecial ? "" : `.map((param) => new ${this.type}(param))`;
         return `this.${this.name} = params?.${this.name}${result} ?? []`;
     }
     classBuild() {
-        return `${this.name}: ${this.type}[]`;
+        const sanitizedType = this.isSpecial ? this.type : `${this.type}[]`;
+        return `${this.name}: ${sanitizedType}[]`;
     }
     interfaceBuild() {
-        const aType = this.isSpecial ? this.type : `${this.type}Interface`;
-        return `${this.name}: ${aType}[]`;
+        const sanitizedType = this.isSpecial ? this.type : `${this.type}Interface`;
+        return `${this.name}: ${sanitizedType}[]`;
     }
     bundleBuild() {
         const result = this.isSpecial ? "" : ".map((obj) => obj.bundle())";

package/dist/main.js

@@ -101,15 +101,26 @@ export class Reflector {
         });
         this.schemaFile.changeData([
             'import { build, BuildedInput } from "$reflector/reflector.svelte";',
+            'import { validateInputs } from "$lib/sanitizers/validateFormats";',
             // ...Array.from(enums),
             ...treatedSchemas,
         ].join("\n\n"));
         this.schemaFile.save();
         const buildFunctions = `
+      import toast from "$lib/utils/toast.svelte";
+
       type ValidatorResult = string | null;
       type ValidatorFn<T> = (v: T) => ValidatorResult;
+      type Partial<T> = {
+        [K in Exclude<keyof T, 'bundle'>]?: BuildedInput<T[K]>;
+      } & {
+        bundle: unknown;
+      };
 
-      export class Behavior { onError?: (e) => void; onSuccess?: (v) => void }
+      export class Behavior<TSuccess = unknown, TError = unknown> {
+        onError?: (e: TError) => void;
+        onSuccess?: (v: TSuccess) => void;
+      }
 
       export class BuildedInput<T> {
         value = $state<T>(null as any);
@@ -135,7 +146,7 @@ export class Reflector {
 
         validate(): ValidatorResult {
           if (!this.validator) return null;
-          return this.value ? this.validator(this.value) : '';
+          return this.validator(this.value);
         }
       }
 
@@ -147,6 +158,20 @@ export class Reflector {
       }): BuildedInput<T> {
         return new BuildedInput(params);
       }
+
+      export function isFormValid<T>(schema: Partial<T>): boolean {
+        delete schema.bundle;
+
+        const arrayOfBuildedInputs = Object.values(schema) as BuildedInput<unknown>[];
+
+        const isValid = arrayOfBuildedInputs.every((a) => a.validate() === null);
+
+        if (!isValid) {
+          toast.error('Erro ao fazer a requisição', 'Um ou mais campos preenchidos estão incorretos.');
+        }
+
+        return isValid;
+      }
     `;
         this.typesSrc.changeData(buildFunctions);
         this.typesSrc.save();

package/dist/method.d.ts

@@ -1,6 +1,7 @@
 import { Request } from "./request.js";
 import type { ReflectorOperation } from "./types/types.js";
 import { PrimitiveProp } from "./primitive-property.js";
+import { ArrayProp } from "./array.property.js";
 export declare class Method {
     name: string;
     description: string | undefined;
@@ -9,8 +10,10 @@ export declare class Method {
     request: Request;
     paths: PrimitiveProp[];
     headers: PrimitiveProp[];
-    querys: PrimitiveProp[];
+    querys: (PrimitiveProp | ArrayProp)[];
     cookies: PrimitiveProp[];
+    private readonly additionalMethod;
+    responseTypeInterface: string;
     constructor(params: {
         operation: ReflectorOperation;
         moduleName: string;
@@ -20,6 +23,7 @@ export declare class Method {
     private getProps;
     private buildCallMethod;
     private readonly methodReturn;
-    build(): string;
+    private getAdditionalMethod;
     private buildDescription;
+    build(): string;
 }

package/dist/method.js

@@ -1,6 +1,7 @@
 import { Request } from "./request.js";
 import { createDangerMessage, getFullEndpoint, treatByUppercase } from "./helpers/helpers.js";
 import { PrimitiveProp } from "./primitive-property.js";
+import { ArrayProp } from "./array.property.js";
 export class Method {
     name;
     // zodProperties: Property[];
@@ -12,6 +13,8 @@ export class Method {
     headers = [];
     querys = [];
     cookies = [];
+    additionalMethod;
+    responseTypeInterface;
     constructor(params) {
         const { operation } = params;
         this.request = new Request(operation);
@@ -19,6 +22,10 @@ export class Method {
         this.endpoint = operation.endpoint;
         this.name = operation.operationId?.split("_")[1] ?? this.request.apiType;
         this.buildProps(params);
+        this.additionalMethod = this.getAdditionalMethod({
+            name: this.name,
+            attributeType: this.request.attributeType,
+        });
     }
     buildProps(params) {
         const { operation } = params;
@@ -34,7 +41,12 @@ export class Method {
                 continue;
             const properties = { name, required: !!required, schemaObject: schema, validator: undefined };
             if (inParam === "query") {
-                this.querys.push(new PrimitiveProp(properties));
+                if (schema.type === "array") {
+                    this.querys.push(new ArrayProp({ name, schemaObject: schema, schemaName: "" }));
+                }
+                else {
+                    this.querys.push(new PrimitiveProp(properties));
+                }
             }
             else if (inParam === "header") {
                 this.headers.push(new PrimitiveProp(properties));
@@ -63,14 +75,12 @@ export class Method {
     }
     buildCallMethod() {
         const beforeResponse = [];
-        const preBuild = () => {
-            return this.request.responseType ? [`${this.request.responseType}Interface`, "const response ="] : ["null", ""];
-        };
-        const [diamond, response] = preBuild();
+        const responseType = this.request.responseType ? `${this.request.responseType}Interface` : "null";
+        this.responseTypeInterface = responseType;
         if (this.request.attributeType === "list") {
             beforeResponse.push(`this.list = ${this.request.responseType}.from(response.data)`);
             const inside = `
-          ${response} await repo.api.get<${diamond}, unknown>({
+          const response = await api.get<${responseType}, unknown>({
             endpoint,
             queryData: { ${this.gee(this.querys)} }
           })
@@ -85,7 +95,7 @@ export class Method {
             }
             let querys = this.querys.length > 0 ? `queryData: {${this.querys.map((q) => q.name).join(",")}}` : "";
             const inside = `
-          ${response} await repo.api.get<${diamond}, unknown>({
+          const response = await api.get<${responseType}, unknown>({
             endpoint,
             ${querys}
           })
@@ -97,7 +107,7 @@ export class Method {
             let data;
             let headers;
             if (this.request.bodyType) {
-                data = `const data = this.forms.${this.name}.bundle()`;
+                data = [`const data = this.forms.${this.name}.bundle()`, `if (!isFormValid(this.forms.${this.name})) return`].join(";");
             }
             const hasHeaders = this.request.parameters.some((p) => p.in === "header");
             const hasData = this.request.bodyType;
@@ -106,7 +116,7 @@ export class Method {
             }
             const outside = ["this.loading = true", data, headers].join("\n");
             const inside = `
-        ${response} await repo.api.${this.request.apiType}<${diamond}>({
+        const response = await api.${this.request.apiType}<${responseType}>({
           endpoint,
           ${hasData ? "data," : ""}
           ${hasHeaders ? "headers," : ""}
@@ -116,7 +126,7 @@ export class Method {
         }
         else if (this.request.apiType === "delete") {
             const inside = `
-        ${response} await repo.api.delete<${diamond}, unknown>({
+        const response = await api.delete<${responseType}, unknown>({
           endpoint,
         })
       `;
@@ -134,6 +144,30 @@ export class Method {
         }
         return this.request.responseType ? `new ${this.request.responseType}(response)` : "null";
     };
+    getAdditionalMethod(params) {
+        const { attributeType, name } = params;
+        let additionalMethod = "";
+        const canAddClearMethod = attributeType === "form" || attributeType === "entity";
+        if (canAddClearMethod && attributeType === "form") {
+            additionalMethod = `
+        /** Limpa o form depois do back retornar uma resposta de sucesso */
+        async ${name}AndClear(behavior: Behavior = new Behavior()) {
+          const data = await this.${name}(behavior)
+
+          if (data) {
+            this.clearForms()
+          }
+
+          return data
+        }
+      `;
+        }
+        // return additionalMethod;
+        return "";
+    }
+    buildDescription() {
+        return `/** ${this.description ?? ""} */`;
+    }
     build() {
         const { inside, outside } = this.buildCallMethod();
         if (this.name === "list")
@@ -143,7 +177,7 @@ export class Method {
         const endpoint = `${a}${getFullEndpoint(this.endpoint)}${a}`;
         return `
       ${description}
-      async ${this.name}(behavior: Behavior = new Behavior()) {
+      async ${this.name}(behavior: Behavior<${this.responseTypeInterface}> = new Behavior()) {
         const {onError, onSuccess} = behavior
         ${this.getProps()}
         const endpoint = ${endpoint}
@@ -161,9 +195,8 @@ export class Method {
           this.loading = false
         }
       }
+
+      ${this.additionalMethod}
     `;
     }
-    buildDescription() {
-        return `/** ${this.description ?? ""} */`;
-    }
 }

package/dist/module.d.ts

@@ -8,6 +8,7 @@ export declare class Module {
     readonly src: Source;
     imports: Set<string>;
     methods: Method[];
+    reflectorImports: Set<string>;
     moduleConstructor: string;
     constructor(params: {
         name: string;
@@ -16,11 +17,10 @@ export declare class Module {
         path: string;
     });
     private buildClassProps;
-    private buildMethod;
-    private creator;
+    private masterBuilder;
+    private processMethods;
+    private processParams;
     private getPath;
-    private getAdditionalMethod;
-    private getParameters;
     private buildClass;
     private buildConstructor;
     buildFile(params: {

package/dist/module.imports.d.ts

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

package/dist/module.imports.js

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

package/dist/module.js

@@ -11,15 +11,13 @@ export class Module {
     src;
     imports;
     methods;
+    reflectorImports;
     moduleConstructor;
     constructor(params) {
         const { name, operations, moduleName, path } = params;
         this.moduleName = moduleName;
-        this.imports = new Set([
-            "// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n",
-            'import repo from "$repository/main"',
-            'import { Behavior, build, BuildedInput } from "$reflector/reflector.svelte";',
-        ]);
+        this.imports = new Set(["// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n", 'import api from "$repository/api"']);
+        this.reflectorImports = new Set(["Behavior"]);
         this.name = capitalizeFirstLetter(name);
         this.path = path;
         this.methods = operations.map((operation) => {
@@ -28,12 +26,9 @@ export class Module {
                 moduleName: this.name,
             });
         });
-        const { cookies, headers, paths, querys } = this.getParameters();
-        const allBuilded = this.creator({
-            cookies,
-            headers,
-            paths,
-            querys,
+        // const { cookies, headers, paths, querys } = this.getParameters();
+        const allBuilded = this.masterBuilder({
+            methods: this.methods,
         });
         this.moduleConstructor = this.buildConstructor(allBuilded.form);
         //sempre por último
@@ -75,77 +70,23 @@ export class Module {
     `;
         return [buildedInterface, buildedClass].join(";");
     }
-    buildMethod(params) {
-        const { hasEntity, hasForm, method } = params;
-        const canAddClearMethod = hasForm && hasEntity;
-        let additionalMethod = this.getAdditionalMethod({ canAddClearMethod, method });
-        return [method.build(), additionalMethod].join("\n");
-    }
-    creator(params) {
-        const { cookies, headers, paths, querys } = params;
-        const buildedModuleTypes = [];
+    masterBuilder(params) {
+        const { methods } = params;
         const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
         const moduleInit = new Set([]);
         const moduleClear = new Set([]);
-        const getParams = (params) => {
-            const { name, props } = params;
-            const capitalizedName = capitalizeFirstLetter(name);
-            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}() }`);
-        };
-        const argEntries = [
-            { name: "querys", props: querys },
-            { name: "headers", props: headers },
-            { name: "paths", props: paths },
-            { name: "cookies", props: cookies },
-        ];
-        for (const { name, props } of argEntries) {
-            if (!props.length)
-                continue;
-            getParams({ name, props });
-        }
-        const hasForm = this.methods.some((m) => m.request.attributeType === "form");
-        const hasEntity = this.methods.some((m) => m.request.attributeType === "entity");
-        const form = [];
-        const formSet = new Set();
-        const entries = new Set();
-        const methods = [];
-        for (const method of this.methods) {
-            const { bodyType, responseType, attributeType } = method.request;
-            if (method.request.bodyType === "string") {
-                createDangerMessage(`Metodo ${method.name} foi ignorado por possuir um body inválido.`);
-                continue;
-            }
-            if (attributeType === "form" && bodyType) {
-                const name = method.name;
-                const type = bodyType;
-                form.push({ name, type });
-                formSet.add(`${name}: new ${type}()`);
-            }
-            methods.push(this.buildMethod({ hasEntity, hasForm, method }));
-            if (attributeType === "entity") {
-                const entityName = treatByUppercase(method.request.responseType ?? "");
-                moduleAttributes.add(`${entityName} = $state<${responseType} | 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']>([])`);
-                moduleInit.add("this.clearList()");
-                moduleClear.add(`clearList() { this.list = [] }`);
-            }
-            if (bodyType) {
-                entries.add(`${bodyType}`);
-            }
-            if (responseType) {
-                entries.add(`type ${responseType}Interface`);
-                entries.add(`${responseType}`);
-            }
-        }
+        const { buildedMethods, entries, form, formSet, methodsAttributes, methodsClear, methodsInit, ...rawParams } = this.processMethods({
+            methods,
+        });
+        const { buildedParamsTypes, paramAttributes, paramClear, paramInit } = this.processParams(rawParams);
+        methodsAttributes.forEach((attr) => moduleAttributes.add(attr));
+        methodsClear.forEach((clear) => moduleClear.add(clear));
+        methodsInit.forEach((init) => moduleInit.add(init));
+        paramAttributes.forEach((attr) => moduleAttributes.add(attr));
+        paramClear.forEach((clear) => moduleClear.add(clear));
+        paramInit.forEach((init) => moduleInit.add(init));
         const cleanEntries = Array.from(entries).filter((x) => x != "type any");
-        const classImports = `import { ${cleanEntries} } from '$reflector/schemas.svelte';`;
+        const classImports = cleanEntries.length > 0 ? `import { ${cleanEntries} } from '$reflector/schemas.svelte';` : "";
         if (formSet.size > 0) {
             moduleAttributes.add(`
         forms = $state({
@@ -159,68 +100,120 @@ export class Module {
         clearForms() { this.forms = this.buildForms(true) };
       `);
         }
-        // return this.methods.map((method) => {
-        // });
         return {
             moduleAttributes: Array.from(moduleAttributes),
-            moduleTypes: buildedModuleTypes,
+            moduleTypes: buildedParamsTypes,
             moduleInit: Array.from(moduleInit),
             moduleClear: Array.from(moduleClear),
             form,
             classImports,
-            buildedMethods: methods,
+            buildedMethods,
         };
     }
-    getPath() {
-        const fileName = this.path.split("/").slice(-2).join("-");
-        const inPath = path.join(generatedDir, this.path);
-        const outPath = path.join(inPath, `${fileName.toLowerCase()}.module.svelte.ts`);
-        fs.mkdirSync(inPath, { recursive: true });
-        return outPath;
-    }
-    getAdditionalMethod(params) {
-        const { method, canAddClearMethod } = params;
-        let additionalMethod = "";
-        if (canAddClearMethod && method.request.attributeType === "form") {
-            additionalMethod = `
-        /** Limpa o form depois do back retornar uma resposta de sucesso */
-        async ${method.name}AndClear(behavior: Behavior = new Behavior()) {
-          const data = await this.${method.name}(behavior)
-
-          if (data) {
-            this.clearForms()
-          }
-
-          return data
-        }
-      `;
-        }
-        return additionalMethod;
-    }
-    // private buildMethods() {
-    // }
-    getParameters() {
+    processMethods(params) {
+        const { methods } = params;
+        const methodsAttributes = new Set();
+        const methodsInit = new Set([]);
+        const methodsClear = new Set([]);
+        const form = [];
+        const formSet = new Set();
+        const entries = new Set();
+        const buildedMethods = [];
         const queryMap = new Map();
         const headerMap = new Map();
         const pathMap = new Map();
         const cookieMap = new Map();
-        for (const method of this.methods) {
-            const { headers, cookies, paths, querys } = method;
+        for (const method of methods) {
+            const { request, headers, cookies, paths, querys } = method;
+            const { bodyType, responseType, attributeType } = request;
             headers.forEach((h) => headerMap.set(h.name, h));
             cookies.forEach((c) => cookieMap.set(c.name, c));
             paths.forEach((p) => pathMap.set(p.name, p));
             querys.forEach((q) => queryMap.set(q.name, q));
+            if (method.request.bodyType === "string") {
+                createDangerMessage(`Metodo ${method.name} foi ignorado por possuir um body inválido.`);
+                continue;
+            }
+            if (attributeType === "form" && bodyType) {
+                const name = method.name;
+                const type = bodyType;
+                form.push({ name, type });
+                formSet.add(`${name}: new ${type}()`);
+                this.reflectorImports.add("isFormValid");
+            }
+            buildedMethods.push(method.build());
+            if (attributeType === "entity") {
+                const entityName = treatByUppercase(method.request.responseType ?? "");
+                methodsAttributes.add(`${entityName} = $state<${responseType} | undefined>()`);
+                methodsInit.add(`this.clear${capitalizeFirstLetter(entityName)}()`);
+                methodsClear.add(`clear${capitalizeFirstLetter(entityName)}() { this.${entityName} = undefined }`);
+            }
+            else if (attributeType === "list") {
+                methodsAttributes.add(`list = $state<${responseType}['data']>([])`);
+                methodsInit.add("this.clearList()");
+                methodsClear.add(`clearList() { this.list = [] }`);
+            }
+            if (bodyType) {
+                entries.add(bodyType);
+            }
+            if (responseType) {
+                entries.add(`type ${responseType}Interface`);
+                entries.add(responseType);
+            }
         }
         return {
+            form,
+            formSet,
+            entries,
+            buildedMethods,
+            methodsAttributes,
+            methodsInit,
+            methodsClear,
             headers: Array.from(headerMap.values()),
             cookies: Array.from(cookieMap.values()),
             paths: Array.from(pathMap.values()),
             querys: Array.from(queryMap.values()),
         };
     }
-    // private buildImportsAndProps() {}
-    // private buildImports() {
-    // }
+    processParams(params) {
+        const { cookies, headers, paths, querys } = params;
+        const buildedParamsTypes = [];
+        const paramAttributes = new Set();
+        const paramInit = new Set([]);
+        const paramClear = new Set([]);
+        const getParams = (params) => {
+            const { name, props } = params;
+            const capitalizedName = capitalizeFirstLetter(name);
+            buildedParamsTypes.push(this.buildClassProps({ props, name: capitalizedName }));
+            paramAttributes.add(`${name} = $state(new ${capitalizedName}())`);
+            paramInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
+            paramClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}() }`);
+        };
+        const argEntries = [
+            { name: "querys", props: querys },
+            { name: "headers", props: headers },
+            { name: "paths", props: paths },
+            { name: "cookies", props: cookies },
+        ];
+        for (const { name, props } of argEntries) {
+            if (!props.length)
+                continue;
+            this.reflectorImports.add("build");
+            this.reflectorImports.add("BuildedInput");
+            getParams({ name, props });
+        }
+        if (buildedParamsTypes.length > 0) {
+            this.imports.add('import { validateInputs } from "$lib/sanitizers/validateFormats"');
+        }
+        return { buildedParamsTypes, paramAttributes, paramInit, paramClear };
+    }
+    getPath() {
+        const fileName = this.path.split("/").slice(-2).join("-");
+        const inPath = path.join(generatedDir, this.path);
+        const outPath = path.join(inPath, `${fileName.toLowerCase()}.module.svelte.ts`);
+        fs.mkdirSync(inPath, { recursive: true });
+        return outPath;
+    }
     buildClass(params) {
         const { moduleInit, moduleAttributes, moduleClear, buildedMethods } = params;
         const reset = moduleAttributes.length > 1
@@ -247,7 +240,7 @@ export class Module {
             return "";
         const teste = `
       constructor(params?: { empty: boolean }) {
-        const isEmpty = params?.empty || PUBLIC_ENVIRONMENT != 'DEV'
+        const isEmpty = params?.empty || import.meta.env.PUBLIC_ENVIRONMENT != 'DEV'
 
         this.forms = this.buildForms(isEmpty);
       }
@@ -264,12 +257,12 @@ export class Module {
     }
     buildFile(params) {
         const { moduleInit, moduleTypes, moduleAttributes, moduleClear, classImports, buildedMethods } = params;
+        const reflectorImports = `import { ${Array.from(this.reflectorImports)} } from "$reflector/reflector.svelte";`;
         return `
       ${Array.from(this.imports).join(";")}
+      ${reflectorImports}
       ${classImports}
 
-      const PUBLIC_ENVIRONMENT = import.meta.env.PUBLIC_ENVIRONMENT;
-
       ${moduleTypes.join(";")}
 
       ${this.buildClass({ moduleAttributes, moduleInit, moduleClear, buildedMethods })}

package/dist/object.property.js

@@ -20,6 +20,6 @@ export class ObjectProp {
         return `${this.name}${req}: ${this.type}Interface`;
     }
     bundleBuild() {
-        return `${this.name}: this.${this.name}.bundle()`;
+        return `${this.name}: this.${this.name}?.bundle()`;
     }
 }

package/dist/primitive-property.js

@@ -6,7 +6,7 @@ export class PrimitiveProp {
     rawType;
     buildedConst;
     constructor(params) {
-        const { name, schemaObject, required } = params;
+        const { name, schemaObject, required, validator } = params;
         const { example: rawExample, type: rawType } = schemaObject;
         const type = rawType ?? "string";
         const example = rawExample ?? this.getEmptyExample({ type, schemaObject });
@@ -16,7 +16,7 @@ export class PrimitiveProp {
         this.rawType = type ?? "any";
         this.type = `BuildedInput<${buildedType}>`;
         this.required = required;
-        this.buildedConst = this.buildConst({ example, name: this.name, required, type });
+        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator });
     }
     treatName(name) {
         let newName = name;
@@ -27,10 +27,26 @@ export class PrimitiveProp {
         return newName;
     }
     buildConst(params) {
-        const { example, name, required, type } = params;
+        const { example, name, required, type, validator } = params;
+        const getValidator = (type) => {
+            if (type === "string") {
+                return "emptyString";
+            }
+            return null;
+        };
+        const buildedValidator = () => {
+            if (validator) {
+                return `validator: ${validator}`;
+            }
+            else if (required && type) {
+                const v = getValidator(type);
+                return v ? `validator: validateInputs.${v}` : "";
+            }
+            return "";
+        };
         const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
         return `
-      build({ key: params?.${name}, example: ${sanitizedExample}, required: ${required}})
+      build({ key: params?.${name}, example: ${sanitizedExample}, required: ${required}, ${buildedValidator()}})
     `;
     }
     getEmptyExample(params) {

package/dist/request.d.ts

@@ -1,6 +1,6 @@
 import type { ParameterObject } from "./types/open-api-spec.interface.js";
 import type { ApiType, ReflectorOperation } from "./types/types.js";
-type ReflectorRequestType = "entity" | "list" | "pagination" | "form" | "other";
+export type ReflectorRequestType = "entity" | "list" | "pagination" | "form" | "other";
 export declare class Request {
     readonly attributeType: ReflectorRequestType;
     readonly apiType: ApiType;
@@ -30,4 +30,3 @@ export declare class Request {
      */
     private typeFromProperties;
 }
-export {};

package/package.json

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