svelte-reflector 1.0.2 → 1.0.4

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

@@ -53,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

@@ -1,6 +1,7 @@
 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;

package/dist/helpers/helpers.js

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

package/dist/main.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpointAndModuleName } from "./helpers/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"];
@@ -12,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;
@@ -54,9 +54,11 @@ export class Reflector {
                 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("");
                 }
             }
             if (!entity)

package/dist/module.js

@@ -25,10 +25,15 @@ 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) {
+            const responseTypeOk = op.request.responseType;
+            const propertiesOk = op.zodProperties.length > 0;
+            if (!responseTypeOk) {
                 createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
             }
-            return op.request.responseType;
+            else if (!propertiesOk) {
+                createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] com tipagem incorreta.`);
+            }
+            return responseTypeOk && propertiesOk;
         });
         this.parameters = this.getParameters();
         const { moduleAtributes, moduleTypes } = this.creator();
@@ -54,12 +59,11 @@ export class Module {
                     type: bodyType,
                 });
             }
-            // console.warn(method);
-            console.warn(attributeType);
             if (attributeType === "entity") {
                 moduleAtributes.add(`entity = $state<${responseType} | undefined>()`);
             }
             else if (attributeType === "list") {
+                this.imports.push(`import z from "zod";`);
                 moduleAtributes.add(`list = $state<${responseType}[]>([])`);
             }
         }
@@ -67,11 +71,13 @@ export class Module {
         for (const f of form) {
             formSet.add(`${f.name}: repo.newForm(${f.type}Schema)`);
         }
-        moduleAtributes.add(`
+        if (formSet.size > 0) {
+            moduleAtributes.add(`
       forms = $state({
         ${Array.from(formSet)}
       })
     `);
+        }
         return {
             moduleAtributes: Array.from(moduleAtributes),
             moduleTypes: buildedModuleTypes,
@@ -113,7 +119,7 @@ export class Module {
         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,7 +142,6 @@ export class Module {
     buildFile(modulesAttributes, moduleTypes) {
         return `
       ${this.imports.join(";")}
-      import z from "zod";
       ${this.buildImports()}
 
       ${moduleTypes.join(";")}

package/dist/property.js

@@ -1,3 +1,4 @@
+import { sanitizeNumber } from "./helpers/helpers.js";
 import { ReflectorInput } from "./helpers/input.js";
 const inputs = new ReflectorInput();
 export class ZodProperty {
@@ -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/package.json

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