svelte-reflector 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { reflector } from "./generate-doc.js";
+try {
+    await reflector(); // lê .env e roda tudo
+    console.log("[reflector] Finalizado com sucesso.");
+    process.exit(0);
+}
+catch (err) {
+    console.error("[reflector] Falha:", err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/file.d.ts

@@ -0,0 +1,12 @@
+export declare class Source {
+    path: string;
+    data: string;
+    constructor(params: {
+        path: string;
+        data?: string;
+    });
+    save(): Promise<void>;
+    safeSave(): Promise<void>;
+    changeData(data: string): Promise<void>;
+    buildPath(endpoint: string[]): string;
+}

package/dist/file.js

@@ -0,0 +1,27 @@
+import { writeFileSync } from "node:fs";
+import prettier from "prettier";
+export class Source {
+    path;
+    data;
+    constructor(params) {
+        const { path, data } = params;
+        this.path = path;
+        this.data = data ?? "";
+    }
+    async save() {
+        const options = await prettier.resolveConfig(process.cwd());
+        const formatted = await prettier.format(this.data, { ...options, filepath: this.path });
+        writeFileSync(this.path, formatted, "utf8");
+    }
+    async safeSave() {
+        writeFileSync(this.path, this.data, "utf8");
+    }
+    async changeData(data) {
+        this.data = data;
+    }
+    buildPath(endpoint) {
+        if (endpoint.length === 1)
+            return endpoint[0];
+        return endpoint.join("/");
+    }
+}

package/dist/generate-doc.d.ts

@@ -0,0 +1,4 @@
+import "dotenv/config";
+export declare function reflector(): Promise<{
+    name: string;
+} | undefined>;

package/dist/generate-doc.js

@@ -0,0 +1,67 @@
+// 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 { Reflector } from "./main.js";
+/** ajuda a pegar a 1ª env definida dentre várias chaves possíveis */
+function pickEnv(...keys) {
+    for (const k of keys) {
+        const v = process.env[k];
+        if (v != null && v !== "")
+            return v;
+    }
+    return undefined;
+}
+/** normaliza URL base com / no fim */
+function withTrailingSlash(u) {
+    if (!u)
+        return u;
+    return u.endsWith("/") ? u : `${u}/`;
+}
+function getParams() {
+    const BACKEND_URL_RAW = pickEnv("BACKEND_URL", "PUBLIC_BACKEND");
+    const ENVIRONMENT_RAW = pickEnv("ENVIRONMENT", "VITE_ENVIRONMENT", "VITE_ENVIROMENT", "NODE_ENV") ?? "PROD";
+    if (!BACKEND_URL_RAW)
+        throw new Error("BACKEND_URL vazio");
+    const ENVIRONMENT = ENVIRONMENT_RAW.toUpperCase();
+    const BACKEND_URL = withTrailingSlash(BACKEND_URL_RAW);
+    if (!BACKEND_URL) {
+        console.warn("[reflector] BACKEND_URL não definido (nem em params nem na .env: BACKEND_URL/PUBLIC_BACKEND).");
+    }
+    if (ENVIRONMENT === "PROD")
+        console.warn("[reflector] Ambiente não-DEV: os schemas serão atualizados automaticamente.");
+    return { BACKEND_URL, ENVIRONMENT };
+}
+export async function reflector() {
+    const { BACKEND_URL, ENVIRONMENT } = getParams();
+    if (ENVIRONMENT === "DEV") {
+        console.warn("[reflector] Ambiente DEV: para regerar os schemas manualmente, use: npx reflect");
+        return breakReflector();
+    }
+    const DOC_URL = `${BACKEND_URL}openapi.json`;
+    let data;
+    try {
+        const documentation = await axios.get(DOC_URL, { timeout: 15000 });
+        data = documentation.data;
+    }
+    catch (e) {
+        console.warn(`[reflector] Não foi possível obter a documentação em ${DOC_URL}. Carregando cópia local...`);
+        const backupPath = path.resolve(process.cwd(), "src/api/backup.json");
+        data = JSON.parse(fs.readFileSync(backupPath, "utf8"));
+    }
+    const { components, paths } = data;
+    if (!components) {
+        console.warn("[reflector] OpenAPI sem components; abortando.");
+        return { name: "vite-plugin-generate-doc" };
+    }
+    const r = new Reflector({ components, paths });
+    r.build();
+    r.localSave(data);
+    breakReflector();
+}
+function breakReflector() {
+    return {
+        name: "vite-plugin-generate-doc",
+    };
+}

package/dist/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function stripState(attr: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function sanitizeKey(name: 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.js

@@ -0,0 +1,35 @@
+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 toCamelCase(str) {
+    return str
+        .split('-')
+        .map((chunk, i) => (i === 0 ? chunk : chunk[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 camel = toCamelCase(raw);
+        // Garante que a primeira letra fique minúscula
+        return camel.charAt(0).toLowerCase() + camel.slice(1);
+    }
+    return toCamelCase(name);
+}
+export function capitalizeFirstLetter(text) {
+    if (!text)
+        return '';
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+export function splitByUppercase(text) {
+    return text.split(/(?=[A-Z])/);
+}
+export function createDangerMessage(text) {
+    console.log('\x1b[31m%s\x1b[0m', `[!] ${text}`);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { reflector } from "./generate-doc.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { reflector } from "./generate-doc.js";

package/dist/input.d.ts

@@ -0,0 +1,3 @@
+export declare class ReflectorInput {
+    password: string;
+}

package/dist/input.js

@@ -0,0 +1,14 @@
+export class ReflectorInput {
+    password = `z
+    .string()
+    .regex(/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$/, {
+      message: 'A senha deve conter pelo menos ',
+    })
+    .min(8, { message: '8 caracteres, ' })
+    .regex(/[A-Z]/, { message: 'uma letra maiúscula, ' })
+    .regex(/[a-z]/, { message: 'uma letra minúscula, ' })
+    .regex(/[0-9]/, { message: 'um número, ' })
+    .regex(/[^A-Za-z0-9]/, { message: 'um caracter especial.' })
+    .default('Senha123!@#')
+  `;
+}

package/dist/main.d.ts

@@ -0,0 +1,25 @@
+import { Source } from "./file.js";
+import { Schema } from "./schema.js";
+import { ComponentsObject, PathsObject, OpenAPIObject } from "./types/open-api-spec.interface.js";
+import { Module } from "./module.js";
+export declare class Reflector {
+    readonly components: ComponentsObject;
+    readonly paths: PathsObject;
+    readonly dir: string;
+    readonly generatedDir: string;
+    readonly localDoc: Source;
+    readonly src: Source;
+    readonly schemaFile: Source;
+    files: Source[];
+    schemas: Schema[];
+    modules: Module[];
+    constructor(params: {
+        components: ComponentsObject;
+        paths: PathsObject;
+    });
+    private getSchemas;
+    getModules(): Module[];
+    build(): {};
+    localSave(data: OpenAPIObject): void;
+    private clearSrc;
+}

package/dist/main.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import fs from "node:fs";
+import { Source } from "./file.js";
+import { sanitizeKey, capitalizeFirstLetter } from "./helpers.js";
+import { Schema } from "./schema.js";
+import { Module } from "./module.js";
+export class Reflector {
+    components;
+    paths;
+    dir = "src/api";
+    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`) });
+    files;
+    schemas;
+    modules;
+    constructor(params) {
+        const { components, paths } = params;
+        this.clearSrc();
+        this.components = components;
+        this.paths = paths;
+        this.files = [];
+        this.modules = this.getModules();
+        this.schemas = this.getSchemas();
+    }
+    getSchemas() {
+        const componentSchemas = this.components.schemas;
+        if (!componentSchemas)
+            return [];
+        const schemas = [];
+        Object.entries(componentSchemas).forEach(([key, object]) => {
+            if ("$ref" in object || !object.properties)
+                return;
+            const properties = object.properties;
+            schemas.push(new Schema({
+                properties,
+                name: key,
+                requireds: object.required || [],
+            }));
+        });
+        console.log(`${schemas.length} schemas gerados com sucesso.`);
+        return schemas;
+    }
+    getModules() {
+        const methodsMap = new Map();
+        const modules = [];
+        for (const [rawEndpoint, object] of Object.entries(this.paths)) {
+            const methods = ["get", "patch", "post", "put", "delete"];
+            let entity;
+            const operations = [];
+            const splittedEntitys = rawEndpoint.split("/");
+            const filteredEntitys = splittedEntitys.filter((item) => item !== "" && !item.includes("{"));
+            const moduleName = filteredEntitys.map((x) => sanitizeKey(capitalizeFirstLetter(x))).join("");
+            const endpoint = filteredEntitys.join("/");
+            for (const method of methods) {
+                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)
+                continue;
+            const existingOps = methodsMap.get(entity);
+            if (existingOps) {
+                existingOps.operations.push(...operations);
+            }
+            else {
+                methodsMap.set(entity, { endpoint, operations, moduleName });
+            }
+        }
+        for (const [name, info] of methodsMap) {
+            modules.push(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.modules.forEach((module) => {
+            module.src.save();
+        });
+        return {};
+    }
+    localSave(data) {
+        this.localDoc.data = JSON.stringify(data);
+        this.localDoc.save();
+    }
+    clearSrc() {
+        fs.rmSync(this.src.path, { recursive: true, force: true });
+        fs.mkdirSync(this.src.path, { recursive: true });
+    }
+}

package/dist/method.d.ts

@@ -0,0 +1,17 @@
+import { Request } from "./request.js";
+import { ZodProperty } from "./property.js";
+import type { ReflectorOperation } from "./types/types.js";
+export declare class Method {
+    name: string;
+    zodProperties: ZodProperty[];
+    description: string | undefined;
+    request: Request;
+    constructor(params: {
+        operation: ReflectorOperation;
+        moduleName: string;
+    });
+    private getParams;
+    private buildCallMethod;
+    private buildDescription;
+    build(): string | undefined;
+}

package/dist/method.js

@@ -0,0 +1,128 @@
+import { Request } from "./request.js";
+import { ZodProperty } from "./property.js";
+import { createDangerMessage } from "./helpers.js";
+export class Method {
+    name;
+    zodProperties;
+    description;
+    request;
+    constructor(params) {
+        const { operation } = params;
+        this.request = new Request(operation);
+        this.description = operation.description;
+        this.name = operation.operationId?.split("_")[1] ?? this.request.apiType;
+        const { parameters } = this.getParams(params);
+        this.zodProperties = parameters;
+    }
+    getParams(params) {
+        const { operation } = params;
+        if (!operation.parameters || operation.parameters?.length === 0) {
+            return { parameters: [] };
+        }
+        const parameters = [];
+        operation.parameters.forEach((object) => {
+            if ("$ref" in object)
+                return;
+            if (!object.schema)
+                return;
+            const { required, name, description, schema } = object;
+            if ("$ref" in schema)
+                return;
+            return parameters.push(new ZodProperty({
+                name,
+                example: schema.default,
+                schemaObject: schema,
+                type: schema.type,
+                description,
+                required: required || true,
+            }));
+        });
+        return { parameters };
+    }
+    buildCallMethod() {
+        const afterResponse = [];
+        const beforeResponse = [];
+        const props = this.zodProperties.map((x) => x.name).join(",");
+        const parameters = `
+      const bundle = repo.intercept.bundle(this.parameters)
+      const {${props}} = bundle
+    `;
+        const query = `
+      queryData: {${props}}
+    `;
+        if (this.request.apiType === "get") {
+            if (this.zodProperties.length > 0) {
+                afterResponse.push(parameters);
+                beforeResponse.push(`\n`);
+            }
+            if (this.request.attributeType === "list") {
+                beforeResponse.push(`const {data, ...params} = response`);
+                beforeResponse.push("\n\n");
+                beforeResponse.push(`this.list = data`);
+                beforeResponse.push(`repo.intercept.rebuild(this.parameters, params)`);
+            }
+            else if (this.request.attributeType === "entity") {
+                beforeResponse.push(`this.entity = response`);
+            }
+            return `
+      ${afterResponse.join(";")}
+        const response = await repo.api.get<${this.request.responseType}, unknown>({
+          endpoint: this.endpoint, ${query}
+        })
+        ${beforeResponse.join(";")}
+
+        return response
+      `;
+        }
+        else if (this.request.apiType === "post" || this.request.apiType === "put") {
+            let data = "";
+            if (this.request.bodyType) {
+                data = `const data = repo.intercept.bundle(this.forms.${this.name})`;
+            }
+            return `
+        ${data}
+
+        const response = await repo.api.post<${this.request.responseType}>({
+          endpoint: this.endpoint,
+          ${data ? "data" : ""}
+        })
+
+        return response
+      `;
+        }
+        else if (this.request.apiType === "delete") {
+            const props = this.zodProperties.map((x) => x.name).join(",");
+            return `
+        const {${props}} = this.parameters
+
+        const response = await repo.api.delete<${this.request.responseType}, unknown>({
+          endpoint: this.endpoint, ${query}
+        })
+
+        this.clear()
+        return response
+      `;
+        }
+        return "";
+    }
+    buildDescription() {
+        return `/** ${this.description ?? ""} */`;
+    }
+    build() {
+        const content = this.buildCallMethod();
+        if (!content)
+            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.`);
+        }
+        return `
+      ${this.buildDescription()}
+      async ${this.name}() {
+        ${content}
+      }
+    `;
+    }
+}

package/dist/module.d.ts

@@ -0,0 +1,30 @@
+import { Source } from "./file.js";
+import { Method } from "./method.js";
+import { ReflectorOperation } from "./types/types.js";
+export declare class Module {
+    readonly name: string;
+    readonly src: Source;
+    readonly endpoint: string;
+    readonly moduleName: string;
+    imports: string[];
+    parameters: string[];
+    methods: Method[];
+    types: {
+        raw: string[];
+        constructor: string[];
+    }[];
+    constructor(params: {
+        name: string;
+        moduleName: string;
+        operations: ReflectorOperation[];
+        endpoint: string;
+        dir: string;
+    });
+    private creator;
+    private getPath;
+    private buildMethods;
+    private getParameters;
+    private buildImports;
+    private buildClass;
+    buildFile(modulesAttributes: string[], moduleTypes: string[]): string;
+}

package/dist/module.js

@@ -0,0 +1,148 @@
+import path from "node:path";
+import fs from "node:fs";
+import { Source } from "./file.js";
+import { capitalizeFirstLetter, createDangerMessage, stripState } from "./helpers.js";
+import { Method } from "./method.js";
+export class Module {
+    name;
+    src;
+    endpoint;
+    moduleName;
+    imports;
+    parameters;
+    methods;
+    types;
+    constructor(params) {
+        const { name, operations, endpoint, dir, moduleName } = params;
+        this.moduleName = moduleName;
+        this.imports = ["// AUTO GERADO. QUEM ALTERAR GOSTA DE RAPAZES!\n", 'import repo from "$repository/main"'];
+        this.types = [
+            {
+                raw: [],
+                constructor: [],
+            },
+        ];
+        this.name = capitalizeFirstLetter(name);
+        this.endpoint = endpoint;
+        const 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) => {
+            if (!op.request.responseType) {
+                createDangerMessage(`Método [ ${op.name} ] do módulo [ ${this.moduleName} ] sem tipagem na resposta.`);
+            }
+            return op.request.responseType;
+        });
+        this.parameters = this.getParameters();
+        const { moduleAtributes, moduleTypes } = this.creator();
+        //sempre por último
+        this.src = new Source({
+            path: this.getPath(dir),
+            data: this.buildFile(moduleAtributes, moduleTypes),
+        });
+    }
+    creator() {
+        const buildedModuleTypes = [];
+        const moduleAtributes = new Set([`endpoint = '${this.endpoint}'`]);
+        if (this.parameters.length > 0) {
+            buildedModuleTypes.push(`const ParametersSchema = z.object({${this.parameters}})`);
+            moduleAtributes.add(`parameters = $state(repo.newForm(ParametersSchema))`);
+        }
+        const form = [];
+        this.methods.forEach((method) => {
+            const { bodyType, responseType, attributeType } = method.request;
+            if (attributeType === "form" && bodyType) {
+                form.push({
+                    name: method.name,
+                    type: bodyType,
+                });
+            }
+            if (attributeType === "entity") {
+                moduleAtributes.add(`list = $state<${responseType}[]>([])`);
+                moduleAtributes.add(`entity = $state<${responseType} | undefined>()`);
+            }
+        });
+        const formSet = new Set();
+        form.forEach((f) => {
+            formSet.add(`${f.name}: repo.newForm(${f.type}Schema)`);
+        });
+        moduleAtributes.add(`
+      forms = $state({
+        ${Array.from(formSet)}
+      })
+    `);
+        return {
+            moduleAtributes: Array.from(moduleAtributes),
+            moduleTypes: buildedModuleTypes,
+        };
+    }
+    getPath(dir) {
+        const fileName = this.endpoint.split("/").slice(-2).join("-");
+        const inPath = path.join(dir, this.endpoint);
+        const outPath = path.join(inPath, `${fileName.toLowerCase()}.module.svelte.ts`);
+        fs.mkdirSync(inPath, { recursive: true });
+        return outPath;
+    }
+    buildMethods() {
+        return this.methods.map((method) => {
+            return method.build();
+        });
+    }
+    getParameters() {
+        const set = new Set();
+        this.methods.forEach((method) => {
+            method.zodProperties.forEach((param) => set.add(param.buildedProp));
+        });
+        return Array.from(set);
+    }
+    buildImports() {
+        const entries = new Set();
+        this.methods.forEach((method) => {
+            const { bodyType, responseType, apiType } = method.request;
+            if (bodyType)
+                entries.add(`${bodyType}Schema`);
+            if (responseType) {
+                if (apiType === "delete")
+                    entries.add(`${responseType}Schema`);
+                entries.add(`type ${responseType}`);
+            }
+        });
+        const cleanEntries = Array.from(entries).filter((x) => x != "type any");
+        if (cleanEntries.length === 0)
+            return "";
+        return `import { ${cleanEntries} } from '$api/schemas';`;
+    }
+    buildClass(modulesAttributes) {
+        const initAssignments = modulesAttributes.map((attr) => `this.${stripState(attr)}`).join(";");
+        return `
+      export class ${this.moduleName}Module {
+        ${modulesAttributes.join(";")}
+
+        ${this.buildMethods().join("\n")}
+
+        private init() {
+          ${initAssignments}
+        }
+
+        clear() {
+          this.init()
+        }
+      }
+    `;
+    }
+    buildFile(modulesAttributes, moduleTypes) {
+        return `
+    ${this.imports.join(";")}
+    import z from "zod";
+    ${this.buildImports()}
+
+    ${moduleTypes.join(";")}
+
+    ${this.buildClass(modulesAttributes)}
+    `;
+    }
+}

package/dist/property.d.ts

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

package/dist/property.js

@@ -0,0 +1,81 @@
+import { ReflectorInput } from "./input.js";
+const inputs = new ReflectorInput();
+export class ZodProperty {
+    name;
+    example;
+    type;
+    buildedProp;
+    description = "";
+    required;
+    constructor(params) {
+        const { name, schemaObject, type, example, required } = params;
+        this.required = required;
+        this.name = name;
+        this.type = type;
+        this.example = this.getExample(example);
+        this.buildedProp = this.build(schemaObject);
+    }
+    getDtoName(ref) {
+        const cavalos = ref.split("/");
+        const dto = cavalos[cavalos.length - 1];
+        return dto;
+    }
+    getExample(example) {
+        if (example)
+            return example;
+        switch (this.type) {
+            case "number":
+                return 1;
+            case "boolean":
+                return true;
+            case "string":
+                return "lorem ipsum";
+            default:
+                return "lorem ipsum";
+        }
+    }
+    // fiscalNumber = cpf | cnpj | fiscalNumber
+    // cep
+    // telefone
+    // CUID
+    // url
+    deepValidator() {
+        if (this.name === "email") {
+            return `z.email().default('${this.example}')`;
+        }
+        else if (this.name === "password") {
+            return inputs.password;
+        }
+        else {
+            return false;
+        }
+    }
+    isNullable() {
+        return this.required ? "" : ".nullable()";
+    }
+    build(value) {
+        const x = `${this.name}: z.${this.type}()${this.isNullable()}`;
+        switch (this.type) {
+            case "string": {
+                const deepValidation = this.deepValidator();
+                return deepValidation ? `${this.name}: ${deepValidation}` : `${x}.default('${this.example}')`;
+            }
+            case "boolean":
+                return `${x}.default(${this.example})`;
+            case "number": {
+                const number = JSON.stringify(this.example) ?? 1;
+                return `${x}.default(${number})`;
+            }
+            case "array": {
+                if (!value.items || !("$ref" in value.items))
+                    return `${x}.default([])`;
+                const dto = this.getDtoName(value.items.$ref);
+                return `${this.name}: z.array(${dto}Schema).default(Array(10).fill(${dto}Schema.parse({})))`;
+            }
+            case "object":
+                return `${this.name}: z.any()`;
+            default:
+                return `${this.name}: z.any()`;
+        }
+    }
+}

package/dist/request.d.ts

@@ -0,0 +1,31 @@
+import { ApiType, ReflectorOperation } from "./types/types.js";
+type ReflectorRequestType = "entity" | "list" | "pagination" | "form" | "other";
+export declare class Request {
+    readonly attributeType: ReflectorRequestType;
+    readonly apiType: ApiType;
+    bodyType?: string;
+    responseType?: string;
+    constructor(operation: ReflectorOperation);
+    private getTypeFromRequestBody;
+    private getTypeFromResponses;
+    private inferAttributeType;
+    private componentName;
+    /**
+     * Lê o primeiro media type do ContentObject e devolve:
+     *  - string com nome de componente (quando é $ref),
+     *  - SchemaObject inline,
+     *  - ou undefined se nada aproveitável.
+     */
+    private getFromContent;
+    /**
+     * Converte um "schema ou nome de tipo" em string (ou undefined).
+     * Cobre: string direta, $ref, allOf, array, properties (com foco em "data"), e fallback por `type`.
+     */
+    private typeFromSchemaOrType;
+    /**
+     * Extrai o tipo a partir de `properties`, priorizando a propriedade `data`.
+     * Se `data` não existir ou não tiver tipo, retorna undefined.
+     */
+    private typeFromProperties;
+}
+export {};

package/dist/request.js

@@ -0,0 +1,114 @@
+function isRef(v) {
+    return !!v && typeof v === "object" && "$ref" in v;
+}
+export class Request {
+    attributeType;
+    apiType;
+    bodyType;
+    responseType;
+    constructor(operation) {
+        this.apiType = operation.apiMethod;
+        this.bodyType = this.getTypeFromRequestBody(operation.requestBody);
+        this.responseType = this.getTypeFromResponses(operation.responses);
+        this.attributeType = this.inferAttributeType(operation) ?? "other";
+    }
+    // ============= Derivações principais =======================================
+    getTypeFromRequestBody(requestBody) {
+        if (!requestBody || isRef(requestBody))
+            return undefined;
+        const schemaOrType = this.getFromContent(requestBody.content);
+        return this.typeFromSchemaOrType(schemaOrType);
+    }
+    getTypeFromResponses(responses) {
+        for (const response of Object.values(responses)) {
+            if (!response || isRef(response))
+                continue;
+            const schemaOrType = this.getFromContent(response.content);
+            const t = this.typeFromSchemaOrType(schemaOrType);
+            if (t !== undefined)
+                return t;
+        }
+        return undefined;
+    }
+    inferAttributeType(operation) {
+        const method = operation.apiMethod;
+        if (method === "post" || method === "put" || method === "patch") {
+            return "form";
+        }
+        if (method === "get") {
+            const params = operation.parameters ?? [];
+            const hasPage = params.some((p) => !isRef(p) && p.name === "page");
+            return (hasPage ? "list" : "entity");
+        }
+        return undefined;
+    }
+    // ============= Helpers de Schema/Content ===================================
+    componentName(refObj) {
+        const parts = refObj.$ref.split("/");
+        return parts[parts.length - 1];
+    }
+    /**
+     * Lê o primeiro media type do ContentObject e devolve:
+     *  - string com nome de componente (quando é $ref),
+     *  - SchemaObject inline,
+     *  - ou undefined se nada aproveitável.
+     */
+    getFromContent(content) {
+        if (!content || isRef(content))
+            return undefined;
+        const first = Object.values(content)[0];
+        const schema = first?.schema;
+        if (!schema)
+            return undefined;
+        if (isRef(schema))
+            return this.componentName(schema);
+        return schema;
+    }
+    /**
+     * Converte um "schema ou nome de tipo" em string (ou undefined).
+     * Cobre: string direta, $ref, allOf, array, properties (com foco em "data"), e fallback por `type`.
+     */
+    typeFromSchemaOrType(schemaOrType) {
+        if (!schemaOrType)
+            return undefined;
+        if (typeof schemaOrType === "string")
+            return schemaOrType;
+        const schema = schemaOrType;
+        // Composição: tenta extrair de allOf[0].properties
+        const allOfFirst = schema.allOf?.[0];
+        if (allOfFirst && !isRef(allOfFirst)) {
+            const t = this.typeFromProperties(allOfFirst.properties);
+            if (t !== undefined)
+                return t;
+        }
+        // Array -> tipo do item
+        if (schema.type === "array" && schema.items) {
+            const items = schema.items;
+            if (isRef(items))
+                return this.componentName(items);
+            return items.type;
+        }
+        // Properties -> prioriza "data"
+        if (schema.properties) {
+            const t = this.typeFromProperties(schema.properties);
+            if (t !== undefined)
+                return t;
+        }
+        // Fallback: usa o próprio `type`, se houver
+        return schema.type;
+    }
+    /**
+     * Extrai o tipo a partir de `properties`, priorizando a propriedade `data`.
+     * Se `data` não existir ou não tiver tipo, retorna undefined.
+     */
+    typeFromProperties(properties) {
+        if (!properties)
+            return undefined;
+        const data = properties.data;
+        if (isRef(data))
+            return this.componentName(data);
+        if (data.type === "any")
+            return;
+        return data.type;
+    }
+}

package/dist/schema.d.ts

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

package/dist/schema.js

@@ -0,0 +1,27 @@
+import { ZodProperty } from "./property.js";
+export class Schema {
+    name;
+    properties = [];
+    type;
+    schema;
+    constructor(params) {
+        const { name, properties, requireds } = params;
+        this.name = name;
+        Object.entries(properties).forEach(([key, value]) => {
+            if ("$ref" in value || !value?.type)
+                return;
+            const required = requireds.includes(key);
+            this.properties.push(new ZodProperty({
+                name: key,
+                schemaObject: value,
+                type: value.type,
+                example: value.example,
+                required,
+            }));
+        });
+        this.type = `export type ${name} = z.infer<typeof ${name}Schema>;`;
+        this.schema = `export const ${name}Schema = z.object({
+      ${this.properties.map((p) => p.buildedProp)}
+    });`;
+    }
+}

package/dist/types/open-api-spec.interface.d.ts

@@ -0,0 +1,239 @@
+export interface OpenAPIObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+export interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject {
+    name: string;
+    url?: string;
+}
+export interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariableObject>;
+}
+export interface ServerVariableObject {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+export interface ComponentsObject {
+    schemas?: Record<string, SchemaObject | ReferenceObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+}
+export type PathsObject = Record<string, PathItemObject>;
+export interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+export interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    callbacks?: CallbacksObject;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export type ParameterLocation = "query" | "header" | "path" | "cookie";
+export type ParameterStyle = "matrix" | "label" | "form" | "simple" | "spaceDelimited" | "pipeDelimited" | "deepObject";
+export interface BaseParameterObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    example?: any;
+    content?: ContentObject;
+}
+export interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+export interface RequestBodyObject {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+export type ContentObject = Record<string, MediaTypeObject>;
+export interface MediaTypeObject {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+export type EncodingObject = Record<string, EncodingPropertyObject>;
+export interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export interface ResponsesObject extends Record<string, ResponseObject | ReferenceObject | undefined> {
+    default?: ResponseObject | ReferenceObject;
+}
+export interface ResponseObject {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+export type CallbacksObject = Record<string, CallbackObject | ReferenceObject>;
+export type CallbackObject = Record<string, PathItemObject>;
+export type HeadersObject = Record<string, HeaderObject | ReferenceObject>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export type LinksObject = Record<string, LinkObject | ReferenceObject>;
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+}
+export type LinkParametersObject = Record<string, any>;
+export type HeaderObject = BaseParameterObject;
+export interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+export type ExamplesObject = Record<string, ExampleObject | ReferenceObject>;
+export interface ReferenceObject {
+    $ref: string;
+}
+export interface SchemaObject {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[] | Record<string, any>;
+    deprecated?: boolean;
+    type?: string;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: Record<string, SchemaObject | ReferenceObject>;
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    patternProperties?: SchemaObject | ReferenceObject | any;
+    description?: string;
+    format?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    "x-enumNames"?: string[];
+}
+export type SchemasObject = Record<string, SchemaObject>;
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Record<string, string>;
+}
+export interface XmlObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export type SecuritySchemeType = "apiKey" | "http" | "oauth2" | "openIdConnect";
+export interface SecuritySchemeObject {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+    "x-tokenName"?: string;
+    [extension: `x-${string}`]: any;
+}
+export interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+export interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+export type ScopesObject = Record<string, any>;
+export type SecurityRequirementObject = Record<string, string[]>;
+export type ExtensionLocation = "root" | "info";

package/dist/types/open-api-spec.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,12 @@
+import { 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;
+};
+export type Info = {
+    endpoint: string;
+    operations: ReflectorOperation[];
+    moduleName: string;
+};
+export type Example = string | boolean | number;

package/dist/types/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "svelte-reflector",
+  "version": "1.0.0",
+  "description": "Reflects zod types from openAPI schemas",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "reflect": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.8.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3"
+  }
+}