svelte-reflector 1.0.9 → 1.0.12

package/dist/generate-doc.js

@@ -4,6 +4,7 @@ import axios from "axios";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Reflector } from "./main.js";
+import { Source } from "./file.js";
 /** ajuda a pegar a 1ª env definida dentre várias chaves possíveis */
 function pickEnv(...keys) {
     for (const k of keys) {
@@ -44,6 +45,8 @@ export async function reflector(manual = false) {
     try {
         const documentation = await axios.get(DOC_URL, { timeout: 15000 });
         data = documentation.data;
+        const backup = new Source({ path: "src/reflector/backup.json", data: JSON.stringify(data) });
+        backup.save();
     }
     catch (e) {
         console.warn(`[reflector] Não foi possível obter a documentação em ${DOC_URL}. Carregando cópia local...`);

package/dist/helpers/helpers.d.ts

@@ -3,9 +3,13 @@ export declare function sanitizeKey(name: string): string;
 export declare function sanitizeNumber(texto: string): string;
 export declare function capitalizeFirstLetter(text: string): string;
 export declare function splitByUppercase(text: string): string[];
+export declare function treatByUppercase(text?: string): string;
 export declare function createDangerMessage(text: string): void;
+export declare function getFilteredEntities(rawEndpoint: string): string[];
 export declare function getEndpointAndModuleName(rawEndpoint: string): {
     baseEndpoint: string;
     moduleName: string;
 };
 export declare function getEndpoint(rawEndpoint: string): string;
+export declare function testeEndpoint(rawEndpoint: string): string;
+export declare function treatenEnum(enums: string[]): string;

package/dist/helpers/helpers.js

@@ -7,6 +7,7 @@
 //   if (!lhs) return "";
 //   return `${lhs.trim()} = ${cleaned}`;
 // }
+const trashWords = new Set(["Kyc", "Get", "Customer", "Response", "Res", "Self", "Admin"]);
 export function toCamelCase(str) {
     return str
         .split("-")
@@ -34,16 +35,38 @@ export function capitalizeFirstLetter(text) {
 export function splitByUppercase(text) {
     return text.split(/(?=[A-Z])/);
 }
+export function treatByUppercase(text) {
+    const base = (text ?? "").trim();
+    const raw = base.length > 0 ? base : "entity";
+    // Se splitByUppercase tiver tipagem "string[] | undefined", isso resolve.
+    const parts = (splitByUppercase(raw) ?? [])
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0)
+        .filter((p) => !trashWords.has(p));
+    if (parts.length === 0)
+        return "entity";
+    const words = parts.length === 1 ? [parts[0], "Entity"] : parts;
+    const first = words[0];
+    if (!first)
+        return "entity"; // deixa o TS 100% feliz
+    let out = first.charAt(0).toLowerCase() + first.slice(1);
+    for (let i = 1; i < words.length; i++) {
+        const w = words[i];
+        if (!w)
+            continue;
+        out += w.charAt(0).toUpperCase() + w.slice(1);
+    }
+    return out.length > 0 ? out : "entity";
+}
 export function createDangerMessage(text) {
     console.log("\x1b[31m%s\x1b[0m", `[!] ${text}`);
 }
-function getFilteredEntities(rawEndpoint) {
+export function getFilteredEntities(rawEndpoint) {
     const splittedEntitys = rawEndpoint.split("/");
     return splittedEntitys.filter((item) => item !== "" && !item.includes("{"));
 }
 export function getEndpointAndModuleName(rawEndpoint) {
     const filteredEntitys = getFilteredEntities(rawEndpoint);
-    // console.log(filteredEntitys);
     const moduleName = filteredEntitys.map((x) => sanitizeKey(capitalizeFirstLetter(x))).join("");
     const baseEndpoint = filteredEntitys.join("/");
     return { baseEndpoint: getEndpoint(baseEndpoint), moduleName };
@@ -52,3 +75,16 @@ export function getEndpoint(rawEndpoint) {
     const filteredEntitys = getFilteredEntities(rawEndpoint);
     return filteredEntitys.join("/");
 }
+export function testeEndpoint(rawEndpoint) {
+    const teste = rawEndpoint.split("/");
+    const a = teste
+        .filter((t) => t !== "")
+        .map((str) => {
+        return str.includes("}") ? `$${str}` : str;
+    });
+    return a.join("/");
+}
+export function treatenEnum(enums) {
+    const a = enums.map((e) => `"${e}"`);
+    return ` z.literal([${a}])`;
+}

package/dist/main.js

@@ -1,17 +1,16 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpoint, getEndpointAndModuleName, splitByUppercase } from "./helpers/helpers.js";
+import { getEndpoint, splitByUppercase, testeEndpoint } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
-// const defaultMethods = ["get", "patch", "post", "put", "delete"] as const;
 export class Reflector {
     components;
     paths;
     dir = "src";
     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) });
+    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`) });
     files;
@@ -35,11 +34,12 @@ export class Reflector {
             if ("$ref" in object || !object.properties)
                 continue;
             const properties = object.properties;
-            schemas.push(new Schema({
+            const schema = {
                 properties,
                 name: key,
                 requireds: object.required || [],
-            }));
+            };
+            schemas.push(new Schema({ ...schema, isEmpty: false }), new Schema({ ...schema, isEmpty: true }));
         }
         console.log(`${schemas.length} schemas gerados com sucesso.`);
         return schemas;
@@ -74,15 +74,18 @@ export class Reflector {
             return new Module({
                 name,
                 ...info,
-                dir: this.generatedDir,
+                dir: `${this.generatedDir}/controllers`,
             });
         });
         return modules;
     }
     build() {
-        this.schemaFile.changeData([`import z from 'zod';`, ...this.schemas.map((s) => `${s.schema} ${s.type}`)].join("\n\n"));
+        const treatedSchemas = this.schemas.map((s) => {
+            return `${s.schema} ${s.type}`;
+        });
+        this.schemaFile.changeData([`import z from 'zod';`, ...treatedSchemas].join("\n\n"));
         this.schemaFile.save();
-        this.typesSrc.changeData("export class Behavior { onError?: () => void; onSuccess?: () => void }");
+        this.typesSrc.changeData("export class Behavior { onError?: (e) => void; onSuccess?: () => void }");
         this.typesSrc.save();
         for (const module of this.modules) {
             if (module.methods.length === 0)

package/dist/method.d.ts

@@ -1,18 +1,23 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 import type { ReflectorOperation } from "./types/types.js";
 export declare class Method {
     name: string;
-    zodProperties: ZodProperty[];
     description: string | undefined;
     endpoint: string;
     request: Request;
+    paths: ZodProperty[];
+    headers: ZodProperty[];
+    querys: ZodProperty[];
+    cookies: ZodProperty[];
     constructor(params: {
         operation: ReflectorOperation;
         moduleName: string;
     });
-    private getParams;
+    private buildZodProperties;
+    private readonly gee;
+    private getProps;
     private buildCallMethod;
-    private buildDescription;
     build(): string;
+    private buildDescription;
 }

package/dist/method.js

@@ -1,81 +1,95 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./property.js";
-import { createDangerMessage, getEndpoint } from "./helpers/helpers.js";
+import { ZodProperty } from "./zodProperty.js";
+import { createDangerMessage, getEndpoint, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
 export class Method {
     name;
-    zodProperties;
+    // zodProperties: ZodProperty[];
     description;
     endpoint;
     request;
+    paths = [];
+    headers = [];
+    querys = [];
+    cookies = [];
     constructor(params) {
         const { operation } = params;
         this.request = new Request(operation);
         this.description = operation.description ?? operation.summary;
         this.endpoint = operation.endpoint;
         this.name = operation.operationId?.split("_")[1] ?? this.request.apiType;
-        const { parameters } = this.getParams(params);
-        this.zodProperties = parameters;
+        this.buildZodProperties(params);
     }
-    getParams(params) {
+    buildZodProperties(params) {
         const { operation } = params;
-        if (!operation.parameters || operation.parameters?.length === 0) {
-            return { parameters: [] };
-        }
-        const parameters = [];
+        if (!operation.parameters || operation.parameters?.length === 0)
+            return;
         for (const object of operation.parameters) {
             if ("$ref" in object)
                 continue;
             if (!object.schema)
                 continue;
-            const { required, name, description, schema } = object;
+            const { required, name, description, schema, in: inParam } = object;
             if ("$ref" in schema)
                 continue;
-            parameters.push(new ZodProperty({
+            const zodPropertie = {
                 name,
                 example: schema.default,
                 schemaObject: schema,
                 type: schema.type,
                 description: description ?? "",
                 required: required || true,
-            }));
+                isEmpty: false,
+                inParam,
+            };
+            if (inParam === "query") {
+                this.querys.push(new ZodProperty(zodPropertie));
+            }
+            else if (inParam === "header") {
+                this.headers.push(new ZodProperty(zodPropertie));
+            }
+            else if (inParam === "path") {
+                this.paths.push(new ZodProperty(zodPropertie));
+            }
+            else if (inParam === "cookie") {
+                this.paths.push(new ZodProperty(zodPropertie));
+            }
         }
-        return { parameters };
+    }
+    gee = (props) => {
+        return props.map((x) => x.name).join(",");
+    };
+    getProps() {
+        const headers = this.gee(this.headers);
+        const querys = this.gee(this.querys);
+        const paths = this.gee(this.paths);
+        const cookies = this.gee(this.cookies);
+        return `
+      ${querys.length > 0 ? `const {${querys}} = repo.intercept.bundle(this.querys)` : ""};
+      ${paths.length > 0 ? `const {${paths}} = repo.intercept.bundle(this.paths)` : ""};
+      ${cookies.length > 0 ? `const {${cookies}} = repo.intercept.bundle(this.cookies)` : ""};
+    `;
     }
     buildCallMethod() {
-        const afterResponse = [];
         const beforeResponse = [];
-        const props = this.zodProperties.map((x) => x.name).join(",");
-        const parameters = `
-      const bundle = repo.intercept.bundle(this.parameters)
-      const {${props}} = bundle
-    `;
-        const query = `
-      queryData: {${props}}
-    `;
+        // const props = this.getProps();
         if (this.request.apiType === "get") {
-            if (this.zodProperties.length > 0) {
-                afterResponse.push(parameters);
-                beforeResponse.push(`\n`);
-            }
             if (this.request.attributeType === "list") {
-                beforeResponse.push(`const {data: { 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.querys, params)");
                 const inside = `
-          ${afterResponse.join(";")}
           const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
             endpoint,
-            ${query}
+            queryData: { ${this.gee(this.querys)} }
           })
           ${beforeResponse.join(";")}
         `;
                 return { inside, outside: "" };
             }
             else if (this.request.attributeType === "entity") {
-                beforeResponse.push(`this.entity = response`);
+                const entityName = treatByUppercase(this.request.responseType);
+                beforeResponse.push(`this.${entityName} = response`);
                 const inside = `
-        ${afterResponse.join(";")}
           const response = await repo.api.get<${this.request.responseType}, unknown>({
             endpoint,
-            ${query}
           })
           ${beforeResponse.join(";")}
         `;
@@ -83,54 +97,53 @@ export class Method {
             }
         }
         else if (this.request.apiType === "post" || this.request.apiType === "put" || this.request.apiType === "patch") {
-            let data = "";
+            let data;
+            let headers;
             if (this.request.bodyType) {
                 data = `const data = repo.intercept.bundle(this.forms.${this.name})`;
             }
-            const outside = ["this.loading = true", data].join("\n");
+            const hasHeaders = this.request.parameters.some((p) => p.in === "header");
+            const hasData = this.request.bodyType;
+            if (hasHeaders) {
+                headers = `const headers = repo.intercept.bundle(this.headers)`;
+            }
+            const outside = ["this.loading = true", data, headers].join("\n");
             const inside = `
-        const response = await repo.api.post<${this.request.responseType}>({
+        const response = await repo.api.${this.request.apiType}<${this.request.responseType}>({
           endpoint,
-          data
+          ${hasData ? "data," : ""}
+          ${hasHeaders ? "headers," : ""}
         })
       `;
             return { outside, inside };
         }
         else if (this.request.apiType === "delete") {
-            const props = this.zodProperties.map((x) => x.name).join(",");
-            const propsString = props.length > 0 ? `const {${props}} = this.parameters` : "";
             const inside = `
-        ${propsString}
-
         const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
           endpoint,
-          ${query}
         })
-
-        this.clearEntity()
       `;
             const outside = "";
             return { inside, outside };
         }
         return { inside: "", outside: "" };
     }
-    buildDescription() {
-        return `/** ${this.description ?? ""} */`;
-    }
     build() {
         const { inside, outside } = this.buildCallMethod();
         if (this.name === "list")
             this.name = "listAll";
-        const hasProprierties = this.zodProperties.length > 0;
+        const hasProprierties = this.querys.length > 0;
         if (!hasProprierties && this.request.apiType === "delete") {
             createDangerMessage(`${this.name} não vai funcionar, pois não aceita parâmetros na requisição.`);
         }
         const description = this.buildDescription();
+        const a = "`";
         return `
       ${description}
       async ${this.name}(behavior: Behavior = new Behavior()) {
         const {onError, onSuccess} = behavior
-        const endpoint = "${getEndpoint(this.endpoint)}"
+        ${this.getProps()}
+        const endpoint = ${a}${testeEndpoint(this.endpoint)}${a}
 
         ${outside}
 
@@ -139,13 +152,15 @@ export class Method {
           onSuccess?.()
 
           return response
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
         } catch(e) {
-          onError?.()
+          onError?.(e)
+        } finally {
+          this.loading = false
         }
-        
-        this.loading = false
       }
     `;
     }
+    buildDescription() {
+        return `/** ${this.description ?? ""} */`;
+    }
 }

package/dist/module.d.ts

@@ -1,14 +1,19 @@
 import { Source } from "./file.js";
 import { Method } from "./method.js";
 import type { ReflectorOperation } from "./types/types.js";
+import { ZodProperty } from "./zodProperty.js";
 export declare class Module {
     readonly name: string;
     readonly path: string;
     readonly moduleName: string;
     readonly src: Source;
     imports: Set<string>;
-    parameters: string[];
     methods: Method[];
+    querys: ZodProperty[];
+    paths: ZodProperty[];
+    headers: ZodProperty[];
+    cookies: ZodProperty[];
+    moduleConstructor: string;
     constructor(params: {
         name: string;
         moduleName: string;
@@ -16,6 +21,7 @@ export declare class Module {
         path: string;
         dir: string;
     });
+    private buildZObject;
     private creator;
     private getPath;
     private getAdditionalMethod;
@@ -23,6 +29,7 @@ export declare class Module {
     private getParameters;
     private buildImports;
     private buildClass;
+    private buildConstructor;
     buildFile(params: {
         moduleAttributes: string[];
         moduleTypes: string[];

package/dist/module.js

@@ -1,16 +1,21 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { capitalizeFirstLetter, createDangerMessage } from "./helpers/helpers.js";
+import { capitalizeFirstLetter, createDangerMessage, treatByUppercase } from "./helpers/helpers.js";
 import { Method } from "./method.js";
+import { ZodProperty } from "./zodProperty.js";
 export class Module {
     name;
     path;
     moduleName;
     src;
     imports;
-    parameters;
     methods;
+    querys = [];
+    paths = [];
+    headers = [];
+    cookies = [];
+    moduleConstructor;
     constructor(params) {
         const { name, operations, path, dir, moduleName } = params;
         this.moduleName = moduleName;
@@ -18,6 +23,8 @@ export class Module {
             "// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n",
             '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;
@@ -30,7 +37,6 @@ export class Module {
         // não vão entrar metodos que não tiverem uma resposta tipada
         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) {
@@ -38,24 +44,47 @@ export class Module {
             }
             return responseTypeOk;
         });
-        this.parameters = this.getParameters();
-        const { moduleAttributes, moduleTypes, moduleInit, moduleClear } = this.creator();
+        const { cookies, headers, paths, querys } = this.getParameters();
+        this.querys.push(...querys);
+        this.headers.push(...headers);
+        this.paths.push(...paths);
+        this.cookies.push(...cookies);
+        const { moduleAttributes, moduleTypes, moduleInit, moduleClear, form } = this.creator();
+        this.moduleConstructor = this.buildConstructor(form);
         //sempre por último
         this.src = new Source({
             path: this.getPath(dir),
             data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
         });
     }
+    buildZObject(props) {
+        const teste = `z.object({${props.map((p) => p.buildedProp)}})`;
+        return teste;
+    }
     creator() {
         const buildedModuleTypes = [];
         const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
         const moduleInit = new Set([]);
         const moduleClear = new Set([]);
-        if (this.parameters.length > 0) {
-            buildedModuleTypes.push(`const ParametersSchema = z.object({${this.parameters}})`);
-            moduleAttributes.add(`parameters = $state(repo.newForm(ParametersSchema))`);
-            moduleInit.add(`this.clearParameters()`);
-            moduleClear.add(`clearParameters() { this.parameters = repo.newForm(ParametersSchema) }`);
+        const getXablau = (params) => {
+            const { name, objets } = params;
+            const capitalizedName = capitalizeFirstLetter(name);
+            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) }`);
+        };
+        if (this.querys.length > 0) {
+            getXablau({ name: "querys", objets: this.querys });
+        }
+        if (this.headers.length > 0) {
+            getXablau({ name: "headers", objets: this.headers });
+        }
+        if (this.paths.length > 0) {
+            getXablau({ name: "paths", objets: this.paths });
+        }
+        if (this.cookies.length > 0) {
+            getXablau({ name: "cookies", objets: this.cookies });
         }
         const form = [];
         for (const method of this.methods) {
@@ -67,22 +96,23 @@ export class Module {
                 });
             }
             if (attributeType === "entity") {
-                moduleAttributes.add(`entity = $state<${responseType} | undefined>()`);
-                moduleInit.add("this.clearEntity()");
-                moduleClear.add(`clearEntity() { this.entity = undefined }`);
+                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 (attributeType === "list" || this.parameters.length > 0) {
+            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(${f.type}Schema)`);
+            formSet.add(`${f.name}: repo.newForm(Empty${f.type}Schema)`);
         }
         if (formSet.size > 0) {
             moduleAttributes.add(`
@@ -94,7 +124,7 @@ export class Module {
         this.clearForms()
       `);
             moduleClear.add(`
-        clearForms() { this.forms = { ${Array.from(formSet)} } }
+        clearForms() { this.forms = this.buildForms(true) };
       `);
         }
         return {
@@ -102,6 +132,7 @@ export class Module {
             moduleTypes: buildedModuleTypes,
             moduleInit: Array.from(moduleInit),
             moduleClear: Array.from(moduleClear),
+            form,
         };
     }
     getPath(dir) {
@@ -140,23 +171,36 @@ export class Module {
         });
     }
     getParameters() {
-        const set = new Set();
+        const queryMap = new Map();
+        const headerMap = new Map();
+        const pathMap = new Map();
+        const cookieMap = new Map();
         for (const method of this.methods) {
-            for (const param of method.zodProperties) {
-                set.add(param.buildedProp);
-            }
+            const { headers, cookies, paths, querys } = method;
+            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));
         }
-        return Array.from(set);
+        return {
+            headers: Array.from(headerMap.values()),
+            cookies: Array.from(cookieMap.values()),
+            paths: Array.from(pathMap.values()),
+            querys: Array.from(queryMap.values()),
+        };
     }
     buildImports() {
         const entries = new Set();
         for (const method of this.methods) {
             const { bodyType, responseType, apiType } = method.request;
-            if (bodyType)
+            if (bodyType) {
                 entries.add(`${bodyType}Schema`);
+                entries.add(`Empty${bodyType}Schema`);
+            }
             if (responseType) {
-                if (apiType === "delete")
+                if (apiType === "delete") {
                     entries.add(`${responseType}Schema`);
+                }
                 entries.add(`type ${responseType}`);
             }
         }
@@ -171,6 +215,8 @@ export class Module {
       export class ${this.moduleName}Module {
         ${moduleAttributes.join(";")}
 
+        ${this.moduleConstructor}
+
         ${this.buildMethods().join("\n")}
 
         ${moduleClear.join("\n\n")}
@@ -181,6 +227,26 @@ export class Module {
       }
     `;
     }
+    buildConstructor(form) {
+        if (form.length === 0)
+            return "";
+        const teste = `        
+      constructor(params?: { empty: boolean }) {
+        const isEmpty = params?.empty || PUBLIC_ENVIRONMENT != 'DEV'
+
+        this.forms = this.buildForms(isEmpty);
+      }
+
+      private buildForms(isEmpty: boolean) {
+        if(isEmpty) return this.forms
+
+        return {
+          ${form.map((f) => `${f.name}: repo.newForm(${f.type}Schema)`)}
+        }
+      }
+    `;
+        return teste;
+    }
     buildFile(params) {
         const { moduleInit, moduleTypes, moduleAttributes, moduleClear } = params;
         return `