svelte-reflector 1.0.6 → 1.0.8

package/dist/file.d.ts

@@ -8,5 +8,5 @@ export declare class Source {
     save(): Promise<void>;
     safeSave(): Promise<void>;
     changeData(data: string): Promise<void>;
-    buildPath(endpoint: string[]): string;
+    buildPath(endpoint: string[]): string | undefined;
 }

package/dist/generate-doc.js

@@ -1,8 +1,8 @@
 // src/generate-doc.ts
 import "dotenv/config"; // carrega .env a partir de process.cwd()
 import axios from "axios";
-import fs from "node:fs";
-import path from "node:path";
+import * as path from "node:path";
+import * as fs from "node:fs";
 import { Reflector } from "./main.js";
 /** ajuda a pegar a 1ª env definida dentre várias chaves possíveis */
 function pickEnv(...keys) {

package/dist/helpers/helpers.d.ts

@@ -1,4 +1,3 @@
-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;
@@ -6,6 +5,7 @@ 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;
+    baseEndpoint: string;
     moduleName: string;
 };
+export declare function getEndpoint(rawEndpoint: string): string;

package/dist/helpers/helpers.js

@@ -1,21 +1,22 @@
-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 stripState(attr: string): string {
+//   // 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;
+//   if (!lhs) return "";
+//   return `${lhs.trim()} = ${cleaned}`;
+// }
 export function toCamelCase(str) {
     return str
         .split("-")
-        .map((chunk, i) => (i === 0 ? chunk : chunk[0].toUpperCase() + chunk.slice(1)))
+        .map((chunk, i) => (i === 0 ? chunk : chunk.charAt(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 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);
@@ -23,7 +24,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)
@@ -36,10 +37,18 @@ export function splitByUppercase(text) {
 export function createDangerMessage(text) {
     console.log("\x1b[31m%s\x1b[0m", `[!] ${text}`);
 }
-export function getEndpointAndModuleName(rawEndpoint) {
+function getFilteredEntities(rawEndpoint) {
     const splittedEntitys = rawEndpoint.split("/");
-    const filteredEntitys = splittedEntitys.filter((item) => item !== "" && !item.includes("{"));
+    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 endpoint = filteredEntitys.join("/");
-    return { endpoint, moduleName };
+    const baseEndpoint = filteredEntitys.join("/");
+    return { baseEndpoint: getEndpoint(baseEndpoint), moduleName };
+}
+export function getEndpoint(rawEndpoint) {
+    const filteredEntitys = getFilteredEntities(rawEndpoint);
+    return filteredEntitys.join("/");
 }

package/dist/main.d.ts

@@ -1,6 +1,6 @@
 import { Source } from "./file.js";
 import { Schema } from "./schema.js";
-import { ComponentsObject, PathsObject, OpenAPIObject } from "./types/open-api-spec.interface.js";
+import type { ComponentsObject, PathsObject, OpenAPIObject } from "./types/open-api-spec.interface.js";
 import { Module } from "./module.js";
 export declare class Reflector {
     readonly components: ComponentsObject;
@@ -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

@@ -1,10 +1,10 @@
-import path from "node:path";
-import fs from "node:fs";
+import * as path from "node:path";
+import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpointAndModuleName, splitByUppercase } from "./helpers/helpers.js";
+import { getEndpoint, getEndpointAndModuleName, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
-const methods = ["get", "patch", "post", "put", "delete"];
+// const defaultMethods = ["get", "patch", "post", "put", "delete"] as const;
 export class Reflector {
     components;
     paths;
@@ -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;
@@ -45,44 +46,44 @@ export class Reflector {
     }
     getModules() {
         const methodsMap = new Map();
-        const modules = [];
-        for (const [rawEndpoint, object] of Object.entries(this.paths)) {
-            let entity;
-            const operations = [];
-            const { endpoint, moduleName } = getEndpointAndModuleName(rawEndpoint);
-            for (const method of methods) {
-                if (!object[method])
-                    continue;
-                operations.push({ ...object[method], apiMethod: method });
-                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)
-                continue;
-            const existingOps = methodsMap.get(entity);
-            if (existingOps) {
-                existingOps.operations.push(...operations);
+        for (const [path, methods] of Object.entries(this.paths)) {
+            const rawName = Object.values(methods)[0];
+            const a = rawName.operationId?.split("_")[0] ?? "";
+            const teste = splitByUppercase(a).filter((x) => x !== "Controller");
+            const moduleName = teste.join("");
+            const baseEndpoint = getEndpoint(path);
+            const operations = Object.entries(methods).map(([apiMethod, attributes]) => {
+                return {
+                    apiMethod,
+                    endpoint: path,
+                    ...attributes,
+                };
+            });
+            const existentModule = methodsMap.get(moduleName);
+            if (existentModule) {
+                methodsMap.set(moduleName, {
+                    ...existentModule,
+                    operations: [...existentModule.operations, ...operations],
+                });
             }
             else {
-                methodsMap.set(entity, { endpoint, operations, moduleName });
+                methodsMap.set(moduleName, { operations, path: baseEndpoint, moduleName });
             }
         }
-        for (const [name, info] of methodsMap) {
-            modules.push(new Module({
+        const modules = Array.from(methodsMap).map(([name, info]) => {
+            return new Module({
                 name,
                 ...info,
                 dir: this.generatedDir,
-            }));
-        }
+            });
+        });
         return modules;
     }
     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

@@ -5,6 +5,7 @@ export declare class Method {
     name: string;
     zodProperties: ZodProperty[];
     description: string | undefined;
+    endpoint: string;
     request: Request;
     constructor(params: {
         operation: ReflectorOperation;

package/dist/method.js

@@ -1,15 +1,17 @@
 import { Request } from "./request.js";
 import { ZodProperty } from "./property.js";
-import { createDangerMessage } from "./helpers/helpers.js";
+import { createDangerMessage, getEndpoint } from "./helpers/helpers.js";
 export class Method {
     name;
     zodProperties;
     description;
+    endpoint;
     request;
     constructor(params) {
         const { operation } = params;
         this.request = new Request(operation);
-        this.description = operation.description;
+        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;
@@ -33,7 +35,7 @@ export class Method {
                 example: schema.default,
                 schemaObject: schema,
                 type: schema.type,
-                description,
+                description: description ?? "",
                 required: required || true,
             }));
         }
@@ -56,15 +58,14 @@ 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>({
-            endpoint: this.endpoint, ${query}
+          const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
+            endpoint, 
+            ${query}
           })
           ${beforeResponse.join(";")}
-
-          return response
         `;
             }
             else if (this.request.attributeType === "entity") {
@@ -72,15 +73,14 @@ export class Method {
                 return `
         ${afterResponse.join(";")}
           const response = await repo.api.get<${this.request.responseType}, unknown>({
-            endpoint: this.endpoint, ${query}
+            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})`;
@@ -89,24 +89,23 @@ export class Method {
         ${data}
 
         const response = await repo.api.post<${this.request.responseType}>({
-          endpoint: this.endpoint,
+          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>({
-          endpoint: this.endpoint, ${query}
+        const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
+          endpoint, 
+          ${query}
         })
 
-        this.clear()
-        return response
+        this.clearEntity()
       `;
         }
         return "";
@@ -116,18 +115,32 @@ export class Method {
     }
     build() {
         const content = this.buildCallMethod();
-        if (!content)
+        if (!content) {
+            createDangerMessage(`Método ${this.name} (${this.request.apiType}) não foi gerado: buildCallMethod vazio`);
             return;
+        }
         if (this.name === "list")
             this.name = "listAll";
         const hasProprierties = this.zodProperties.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();
         return `
-      ${this.buildDescription()}
-      async ${this.name}() {
-        ${content}
+      ${description}
+      async ${this.name}(behavior: Behavior = new Behavior()) {
+        const {onError, onSuccess} = behavior
+        const endpoint = "${getEndpoint(this.endpoint)}"
+
+        try{
+          ${content}
+          onSuccess?.()
+
+          return response
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch(e) {
+          onError?.()
+        }
       }
     `;
     }

package/dist/module.d.ts

@@ -1,9 +1,9 @@
 import { Source } from "./file.js";
 import { Method } from "./method.js";
-import { ReflectorOperation } from "./types/types.js";
+import type { ReflectorOperation } from "./types/types.js";
 export declare class Module {
     readonly name: string;
-    readonly endpoint: string;
+    readonly path: string;
     readonly moduleName: string;
     readonly src: Source;
     imports: Set<string>;
@@ -13,14 +13,20 @@ export declare class Module {
         name: string;
         moduleName: string;
         operations: ReflectorOperation[];
-        endpoint: string;
+        path: string;
         dir: string;
     });
     private creator;
     private getPath;
+    private getAdditionalMethod;
     private buildMethods;
     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,22 +1,26 @@
-import path from "node:path";
-import fs from "node:fs";
+import * as path from "node:path";
+import * as 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;
-    endpoint;
+    path;
     moduleName;
     src;
     imports;
     parameters;
     methods;
     constructor(params) {
-        const { name, operations, endpoint, dir, moduleName } = params;
+        const { name, operations, path, 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;
+        this.path = path;
         const methods = operations.map((operation) => {
             return new Method({
                 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;
         });
         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();
+        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,27 +85,58 @@ 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) {
-        const fileName = this.endpoint.split("/").slice(-2).join("-");
-        const inPath = path.join(dir, this.endpoint);
+        const fileName = this.path.split("/").slice(-2).join("-");
+        const inPath = path.join(dir, this.path);
         const outPath = path.join(inPath, `${fileName.toLowerCase()}.module.svelte.ts`);
         fs.mkdirSync(inPath, { recursive: true });
         return outPath;
     }
+    getAdditionalMethod(params) {
+        const { method, canAddClearMethod } = params;
+        let additionalMethod = "";
+        if (canAddClearMethod && method.request.attributeType === "form") {
+            additionalMethod = `
+        /** Limpa o form depois do back retornar uma resposta de sucesso */
+        async ${method.name}AndClear(behavior: Behavior = new Behavior()) {
+          const data = await this.${method.name}(behavior)
+
+          if (data) {
+            this.clearForms()
+          }
+
+          return data
+        }
+      `;
+        }
+        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) => {
-            return method.build();
+            let additionalMethod = this.getAdditionalMethod({ canAddClearMethod, method });
+            return [method.build(), additionalMethod].join("\n");
         });
     }
     getParameters() {
@@ -123,32 +165,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.d.ts

@@ -1,11 +1,11 @@
-import { SchemaObject } from "./types/open-api-spec.interface.js";
-import { Example, ReflectorParamType } from "./types/types.js";
+import { type SchemaObject } from "./types/open-api-spec.interface.js";
+import { type Example, type ReflectorParamType } from "./types/types.js";
 export declare class ZodProperty {
     name: string;
-    example: Example;
+    example: Example | undefined;
     type: ReflectorParamType;
     buildedProp: string;
-    description: string;
+    description?: string;
     required: boolean;
     constructor(params: {
         name: string;

package/dist/property.js

@@ -1,20 +1,25 @@
 import { sanitizeNumber } from "./helpers/helpers.js";
 import { ReflectorInput } from "./helpers/input.js";
+import {} from "./types/open-api-spec.interface.js";
+import {} from "./types/types.js";
 const inputs = new ReflectorInput();
 export class ZodProperty {
     name;
     example;
     type;
     buildedProp;
-    description = "";
+    description;
     required;
     constructor(params) {
-        const { name, schemaObject, type, example, required } = params;
+        const { name, schemaObject, type, example, required, description } = 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);
+        if (description)
+            this.description = description;
     }
     getDtoName(ref) {
         const cavalos = ref.split("/");
@@ -35,11 +40,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/dist/request.d.ts

@@ -1,4 +1,4 @@
-import { ApiType, ReflectorOperation } from "./types/types.js";
+import type { ApiType, ReflectorOperation } from "./types/types.js";
 type ReflectorRequestType = "entity" | "list" | "pagination" | "form" | "other";
 export declare class Request {
     readonly attributeType: ReflectorRequestType;

package/dist/request.js

@@ -8,8 +8,12 @@ export class Request {
     responseType;
     constructor(operation) {
         this.apiType = operation.apiMethod;
-        this.bodyType = this.getTypeFromRequestBody(operation.requestBody);
-        this.responseType = this.getTypeFromResponses(operation.responses);
+        const body = this.getTypeFromRequestBody(operation.requestBody);
+        if (body)
+            this.bodyType = body;
+        const response = this.getTypeFromResponses(operation.responses);
+        if (response)
+            this.responseType = response;
         this.attributeType = this.inferAttributeType(operation) ?? "other";
     }
     // ============= Derivações principais =======================================
@@ -102,9 +106,9 @@ export class Request {
      * Se `data` não existir ou não tiver tipo, retorna undefined.
      */
     typeFromProperties(properties) {
-        if (!properties)
+        if (!properties?.["data"])
             return undefined;
-        const data = properties.data;
+        const data = properties["data"];
         if (isRef(data))
             return this.componentName(data);
         if (data.type === "any")

package/dist/schema.d.ts

@@ -1,5 +1,5 @@
 import { ZodProperty } from "./property.js";
-import { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
+import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 export declare class Schema {
     name: string;
     properties: ZodProperty[];

package/dist/types/types.d.ts

@@ -1,11 +1,12 @@
-import { OperationObject } from "./open-api-spec.interface.js";
+import type { OperationObject } from "./open-api-spec.interface.js";
 export type ReflectorParamType = "string" | "boolean" | "number" | "array" | "object";
 export type ApiType = "get" | "post" | "delete" | "patch" | "put";
 export type ReflectorOperation = OperationObject & {
     apiMethod: ApiType;
+    endpoint: string;
 };
 export type Info = {
-    endpoint: string;
+    path: string;
     operations: ReflectorOperation[];
     moduleName: string;
 };

package/package.json

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