svelte-reflector 1.0.5 → 1.0.7

package/dist/helpers/helpers.js

@@ -23,7 +23,7 @@ export function sanitizeKey(name) {
     return toCamelCase(name);
 }
 export function sanitizeNumber(texto) {
-    return texto.replace(/["']/g, "");
+    return texto.replaceAll(/["']/g, "");
 }
 export function capitalizeFirstLetter(text) {
     if (!text)

package/dist/main.d.ts

@@ -9,6 +9,7 @@ export declare class Reflector {
     readonly generatedDir: string;
     readonly localDoc: Source;
     readonly src: Source;
+    readonly typesSrc: Source;
     readonly schemaFile: Source;
     files: Source[];
     schemas: Schema[];

package/dist/main.js

@@ -12,6 +12,7 @@ export class Reflector {
     generatedDir = `${this.dir}/reflector`;
     localDoc = new Source({ path: path.resolve(process.cwd(), `${this.dir}/backup.json`) });
     src = new Source({ path: path.resolve(process.cwd(), this.generatedDir) });
+    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`) });
     files;
     schemas;
@@ -83,6 +84,8 @@ export class Reflector {
     build() {
         this.schemaFile.changeData([`import z from 'zod';`, ...this.schemas.map((s) => `${s.schema} ${s.type}`)].join("\n\n"));
         this.schemaFile.save();
+        this.typesSrc.changeData("export class Behavior { onError?: () => void; onSuccess?: () => void }");
+        this.typesSrc.save();
         for (const module of this.modules) {
             if (module.methods.length === 0)
                 continue;

package/dist/method.d.ts

@@ -4,7 +4,7 @@ import type { ReflectorOperation } from "./types/types.js";
 export declare class Method {
     name: string;
     zodProperties: ZodProperty[];
-    description: string | undefined;
+    description?: string;
     request: Request;
     constructor(params: {
         operation: ReflectorOperation;

package/dist/method.js

@@ -9,7 +9,7 @@ export class Method {
     constructor(params) {
         const { operation } = params;
         this.request = new Request(operation);
-        this.description = operation.description;
+        this.description = operation.description ?? operation.summary;
         this.name = operation.operationId?.split("_")[1] ?? this.request.apiType;
         const { parameters } = this.getParams(params);
         this.zodProperties = parameters;
@@ -56,15 +56,13 @@ export class Method {
                 beforeResponse.push(`\n`);
             }
             if (this.request.attributeType === "list") {
-                beforeResponse.push(`const {data, ...params} = response`, "\n\n", `this.list = data`, `repo.intercept.rebuild(this.parameters, params)`);
+                beforeResponse.push(`const {data: { data }, ...params} = response`, "\n\n", `this.list = data`, `repo.intercept.rebuild(this.parameters, params)`);
                 return `
           ${afterResponse.join(";")}
-          const response = await repo.api.get<{data: ${this.request.responseType}[]}, unknown>({
+          const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
             endpoint: this.endpoint, ${query}
           })
           ${beforeResponse.join(";")}
-
-          return response
         `;
             }
             else if (this.request.attributeType === "entity") {
@@ -75,12 +73,10 @@ export class Method {
             endpoint: this.endpoint, ${query}
           })
           ${beforeResponse.join(";")}
-
-          return response
         `;
             }
         }
-        else if (this.request.apiType === "post" || this.request.apiType === "put") {
+        else if (this.request.apiType === "post" || this.request.apiType === "put" || this.request.apiType === "patch") {
             let data = "";
             if (this.request.bodyType) {
                 data = `const data = repo.intercept.bundle(this.forms.${this.name})`;
@@ -92,21 +88,19 @@ export class Method {
           endpoint: this.endpoint,
           ${data ? "data" : ""}
         })
-
-        return response
       `;
         }
         else if (this.request.apiType === "delete") {
             const props = this.zodProperties.map((x) => x.name).join(",");
+            const propsString = props.length > 0 ? `const {${props}} = this.parameters` : "";
             return `
-        const {${props}} = this.parameters
+        ${propsString}
 
-        const response = await repo.api.delete<${this.request.responseType}, unknown>({
+        const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
           endpoint: this.endpoint, ${query}
         })
 
-        this.clear()
-        return response
+        this.clearEntity()
       `;
         }
         return "";
@@ -124,11 +118,39 @@ export class Method {
         if (!hasProprierties && this.request.apiType === "delete") {
             createDangerMessage(`${this.name} não vai funcionar, pois não aceita parâmetros na requisição.`);
         }
+        let additionalMethod = "";
+        const description = this.buildDescription();
+        if (this.request.apiType === "post") {
+            additionalMethod = `
+        /** Limpa a entity depois de ser criada com sucesso */
+        async ${this.name}AndClear(behavior: Behavior = new Behavior()) {
+          const data = await this.${this.name}(behavior)
+
+          if(data) {
+            this.clearEntity()
+          }
+
+          return data
+        }
+      `;
+        }
         return `
-      ${this.buildDescription()}
-      async ${this.name}() {
-        ${content}
+      ${description}
+      async ${this.name}(behavior: Behavior = new Behavior()) {
+        const {onError, onSuccess} = behavior
+
+        try{
+          ${content}
+          onSuccess?.()
+
+          return response
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch(e) {
+          onError?.()
+        }
       }
+
+      ${additionalMethod}
     `;
     }
 }

package/dist/module.d.ts

@@ -22,5 +22,10 @@ export declare class Module {
     private getParameters;
     private buildImports;
     private buildClass;
-    buildFile(modulesAttributes: string[], moduleTypes: string[]): string;
+    buildFile(params: {
+        moduleAttributes: string[];
+        moduleTypes: string[];
+        moduleInit: string[];
+        moduleClear: string[];
+    }): string;
 }

package/dist/module.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import { Source } from "./file.js";
-import { capitalizeFirstLetter, createDangerMessage, stripState } from "./helpers/helpers.js";
+import { capitalizeFirstLetter, createDangerMessage } from "./helpers/helpers.js";
 import { Method } from "./method.js";
 export class Module {
     name;
@@ -14,7 +14,11 @@ export class Module {
     constructor(params) {
         const { name, operations, endpoint, dir, moduleName } = params;
         this.moduleName = moduleName;
-        this.imports = new Set(["// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n", 'import repo from "$repository/main"']);
+        this.imports = new Set([
+            "// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n",
+            'import repo from "$repository/main"',
+            'import { Behavior } from "$reflector/reflector.types";',
+        ]);
         this.name = capitalizeFirstLetter(name);
         this.endpoint = endpoint;
         const methods = operations.map((operation) => {
@@ -27,28 +31,31 @@ export class Module {
         this.methods = methods.filter((op) => {
             const responseTypeOk = op.request.responseType;
             const propertiesOk = op.zodProperties.length > 0;
+            if (op.request.apiType === "delete")
+                return true;
             if (!responseTypeOk) {
                 createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
             }
-            else if (!propertiesOk) {
-                createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] com tipagem incorreta.`);
-            }
-            return responseTypeOk && propertiesOk;
+            return responseTypeOk;
         });
         this.parameters = this.getParameters();
-        const { moduleAtributes, moduleTypes } = this.creator();
+        const { moduleAttributes, moduleTypes, moduleInit, moduleClear } = this.creator();
         //sempre por último
         this.src = new Source({
             path: this.getPath(dir),
-            data: this.buildFile(moduleAtributes, moduleTypes),
+            data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
         });
     }
     creator() {
         const buildedModuleTypes = [];
-        const moduleAtributes = new Set([`endpoint = '${this.endpoint}'`]);
+        const moduleAttributes = new Set([`endpoint = '${this.endpoint}'`]);
+        const moduleInit = new Set([]);
+        const moduleClear = new Set([]);
         if (this.parameters.length > 0) {
             buildedModuleTypes.push(`const ParametersSchema = z.object({${this.parameters}})`);
-            moduleAtributes.add(`parameters = $state(repo.newForm(ParametersSchema))`);
+            moduleAttributes.add(`parameters = $state(repo.newForm(ParametersSchema))`);
+            moduleInit.add(`this.clearParameters()`);
+            moduleClear.add(`clearParameters() { this.parameters = repo.newForm(ParametersSchema) }`);
         }
         const form = [];
         for (const method of this.methods) {
@@ -60,10 +67,14 @@ export class Module {
                 });
             }
             if (attributeType === "entity") {
-                moduleAtributes.add(`entity = $state<${responseType} | undefined>()`);
+                moduleAttributes.add(`entity = $state<${responseType} | undefined>()`);
+                moduleInit.add("this.clearEntity()");
+                moduleClear.add(`clearEntity() { this.entity = undefined }`);
             }
             else if (attributeType === "list") {
-                moduleAtributes.add(`list = $state<${responseType}[]>([])`);
+                moduleAttributes.add(`list = $state<${responseType}['data']>([])`);
+                moduleInit.add("this.clearList()");
+                moduleClear.add(`clearList() { this.list = [] }`);
             }
             if (attributeType === "list" || this.parameters.length > 0) {
                 this.imports.add(`import z from "zod";`);
@@ -74,15 +85,23 @@ export class Module {
             formSet.add(`${f.name}: repo.newForm(${f.type}Schema)`);
         }
         if (formSet.size > 0) {
-            moduleAtributes.add(`
-      forms = $state({
-        ${Array.from(formSet)}
-      })
-    `);
+            moduleAttributes.add(`
+        forms = $state({
+          ${Array.from(formSet)}
+        })
+      `);
+            moduleInit.add(`
+        this.clearForms()
+      `);
+            moduleClear.add(`
+        clearForms() { this.forms = { ${Array.from(formSet)} } }
+      `);
         }
         return {
-            moduleAtributes: Array.from(moduleAtributes),
+            moduleAttributes: Array.from(moduleAttributes),
             moduleTypes: buildedModuleTypes,
+            moduleInit: Array.from(moduleInit),
+            moduleClear: Array.from(moduleClear),
         };
     }
     getPath(dir) {
@@ -123,32 +142,31 @@ export class Module {
             return "";
         return `import { ${cleanEntries} } from '$reflector/schemas';`;
     }
-    buildClass(modulesAttributes) {
-        const initAssignments = modulesAttributes.map((attr) => `this.${stripState(attr)}`).join(";");
+    buildClass(params) {
+        const { moduleInit, moduleAttributes, moduleClear } = params;
         return `
       export class ${this.moduleName}Module {
-        ${modulesAttributes.join(";")}
+        ${moduleAttributes.join(";")}
 
         ${this.buildMethods().join("\n")}
 
-        private init() {
-          ${initAssignments}
-        }
-
-        clear() {
-          this.init()
+        ${moduleClear.join("\n\n")}
+        
+        clearAll() {
+          ${moduleInit.join(";")}
         }
       }
     `;
     }
-    buildFile(modulesAttributes, moduleTypes) {
+    buildFile(params) {
+        const { moduleInit, moduleTypes, moduleAttributes, moduleClear } = params;
         return `
       ${Array.from(this.imports).join(";")}
       ${this.buildImports()}
 
       ${moduleTypes.join(";")}
 
-      ${this.buildClass(modulesAttributes)}
+      ${this.buildClass({ moduleAttributes, moduleInit, moduleClear })}
     `;
     }
 }

package/dist/property.js

@@ -10,10 +10,11 @@ export class ZodProperty {
     required;
     constructor(params) {
         const { name, schemaObject, type, example, required } = params;
+        const realExample = example ?? schemaObject.example;
         this.required = required;
         this.name = name;
         this.type = type;
-        this.example = this.getExample(example);
+        this.example = this.getExample(realExample);
         this.buildedProp = this.build(schemaObject);
     }
     getDtoName(ref) {
@@ -35,11 +36,6 @@ export class ZodProperty {
                 return "lorem ipsum";
         }
     }
-    // fiscalNumber = cpf | cnpj | fiscalNumber
-    // cep
-    // telefone
-    // CUID
-    // url
     deepValidator() {
         if (this.name === "email") {
             return `z.email().default('${this.example}')`;

package/package.json

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