svelte-reflector 1.3.2 → 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/method/Method.d.ts

@@ -11,6 +11,7 @@ export interface MethodAnalyzers {
         apiType: ApiType;
         parameters: any[];
         hasEnumResponse: boolean;
+        isPrimitiveResponse: boolean;
     };
     props: {
         paths: PrimitiveProp[];

package/dist/core/method/MethodBuilder.js

@@ -24,10 +24,11 @@ export class MethodBuilder {
                 apiType,
                 parameters: this.requestAnalyzer.paths,
                 hasEnumResponse: this.responseAnalyzer.hasEnumResponse,
+                isPrimitiveResponse: this.responseAnalyzer.isPrimitiveResponse,
             },
             props,
         };
-        const responseTypeInterface = this.buildResponseTypeInterface(analyzers.request.responseType);
+        const responseTypeInterface = this.buildResponseTypeInterface(analyzers.request.responseType, analyzers.request.isPrimitiveResponse);
         return new Method({
             name,
             endpoint: operation.endpoint,
@@ -44,7 +45,11 @@ export class MethodBuilder {
             return "listAll";
         return extracted ?? this.apiTypeAnalyzer.analyze(operation).apiType;
     }
-    buildResponseTypeInterface(responseType) {
-        return responseType ? `${responseType}Interface` : "null";
+    buildResponseTypeInterface(responseType, isPrimitiveResponse) {
+        if (!responseType)
+            return "null";
+        if (isPrimitiveResponse)
+            return responseType;
+        return `${responseType}Interface`;
     }
 }

package/dist/core/method/MethodResponseAnalyzer.d.ts

@@ -2,7 +2,9 @@ import type { ResponsesObject } from "../../types/open-api-spec.interface.js";
 export declare class MethodResponseAnalyzer {
     responseType: string | null;
     hasEnumResponse: boolean;
+    isPrimitiveResponse: boolean;
     analyze(responses: ResponsesObject): void;
+    private normalizePrimitive;
     private isRef;
     private componentName;
     private getFromContent;

package/dist/core/method/MethodResponseAnalyzer.js

@@ -1,6 +1,8 @@
+const PRIMITIVE_RESPONSE_TYPES = new Set(["string", "number", "boolean", "integer", "any", "object", "array"]);
 export class MethodResponseAnalyzer {
     responseType = null;
     hasEnumResponse = false;
+    isPrimitiveResponse = false;
     analyze(responses) {
         for (const response of Object.values(responses)) {
             if (!response || this.isRef(response))
@@ -8,11 +10,21 @@ export class MethodResponseAnalyzer {
             const schemaOrType = this.getFromContent(response.content);
             const type = this.typeFromSchemaOrType(schemaOrType);
             if (type !== undefined) {
-                this.responseType = type;
+                this.isPrimitiveResponse = PRIMITIVE_RESPONSE_TYPES.has(type);
+                this.responseType = this.normalizePrimitive(type);
                 break;
             }
         }
     }
+    normalizePrimitive(type) {
+        if (type === "integer")
+            return "number";
+        if (type === "array")
+            return "unknown[]";
+        if (type === "object")
+            return "unknown";
+        return type;
+    }
     isRef(v) {
         return !!v && typeof v === "object" && "$ref" in v;
     }
@@ -46,11 +58,14 @@ export class MethodResponseAnalyzer {
             this.hasEnumResponse = true;
             return this.extractEnumType(schema);
         }
-        const allOfFirst = schema.allOf?.[0];
-        if (allOfFirst && !this.isRef(allOfFirst)) {
-            const t = this.typeFromProperties(allOfFirst.properties);
-            if (t !== undefined)
-                return t;
+        if (schema.allOf) {
+            for (const entry of schema.allOf) {
+                if (this.isRef(entry))
+                    continue;
+                const t = this.typeFromProperties(entry.properties);
+                if (t !== undefined)
+                    return t;
+            }
         }
         if (schema.type === "array" && schema.items) {
             const items = schema.items;

package/dist/core/method/generators/MethodApiCallBuilder.js

@@ -31,9 +31,10 @@ export class MethodApiCallBuilder {
     }
     buildEntityCall(method, responseType) {
         const rType = method.analyzers.request.responseType;
+        const isPrimitive = method.analyzers.request.isPrimitiveResponse;
         const querys = this.buildQuerys(method.analyzers.props.querys);
         const entityName = treatByUppercase(rType ?? "");
-        const buildedThisResponseType = rType
+        const buildedThisResponseType = rType && !isPrimitive
             ? `this.${entityName} = new ${method.analyzers.request.responseType}({ data: response })`
             : "";
         const inside = `

package/dist/core/method/generators/MethodGenerator.js

@@ -62,7 +62,7 @@ export class MethodGenerator {
         return `/** ${method.description ?? ""} */`;
     }
     buildMethodReturn(method) {
-        const { attributeType, responseType, hasEnumResponse } = method.analyzers.request;
+        const { attributeType, responseType, hasEnumResponse, isPrimitiveResponse } = method.analyzers.request;
         if (attributeType === "list") {
             return "this.list";
         }
@@ -72,6 +72,9 @@ export class MethodGenerator {
         if (hasEnumResponse) {
             return "response.data";
         }
+        if (isPrimitiveResponse) {
+            return "response";
+        }
         return `new ${responseType}({ data: response })`;
     }
 }

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/core/module/ModuleMethodProcessor.js

@@ -7,21 +7,21 @@ export class ModuleMethodProcessor {
     shouldSkipMethod(method) {
         const { bodyType, responseType, attributeType } = method.request;
         if (bodyType === "string") {
-            createDangerMessage(`Metodo ${method.name} foi ignorado por possuir um body inválido.`);
+            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(`Metodo ${method.name} foi ignorado por possuir uma resposta nula.`);
+            createDangerMessage(`Method ${method.name} was skipped because it has a null response.`);
             return true;
         }
-        // Verifica se todos os path params do endpoint estão declarados como parâmetros
+        // Check that all endpoint path params are declared as parameters
         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(`Metodo ${method.name} foi ignorado por possuir path params não declarados: ${undeclared.join(", ")}`);
+                createDangerMessage(`Method ${method.name} was skipped because it has undeclared path params: ${undeclared.join(", ")}`);
                 return true;
             }
         }
@@ -42,7 +42,7 @@ export class ModuleMethodProcessor {
         const cookieMap = new Map();
         for (const method of methods) {
             const { request, headers, cookies, paths, querys } = method;
-            const { bodyType, responseType, attributeType } = request;
+            const { bodyType, responseType, attributeType, isPrimitiveResponse } = request;
             headers.forEach((h) => headerMap.set(h.name, h));
             cookies.forEach((c) => cookieMap.set(c.name, c));
             paths.forEach((p) => pathMap.set(p.name, p));
@@ -57,7 +57,7 @@ export class ModuleMethodProcessor {
                 this.imports.addReflectorImport("isFormValid");
             }
             buildedMethods.push(method.build());
-            if (attributeType === "entity") {
+            if (attributeType === "entity" && !isPrimitiveResponse) {
                 const entityName = treatByUppercase(method.request.responseType ?? "");
                 methodsAttributes.add(`${entityName} = $state<${responseType} | undefined>()`);
                 methodsInit.add(`this.clear${capitalizeFirstLetter(entityName)}()`);
@@ -74,7 +74,7 @@ export class ModuleMethodProcessor {
             if (bodyType) {
                 entries.add(bodyType);
             }
-            if (responseType && responseType !== "response") {
+            if (responseType && responseType !== "response" && !isPrimitiveResponse) {
                 entries.add(`type ${responseType}Interface`);
                 entries.add(responseType);
             }

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,13 +21,44 @@ 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.
+     * Without this, `MethodBodyAnalyzer` falls back to `schema.type` ("object")
+     * because inline bodies aren't referenced by a `$ref`, and the resulting
+     * body type name collides with the JS primitive — so the generated module
+     * imports a non-existent `{ object }` class and the schema file is never
+     * emitted (resolveTransitiveDeps finds nothing in schemaMap).
+     */
+    private extractInlineBodies;
+    private promoteInlineBody;
+    /**
+     * Promotes inline response `data` schemas to named components.
+     * Responses in this API follow a `{success, data, message}` envelope where
+     * `data` is either declared directly or overlaid via `allOf`. When `data` is
+     * an inline object/array (no `$ref`), the response analyzer can only
+     * extract the raw `schema.type` ("object"/"array"), which isn't a valid
+     * class name. Promoting `data` to a named component gives the analyzer a
+     * proper `$ref` to resolve.
+     */
+    private extractInlineResponses;
+    private promoteInlineResponse;
+    private findSuccessResponse;
+    /**
+     * Locates the inline `data` sub-schema inside a response envelope, whether
+     * it lives at `schema.properties.data` or inside an `allOf` entry. Returns
+     * a handle that lets the caller swap the inline schema for a `$ref`.
+     */
+    private findInlineDataHolder;
+    private hasExtractableContent;
     private getSchemas;
     private getModules;
     build(): Promise<{}>;

package/dist/main.js

@@ -1,11 +1,12 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpoint, isReferenceObject, splitByUppercase } from "./helpers/helpers.js";
+import { capitalizeFirstLetter, getEndpoint, isReferenceObject, splitByUppercase } from "./helpers/helpers.js";
 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,22 +25,160 @@ 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;
-        // Limpa estado global entre execuções
+        // Clear global state between runs
         enumTypes.clear();
         mockedParams.clear();
         this.clearSrc();
         this.components = components;
         this.paths = paths;
+        this.extractInlineBodies();
+        this.extractInlineResponses();
         this.files = [];
         this.modules = this.getModules();
         const { propertiesNames, schemas } = this.getSchemas({ fieldConfigs });
         this.propertiesNames = propertiesNames;
         this.schemas = schemas;
     }
+    /**
+     * Promotes inline object request-body schemas to named components.
+     * Without this, `MethodBodyAnalyzer` falls back to `schema.type` ("object")
+     * because inline bodies aren't referenced by a `$ref`, and the resulting
+     * body type name collides with the JS primitive — so the generated module
+     * imports a non-existent `{ object }` class and the schema file is never
+     * emitted (resolveTransitiveDeps finds nothing in schemaMap).
+     */
+    extractInlineBodies() {
+        this.components.schemas ??= {};
+        const schemas = this.components.schemas;
+        const usedNames = new Set(Object.keys(schemas));
+        const httpMethods = ["get", "put", "post", "delete", "patch", "options", "head", "trace"];
+        for (const [pathStr, pathItem] of Object.entries(this.paths)) {
+            if (!pathItem)
+                continue;
+            for (const httpMethod of httpMethods) {
+                this.promoteInlineBody(pathItem[httpMethod], httpMethod, pathStr, schemas, usedNames);
+            }
+        }
+    }
+    promoteInlineBody(operation, httpMethod, pathStr, schemas, usedNames) {
+        if (!operation?.requestBody || "$ref" in operation.requestBody)
+            return;
+        const firstEntry = Object.values(operation.requestBody.content ?? {})[0];
+        const schema = firstEntry?.schema;
+        if (!schema || "$ref" in schema || !schema.properties)
+            return;
+        const base = operation.operationId
+            ? capitalizeFirstLetter(operation.operationId)
+            : capitalizeFirstLetter(httpMethod) + pathStr.replaceAll(/[^a-zA-Z0-9]/g, "");
+        let name = `${base}Body`;
+        let suffix = 2;
+        while (usedNames.has(name)) {
+            name = `${base}Body${suffix++}`;
+        }
+        usedNames.add(name);
+        schemas[name] = schema;
+        firstEntry.schema = { $ref: `#/components/schemas/${name}` };
+    }
+    /**
+     * Promotes inline response `data` schemas to named components.
+     * Responses in this API follow a `{success, data, message}` envelope where
+     * `data` is either declared directly or overlaid via `allOf`. When `data` is
+     * an inline object/array (no `$ref`), the response analyzer can only
+     * extract the raw `schema.type` ("object"/"array"), which isn't a valid
+     * class name. Promoting `data` to a named component gives the analyzer a
+     * proper `$ref` to resolve.
+     */
+    extractInlineResponses() {
+        this.components.schemas ??= {};
+        const schemas = this.components.schemas;
+        const usedNames = new Set(Object.keys(schemas));
+        const httpMethods = ["get", "put", "post", "delete", "patch", "options", "head", "trace"];
+        for (const [pathStr, pathItem] of Object.entries(this.paths)) {
+            if (!pathItem)
+                continue;
+            for (const httpMethod of httpMethods) {
+                this.promoteInlineResponse(pathItem[httpMethod], httpMethod, pathStr, schemas, usedNames);
+            }
+        }
+    }
+    promoteInlineResponse(operation, httpMethod, pathStr, schemas, usedNames) {
+        if (!operation?.responses)
+            return;
+        const successResponse = this.findSuccessResponse(operation.responses);
+        if (!successResponse || "$ref" in successResponse || !successResponse.content)
+            return;
+        const firstEntry = Object.values(successResponse.content)[0];
+        const schema = firstEntry?.schema;
+        if (!schema || "$ref" in schema)
+            return;
+        const dataHolder = this.findInlineDataHolder(schema);
+        if (!dataHolder)
+            return;
+        const base = operation.operationId
+            ? capitalizeFirstLetter(operation.operationId)
+            : capitalizeFirstLetter(httpMethod) + pathStr.replaceAll(/[^a-zA-Z0-9]/g, "");
+        let name = `${base}Response`;
+        let suffix = 2;
+        while (usedNames.has(name)) {
+            name = `${base}Response${suffix++}`;
+        }
+        usedNames.add(name);
+        schemas[name] = dataHolder.data;
+        dataHolder.replace({ $ref: `#/components/schemas/${name}` });
+    }
+    findSuccessResponse(responses) {
+        for (const [code, response] of Object.entries(responses)) {
+            if (code.startsWith("2"))
+                return response;
+        }
+        return undefined;
+    }
+    /**
+     * Locates the inline `data` sub-schema inside a response envelope, whether
+     * it lives at `schema.properties.data` or inside an `allOf` entry. Returns
+     * a handle that lets the caller swap the inline schema for a `$ref`.
+     */
+    findInlineDataHolder(schema) {
+        const holders = [];
+        if (schema.properties)
+            holders.push(schema);
+        if (schema.allOf) {
+            for (const entry of schema.allOf) {
+                if (!("$ref" in entry) && entry.properties) {
+                    holders.push(entry);
+                }
+            }
+        }
+        for (const holder of holders) {
+            const data = holder.properties?.["data"];
+            if (!data || "$ref" in data)
+                continue;
+            if (!this.hasExtractableContent(data))
+                continue;
+            return {
+                data,
+                replace: (ref) => {
+                    holder.properties["data"] = ref;
+                },
+            };
+        }
+        return null;
+    }
+    hasExtractableContent(schema) {
+        if (schema.properties)
+            return true;
+        if (schema.items)
+            return true;
+        if (schema.allOf?.length)
+            return true;
+        return false;
+    }
     getSchemas(params) {
         const { fieldConfigs } = params;
         const componentSchemas = this.components.schemas;
@@ -65,7 +204,7 @@ export class Reflector {
         for (const schema of schemas) {
             this.schemaMap.set(schema.name, schema);
         }
-        console.log(`${schemas.length} schemas gerados com sucesso.`);
+        console.log(`${schemas.length} schemas generated successfully.`);
         return { schemas, propertiesNames };
     }
     getModules() {
@@ -73,8 +212,8 @@ export class Reflector {
         for (const [path, methods] of Object.entries(this.paths)) {
             const rawMethod = Object.values(methods)[0];
             const rawName = rawMethod.operationId?.split("_")[0] ?? "";
-            const teste = splitByUppercase(rawName).filter((x) => x !== "Controller");
-            const moduleName = teste.join("");
+            const nameParts = splitByUppercase(rawName).filter((x) => x !== "Controller");
+            const moduleName = nameParts.join("");
             const baseEndpoint = getEndpoint(path);
             const operations = Object.entries(methods).map(([apiMethod, attributes]) => {
                 return {
@@ -101,6 +240,7 @@ export class Reflector {
                 name,
                 ...info,
                 apiImport: this.apiImport,
+                experimentalFeatures: this.experimentalFeatures,
             });
         });
         return modules;
@@ -146,7 +286,7 @@ export class Reflector {
       export default mockedParams
     `;
         this.mockedParamsFile.changeData(mockedFile);
-        // Salva todos os arquivos em paralelo, aguardando conclusão
+        // Save all files in parallel, awaiting completion
         await Promise.all([
             ...moduleSchemaFiles.map((f) => f.save()),
             this.typesSrc.save(),
@@ -154,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

@@ -15,7 +15,10 @@ export declare class Method {
         apiType: import("./types/types.js").ApiType;
         parameters: any[];
         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;
@@ -58,9 +59,11 @@ export class Module {
             data: this.fileBuilder.build({
                 ...allBuilded,
                 moduleConstructor,
-                moduleName: this.moduleName,
+                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/props/primitive.property.js

@@ -22,7 +22,8 @@ export class PrimitiveProp {
         const { name, schemaObject, required, validator, customType, isParam, isNullable } = params;
         const { type: rawType } = schemaObject;
         this.isNullable = !!isNullable;
-        const type = rawType ?? "string";
+        const normalizedRawType = rawType === "integer" ? "number" : rawType;
+        const type = normalizedRawType ?? "string";
         const { emptyExample, example } = this.getExampleAndFallback({ schemaObject, type, name });
         this.example = example;
         this.fallbackExample = emptyExample;

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.2",
+  "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": {