svelte-reflector 1.3.5 → 1.3.6

package/dist/core/generators/ApiCallStrategy.d.ts

@@ -1,6 +1,6 @@
 import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
 export declare class ApiCallStrategy implements CallStrategy {
-    readonly listStateAccess = "this.data";
+    listStateAccess(_method: CallMethodInput): string;
     buildSignature(method: CallMethodInput): string;
     entityStateAccess(_method: CallMethodInput): string;
     formStateAccess(_method: CallMethodInput): string;

package/dist/core/generators/ApiCallStrategy.js

@@ -1,5 +1,7 @@
 export class ApiCallStrategy {
-    listStateAccess = "this.data";
+    listStateAccess(_method) {
+        return "this.data";
+    }
     buildSignature(method) {
         const paramsType = this.buildParamsType(method);
         return `async call(params?: ${paramsType})`;

package/dist/core/generators/CallMethodGenerator.js

@@ -78,7 +78,7 @@ export class CallMethodGenerator {
         endpoint,
         queryData: { ${querys} }
       })
-      ${strategy.listStateAccess} = ${method.analyzers.request.responseType}.from(response.data);
+      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
       this.totalPages = response.totalPages;
     `;
         return { inside, outside: "" };
@@ -134,7 +134,7 @@ export class CallMethodGenerator {
     buildMethodReturn(method, strategy) {
         const { attributeType, responseType, hasEnumResponse, isPrimitiveResponse } = method.analyzers.request;
         if (attributeType === "list")
-            return strategy.listStateAccess;
+            return strategy.listStateAccess(method);
         if (!responseType)
             return "null";
         if (hasEnumResponse)

package/dist/core/generators/CallStrategy.d.ts

@@ -2,6 +2,11 @@ import type { MethodAnalyzers } from "../method/Method.js";
 /** Structural subset of `Method` that the generator and strategies actually read. */
 export interface CallMethodInput {
     name: string;
+    /** Disambiguation suffix appended to the base name; empty when unique. */
+    nameSuffix: string;
+    /** Disambiguation suffix for the shared list state field; empty when
+     *  the module has at most one list-typed method. */
+    stateSuffix: string;
     endpoint: string;
     description: string | undefined;
     responseTypeInterface: string;
@@ -14,8 +19,10 @@ export interface CallMethodInput {
 export interface CallStrategy {
     /** Full method signature incl. params — e.g. `async call(params?: ...)` or `protected async _foo(params?: ...)` */
     buildSignature(method: CallMethodInput): string;
-    /** State field holding list results — e.g. `this.list` (module) or `this.data` (api) */
-    readonly listStateAccess: string;
+    /** State field holding list results — e.g. `this.list` / `this.listControllers` (module) or `this.data` (api).
+     *  Takes `method` so the module strategy can suffix the field when two list
+     *  operations collide in the same controller. */
+    listStateAccess(method: CallMethodInput): string;
     /** State field receiving the fetched entity */
     entityStateAccess(method: CallMethodInput): string;
     /** Form instance accessed to bundle body data */

package/dist/core/generators/ModuleCallStrategy.d.ts

@@ -1,6 +1,6 @@
 import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
 export declare class ModuleCallStrategy implements CallStrategy {
-    readonly listStateAccess = "this.list";
+    listStateAccess(method: CallMethodInput): string;
     buildSignature(method: CallMethodInput): string;
     entityStateAccess(method: CallMethodInput): string;
     formStateAccess(method: CallMethodInput): string;

package/dist/core/generators/ModuleCallStrategy.js

@@ -1,6 +1,8 @@
 import { treatByUppercase } from "../../helpers/helpers.js";
 export class ModuleCallStrategy {
-    listStateAccess = "this.list";
+    listStateAccess(method) {
+        return `this.list${method.stateSuffix}`;
+    }
     buildSignature(method) {
         const paramsType = this.buildParamsType(method);
         return `protected async _${method.name}(params?: ${paramsType})`;

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

@@ -22,7 +22,16 @@ export interface MethodAnalyzers {
     };
 }
 export declare class Method {
-    readonly name: string;
+    name: string;
+    /** Disambiguation suffix appended to the base name when two methods in
+     *  the same module collide (e.g. two `listAll`). Empty when unique. */
+    nameSuffix: string;
+    /** Disambiguation suffix for the shared list state field (`list`,
+     *  `bundledList`, `clearList`). Set when the module has more than one
+     *  `list`-typed method, even if the method names themselves are unique
+     *  (e.g. `listAll` + `getMessages` both producing `list`). Empty when
+     *  the module has at most one list method. */
+    stateSuffix: string;
     readonly endpoint: string;
     readonly apiType: ApiType;
     readonly attributeType: ReflectorRequestType;

package/dist/core/method/Method.js

@@ -2,6 +2,15 @@ import { MethodBuilder } from "./MethodBuilder.js";
 import { MethodGenerator } from "./generators/MethodGenerator.js";
 export class Method {
     name;
+    /** Disambiguation suffix appended to the base name when two methods in
+     *  the same module collide (e.g. two `listAll`). Empty when unique. */
+    nameSuffix = "";
+    /** Disambiguation suffix for the shared list state field (`list`,
+     *  `bundledList`, `clearList`). Set when the module has more than one
+     *  `list`-typed method, even if the method names themselves are unique
+     *  (e.g. `listAll` + `getMessages` both producing `list`). Empty when
+     *  the module has at most one list method. */
+    stateSuffix = "";
     endpoint;
     apiType;
     attributeType;

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

@@ -0,0 +1,38 @@
+import type { Method } from "./Method.js";
+/**
+ * Two kinds of collision inside a single controller (module) produce invalid
+ * generated code. Both are fixed here by appending a suffix derived from the
+ * path's last non-parameterized segment.
+ *
+ * 1. Method-name collision (`nameSuffix`).
+ *    Two operations with the same base name (e.g. two `listAll`, two
+ *    `findOne`) would emit duplicate `_listAll` / `_findOne` methods and
+ *    duplicate per-operation classes (`ListAll`, `FindOnePaths`, etc.).
+ *
+ * 2. List-state collision (`stateSuffix`).
+ *    Any two list-typed operations in the same module emit `list = $state<…>`
+ *    twice, even when their method names differ (e.g. `listAll` vs
+ *    `getMessages`). The `list` field, `bundledList`, and `clearList()` must
+ *    be suffixed per method so both are unique.
+ *
+ * Suffix derivation (same for both cases, so a single method can reuse one
+ * suffix for both):
+ *  - Take the last non-`{param}` segment of the endpoint path.
+ *  - Pluralize it when the path does NOT end with a `{param}`
+ *    (collection endpoints: listAll, create).
+ *  - Keep it singular when the path ends with a `{param}`
+ *    (item endpoints: findOne, update, remove).
+ *  - Camel-case the result to strip hyphens and capitalize.
+ *
+ * When a method has no collision of either kind, both suffixes stay empty
+ * and the output matches the pre-fix behavior — no churn for consumers of
+ * non-colliding controllers.
+ */
+export declare class MethodNameDisambiguator {
+    static apply(methods: Method[]): void;
+    private static disambiguateNames;
+    private static disambiguateListStates;
+    private static ensureUnique;
+    private static deriveSuffix;
+    private static pluralize;
+}

package/dist/core/method/MethodNameDisambiguator.js

@@ -0,0 +1,118 @@
+import { capitalizeFirstLetter, toCamelCase } from "../../helpers/helpers.js";
+/**
+ * Two kinds of collision inside a single controller (module) produce invalid
+ * generated code. Both are fixed here by appending a suffix derived from the
+ * path's last non-parameterized segment.
+ *
+ * 1. Method-name collision (`nameSuffix`).
+ *    Two operations with the same base name (e.g. two `listAll`, two
+ *    `findOne`) would emit duplicate `_listAll` / `_findOne` methods and
+ *    duplicate per-operation classes (`ListAll`, `FindOnePaths`, etc.).
+ *
+ * 2. List-state collision (`stateSuffix`).
+ *    Any two list-typed operations in the same module emit `list = $state<…>`
+ *    twice, even when their method names differ (e.g. `listAll` vs
+ *    `getMessages`). The `list` field, `bundledList`, and `clearList()` must
+ *    be suffixed per method so both are unique.
+ *
+ * Suffix derivation (same for both cases, so a single method can reuse one
+ * suffix for both):
+ *  - Take the last non-`{param}` segment of the endpoint path.
+ *  - Pluralize it when the path does NOT end with a `{param}`
+ *    (collection endpoints: listAll, create).
+ *  - Keep it singular when the path ends with a `{param}`
+ *    (item endpoints: findOne, update, remove).
+ *  - Camel-case the result to strip hyphens and capitalize.
+ *
+ * When a method has no collision of either kind, both suffixes stay empty
+ * and the output matches the pre-fix behavior — no churn for consumers of
+ * non-colliding controllers.
+ */
+export class MethodNameDisambiguator {
+    static apply(methods) {
+        this.disambiguateNames(methods);
+        this.disambiguateListStates(methods);
+    }
+    static disambiguateNames(methods) {
+        const groups = new Map();
+        for (const m of methods) {
+            const bucket = groups.get(m.name);
+            if (bucket)
+                bucket.push(m);
+            else
+                groups.set(m.name, [m]);
+        }
+        for (const bucket of groups.values()) {
+            if (bucket.length < 2)
+                continue;
+            const used = new Set();
+            for (const method of bucket) {
+                const suffix = this.deriveSuffix(method.endpoint);
+                if (!suffix)
+                    continue;
+                const finalSuffix = this.ensureUnique(suffix, used);
+                used.add(finalSuffix);
+                method.name = `${method.name}${finalSuffix}`;
+                method.nameSuffix = finalSuffix;
+            }
+        }
+    }
+    static disambiguateListStates(methods) {
+        const listMethods = methods.filter((m) => m.analyzers.request.attributeType === "list");
+        if (listMethods.length < 2)
+            return;
+        const used = new Set();
+        for (const method of listMethods) {
+            // If `disambiguateNames` already assigned a suffix for this method
+            // (two list-typed ops with the same name), reuse it so the method
+            // name and list state stay aligned (e.g. `_listAllPackages` ↔
+            // `listPackages`).
+            let suffix = method.nameSuffix || this.deriveSuffix(method.endpoint);
+            if (!suffix)
+                continue;
+            const finalSuffix = this.ensureUnique(suffix, used);
+            used.add(finalSuffix);
+            method.stateSuffix = finalSuffix;
+        }
+    }
+    static ensureUnique(suffix, used) {
+        if (!used.has(suffix))
+            return suffix;
+        let i = 2;
+        let candidate = `${suffix}${i}`;
+        while (used.has(candidate)) {
+            i += 1;
+            candidate = `${suffix}${i}`;
+        }
+        return candidate;
+    }
+    static deriveSuffix(rawPath) {
+        const segments = rawPath.split("/").filter(Boolean);
+        if (segments.length === 0)
+            return "";
+        const isParam = (s) => /^\{.+\}$/.test(s);
+        const last = segments[segments.length - 1];
+        let baseSegment = "";
+        for (let i = segments.length - 1; i >= 0; i--) {
+            const seg = segments[i];
+            if (!isParam(seg)) {
+                baseSegment = seg;
+                break;
+            }
+        }
+        if (!baseSegment)
+            return "";
+        const shouldPluralize = !isParam(last);
+        const word = shouldPluralize ? this.pluralize(baseSegment) : baseSegment;
+        return capitalizeFirstLetter(toCamelCase(word));
+    }
+    static pluralize(word) {
+        if (word.endsWith("s"))
+            return word;
+        if (/[^aeiou]y$/i.test(word))
+            return `${word.slice(0, -1)}ies`;
+        if (/(x|ch|sh)$/i.test(word))
+            return `${word}es`;
+        return `${word}s`;
+    }
+}

package/dist/core/module/Module.js

@@ -2,6 +2,7 @@ import * as path from "node:path";
 import { Source } from "../../file.js";
 import { capitalizeFirstLetter, toKebabCase } from "../../helpers/helpers.js";
 import { Method } from "../method/Method.js";
+import { MethodNameDisambiguator } from "../method/MethodNameDisambiguator.js";
 import { generatedDir } from "../../vars.global.js";
 import { ModuleImports, ModuleMethodProcessor, ModuleParamProcessor, ModuleClassBuilder, ModuleConstructorBuilder, ModuleFileBuilder, ApiFileBuilder, ApiClassBuilder, } from "../index.js";
 export class Module {
@@ -42,6 +43,7 @@ export class Module {
         this.fileBuilder = new ModuleFileBuilder({ imports: this.imports });
         // Processa os métodos
         this.methods = operations.map((operation) => Method.fromOperation(operation, this.name, context));
+        MethodNameDisambiguator.apply(this.methods);
         const processedMethods = this.methodProcessor.process({ methods: this.methods });
         // Processa os parâmetros
         const processedParams = this.paramProcessor.process({

package/dist/core/module/ModuleMethodProcessor.js

@@ -42,12 +42,15 @@ export class ModuleMethodProcessor {
                 methodsClear.add(`protected clear${capitalizeFirstLetter(entityName)}() { this.${entityName} = undefined }`);
             }
             else if (attributeType === "list") {
+                const listField = `list${method.stateSuffix}`;
+                const bundledField = `bundled${capitalizeFirstLetter(listField)}`;
+                const clearMethod = `clear${capitalizeFirstLetter(listField)}`;
                 methodsAttributes.add("totalPages = $state<number>(1)");
-                methodsAttributes.add(`list = $state<${responseType}['data']>([])`);
+                methodsAttributes.add(`${listField} = $state<${responseType}['data']>([])`);
                 this.imports.addReflectorImport("genericArrayBundler");
-                methodsAttributes.add(`bundledList = $derived(genericArrayBundler(this.list))`);
-                methodsInit.add("this.clearList()");
-                methodsClear.add(`protected clearList() { this.list = [] }`);
+                methodsAttributes.add(`${bundledField} = $derived(genericArrayBundler(this.${listField}))`);
+                methodsInit.add(`this.${clearMethod}()`);
+                methodsClear.add(`protected ${clearMethod}() { this.${listField} = [] }`);
             }
             if (bodyType) {
                 entries.add(bodyType);

package/package.json

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