svelte-reflector 1.3.1 → 1.3.3

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/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/main.d.ts

@@ -28,6 +28,35 @@ export declare class Reflector {
         typeImports: TypeImports;
         apiImport: string;
     });
+    /**
+     * 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,7 +1,7 @@
 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";
@@ -28,18 +28,154 @@ export class Reflector {
         const { components, paths, fieldConfigs, typeImports, apiImport } = params;
         this.apiImport = apiImport;
         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 +201,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 +209,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 {
@@ -146,7 +282,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(),

package/dist/method.d.ts

@@ -15,6 +15,7 @@ export declare class Method {
         apiType: import("./types/types.js").ApiType;
         parameters: any[];
         hasEnumResponse: boolean;
+        isPrimitiveResponse: boolean;
     };
     get headers(): PrimitiveProp[];
     get cookies(): PrimitiveProp[];

package/dist/module.js

@@ -58,7 +58,7 @@ export class Module {
             data: this.fileBuilder.build({
                 ...allBuilded,
                 moduleConstructor,
-                moduleName: this.moduleName,
+                moduleName: this.name,
             }),
         });
     }

package/dist/props/primitive.property.d.ts

@@ -15,6 +15,8 @@ export declare class PrimitiveProp {
     private readonly example;
     private readonly fallbackExample;
     private get effectiveType();
+    /** Non-required fields become nullable (| null) instead of optional (?) */
+    private get isEffectivelyNullable();
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;

package/dist/props/primitive.property.js

@@ -14,11 +14,16 @@ export class PrimitiveProp {
     get effectiveType() {
         return this.customType ?? this.rawType;
     }
+    /** Non-required fields become nullable (| null) instead of optional (?) */
+    get isEffectivelyNullable() {
+        return this.isNullable || !this.required;
+    }
     constructor(params) {
         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;
@@ -94,8 +99,15 @@ export class PrimitiveProp {
             return "";
         };
         const buildedExample = `params?.empty || isEmpty ? ${this.fallbackExample} : ${this.example}`;
-        const keyExpr = this.isNullable ? `params?.data?.${name} ?? null` : `params?.data?.${name}`;
-        const typeParam = this.isNullable ? `<${this.effectiveType} | null>` : "";
+        const effectivelyNullable = this.isEffectivelyNullable;
+        const keyExpr = effectivelyNullable ? `params?.data?.${name} ?? null` : `params?.data?.${name}`;
+        let typeParam = "";
+        if (effectivelyNullable) {
+            typeParam = `<${this.effectiveType} | null>`;
+        }
+        else if (this.customType) {
+            typeParam = `<${this.effectiveType}>`;
+        }
         return `
       build${typeParam}({ key: ${keyExpr}, placeholder: ${this.example}, example: ${buildedExample}, required: ${required}, ${buildedValidator()}})
     `;
@@ -107,13 +119,13 @@ export class PrimitiveProp {
         return `${this.thisDot()}${this.name} = ${this.buildedConst}`;
     }
     classBuild() {
-        const req = (this.required || this.isNullable) ? "" : "?";
-        const nullable = this.isNullable ? " | null" : "";
+        const req = (this.required || this.isEffectivelyNullable) ? "" : "?";
+        const nullable = this.isEffectivelyNullable ? " | null" : "";
         return `${this.name}${req}: BuildedInput<${this.effectiveType}${nullable}>`;
     }
     interfaceBuild() {
-        const req = this.required ? "" : "?";
-        const nullable = this.isNullable ? " | null" : "";
+        const req = (this.required || this.isEffectivelyNullable) ? "" : "?";
+        const nullable = this.isEffectivelyNullable ? " | null" : "";
         return `${this.name}${req}: ${this.effectiveType}${nullable}`;
     }
     patchBuild() {

package/package.json

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