svelte-reflector 1.3.3 → 1.3.4

package/dist/core/api/ApiClassBuilder.d.ts

@@ -0,0 +1,23 @@
+import type { Method } from "../../method.js";
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ModuleClassBuilder } from "../module/ModuleClassBuilder.js";
+export interface ApiEndpointBlock {
+    paramCode: string;
+    classCode: string;
+    schemaEntries: Set<string>;
+}
+export declare class ApiClassBuilder {
+    private readonly imports;
+    private readonly methodGenerator;
+    private readonly paramProcessor;
+    constructor(params: {
+        imports: ModuleImports;
+        classBuilder: ModuleClassBuilder;
+    });
+    build(params: {
+        method: Method;
+    }): ApiEndpointBlock | null;
+    private buildStateProperties;
+    private buildResetLines;
+    private shouldSkipMethod;
+}

package/dist/core/api/ApiClassBuilder.js

@@ -0,0 +1,125 @@
+import { capitalizeFirstLetter, createDangerMessage, treatByUppercase } from "../../helpers/helpers.js";
+import { ApiMethodGenerator } from "./ApiMethodGenerator.js";
+import { ApiParamProcessor } from "./ApiParamProcessor.js";
+export class ApiClassBuilder {
+    imports;
+    methodGenerator = new ApiMethodGenerator();
+    paramProcessor;
+    constructor(params) {
+        this.imports = params.imports;
+        this.paramProcessor = new ApiParamProcessor({
+            imports: params.imports,
+            classBuilder: params.classBuilder,
+        });
+    }
+    build(params) {
+        const { method } = params;
+        if (this.shouldSkipMethod(method))
+            return null;
+        const { request, headers, cookies, paths, querys } = method;
+        const { bodyType, responseType, attributeType, isPrimitiveResponse } = request;
+        // Process per-endpoint params
+        const processedParams = this.paramProcessor.process({
+            methodName: capitalizeFirstLetter(method.name),
+            querys,
+            paths,
+            headers,
+            cookies,
+        });
+        // Build state properties
+        const stateProps = this.buildStateProperties(method);
+        // Build the call method
+        const callMethod = this.methodGenerator.generate(method);
+        // Build reset method
+        const resetLines = this.buildResetLines(method, processedParams.paramReset);
+        // Collect schema entries
+        const schemaEntries = new Set();
+        if (bodyType) {
+            schemaEntries.add(bodyType);
+        }
+        if (responseType && responseType !== "response" && !isPrimitiveResponse) {
+            schemaEntries.add(`type ${responseType}Interface`);
+            schemaEntries.add(responseType);
+        }
+        // Handle form imports
+        if (attributeType === "form" && bodyType) {
+            this.imports.addReflectorImport("isFormValid");
+        }
+        // Handle list imports
+        if (attributeType === "list") {
+            this.imports.addReflectorImport("genericArrayBundler");
+        }
+        const className = capitalizeFirstLetter(method.name);
+        const classCode = `
+      export class ${className} {
+        ${stateProps.join(";")}
+        ${processedParams.paramAttributes.map((a) => `${a};`).join("\n        ")}
+
+        ${callMethod}
+
+        reset() {
+          ${resetLines.join(";")}
+        }
+      }
+    `;
+        const paramCode = processedParams.paramClasses.join("\n");
+        return { paramCode, classCode, schemaEntries };
+    }
+    buildStateProperties(method) {
+        const { attributeType, responseType, bodyType, isPrimitiveResponse } = method.request;
+        const props = ["loading = $state<boolean>(false)"];
+        if (attributeType === "form" && bodyType) {
+            // For form endpoints, the form IS the data
+            props.push(`form = new ${bodyType}()`);
+        }
+        else if (attributeType === "list") {
+            props.push(`data = $state<${responseType}['data']>([])`);
+            props.push("totalPages = $state<number>(1)");
+        }
+        else if (attributeType === "entity" && responseType && !isPrimitiveResponse) {
+            props.push(`data = $state<${responseType} | undefined>()`);
+        }
+        else {
+            props.push("data = $state<unknown>(undefined)");
+        }
+        return props;
+    }
+    buildResetLines(method, paramReset) {
+        const { attributeType, bodyType } = method.request;
+        const lines = [];
+        if (attributeType === "form" && bodyType) {
+            lines.push(`this.form = new ${bodyType}()`);
+        }
+        else if (attributeType === "list") {
+            lines.push("this.data = []");
+            lines.push("this.totalPages = 1");
+        }
+        else {
+            lines.push("this.data = undefined");
+        }
+        lines.push(...paramReset);
+        return lines;
+    }
+    shouldSkipMethod(method) {
+        const { bodyType, responseType, attributeType } = method.request;
+        if (bodyType === "string") {
+            createDangerMessage(`Method ${method.name} was skipped because it has an invalid body.`);
+            return true;
+        }
+        const isNullResponse = !responseType || responseType === "null";
+        if ((attributeType === "entity" || attributeType === "list") && isNullResponse) {
+            createDangerMessage(`Method ${method.name} was skipped because it has a null response.`);
+            return true;
+        }
+        const endpointParams = [...method.endpoint.matchAll(/\{(\w+)\}/g)].map((m) => m[1]).filter(Boolean);
+        if (endpointParams.length > 0) {
+            const declaredPaths = new Set(method.paths.map((p) => p.name));
+            const undeclared = endpointParams.filter((p) => !declaredPaths.has(p));
+            if (undeclared.length > 0) {
+                createDangerMessage(`Method ${method.name} was skipped because it has undeclared path params: ${undeclared.join(", ")}`);
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/core/api/ApiFileBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ApiEndpointBlock } from "./ApiClassBuilder.js";
+export declare class ApiFileBuilder {
+    private readonly imports;
+    constructor(params: {
+        imports: ModuleImports;
+    });
+    build(params: {
+        endpointBlocks: ApiEndpointBlock[];
+        classImports: string;
+    }): string;
+}

package/dist/core/api/ApiFileBuilder.js

@@ -0,0 +1,24 @@
+export class ApiFileBuilder {
+    imports;
+    constructor(params) {
+        this.imports = params.imports;
+    }
+    build(params) {
+        const { endpointBlocks, classImports } = params;
+        const reflectorImports = this.imports.buildReflectorImportsLine();
+        const enumImports = this.imports.buildEnumImportsLine();
+        const mockedImports = this.imports.buildMockedImportsLine();
+        const sections = endpointBlocks.map((block) => {
+            return `${block.paramCode}\n${block.classCode}`;
+        });
+        return `
+      ${this.imports.getImportsArray().join(";")}
+      ${reflectorImports}
+      ${mockedImports}
+      ${enumImports}
+      ${classImports}
+
+      ${sections.join("\n\n")}
+    `;
+    }
+}

package/dist/core/api/ApiMethodGenerator.d.ts

@@ -0,0 +1,17 @@
+import type { Method } from "../../method.js";
+export declare class ApiMethodGenerator {
+    private readonly endpointBuilder;
+    generate(method: Method): string;
+    private buildProps;
+    private buildPathsInfo;
+    private buildApiCall;
+    private buildListCall;
+    private buildEntityCall;
+    private buildFormCall;
+    private buildDeleteCall;
+    private buildParamsType;
+    private buildDescription;
+    private buildMethodReturn;
+    private joinProps;
+    private buildQuerys;
+}

package/dist/core/api/ApiMethodGenerator.js

@@ -0,0 +1,176 @@
+import { MethodEndpointBuilder } from "../method/MethodEndpointBuilder.js";
+export class ApiMethodGenerator {
+    endpointBuilder = new MethodEndpointBuilder();
+    generate(method) {
+        const description = this.buildDescription(method);
+        const endpoint = this.endpointBuilder.build(method.endpoint, method.paths);
+        const apiCall = this.buildApiCall(method);
+        const props = this.buildProps(method);
+        const pathsInfo = this.buildPathsInfo(method);
+        const paramsType = this.buildParamsType(method, pathsInfo);
+        return `
+      ${description}
+      async call(params?: ${paramsType}) {
+
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
+        ${props}
+        const endpoint = ${endpoint}
+
+        ${apiCall.outside}
+
+        try {
+          ${apiCall.inside}
+          await onSuccess?.(response);
+
+          return ${this.buildMethodReturn(method)};
+        } catch (e) {
+          let parsedError: ApiErrorResponse;
+          try {
+            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
+          } catch {
+            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
+          }
+          return await onError?.(parsedError);
+        } finally {
+          this.loading = false;
+        }
+      }
+    `;
+    }
+    buildProps(method) {
+        const { querys, paths, cookies } = method;
+        const lines = [];
+        if (querys.length > 0) {
+            lines.push(`const { ${querys.map((x) => x.name).join(", ")} } = this.querys.bundle()`);
+        }
+        if (paths.length > 0) {
+            lines.push(`const { ${paths.map((x) => x.name).join(", ")} } = params?.paths ?? this.paths`);
+        }
+        if (cookies.length > 0) {
+            lines.push(`const cookies = this.cookies`);
+        }
+        return lines.join("\n");
+    }
+    buildPathsInfo(method) {
+        const { paths } = method;
+        if (paths.length === 0)
+            return undefined;
+        return `{ ${paths
+            .map((p) => {
+            const type = p.rawType ?? p.type;
+            return `${p.name}: ${type}`;
+        })
+            .join("; ")} }`;
+    }
+    buildApiCall(method) {
+        const { attributeType, apiType, responseType, bodyType, hasEnumResponse } = method.request;
+        const responseTypeStr = hasEnumResponse && responseType ? responseType : method.responseTypeInterface;
+        if (attributeType === "list") {
+            return this.buildListCall(method, responseTypeStr);
+        }
+        if (attributeType === "entity") {
+            return this.buildEntityCall(method, responseTypeStr);
+        }
+        if (apiType === "post" || apiType === "put" || apiType === "patch") {
+            return this.buildFormCall(method, responseTypeStr, bodyType);
+        }
+        if (apiType === "delete") {
+            return this.buildDeleteCall(responseTypeStr);
+        }
+        return { inside: "", outside: "" };
+    }
+    buildListCall(method, responseType) {
+        const querys = this.joinProps(method.querys);
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        queryData: { ${querys} }
+      })
+      this.data = ${method.request.responseType}.from(response.data);
+      this.totalPages = response.totalPages;
+    `;
+        return { inside, outside: "" };
+    }
+    buildEntityCall(method, responseType) {
+        const rType = method.request.responseType;
+        const isPrimitive = method.request.isPrimitiveResponse;
+        const querys = this.buildQuerys(method.querys);
+        const buildedThisResponseType = rType && !isPrimitive
+            ? `this.data = new ${rType}({ data: response })`
+            : "";
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        ${querys}
+      })
+
+      ${buildedThisResponseType}
+    `;
+        return { inside, outside: "" };
+    }
+    buildFormCall(method, responseType, bodyType) {
+        const { apiType } = method.request;
+        const hasHeaders = method.headers.length > 0;
+        const hasData = !!bodyType;
+        const outside = [];
+        if (hasData) {
+            outside.push(`const data = this.form.bundle()`);
+        }
+        if (hasHeaders) {
+            outside.push(`const headers = this.headers.bundle()`);
+        }
+        const inside = `
+      const response = await api.${apiType}<${responseType}>({
+        endpoint,
+        ${hasData ? "data," : ""}
+        ${hasHeaders ? "headers," : ""}
+      })
+    `;
+        return { inside, outside: outside.join("\n") };
+    }
+    buildDeleteCall(responseType) {
+        const inside = `
+      const response = await api.delete<${responseType}, unknown>({
+        endpoint,
+      })
+    `;
+        return { inside, outside: "" };
+    }
+    buildParamsType(method, paramsPaths) {
+        const responseType = method.responseTypeInterface;
+        if (paramsPaths) {
+            return `ApiCallParams<${responseType}, ${paramsPaths}>`;
+        }
+        return `ApiCallParams<${responseType}>`;
+    }
+    buildDescription(method) {
+        return `/** ${method.description ?? ""} */`;
+    }
+    buildMethodReturn(method) {
+        const { attributeType, responseType, hasEnumResponse, isPrimitiveResponse } = method.request;
+        if (attributeType === "list") {
+            return "this.data";
+        }
+        if (!responseType) {
+            return "null";
+        }
+        if (hasEnumResponse) {
+            return "response.data";
+        }
+        if (isPrimitiveResponse) {
+            return "response";
+        }
+        return `new ${responseType}({ data: response })`;
+    }
+    joinProps(props) {
+        return props.map((x) => x.name).join(",");
+    }
+    buildQuerys(querys) {
+        if (querys.length === 0)
+            return "";
+        return `queryData: {${querys.map((q) => q.name).join(",")}}`;
+    }
+}

package/dist/core/api/ApiParamProcessor.d.ts

@@ -0,0 +1,24 @@
+import type { AttributeProp } from "../../types/types.js";
+import type { PrimitiveProp } from "../../props/primitive.property.js";
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ModuleClassBuilder } from "../module/ModuleClassBuilder.js";
+export interface ApiProcessedParams {
+    paramClasses: string[];
+    paramAttributes: string[];
+    paramReset: string[];
+}
+export declare class ApiParamProcessor {
+    private readonly imports;
+    private readonly classBuilder;
+    constructor(params: {
+        imports: ModuleImports;
+        classBuilder: ModuleClassBuilder;
+    });
+    process(params: {
+        methodName: string;
+        querys: AttributeProp[];
+        paths: PrimitiveProp[];
+        headers: PrimitiveProp[];
+        cookies: PrimitiveProp[];
+    }): ApiProcessedParams;
+}

package/dist/core/api/ApiParamProcessor.js

@@ -0,0 +1,36 @@
+import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+export class ApiParamProcessor {
+    imports;
+    classBuilder;
+    constructor(params) {
+        this.imports = params.imports;
+        this.classBuilder = params.classBuilder;
+    }
+    process(params) {
+        const { methodName, cookies, headers, paths, querys } = params;
+        const paramClasses = [];
+        const paramAttributes = [];
+        const paramReset = [];
+        const processParam = (paramData) => {
+            const { paramType, attrName, props } = paramData;
+            const className = `${capitalizeFirstLetter(methodName)}${capitalizeFirstLetter(paramType)}`;
+            paramClasses.push(this.classBuilder.buildClassProps({ props, name: paramType, className }));
+            paramAttributes.push(`${attrName} = new ${className}()`);
+            paramReset.push(`this.${attrName} = new ${className}()`);
+        };
+        const argEntries = [
+            { attrName: "querys", props: querys },
+            { attrName: "headers", props: headers },
+            { attrName: "paths", props: paths },
+            { attrName: "cookies", props: cookies },
+        ];
+        for (const { attrName, props } of argEntries) {
+            if (!props.length)
+                continue;
+            this.imports.addReflectorImport("QueryBuilder");
+            const paramType = capitalizeFirstLetter(attrName);
+            processParam({ paramType, attrName, props });
+        }
+        return { paramClasses, paramAttributes, paramReset };
+    }
+}

package/dist/core/index.d.ts

@@ -4,6 +4,10 @@ export { ModuleParamProcessor, type ProcessedParams } from "./module/ModuleParam
 export { ModuleClassBuilder } from "./module/ModuleClassBuilder.js";
 export { ModuleConstructorBuilder, type Form } from "./module/ModuleConstructorBuilder.js";
 export { ModuleFileBuilder, type FileBuildParams } from "./module/ModuleFileBuilder.js";
+export { ApiFileBuilder } from "./api/ApiFileBuilder.js";
+export { ApiClassBuilder, type ApiEndpointBlock } from "./api/ApiClassBuilder.js";
+export { ApiMethodGenerator } from "./api/ApiMethodGenerator.js";
+export { ApiParamProcessor, type ApiProcessedParams } from "./api/ApiParamProcessor.js";
 export { Method } from "./method/Method.js";
 export { MethodBuilder } from "./method/MethodBuilder.js";
 export { MethodApiTypeAnalyzer } from "./method/MethodApiTypeAnalyzer.js";

package/dist/core/index.js

@@ -5,6 +5,11 @@ export { ModuleParamProcessor } from "./module/ModuleParamProcessor.js";
 export { ModuleClassBuilder } from "./module/ModuleClassBuilder.js";
 export { ModuleConstructorBuilder } from "./module/ModuleConstructorBuilder.js";
 export { ModuleFileBuilder } from "./module/ModuleFileBuilder.js";
+// Api-related exports
+export { ApiFileBuilder } from "./api/ApiFileBuilder.js";
+export { ApiClassBuilder } from "./api/ApiClassBuilder.js";
+export { ApiMethodGenerator } from "./api/ApiMethodGenerator.js";
+export { ApiParamProcessor } from "./api/ApiParamProcessor.js";
 // Method-related exports
 export { Method } from "./method/Method.js";
 export { MethodBuilder } from "./method/MethodBuilder.js";

package/dist/core/module/ModuleClassBuilder.d.ts

@@ -8,5 +8,6 @@ export declare class ModuleClassBuilder {
     buildClassProps(params: {
         props: AttributeProp[];
         name: ParamType;
+        className?: string;
     }): string;
 }

package/dist/core/module/ModuleClassBuilder.js

@@ -5,7 +5,8 @@ export class ModuleClassBuilder {
         this.imports = params.imports;
     }
     buildClassProps(params) {
-        const { name, props } = params;
+        const { name, props, className } = params;
+        const outputName = className ?? name;
         const bundle = [];
         const attributes = [];
         if (name === "Paths") {
@@ -18,7 +19,7 @@ export class ModuleClassBuilder {
             });
             this.imports.addPageStateImport();
             return `
-        class ${name} {
+        class ${outputName} {
           ${attributes.join(";")}
         }
       `;
@@ -66,7 +67,7 @@ export class ModuleClassBuilder {
         }
       `;
             return `
-        class ${name} {
+        class ${outputName} {
           ${attributes.join(";")}
 
           ${constructorBuild}
@@ -100,7 +101,7 @@ export class ModuleClassBuilder {
     `
             : "";
         return `
-      class ${name} {
+      class ${outputName} {
         ${attributes.join(";")}
 
         ${bundleBuild}

package/dist/core/module/ModuleImports.d.ts

@@ -16,6 +16,7 @@ export declare class ModuleImports {
     hasEnumImports(): boolean;
     private hasMockedImports;
     getMockedImports(): string[];
+    private readonly typeOnlyImports;
     buildReflectorImportsLine(): string;
     buildEnumImportsLine(): string;
     buildMockedImportsLine(): string;

package/dist/core/module/ModuleImports.js

@@ -50,11 +50,16 @@ export class ModuleImports {
     getMockedImports() {
         return Array.from(this.mockedImports);
     }
+    typeOnlyImports = new Set(["ApiCallParams"]);
     buildReflectorImportsLine() {
         const imports = this.getReflectorImportsArray();
-        const regularImports = imports.filter(i => i !== "setQueryGroup");
+        const regularImports = imports.filter(i => i !== "setQueryGroup" && !this.typeOnlyImports.has(i));
+        const typeImports = imports.filter(i => this.typeOnlyImports.has(i));
         const hasSetQueryGroup = imports.includes("setQueryGroup");
         let result = `import { ${regularImports.join(", ")}, type ApiErrorResponse`;
+        for (const t of typeImports) {
+            result += `, type ${t}`;
+        }
         if (hasSetQueryGroup) {
             result += `, setQueryGroup`;
         }

package/dist/generate-doc.js

@@ -84,12 +84,16 @@ export async function reflector(manual = false) {
     }
     // Lê reflector.json do projeto consumidor (opcional)
     let apiImport = "$lib/api";
+    let experimentalFeatures = false;
     try {
         const reflectorJsonPath = path.resolve(process.cwd(), "reflector.json");
         const reflectorJson = JSON.parse(fs.readFileSync(reflectorJsonPath, "utf8"));
         if (reflectorJson.api) {
             apiImport = reflectorJson.api;
         }
+        if (reflectorJson.experimentalFeatures === true) {
+            experimentalFeatures = true;
+        }
     }
     catch {
         // reflector.json não encontrado ou inválido — usa o padrão
@@ -99,7 +103,7 @@ export async function reflector(manual = false) {
         console.warn("[reflector] OpenAPI sem components; abortando.");
         return breakReflector();
     }
-    const r = new Reflector({ components, paths, fieldConfigs, typeImports, apiImport });
+    const r = new Reflector({ components, paths, fieldConfigs, typeImports, apiImport, experimentalFeatures });
     await r.build();
     await r.localSave(data);
     return breakReflector();

package/dist/main.d.ts

@@ -21,12 +21,14 @@ export declare class Reflector {
     schemas: Schema[];
     modules: Module[];
     readonly apiImport: string;
+    readonly experimentalFeatures: boolean;
     constructor(params: {
         components: ComponentsObject;
         paths: PathsObject;
         fieldConfigs: FieldConfigs;
         typeImports: TypeImports;
         apiImport: string;
+        experimentalFeatures?: boolean;
     });
     /**
      * Promotes inline object request-body schemas to named components.

package/dist/main.js

@@ -6,6 +6,7 @@ import { Schema } from "./schema.js";
 import { Module } from "./module.js";
 import { generatedDir } from "./vars.global.js";
 import { ReflectorFile } from "./reflector.js";
+import * as process from "node:process";
 export const enumTypes = new Map();
 export const mockedParams = new Set();
 export class Reflector {
@@ -24,9 +25,11 @@ export class Reflector {
     schemas;
     modules;
     apiImport;
+    experimentalFeatures;
     constructor(params) {
-        const { components, paths, fieldConfigs, typeImports, apiImport } = params;
+        const { components, paths, fieldConfigs, typeImports, apiImport, experimentalFeatures } = params;
         this.apiImport = apiImport;
+        this.experimentalFeatures = experimentalFeatures ?? false;
         this.typeImports = typeImports;
         // Clear global state between runs
         enumTypes.clear();
@@ -237,6 +240,7 @@ export class Reflector {
                 name,
                 ...info,
                 apiImport: this.apiImport,
+                experimentalFeatures: this.experimentalFeatures,
             });
         });
         return modules;
@@ -290,6 +294,7 @@ export class Reflector {
             this.enumFile.save(),
             this.mockedParamsFile.save(),
             ...this.modules.filter((m) => m.methods.length > 0).map((m) => m.src.save()),
+            ...this.modules.filter((m) => m.methods.length > 0 && m.apiSrc).map((m) => m.apiSrc.save()),
         ]);
         return {};
     }

package/dist/method.d.ts

@@ -17,6 +17,8 @@ export declare class Method {
         hasEnumResponse: boolean;
         isPrimitiveResponse: boolean;
     };
+    get analyzers(): import("./core/method/Method.js").MethodAnalyzers;
+    get responseTypeInterface(): string;
     get headers(): PrimitiveProp[];
     get cookies(): PrimitiveProp[];
     get paths(): PrimitiveProp[];

package/dist/method.js

@@ -11,6 +11,12 @@ export class Method {
     get request() {
         return this.method.analyzers.request;
     }
+    get analyzers() {
+        return this.method.analyzers;
+    }
+    get responseTypeInterface() {
+        return this.method.responseTypeInterface;
+    }
     get headers() {
         return this.method.analyzers.props.headers;
     }

package/dist/module.d.ts

@@ -6,6 +6,7 @@ export declare class Module {
     readonly path: string;
     readonly moduleName: string;
     readonly src: Source;
+    readonly apiSrc: Source | null;
     readonly methods: Method[];
     /** Schema class names directly used by this module (for per-module schema generation) */
     readonly schemaClassNames: string[];
@@ -21,7 +22,10 @@ export declare class Module {
         operations: ReflectorOperation[];
         path: string;
         apiImport: string;
+        experimentalFeatures?: boolean;
     });
     private buildModuleData;
+    private buildApiFile;
+    private getApiPath;
     private getPath;
 }

package/dist/module.js

@@ -4,12 +4,13 @@ import { Source } from "./file.js";
 import { capitalizeFirstLetter, toKebabCase } from "./helpers/helpers.js";
 import { Method } from "./method.js";
 import { generatedDir } from "./vars.global.js";
-import { ModuleImports, ModuleMethodProcessor, ModuleParamProcessor, ModuleClassBuilder, ModuleConstructorBuilder, ModuleFileBuilder, } from "./core/index.js";
+import { ModuleImports, ModuleMethodProcessor, ModuleParamProcessor, ModuleClassBuilder, ModuleConstructorBuilder, ModuleFileBuilder, ApiFileBuilder, ApiClassBuilder, } from "./core/index.js";
 export class Module {
     name;
     path;
     moduleName;
     src;
+    apiSrc;
     methods;
     /** Schema class names directly used by this module (for per-module schema generation) */
     schemaClassNames;
@@ -20,7 +21,7 @@ export class Module {
     constructorBuilder;
     fileBuilder;
     constructor(params) {
-        const { name, operations, moduleName, path: modulePath, apiImport } = params;
+        const { name, operations, moduleName, path: modulePath, apiImport, experimentalFeatures } = params;
         this.moduleName = moduleName;
         this.name = capitalizeFirstLetter(name);
         this.path = modulePath;
@@ -61,6 +62,8 @@ export class Module {
                 moduleName: this.name,
             }),
         });
+        // Cria o arquivo Api (apenas com experimentalFeatures)
+        this.apiSrc = experimentalFeatures ? this.buildApiFile(apiImport) : null;
     }
     buildModuleData(processedMethods, processedParams) {
         const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
@@ -102,6 +105,36 @@ export class Module {
             buildedMethods,
         };
     }
+    buildApiFile(apiImport) {
+        const apiImports = new ModuleImports(apiImport);
+        apiImports.addReflectorImport("ApiCallParams");
+        const apiClassBuilderDep = new ModuleClassBuilder({ imports: apiImports });
+        const apiClassBuilder = new ApiClassBuilder({ imports: apiImports, classBuilder: apiClassBuilderDep });
+        const apiFileBuilder = new ApiFileBuilder({ imports: apiImports });
+        const endpointBlocks = [];
+        const apiSchemaEntries = new Set();
+        for (const method of this.methods) {
+            const block = apiClassBuilder.build({ method });
+            if (!block)
+                continue;
+            endpointBlocks.push(block);
+            block.schemaEntries.forEach((e) => apiSchemaEntries.add(e));
+        }
+        const cleanEntries = Array.from(apiSchemaEntries).filter((x) => x !== "type any");
+        const kebabName = toKebabCase(this.name);
+        const classImports = cleanEntries.length > 0
+            ? `import { ${cleanEntries.join(", ")} } from './${kebabName}.schema.svelte';`
+            : "";
+        return new Source({
+            path: this.getApiPath(),
+            data: apiFileBuilder.build({ endpointBlocks, classImports }),
+        });
+    }
+    getApiPath() {
+        const kebabName = toKebabCase(this.name);
+        const inPath = path.join(generatedDir, "controllers", kebabName);
+        return path.join(inPath, `${kebabName}.api.svelte.ts`);
+    }
     getPath() {
         const kebabName = toKebabCase(this.name);
         const inPath = path.join(generatedDir, "controllers", kebabName);

package/dist/reflector.js

@@ -10,6 +10,10 @@ export class ReflectorFile {
         "type ValidatorResult = string | null",
         "type ValidatorFn<T> = (v: T) => ValidatorResult",
         "type BundleResult<T> = T extends { bundle: () => infer R } ? R : T;",
+        `export type ApiCallParams<TResponse, TPaths = void> =
+      TPaths extends void
+        ? { behavior?: Behavior<TResponse, ApiErrorResponse> }
+        : { behavior?: Behavior<TResponse, ApiErrorResponse>; paths?: TPaths }`,
         `type PartialBuildedInput<T> = {
         [K in Exclude<keyof T, 'bundle'>]?: BuildedInput<T[K]>;
       } & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-reflector",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "dotenv": "^16.4.5"
   },
   "devDependencies": {
-    "@types/node": "^24.12.0",
+    "@types/node": "^24.12.2",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {