svelte-reflector 1.0.22 → 1.0.24

package/dist/array.property.d.ts

@@ -0,0 +1,16 @@
+import type { SchemaObject } from "./types/open-api-spec.interface.js";
+export declare class ArrayProp {
+    name: string;
+    type: string;
+    constructor(params: {
+        name: string;
+        schemaObject: SchemaObject;
+        schemaName: string;
+    });
+    private treatName;
+    private getType;
+    constructorBuild(): string;
+    classBuild(): string;
+    interfaceBuild(): string;
+    bundleBuild(): string;
+}

package/dist/array.property.js

@@ -0,0 +1,38 @@
+export class ArrayProp {
+    name;
+    type;
+    constructor(params) {
+        const { name, schemaObject, schemaName } = params;
+        this.name = this.treatName(name);
+        this.type = this.getType({ schemaObject, schemaName });
+    }
+    treatName(name) {
+        let newName = name;
+        if (name.split("-").length > 1) {
+            newName = `['${name}']`;
+        }
+        return newName;
+    }
+    getType(params) {
+        const { schemaObject, schemaName } = params;
+        let name = schemaName;
+        const teste = schemaObject.items;
+        if (teste && "$ref" in teste) {
+            const a = teste.$ref;
+            name = a.split("/").at(-1);
+        }
+        return name;
+    }
+    constructorBuild() {
+        return `this.${this.name} = params?.${this.name}.map((param) => new ${this.type}(param)) ?? []`;
+    }
+    classBuild() {
+        return `${this.name}: ${this.type}[]`;
+    }
+    interfaceBuild() {
+        return `${this.name}: ${this.type}Interface[]`;
+    }
+    bundleBuild() {
+        return `${this.name}: this.${this.name}.map((obj) => obj.bundle())`;
+    }
+}

package/dist/interface.d.ts

@@ -1,5 +1,6 @@
+import type { ArrayProp } from "./array.property.js";
+import type { ObjectProp } from "./object.property.js";
 import type { PrimitiveProp } from "./primitive-property.js";
-import type { ArrayProp, ObjectProp } from "./property.js";
 export declare class ReflectorInterface {
     builded: string;
     constructor(params: {

package/dist/method.js

@@ -63,11 +63,12 @@ export class Method {
     buildCallMethod() {
         const beforeResponse = [];
         // const props = this.getProps();
+        const diamond = this.request.responseType ? `${this.request.responseType}Interface` : "null";
         if (this.request.apiType === "get") {
             if (this.request.attributeType === "list") {
                 beforeResponse.push(`const {data: { data }} = response`, "\n\n", `this.list = data`);
                 const inside = `
-          const response = await repo.api.get<{data: ${this.request.responseType}Interface}, unknown>({
+          const response = await repo.api.get<{data: ${diamond}}, unknown>({
             endpoint,
             queryData: { ${this.gee(this.querys)} }
           })
@@ -76,10 +77,10 @@ export class Method {
                 return { inside, outside: "" };
             }
             else if (this.request.attributeType === "entity") {
-                const entityName = treatByUppercase(this.request.responseType);
+                const entityName = treatByUppercase(this.request.responseType ?? "");
                 beforeResponse.push(`this.${entityName} = new ${this.request.responseType}(response)`);
                 const inside = `
-          const response = await repo.api.get<${this.request.responseType}Interface, unknown>({
+          const response = await repo.api.get<${diamond}, unknown>({
             endpoint,
           })
           ${beforeResponse.join(";")}
@@ -100,7 +101,7 @@ export class Method {
             }
             const outside = ["this.loading = true", data, headers].join("\n");
             const inside = `
-        const response = await repo.api.${this.request.apiType}<${this.request.responseType}Interface>({
+        const response = await repo.api.${this.request.apiType}<${diamond}>({
           endpoint,
           ${hasData ? "data," : ""}
           ${hasHeaders ? "headers," : ""}
@@ -109,7 +110,6 @@ export class Method {
             return { outside, inside };
         }
         else if (this.request.apiType === "delete") {
-            const diamond = this.request.responseType ? `${this.request.responseType}Interface` : "null";
             const inside = `
         const response = await repo.api.delete<${diamond}, unknown>({
           endpoint,
@@ -124,12 +124,13 @@ export class Method {
         const { inside, outside } = this.buildCallMethod();
         if (this.name === "list")
             this.name = "listAll";
-        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 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 = "`";
+        const methodReturn = this.request.responseType ? `new ${this.request.responseType}(response)` : "null";
         return `
       ${description}
       async ${this.name}(behavior: Behavior = new Behavior()) {
@@ -143,7 +144,7 @@ export class Method {
           ${inside}
           onSuccess?.()
 
-          return new ${this.request.responseType}(response)
+          return ${methodReturn}
         } catch(e) {
           onError?.(e)
         } finally {

package/dist/module.js

@@ -23,22 +23,21 @@ export class Module {
         ]);
         this.name = capitalizeFirstLetter(name);
         this.path = path;
-        const methods = operations.map((operation) => {
+        this.methods = operations.map((operation) => {
             return new Method({
                 operation,
                 moduleName: this.name,
             });
         });
-        // não vão entrar metodos que não tiverem uma resposta tipada
-        this.methods = methods.filter((op) => {
-            const responseTypeOk = op.request.responseType;
-            if (op.request.apiType === "delete")
-                return true;
-            if (!responseTypeOk) {
-                createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
-            }
-            return responseTypeOk;
-        });
+        // // não vão entrar metodos que não tiverem uma resposta tipada
+        // this.methods = methods.filter((op) => {
+        //   const responseTypeOk = op.request.responseType;
+        //   if (op.request.apiType === "delete") return true;
+        //   if (!responseTypeOk) {
+        //     createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
+        //   }
+        //   return responseTypeOk;
+        // });
         const { cookies, headers, paths, querys } = this.getParameters();
         const { moduleAttributes, moduleTypes, moduleInit, moduleClear, form } = this.creator({ cookies, headers, paths, querys });
         this.moduleConstructor = this.buildConstructor(form);
@@ -117,7 +116,7 @@ export class Module {
                 });
             }
             if (attributeType === "entity") {
-                const entityName = treatByUppercase(method.request.responseType);
+                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 }`);

package/dist/object.property.d.ts

@@ -0,0 +1,14 @@
+import type { ReferenceObject } from "./types/open-api-spec.interface.js";
+export declare class ObjectProp {
+    name: string;
+    type: string;
+    private readonly required;
+    constructor(params: {
+        referenceObject: ReferenceObject;
+        name: string;
+    });
+    constructorBuild(): string;
+    classBuild(): string;
+    interfaceBuild(): string;
+    bundleBuild(): string;
+}

package/dist/object.property.js

@@ -0,0 +1,25 @@
+export class ObjectProp {
+    name;
+    type;
+    required;
+    constructor(params) {
+        const { referenceObject, name } = params;
+        this.name = name;
+        this.type = referenceObject.$ref.split("/").at(-1) ?? "";
+        this.required = true; // tem que ver isso daí
+    }
+    constructorBuild() {
+        return `this.${this.name} = new ${this.type}(params?.${this.name})`;
+    }
+    classBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.type}`;
+    }
+    interfaceBuild() {
+        const req = this.required ? "" : "?";
+        return `${this.name}${req}: ${this.type}Interface`;
+    }
+    bundleBuild() {
+        return `${this.name}: this.${this.name}.bundle()`;
+    }
+}

package/dist/primitive-property.d.ts

@@ -14,6 +14,8 @@ export declare class PrimitiveProp {
     });
     private treatName;
     private buildConst;
+    private getEmptyExample;
+    private thisDot;
     constructorBuild(): string;
     classBuild(): string;
     interfaceBuild(): string;

package/dist/primitive-property.js

@@ -12,7 +12,7 @@ export class PrimitiveProp {
         this.rawType = type ?? "any";
         this.type = `BuildedInput<${type}>`;
         this.required = required;
-        this.buildedConst = this.buildConst({ example, name, required, type });
+        this.buildedConst = this.buildConst({ example, name: this.name, required, type });
     }
     treatName(name) {
         let newName = name;
@@ -29,8 +29,26 @@ export class PrimitiveProp {
       build({ key: params?.${name}, example: ${sanitizedExample}, required: ${required}})
     `;
     }
+    getEmptyExample(params) {
+        const { schemaObject, type } = params;
+        if (type === "number") {
+            return 0;
+        }
+        else if (type === "boolean") {
+            return false;
+        }
+        else if (schemaObject.enum) {
+            return `'${schemaObject.enum[0]}'`;
+        }
+        else {
+            return "''";
+        }
+    }
+    thisDot() {
+        return `this${this.isSpecial ? "" : "."}`;
+    }
     constructorBuild() {
-        return `this.${this.name} = ${this.buildedConst}`;
+        return `${this.thisDot()}${this.name} = ${this.buildedConst}`;
     }
     classBuild() {
         const req = this.required ? "" : "?";
@@ -41,6 +59,15 @@ export class PrimitiveProp {
         return `${this.name}${req}: ${this.rawType}`;
     }
     bundleBuild() {
-        return `${this.name}: this.${this.name}?.value`;
+        return `${this.name}: ${this.thisDot()}${this.name}?.value`;
     }
 }
+// class Teste {
+//   ["x-two-factor-code"]: string;
+//   constructor() {
+//     this["x-two-factor-code"] = "aaaaaaa";
+//   }
+//   bundle() {
+//     return { ["x-two-factor-code"]: this["x-two-factor-code"] };
+//   }
+// }

package/dist/property.d.ts

@@ -1,28 +1 @@
-import { type ReferenceObject, type SchemaObject } from "./types/open-api-spec.interface.js";
-export declare class ArrayProp {
-    name: string;
-    type: string;
-    constructor(params: {
-        name: string;
-        schemaObject: SchemaObject;
-        schemaName: string;
-    });
-    private treatName;
-    private getType;
-    constructorBuild(): string;
-    classBuild(): string;
-    interfaceBuild(): string;
-    bundleBuild(): string;
-}
-export declare class ObjectProp {
-    name: string;
-    type: string;
-    private readonly required;
-    constructor(params: {
-        referenceObject: ReferenceObject;
-        name: string;
-    });
-    constructorBuild(): string;
-    classBuild(): string;
-    interfaceBuild(): string;
-}
+export {};

package/dist/property.js

@@ -113,63 +113,3 @@ import {} from "./types/types.js";
 //     }
 //   }
 // }
-export class ArrayProp {
-    name;
-    type;
-    constructor(params) {
-        const { name, schemaObject, schemaName } = params;
-        this.name = this.treatName(name);
-        this.type = this.getType({ schemaObject, schemaName });
-    }
-    treatName(name) {
-        let newName = name;
-        if (name.split("-").length > 1) {
-            newName = `['${name}']`;
-        }
-        return newName;
-    }
-    getType(params) {
-        const { schemaObject, schemaName } = params;
-        let name = schemaName;
-        const teste = schemaObject.items;
-        if (teste && "$ref" in teste) {
-            const a = teste.$ref;
-            name = a.split("/").at(-1);
-        }
-        return name;
-    }
-    constructorBuild() {
-        return `this.${this.name} = params?.${this.name}.map((param) => new ${this.type}(param)) ?? []`;
-    }
-    classBuild() {
-        return `${this.name}: ${this.type}[]`;
-    }
-    interfaceBuild() {
-        return `${this.name}: ${this.type}Interface[]`;
-    }
-    bundleBuild() {
-        return `${this.name}: this.${this.name}.map((obj) => obj.bundle())`;
-    }
-}
-export class ObjectProp {
-    name;
-    type;
-    required;
-    constructor(params) {
-        const { referenceObject, name } = params;
-        this.name = name;
-        this.type = referenceObject.$ref.split("/").at(-1) ?? "";
-        this.required = true; // tem que ver isso daí
-    }
-    constructorBuild() {
-        return `this.${this.name} = new ${this.type}(params?.${this.name})`;
-    }
-    classBuild() {
-        const req = this.required ? "" : "?";
-        return `${this.name}${req}: ${this.type}`;
-    }
-    interfaceBuild() {
-        const req = this.required ? "" : "?";
-        return `${this.name}${req}: ${this.type}Interface`;
-    }
-}

package/dist/request.d.ts

@@ -5,7 +5,7 @@ export declare class Request {
     readonly attributeType: ReflectorRequestType;
     readonly apiType: ApiType;
     bodyType?: string;
-    responseType?: string;
+    responseType: string | null;
     parameters: ParameterObject[];
     constructor(operation: ReflectorOperation);
     private getTypeFromRequestBody;

package/dist/request.js

@@ -20,8 +20,7 @@ export class Request {
         if (body)
             this.bodyType = body;
         const response = this.getTypeFromResponses(operation.responses);
-        if (response)
-            this.responseType = response;
+        this.responseType = response ?? null;
         this.attributeType = this.inferAttributeType(operation) ?? "other";
     }
     // ============= Derivações principais =======================================

package/dist/schema.d.ts

@@ -1,5 +1,6 @@
+import { ArrayProp } from "./array.property.js";
+import { ObjectProp } from "./object.property.js";
 import { PrimitiveProp } from "./primitive-property.js";
-import { ArrayProp, ObjectProp } from "./property.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 import type { FieldValidators } from "./types/types.js";
 export declare class Schema {

package/dist/schema.js

@@ -1,7 +1,8 @@
+import { ArrayProp } from "./array.property.js";
 import { capitalizeFirstLetter } from "./helpers/helpers.js";
 import { ReflectorInterface } from "./interface.js";
+import { ObjectProp } from "./object.property.js";
 import { PrimitiveProp } from "./primitive-property.js";
-import { ArrayProp, ObjectProp } from "./property.js";
 export class Schema {
     name;
     primitiveProps = [];
@@ -64,7 +65,7 @@ export class Schema {
         this.objectProps.forEach((prop) => {
             constructorThis.push(prop.constructorBuild());
             keys.push(prop.classBuild());
-            // bundleParams.push(prop.bundleBuild());
+            bundleParams.push(prop.bundleBuild());
         });
         this.schema = `
     export class ${this.name} {

package/package.json

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