svelte-reflector 1.0.1 → 1.0.3

package/dist/cli.js

@@ -1,12 +1,3 @@
 #!/usr/bin/env node
 import { reflector } from "./generate-doc.js";
-// (async () => {
-//   try {
-//     console.log("[reflector] Finalizado com sucesso.");
-//     process.exit(0);
-//   } catch (err) {
-//     console.error("[reflector] Falha:", err instanceof Error ? err.message : err);
-//     process.exit(1);
-//   }
-// })();
 await reflector(true);

package/dist/generate-doc.d.ts

@@ -1,4 +1,4 @@
 import "dotenv/config";
 export declare function reflector(manual?: boolean): Promise<{
     name: string;
-} | undefined>;
+}>;

package/dist/generate-doc.js

@@ -35,7 +35,6 @@ function getParams() {
 }
 export async function reflector(manual = false) {
     const { BACKEND_URL, ENVIRONMENT } = getParams();
-    console.warn("opa");
     if (ENVIRONMENT === "DEV" && !manual) {
         console.warn("[reflector] Ambiente DEV: para regerar os schemas manualmente, use: npx reflect");
         return breakReflector();
@@ -54,12 +53,12 @@ export async function reflector(manual = false) {
     const { components, paths } = data;
     if (!components) {
         console.warn("[reflector] OpenAPI sem components; abortando.");
-        return { name: "vite-plugin-generate-doc" };
+        return breakReflector();
     }
     const r = new Reflector({ components, paths });
     r.build();
     r.localSave(data);
-    breakReflector();
+    return breakReflector();
 }
 function breakReflector() {
     return {

package/dist/helpers/helpers.d.ts

@@ -0,0 +1,11 @@
+export declare function stripState(attr: string): string;
+export declare function toCamelCase(str: string): string;
+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 createDangerMessage(text: string): void;
+export declare function getEndpointAndModuleName(rawEndpoint: string): {
+    endpoint: string;
+    moduleName: string;
+};

package/dist/helpers/helpers.js

@@ -0,0 +1,45 @@
+export function stripState(attr) {
+    // Ex.: "form = $state(newForm(DefaultCreateUserDtoSchema))"
+    const [lhs, rhsRaw = ""] = attr.split("=");
+    const rhs = rhsRaw.trim();
+    // remove apenas UM wrapper $state( ... ) do início ao fim
+    const cleaned = rhs.startsWith("$state(") && rhs.endsWith(")") ? rhs.slice("$state(".length, -1).trim() : rhs;
+    return `${lhs.trim()} = ${cleaned}`;
+}
+export function toCamelCase(str) {
+    return str
+        .split("-")
+        .map((chunk, i) => (i === 0 ? chunk : chunk[0].toUpperCase() + chunk.slice(1)))
+        .join("");
+}
+export function sanitizeKey(name) {
+    const match = /^\[id(.+)\]$|^\{(.+)\}$/.exec(name);
+    if (match) {
+        const raw = match[1] || match[2]; // pega o conteúdo entre [] ou {}
+        const camel = toCamelCase(raw);
+        // Garante que a primeira letra fique minúscula
+        return camel.charAt(0).toLowerCase() + camel.slice(1);
+    }
+    return toCamelCase(name);
+}
+export function sanitizeNumber(texto) {
+    return texto.replace(/["']/g, "");
+}
+export function capitalizeFirstLetter(text) {
+    if (!text)
+        return "";
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+export function splitByUppercase(text) {
+    return text.split(/(?=[A-Z])/);
+}
+export function createDangerMessage(text) {
+    console.log("\x1b[31m%s\x1b[0m", `[!] ${text}`);
+}
+export function getEndpointAndModuleName(rawEndpoint) {
+    const splittedEntitys = rawEndpoint.split("/");
+    const filteredEntitys = splittedEntitys.filter((item) => item !== "" && !item.includes("{"));
+    const moduleName = filteredEntitys.map((x) => sanitizeKey(capitalizeFirstLetter(x))).join("");
+    const endpoint = filteredEntitys.join("/");
+    return { endpoint, moduleName };
+}

package/dist/helpers/input.d.ts

@@ -0,0 +1,3 @@
+export declare class ReflectorInput {
+    password: string;
+}

package/dist/helpers/input.js

@@ -0,0 +1,14 @@
+export class ReflectorInput {
+    password = `z
+    .string()
+    .regex(/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$/, {
+      message: 'A senha deve conter pelo menos ',
+    })
+    .min(8, { message: '8 caracteres, ' })
+    .regex(/[A-Z]/, { message: 'uma letra maiúscula, ' })
+    .regex(/[a-z]/, { message: 'uma letra minúscula, ' })
+    .regex(/[0-9]/, { message: 'um número, ' })
+    .regex(/[^A-Za-z0-9]/, { message: 'um caracter especial.' })
+    .default('Senha123!@#')
+  `;
+}

package/dist/main.d.ts

@@ -18,7 +18,7 @@ export declare class Reflector {
         paths: PathsObject;
     });
     private getSchemas;
-    getModules(): Module[];
+    private getModules;
     build(): {};
     localSave(data: OpenAPIObject): void;
     private clearSrc;

package/dist/main.js

@@ -1,9 +1,10 @@
 import path from "node:path";
 import fs from "node:fs";
 import { Source } from "./file.js";
-import { sanitizeKey, capitalizeFirstLetter } from "./helpers.js";
+import { getEndpointAndModuleName, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
+const methods = ["get", "patch", "post", "put", "delete"];
 export class Reflector {
     components;
     paths;
@@ -11,7 +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) });
-    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.dir}/schemas.ts`) });
+    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/schemas.ts`) });
     files;
     schemas;
     modules;
@@ -29,16 +30,16 @@ export class Reflector {
         if (!componentSchemas)
             return [];
         const schemas = [];
-        Object.entries(componentSchemas).forEach(([key, object]) => {
+        for (const [key, object] of Object.entries(componentSchemas)) {
             if ("$ref" in object || !object.properties)
-                return;
+                continue;
             const properties = object.properties;
             schemas.push(new Schema({
                 properties,
                 name: key,
                 requireds: object.required || [],
             }));
-        });
+        }
         console.log(`${schemas.length} schemas gerados com sucesso.`);
         return schemas;
     }
@@ -46,22 +47,21 @@ export class Reflector {
         const methodsMap = new Map();
         const modules = [];
         for (const [rawEndpoint, object] of Object.entries(this.paths)) {
-            const methods = ["get", "patch", "post", "put", "delete"];
             let entity;
             const operations = [];
-            const splittedEntitys = rawEndpoint.split("/");
-            const filteredEntitys = splittedEntitys.filter((item) => item !== "" && !item.includes("{"));
-            const moduleName = filteredEntitys.map((x) => sanitizeKey(capitalizeFirstLetter(x))).join("");
-            const endpoint = filteredEntitys.join("/");
+            const { endpoint, moduleName } = getEndpointAndModuleName(rawEndpoint);
             for (const method of methods) {
                 if (!object[method])
                     continue;
                 operations.push({ ...object[method], apiMethod: method });
-                const tags = object[method].tags;
-                if (!entity && tags) {
-                    entity = tags.join("").split("/").join("");
+                if (!entity) {
+                    const teste = object[method].operationId.split("_")[0];
+                    const x = splitByUppercase(teste);
+                    const aaa = x.filter((y) => y !== "Controller");
+                    entity = aaa.join("");
                 }
             }
+            // console.warn(entity)
             if (!entity)
                 continue;
             const existingOps = methodsMap.get(entity);
@@ -84,9 +84,9 @@ 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.modules.forEach((module) => {
+        for (const module of this.modules) {
             module.src.save();
-        });
+        }
         return {};
     }
     localSave(data) {

package/dist/method.js

@@ -1,6 +1,6 @@
 import { Request } from "./request.js";
 import { ZodProperty } from "./property.js";
-import { createDangerMessage } from "./helpers.js";
+import { createDangerMessage } from "./helpers/helpers.js";
 export class Method {
     name;
     zodProperties;
@@ -20,15 +20,15 @@ export class Method {
             return { parameters: [] };
         }
         const parameters = [];
-        operation.parameters.forEach((object) => {
+        for (const object of operation.parameters) {
             if ("$ref" in object)
-                return;
+                continue;
             if (!object.schema)
-                return;
+                continue;
             const { required, name, description, schema } = object;
             if ("$ref" in schema)
-                return;
-            return parameters.push(new ZodProperty({
+                continue;
+            parameters.push(new ZodProperty({
                 name,
                 example: schema.default,
                 schemaObject: schema,
@@ -36,7 +36,7 @@ export class Method {
                 description,
                 required: required || true,
             }));
-        });
+        }
         return { parameters };
     }
     buildCallMethod() {
@@ -56,23 +56,29 @@ export class Method {
                 beforeResponse.push(`\n`);
             }
             if (this.request.attributeType === "list") {
-                beforeResponse.push(`const {data, ...params} = response`);
-                beforeResponse.push("\n\n");
-                beforeResponse.push(`this.list = data`);
-                beforeResponse.push(`repo.intercept.rebuild(this.parameters, params)`);
+                beforeResponse.push(`const {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>({
+            endpoint: this.endpoint, ${query}
+          })
+          ${beforeResponse.join(";")}
+
+          return response
+        `;
             }
             else if (this.request.attributeType === "entity") {
                 beforeResponse.push(`this.entity = response`);
-            }
-            return `
-      ${afterResponse.join(";")}
-        const response = await repo.api.get<${this.request.responseType}, unknown>({
-          endpoint: this.endpoint, ${query}
-        })
-        ${beforeResponse.join(";")}
+                return `
+        ${afterResponse.join(";")}
+          const response = await repo.api.get<${this.request.responseType}, unknown>({
+            endpoint: this.endpoint, ${query}
+          })
+          ${beforeResponse.join(";")}
 
-        return response
-      `;
+          return response
+        `;
+            }
         }
         else if (this.request.apiType === "post" || this.request.apiType === "put") {
             let data = "";

package/dist/module.d.ts

@@ -3,16 +3,12 @@ import { Method } from "./method.js";
 import { ReflectorOperation } from "./types/types.js";
 export declare class Module {
     readonly name: string;
-    readonly src: Source;
     readonly endpoint: string;
     readonly moduleName: string;
+    readonly src: Source;
     imports: string[];
     parameters: string[];
     methods: Method[];
-    types: {
-        raw: string[];
-        constructor: string[];
-    }[];
     constructor(params: {
         name: string;
         moduleName: string;

package/dist/module.js

@@ -1,27 +1,20 @@
 import path from "node:path";
 import fs from "node:fs";
 import { Source } from "./file.js";
-import { capitalizeFirstLetter, createDangerMessage, stripState } from "./helpers.js";
+import { capitalizeFirstLetter, stripState } from "./helpers/helpers.js";
 import { Method } from "./method.js";
 export class Module {
     name;
-    src;
     endpoint;
     moduleName;
+    src;
     imports;
     parameters;
     methods;
-    types;
     constructor(params) {
         const { name, operations, endpoint, dir, moduleName } = params;
         this.moduleName = moduleName;
         this.imports = ["// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n", 'import repo from "$repository/main"'];
-        this.types = [
-            {
-                raw: [],
-                constructor: [],
-            },
-        ];
         this.name = capitalizeFirstLetter(name);
         this.endpoint = endpoint;
         const methods = operations.map((operation) => {
@@ -32,9 +25,9 @@ export class Module {
         });
         // não vão entrar metodos que não tiverem uma resposta tipada
         this.methods = methods.filter((op) => {
-            if (!op.request.responseType) {
-                createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
-            }
+            // if (!op.request.responseType) {
+            //   createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
+            // }
             return op.request.responseType;
         });
         this.parameters = this.getParameters();
@@ -53,7 +46,7 @@ export class Module {
             moduleAtributes.add(`parameters = $state(repo.newForm(ParametersSchema))`);
         }
         const form = [];
-        this.methods.forEach((method) => {
+        for (const method of this.methods) {
             const { bodyType, responseType, attributeType } = method.request;
             if (attributeType === "form" && bodyType) {
                 form.push({
@@ -61,15 +54,18 @@ export class Module {
                     type: bodyType,
                 });
             }
+            console.warn(attributeType);
             if (attributeType === "entity") {
-                moduleAtributes.add(`list = $state<${responseType}[]>([])`);
                 moduleAtributes.add(`entity = $state<${responseType} | undefined>()`);
             }
-        });
+            else if (attributeType === "list") {
+                moduleAtributes.add(`list = $state<${responseType}[]>([])`);
+            }
+        }
         const formSet = new Set();
-        form.forEach((f) => {
+        for (const f of form) {
             formSet.add(`${f.name}: repo.newForm(${f.type}Schema)`);
-        });
+        }
         moduleAtributes.add(`
       forms = $state({
         ${Array.from(formSet)}
@@ -94,14 +90,16 @@ export class Module {
     }
     getParameters() {
         const set = new Set();
-        this.methods.forEach((method) => {
-            method.zodProperties.forEach((param) => set.add(param.buildedProp));
-        });
+        for (const method of this.methods) {
+            for (const param of method.zodProperties) {
+                set.add(param.buildedProp);
+            }
+        }
         return Array.from(set);
     }
     buildImports() {
         const entries = new Set();
-        this.methods.forEach((method) => {
+        for (const method of this.methods) {
             const { bodyType, responseType, apiType } = method.request;
             if (bodyType)
                 entries.add(`${bodyType}Schema`);
@@ -110,11 +108,11 @@ export class Module {
                     entries.add(`${responseType}Schema`);
                 entries.add(`type ${responseType}`);
             }
-        });
+        }
         const cleanEntries = Array.from(entries).filter((x) => x != "type any");
         if (cleanEntries.length === 0)
             return "";
-        return `import { ${cleanEntries} } from '$api/schemas';`;
+        return `import { ${cleanEntries} } from '$reflector/schemas';`;
     }
     buildClass(modulesAttributes) {
         const initAssignments = modulesAttributes.map((attr) => `this.${stripState(attr)}`).join(";");
@@ -136,13 +134,13 @@ export class Module {
     }
     buildFile(modulesAttributes, moduleTypes) {
         return `
-    ${this.imports.join(";")}
-    import z from "zod";
-    ${this.buildImports()}
+      ${this.imports.join(";")}
+      import z from "zod";
+      ${this.buildImports()}
 
-    ${moduleTypes.join(";")}
+      ${moduleTypes.join(";")}
 
-    ${this.buildClass(modulesAttributes)}
+      ${this.buildClass(modulesAttributes)}
     `;
     }
 }

package/dist/property.js

@@ -1,4 +1,5 @@
-import { ReflectorInput } from "./input.js";
+import { sanitizeNumber } from "./helpers/helpers.js";
+import { ReflectorInput } from "./helpers/input.js";
 const inputs = new ReflectorInput();
 export class ZodProperty {
     name;
@@ -64,13 +65,14 @@ export class ZodProperty {
                 return `${x}.default(${this.example})`;
             case "number": {
                 const number = JSON.stringify(this.example) ?? 1;
-                return `${x}.default(${number})`;
+                return `${x}.default(${sanitizeNumber(number)})`;
             }
             case "array": {
-                if (!value.items || !("$ref" in value.items))
-                    return `${x}.default([])`;
+                if (!value.items || !("$ref" in value.items)) {
+                    return `${this.name}: z.${this.type}(z.${value.items?.type || "string"}())${this.isNullable()}.default([])`;
+                }
                 const dto = this.getDtoName(value.items.$ref);
-                return `${this.name}: z.array(${dto}Schema).default(Array(10).fill(${dto}Schema.parse({})))`;
+                return `${this.name}: z.array(${dto}Schema).default(new Array(10).fill(${dto}Schema.parse({})))`;
             }
             case "object":
                 return `${this.name}: z.any()`;

package/dist/schema.js

@@ -7,9 +7,9 @@ export class Schema {
     constructor(params) {
         const { name, properties, requireds } = params;
         this.name = name;
-        Object.entries(properties).forEach(([key, value]) => {
+        for (const [key, value] of Object.entries(properties)) {
             if ("$ref" in value || !value?.type)
-                return;
+                continue;
             const required = requireds.includes(key);
             this.properties.push(new ZodProperty({
                 name: key,
@@ -18,7 +18,7 @@ export class Schema {
                 example: value.example,
                 required,
             }));
-        });
+        }
         this.type = `export type ${name} = z.infer<typeof ${name}Schema>;`;
         this.schema = `export const ${name}Schema = z.object({
       ${this.properties.map((p) => p.buildedProp)}

package/package.json

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