svelte-reflector 1.0.7 → 1.0.9

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);
@@ -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;

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;
@@ -46,39 +46,37 @@ 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() {

package/dist/method.d.ts

@@ -4,7 +4,8 @@ import type { ReflectorOperation } from "./types/types.js";
 export declare class Method {
     name: string;
     zodProperties: ZodProperty[];
-    description?: string;
+    description: string | undefined;
+    endpoint: string;
     request: Request;
     constructor(params: {
         operation: ReflectorOperation;
@@ -13,5 +14,5 @@ export declare class Method {
     private getParams;
     private buildCallMethod;
     private buildDescription;
-    build(): string | undefined;
+    build(): string;
 }

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 ?? 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,
             }));
         }
@@ -57,23 +59,27 @@ export class Method {
             }
             if (this.request.attributeType === "list") {
                 beforeResponse.push(`const {data: { data }, ...params} = response`, "\n\n", `this.list = data`, `repo.intercept.rebuild(this.parameters, params)`);
-                return `
+                const inside = `
           ${afterResponse.join(";")}
           const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
-            endpoint: this.endpoint, ${query}
+            endpoint,
+            ${query}
           })
           ${beforeResponse.join(";")}
         `;
+                return { inside, outside: "" };
             }
             else if (this.request.attributeType === "entity") {
                 beforeResponse.push(`this.entity = response`);
-                return `
+                const inside = `
         ${afterResponse.join(";")}
           const response = await repo.api.get<${this.request.responseType}, unknown>({
-            endpoint: this.endpoint, ${query}
+            endpoint,
+            ${query}
           })
           ${beforeResponse.join(";")}
         `;
+                return { inside, outside: "" };
             }
         }
         else if (this.request.apiType === "post" || this.request.apiType === "put" || this.request.apiType === "patch") {
@@ -81,66 +87,55 @@ export class Method {
             if (this.request.bodyType) {
                 data = `const data = repo.intercept.bundle(this.forms.${this.name})`;
             }
-            return `
-        ${data}
-
+            const outside = ["this.loading = true", data].join("\n");
+            const inside = `
         const response = await repo.api.post<${this.request.responseType}>({
-          endpoint: this.endpoint,
-          ${data ? "data" : ""}
+          endpoint,
+          data
         })
       `;
+            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` : "";
-            return `
+            const inside = `
         ${propsString}
 
         const response = await repo.api.delete<${this.request.responseType ?? "null"}, unknown>({
-          endpoint: this.endpoint, ${query}
+          endpoint,
+          ${query}
         })
 
         this.clearEntity()
       `;
+            const outside = "";
+            return { inside, outside };
         }
-        return "";
+        return { inside: "", outside: "" };
     }
     buildDescription() {
         return `/** ${this.description ?? ""} */`;
     }
     build() {
-        const content = this.buildCallMethod();
-        if (!content)
-            return;
+        const { inside, outside } = this.buildCallMethod();
         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.`);
         }
-        let additionalMethod = "";
         const description = this.buildDescription();
-        if (this.request.apiType === "post") {
-            additionalMethod = `
-        /** Limpa a entity depois de ser criada com sucesso */
-        async ${this.name}AndClear(behavior: Behavior = new Behavior()) {
-          const data = await this.${this.name}(behavior)
-
-          if(data) {
-            this.clearEntity()
-          }
-
-          return data
-        }
-      `;
-        }
         return `
       ${description}
       async ${this.name}(behavior: Behavior = new Behavior()) {
         const {onError, onSuccess} = behavior
+        const endpoint = "${getEndpoint(this.endpoint)}"
+
+        ${outside}
 
         try{
-          ${content}
+          ${inside}
           onSuccess?.()
 
           return response
@@ -148,9 +143,9 @@ export class Method {
         } catch(e) {
           onError?.()
         }
+        
+        this.loading = false
       }
-
-      ${additionalMethod}
     `;
     }
 }

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,11 +13,12 @@ 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;

package/dist/module.js

@@ -1,18 +1,18 @@
-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 } 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",
@@ -20,7 +20,7 @@ export class Module {
             '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,
@@ -48,7 +48,7 @@ export class Module {
     }
     creator() {
         const buildedModuleTypes = [];
-        const moduleAttributes = new Set([`endpoint = '${this.endpoint}'`]);
+        const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
         const moduleInit = new Set([]);
         const moduleClear = new Set([]);
         if (this.parameters.length > 0) {
@@ -105,15 +105,38 @@ export class Module {
         };
     }
     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() {
@@ -152,7 +175,7 @@ export class Module {
 
         ${moduleClear.join("\n\n")}
         
-        clearAll() {
+        reset() {
           ${moduleInit.join(";")}
         }
       }

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,21 +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(realExample);
         this.buildedProp = this.build(schemaObject);
+        if (description)
+            this.description = description;
     }
     getDtoName(ref) {
         const cavalos = ref.split("/");

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.7",
+  "version": "1.0.9",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",