svelte-reflector 1.0.9 → 1.0.12

package/dist/request.d.ts

@@ -1,3 +1,4 @@
+import type { ParameterObject } from "./types/open-api-spec.interface.js";
 import type { ApiType, ReflectorOperation } from "./types/types.js";
 type ReflectorRequestType = "entity" | "list" | "pagination" | "form" | "other";
 export declare class Request {
@@ -5,6 +6,7 @@ export declare class Request {
     readonly apiType: ApiType;
     bodyType?: string;
     responseType?: string;
+    parameters: ParameterObject[];
     constructor(operation: ReflectorOperation);
     private getTypeFromRequestBody;
     private getTypeFromResponses;

package/dist/request.js

@@ -6,8 +6,16 @@ export class Request {
     apiType;
     bodyType;
     responseType;
+    parameters = [];
+    // inType:
     constructor(operation) {
         this.apiType = operation.apiMethod;
+        const parameters = operation.parameters;
+        if (parameters) {
+            parameters.forEach((p) => {
+                this.parameters.push(p);
+            });
+        }
         const body = this.getTypeFromRequestBody(operation.requestBody);
         if (body)
             this.bodyType = body;

package/dist/schema.d.ts

@@ -1,13 +1,16 @@
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 export declare class Schema {
     name: string;
     properties: ZodProperty[];
     type: string;
     schema: string;
+    enums: Set<string>;
     constructor(params: {
         properties: Record<string, SchemaObject | ReferenceObject>;
         name: string;
         requireds: string[];
+        isEmpty: boolean;
     });
+    private getEnumConst;
 }

package/dist/schema.js

@@ -1,27 +1,45 @@
-import { ZodProperty } from "./property.js";
+import { ZodProperty } from "./zodProperty.js";
 export class Schema {
     name;
     properties = [];
     type;
     schema;
+    enums = new Set();
     constructor(params) {
-        const { name, properties, requireds } = params;
-        this.name = name;
+        const { name, properties, requireds, isEmpty } = params;
+        this.name = `${isEmpty ? "Empty" : ""}${name}`;
         for (const [key, value] of Object.entries(properties)) {
             if ("$ref" in value || !value?.type)
                 continue;
             const required = requireds.includes(key);
+            const teste = value.items;
+            if (teste && !("$ref" in teste) && teste.enum) {
+                this.enums.add(this.getEnumConst({ enums: teste.enum, schemaName: key }));
+            }
+            else if (value.enum) {
+                this.enums.add(this.getEnumConst({ enums: value.enum, schemaName: key }));
+            }
             this.properties.push(new ZodProperty({
+                schemaName: this.name,
                 name: key,
                 schemaObject: value,
                 type: value.type,
                 example: value.example,
                 required,
+                isEmpty,
+                inParam: "path",
             }));
         }
-        this.type = `export type ${name} = z.infer<typeof ${name}Schema>;`;
-        this.schema = `export const ${name}Schema = z.object({
-      ${this.properties.map((p) => p.buildedProp)}
+        this.type = `export type ${this.name} = z.infer<typeof ${this.name}Schema>;`;
+        this.schema = `export const ${this.name}Schema = z.object({
+      ${this.properties.map((p) => {
+            return p.buildedProp;
+        })}
     });`;
     }
+    getEnumConst(params) {
+        const { enums, schemaName } = params;
+        const enumList = enums.map((en) => `'${en}'`);
+        return `export const ${schemaName}EnumSchema = z.enum([${enumList}])`;
+    }
 }

package/dist/zodProperty.d.ts

@@ -0,0 +1,32 @@
+import { type ParameterLocation, type SchemaObject } from "./types/open-api-spec.interface.js";
+import { type Example, type ReflectorParamType } from "./types/types.js";
+export declare class ZodProperty {
+    schemaName?: string;
+    name: string;
+    example: Example | undefined;
+    type: ReflectorParamType;
+    buildedProp: string;
+    description?: string;
+    required: boolean;
+    inParam: ParameterLocation;
+    isEnum: boolean;
+    enums: string[];
+    constructor(params: {
+        schemaName?: string;
+        name: string;
+        schemaObject: SchemaObject;
+        type: ReflectorParamType;
+        example: Example | undefined;
+        required: boolean;
+        description?: string;
+        isEmpty: boolean;
+        inParam: ParameterLocation;
+    });
+    private getDtoName;
+    private getEmptyExample;
+    private getExample;
+    private deepValidator;
+    private isNullable;
+    private treatName;
+    private build;
+}

package/dist/zodProperty.js

@@ -0,0 +1,123 @@
+import { sanitizeNumber, splitByUppercase, treatenEnum } 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 {
+    schemaName;
+    name;
+    example;
+    type;
+    buildedProp;
+    description;
+    required;
+    inParam;
+    isEnum = false;
+    enums = [];
+    constructor(params) {
+        const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
+        this.inParam = inParam;
+        this.isEnum = false;
+        const items = schemaObject.items;
+        if (items && !("$ref" in items) && items.enum) {
+            this.isEnum = true;
+            this.enums = items.enum;
+        }
+        else if (schemaObject.enum) {
+            this.isEnum = true;
+            this.enums = schemaObject.enum;
+        }
+        if (schemaName) {
+            this.schemaName = schemaName;
+        }
+        if (name.split("-").length > 1) {
+            this.name = `['${name}']`;
+        }
+        else {
+            this.name = name;
+        }
+        this.required = required;
+        this.type = type;
+        this.example = isEmpty ? this.getEmptyExample() : this.getExample(example);
+        this.buildedProp = this.build(schemaObject);
+        if (description)
+            this.description = description;
+    }
+    getDtoName(ref) {
+        const cavalos = ref.split("/");
+        const dto = cavalos[cavalos.length - 1];
+        return dto;
+    }
+    getEmptyExample() {
+        switch (this.type) {
+            case "number":
+                return 0;
+            case "boolean":
+                return false;
+            case "string":
+                return "";
+            default:
+                return "";
+        }
+    }
+    getExample(example) {
+        if (example)
+            return example;
+        return this.getEmptyExample();
+    }
+    deepValidator() {
+        if (this.name === "email") {
+            return `z.email().default('${this.example}')`;
+        }
+        else if (this.name === "password") {
+            return inputs.password;
+        }
+        else if (this.isEnum) {
+            return `${treatenEnum(this.enums)}.default('${this.enums[0]}')`;
+        }
+        else {
+            return false;
+        }
+    }
+    isNullable() {
+        return this.required ? "" : ".nullable()";
+    }
+    treatName(name) {
+        return name;
+    }
+    build(schemaObject) {
+        const name = this.treatName(this.name);
+        const x = `${name}: z.${this.type}()${this.isNullable()}`;
+        switch (this.type) {
+            case "string": {
+                // console.log(schemaObject.enum);
+                const deepValidation = this.deepValidator();
+                return deepValidation ? `${name}: ${deepValidation}` : `${x}.default('${this.example}')`;
+            }
+            case "boolean":
+                return `${x}.default(${this.example})`;
+            case "number": {
+                const number = JSON.stringify(this.example) ?? 0;
+                return `${x}.default(${sanitizeNumber(number)})`;
+            }
+            case "array": {
+                if (!schemaObject.items || !("$ref" in schemaObject.items)) {
+                    let zodType = "z.string()";
+                    if (schemaObject.items?.enum) {
+                        zodType = treatenEnum(schemaObject.items.enum);
+                    }
+                    else if (schemaObject.items?.type) {
+                        zodType = `z.${schemaObject.items.type}()`;
+                    }
+                    return `${name}: z.${this.type}(${zodType})${this.isNullable()}.default([])`;
+                }
+                const dto = this.getDtoName(schemaObject.items.$ref);
+                return `${name}: z.array(${dto}Schema).default(new Array(10).fill(${dto}Schema.parse({})))`;
+            }
+            case "object":
+                return `${name}: z.any()`;
+            default:
+                return `${name}: z.any()`;
+        }
+    }
+}

package/package.json

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