svelte-reflector 1.0.31 → 1.0.32

package/dist/module.d.ts

@@ -16,12 +16,11 @@ export declare class Module {
         path: string;
     });
     private buildClassProps;
+    private buildMethod;
     private creator;
     private getPath;
     private getAdditionalMethod;
-    private buildMethods;
     private getParameters;
-    private buildImports;
     private buildClass;
     private buildConstructor;
     buildFile(params: {
@@ -29,5 +28,7 @@ export declare class Module {
         moduleTypes: string[];
         moduleInit: string[];
         moduleClear: string[];
+        classImports: string;
+        buildedMethods: string[];
     }): string;
 }

package/dist/module.js

@@ -19,7 +19,6 @@ export class Module {
             "// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n",
             'import repo from "$repository/main"',
             'import { Behavior, build, BuildedInput } from "$reflector/reflector.svelte";',
-            'import { PUBLIC_ENVIRONMENT } from "$env/static/public";',
         ]);
         this.name = capitalizeFirstLetter(name);
         this.path = path;
@@ -30,12 +29,17 @@ export class Module {
             });
         });
         const { cookies, headers, paths, querys } = this.getParameters();
-        const { moduleAttributes, moduleTypes, moduleInit, moduleClear, form } = this.creator({ cookies, headers, paths, querys });
-        this.moduleConstructor = this.buildConstructor(form);
+        const allBuilded = this.creator({
+            cookies,
+            headers,
+            paths,
+            querys,
+        });
+        this.moduleConstructor = this.buildConstructor(allBuilded.form);
         //sempre por último
         this.src = new Source({
             path: this.getPath(),
-            data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
+            data: this.buildFile(allBuilded),
         });
     }
     buildClassProps(params) {
@@ -71,6 +75,12 @@ 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 = [];
@@ -85,36 +95,36 @@ export class Module {
             moduleInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
             moduleClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}() }`);
         };
-        if (querys.length > 0) {
-            querys.forEach((q) => {
-                if (q.name === "permissions") {
-                    // console.log(q);
-                }
-            });
-            getParams({ name: "querys", props: querys });
-        }
-        if (headers.length > 0) {
-            getParams({ name: "headers", props: headers });
-        }
-        if (paths.length > 0) {
-            getParams({ name: "paths", props: paths });
-        }
-        if (cookies.length > 0) {
-            getParams({ name: "cookies", props: cookies });
+        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.isValid) {
-            //   console.log(`Método ${method.name} não foi adicionado devido à falta de tipagem na resposta`)
-            //   continue;
-            // }
+            if (method.request.bodyType === "string") {
+                createDangerMessage(`Metodo ${method.name} foi ignorado por possuir um body inválido.`);
+                continue;
+            }
             if (attributeType === "form" && bodyType) {
-                form.push({
-                    name: method.name,
-                    type: 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>()`);
@@ -126,11 +136,16 @@ export class Module {
                 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 formSet = new Set();
-        for (const f of form) {
-            formSet.add(`${f.name}: new ${f.type}()`);
-        }
+        const cleanEntries = Array.from(entries).filter((x) => x != "type any");
+        const classImports = `import { ${cleanEntries} } from '$reflector/schemas.svelte';`;
         if (formSet.size > 0) {
             moduleAttributes.add(`
         forms = $state({
@@ -144,12 +159,16 @@ export class Module {
         clearForms() { this.forms = this.buildForms(true) };
       `);
         }
+        // return this.methods.map((method) => {
+        // });
         return {
             moduleAttributes: Array.from(moduleAttributes),
             moduleTypes: buildedModuleTypes,
             moduleInit: Array.from(moduleInit),
             moduleClear: Array.from(moduleClear),
             form,
+            classImports,
+            buildedMethods: methods,
         };
     }
     getPath() {
@@ -178,15 +197,8 @@ export class Module {
         }
         return additionalMethod;
     }
-    buildMethods() {
-        const hasForm = this.methods.some((m) => m.request.attributeType === "form");
-        const hasEntity = this.methods.some((m) => m.request.attributeType === "entity");
-        const canAddClearMethod = hasForm && hasEntity;
-        return this.methods.map((method) => {
-            let additionalMethod = this.getAdditionalMethod({ canAddClearMethod, method });
-            return [method.build(), additionalMethod].join("\n");
-        });
-    }
+    // private buildMethods() {
+    // }
     getParameters() {
         const queryMap = new Map();
         const headerMap = new Map();
@@ -206,25 +218,11 @@ export class Module {
             querys: Array.from(queryMap.values()),
         };
     }
-    buildImports() {
-        const entries = new Set();
-        for (const method of this.methods) {
-            const { bodyType, responseType, apiType } = method.request;
-            if (bodyType) {
-                entries.add(`${bodyType}`);
-            }
-            if (responseType) {
-                entries.add(`type ${responseType}Interface`);
-                entries.add(`${responseType}`);
-            }
-        }
-        const cleanEntries = Array.from(entries).filter((x) => x != "type any");
-        if (cleanEntries.length === 0)
-            return "";
-        return `import { ${cleanEntries} } from '$reflector/schemas.svelte';`;
-    }
+    // private buildImportsAndProps() {}
+    // private buildImports() {
+    // }
     buildClass(params) {
-        const { moduleInit, moduleAttributes, moduleClear } = params;
+        const { moduleInit, moduleAttributes, moduleClear, buildedMethods } = params;
         const reset = moduleAttributes.length > 1
             ? `reset() {
           ${moduleInit.join(";")}
@@ -236,7 +234,7 @@ export class Module {
 
         ${this.moduleConstructor}
 
-        ${this.buildMethods().join("\n")}
+        ${buildedMethods.join("\n")}
 
         ${moduleClear.join("\n\n")}
 
@@ -265,14 +263,16 @@ export class Module {
         return teste;
     }
     buildFile(params) {
-        const { moduleInit, moduleTypes, moduleAttributes, moduleClear } = params;
+        const { moduleInit, moduleTypes, moduleAttributes, moduleClear, classImports, buildedMethods } = params;
         return `
       ${Array.from(this.imports).join(";")}
-      ${this.buildImports()}
+      ${classImports}
+
+      const PUBLIC_ENVIRONMENT = import.meta.env.PUBLIC_ENVIRONMENT;
 
       ${moduleTypes.join(";")}
 
-      ${this.buildClass({ moduleAttributes, moduleInit, moduleClear })}
+      ${this.buildClass({ moduleAttributes, moduleInit, moduleClear, buildedMethods })}
     `;
     }
 }

package/package.json

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