svelte-reflector 1.3.4 → 1.3.6

package/dist/core/CodegenContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Per-run codegen state. Replaces module-level mutable globals so two
+ * concurrent Reflector instances don't corrupt each other's output.
+ *
+ * - `enumTypes`: maps the joined enum literal string (e.g. `'a','b','c'`) to
+ *   its generated type name. `EnumProp` writes here on first sighting and
+ *   reads back the stable name on repeat sightings.
+ * - `mockedParams`: set of path-param names that need `$state` fallbacks in
+ *   the generated `MockedParams` class. Written by `ModuleClassBuilder` when
+ *   it sees path params.
+ */
+export declare class CodegenContext {
+    readonly enumTypes: Map<string, string>;
+    readonly mockedParams: Set<string>;
+}

package/dist/core/CodegenContext.js

@@ -0,0 +1,15 @@
+/**
+ * Per-run codegen state. Replaces module-level mutable globals so two
+ * concurrent Reflector instances don't corrupt each other's output.
+ *
+ * - `enumTypes`: maps the joined enum literal string (e.g. `'a','b','c'`) to
+ *   its generated type name. `EnumProp` writes here on first sighting and
+ *   reads back the stable name on repeat sightings.
+ * - `mockedParams`: set of path-param names that need `$state` fallbacks in
+ *   the generated `MockedParams` class. Written by `ModuleClassBuilder` when
+ *   it sees path params.
+ */
+export class CodegenContext {
+    enumTypes = new Map();
+    mockedParams = new Set();
+}

package/dist/core/Reflector.d.ts

@@ -0,0 +1,25 @@
+import { Module } from "./module/Module.js";
+import { Schema } from "./schema/Schema.js";
+import type { ComponentsObject, PathsObject } from "../types/open-api-spec.interface.js";
+import type { FieldConfigs, TypeImports } from "../types/types.js";
+import type { ReflectorConfig } from "./config/ReflectorConfig.js";
+export declare class Reflector {
+    readonly schemas: Schema[];
+    readonly modules: Module[];
+    readonly propertiesNames: Set<string>;
+    private readonly registry;
+    private readonly typeImports;
+    private readonly config;
+    private readonly context;
+    private readonly srcDir;
+    constructor(params: {
+        components: ComponentsObject;
+        paths: PathsObject;
+        fieldConfigs: FieldConfigs;
+        typeImports: TypeImports;
+        apiImport: string;
+        experimentalFeatures?: boolean;
+        config?: Partial<ReflectorConfig>;
+    });
+    build(): Promise<{}>;
+}

package/dist/core/Reflector.js

@@ -0,0 +1,66 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as process from "node:process";
+import { Source } from "../file.js";
+import { Module } from "./module/Module.js";
+import { Schema } from "./schema/Schema.js";
+import { CodegenContext } from "./CodegenContext.js";
+import { InlineSchemaPromoter } from "./openapi/InlineSchemaPromoter.js";
+import { SchemaRegistry } from "./schema/SchemaRegistry.js";
+import { ModuleFactory } from "./module/ModuleFactory.js";
+import { ModuleSchemaFileBuilder } from "./module/ModuleSchemaFileBuilder.js";
+import { RuntimeFilesEmitter } from "./emit/RuntimeFilesEmitter.js";
+import { resolveReflectorConfig } from "./config/ReflectorConfig.js";
+import { generatedDir } from "../vars.global.js";
+export class Reflector {
+    schemas;
+    modules;
+    propertiesNames;
+    registry;
+    typeImports;
+    config;
+    context = new CodegenContext();
+    srcDir = path.resolve(process.cwd(), `${generatedDir}/controllers`);
+    constructor(params) {
+        const { components, paths, fieldConfigs, typeImports, apiImport, experimentalFeatures, config } = params;
+        this.typeImports = typeImports;
+        this.config = resolveReflectorConfig(config);
+        InlineSchemaPromoter.promote(components, paths);
+        this.modules = ModuleFactory.build({
+            paths,
+            apiImport,
+            experimentalFeatures: experimentalFeatures ?? false,
+            context: this.context,
+            config: this.config,
+        });
+        this.registry = new SchemaRegistry({ components, fieldConfigs, context: this.context });
+        this.schemas = this.registry.schemas;
+        this.propertiesNames = this.registry.propertiesNames;
+    }
+    async build() {
+        fs.rmSync(this.srcDir, { recursive: true, force: true });
+        fs.mkdirSync(this.srcDir, { recursive: true });
+        const moduleSchemaFiles = [];
+        for (const module of this.modules) {
+            if (module.methods.length === 0 || module.schemaClassNames.length === 0)
+                continue;
+            const neededSchemas = this.registry.resolveTransitiveDeps(module.schemaClassNames);
+            if (neededSchemas.length === 0)
+                continue;
+            const data = ModuleSchemaFileBuilder.build({ schemas: neededSchemas, typeImports: this.typeImports, config: this.config });
+            const schemaFilePath = module.src.path.replace(".module.svelte.ts", ".schema.svelte.ts");
+            moduleSchemaFiles.push(new Source({ path: schemaFilePath, data }));
+        }
+        const runtimeFiles = RuntimeFilesEmitter.build({
+            propertiesNames: this.propertiesNames,
+            context: this.context,
+        });
+        await Promise.all([
+            ...moduleSchemaFiles.map((f) => f.save()),
+            ...runtimeFiles.map((f) => f.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/core/api/ApiClassBuilder.d.ts

@@ -1,4 +1,4 @@
-import type { Method } from "../../method.js";
+import type { Method } from "../method/Method.js";
 import type { ModuleImports } from "../module/ModuleImports.js";
 import type { ModuleClassBuilder } from "../module/ModuleClassBuilder.js";
 export interface ApiEndpointBlock {
@@ -9,6 +9,7 @@ export interface ApiEndpointBlock {
 export declare class ApiClassBuilder {
     private readonly imports;
     private readonly methodGenerator;
+    private readonly callStrategy;
     private readonly paramProcessor;
     constructor(params: {
         imports: ModuleImports;
@@ -19,5 +20,4 @@ export declare class ApiClassBuilder {
     }): ApiEndpointBlock | null;
     private buildStateProperties;
     private buildResetLines;
-    private shouldSkipMethod;
 }

package/dist/core/api/ApiClassBuilder.js

@@ -1,9 +1,12 @@
-import { capitalizeFirstLetter, createDangerMessage, treatByUppercase } from "../../helpers/helpers.js";
-import { ApiMethodGenerator } from "./ApiMethodGenerator.js";
+import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+import { MethodValidator } from "../method/MethodValidator.js";
+import { CallMethodGenerator } from "../generators/CallMethodGenerator.js";
+import { ApiCallStrategy } from "../generators/ApiCallStrategy.js";
 import { ApiParamProcessor } from "./ApiParamProcessor.js";
 export class ApiClassBuilder {
     imports;
-    methodGenerator = new ApiMethodGenerator();
+    methodGenerator = new CallMethodGenerator();
+    callStrategy = new ApiCallStrategy();
     paramProcessor;
     constructor(params) {
         this.imports = params.imports;
@@ -14,7 +17,7 @@ export class ApiClassBuilder {
     }
     build(params) {
         const { method } = params;
-        if (this.shouldSkipMethod(method))
+        if (MethodValidator.isSkippable(method))
             return null;
         const { request, headers, cookies, paths, querys } = method;
         const { bodyType, responseType, attributeType, isPrimitiveResponse } = request;
@@ -29,7 +32,7 @@ export class ApiClassBuilder {
         // Build state properties
         const stateProps = this.buildStateProperties(method);
         // Build the call method
-        const callMethod = this.methodGenerator.generate(method);
+        const callMethod = this.methodGenerator.generate(method, this.callStrategy);
         // Build reset method
         const resetLines = this.buildResetLines(method, processedParams.paramReset);
         // Collect schema entries
@@ -100,26 +103,4 @@ export class ApiClassBuilder {
         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/config/ReflectorConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Isolates the consumer's framework conventions (import aliases, env flag
+ * name) from the codegen core. Defaults reproduce the previous hard-coded
+ * SvelteKit paths so existing consumers don't need to change anything.
+ */
+export interface ReflectorConfig {
+    /** Alias that resolves to the generated reflector folder (e.g. `$reflector`). */
+    reflectorAlias: string;
+    /** Full import path to the validators/sanitizers module. */
+    validatorsImport: string;
+    /** Module path for the environment flag (e.g. `$env/static/public`). */
+    environmentImport: string;
+    /** Name of the exported environment flag — values other than `DEV` are treated as prod. */
+    environmentFlag: string;
+}
+export declare const DEFAULT_REFLECTOR_CONFIG: ReflectorConfig;
+export declare function resolveReflectorConfig(partial?: Partial<ReflectorConfig>): ReflectorConfig;

package/dist/core/config/ReflectorConfig.js

@@ -0,0 +1,9 @@
+export const DEFAULT_REFLECTOR_CONFIG = {
+    reflectorAlias: "$reflector",
+    validatorsImport: "$lib/sanitizers/validateFormats",
+    environmentImport: "$env/static/public",
+    environmentFlag: "PUBLIC_ENVIRONMENT",
+};
+export function resolveReflectorConfig(partial) {
+    return { ...DEFAULT_REFLECTOR_CONFIG, ...(partial ?? {}) };
+}

package/dist/core/emit/RuntimeFilesEmitter.d.ts

@@ -0,0 +1,13 @@
+import { Source } from "../../file.js";
+import type { CodegenContext } from "../CodegenContext.js";
+/**
+ * Emits the shared runtime-support files that sit alongside the generated
+ * module files: the reflector runtime template, the FIELD_NAMES list, the
+ * enum unions, and the MockedParams class used by path-param stubs.
+ */
+export declare class RuntimeFilesEmitter {
+    static build(params: {
+        propertiesNames: Set<string>;
+        context: CodegenContext;
+    }): Source[];
+}

package/dist/core/emit/RuntimeFilesEmitter.js

@@ -0,0 +1,55 @@
+import * as path from "node:path";
+import * as process from "node:process";
+import { Source } from "../../file.js";
+import { loadReflectorTemplate } from "../../loadTemplate.js";
+import { generatedDir } from "../../vars.global.js";
+import { dedent } from "../../helpers/codegen.js";
+function generated(relPath) {
+    return path.resolve(process.cwd(), `${generatedDir}/${relPath}`);
+}
+/**
+ * Emits the shared runtime-support files that sit alongside the generated
+ * module files: the reflector runtime template, the FIELD_NAMES list, the
+ * enum unions, and the MockedParams class used by path-param stubs.
+ */
+export class RuntimeFilesEmitter {
+    static build(params) {
+        const { propertiesNames, context } = params;
+        const typesSrc = new Source({
+            path: generated("reflector.svelte.ts"),
+            data: loadReflectorTemplate(),
+        });
+        const fieldLiterals = Array.from(propertiesNames).map((p) => `'${p}'`);
+        const fieldsFile = new Source({
+            path: generated("fields.ts"),
+            data: dedent `
+        export const FIELD_NAMES = [
+          ${fieldLiterals}
+        ] as const;
+        export type FieldName = (typeof FIELD_NAMES)[number]
+      `,
+        });
+        const enumss = Array.from(context.enumTypes)
+            .map(([types, key]) => `export const ${key} = [ ${types} ] as const; export type ${key} = typeof ${key}[number] `)
+            .join(";");
+        const enumFile = new Source({
+            path: generated("enums.ts"),
+            data: enumss,
+        });
+        const mockedFields = Array.from(context.mockedParams)
+            .map((paramName) => `${paramName} = $state<string | null>(null)`)
+            .join(";");
+        const mockedFile = new Source({
+            path: generated("mocked-params.svelte.ts"),
+            data: dedent `
+        class MockedParams {
+          ${mockedFields}
+        }
+
+        const mockedParams = new MockedParams()
+        export default mockedParams
+      `,
+        });
+        return [typesSrc, fieldsFile, enumFile, mockedFile];
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
+export declare class ApiCallStrategy implements CallStrategy {
+    listStateAccess(_method: CallMethodInput): string;
+    buildSignature(method: CallMethodInput): string;
+    entityStateAccess(_method: CallMethodInput): string;
+    formStateAccess(_method: CallMethodInput): string;
+    private buildParamsType;
+    private buildPathsInfo;
+}

package/dist/core/generators/ApiCallStrategy.js

@@ -0,0 +1,34 @@
+export class ApiCallStrategy {
+    listStateAccess(_method) {
+        return "this.data";
+    }
+    buildSignature(method) {
+        const paramsType = this.buildParamsType(method);
+        return `async call(params?: ${paramsType})`;
+    }
+    entityStateAccess(_method) {
+        return "this.data";
+    }
+    formStateAccess(_method) {
+        return "this.form";
+    }
+    buildParamsType(method) {
+        const responseType = method.responseTypeInterface;
+        const pathsBlock = this.buildPathsInfo(method);
+        if (pathsBlock) {
+            return `ApiCallParams<${responseType}, ${pathsBlock}>`;
+        }
+        return `ApiCallParams<${responseType}>`;
+    }
+    buildPathsInfo(method) {
+        const paths = method.analyzers.props.paths;
+        if (paths.length === 0)
+            return undefined;
+        return `{ ${paths
+            .map((p) => {
+            const type = p.rawType ?? p.type;
+            return `${p.name}: ${type}`;
+        })
+            .join("; ")} }`;
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
+export declare class CallMethodGenerator {
+    private readonly endpointBuilder;
+    generate(method: CallMethodInput, strategy: CallStrategy): string;
+    private buildProps;
+    private buildApiCall;
+    private buildListCall;
+    private buildEntityCall;
+    private buildFormCall;
+    private buildDeleteCall;
+    private buildMethodReturn;
+    private joinNames;
+    private buildQuerys;
+}

package/dist/core/generators/CallMethodGenerator.js

@@ -0,0 +1,154 @@
+import { MethodEndpointBuilder } from "../method/MethodEndpointBuilder.js";
+export class CallMethodGenerator {
+    endpointBuilder = new MethodEndpointBuilder();
+    generate(method, strategy) {
+        const description = `/** ${method.description ?? ""} */`;
+        const endpoint = this.endpointBuilder.build(method.endpoint, method.analyzers.props.paths);
+        const props = this.buildProps(method);
+        const { inside, outside } = this.buildApiCall(method, strategy);
+        const methodReturn = this.buildMethodReturn(method, strategy);
+        const signature = strategy.buildSignature(method);
+        return `
+      ${description}
+      ${signature} {
+
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
+        ${props}
+        const endpoint = ${endpoint}
+
+        ${outside}
+
+        try {
+          ${inside}
+          await onSuccess?.(response);
+
+          return ${methodReturn};
+        } 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.analyzers.props;
+        const lines = [];
+        if (querys.length > 0) {
+            lines.push(`const { ${this.joinNames(querys)} } = this.querys.bundle()`);
+        }
+        if (paths.length > 0) {
+            lines.push(`const { ${this.joinNames(paths)} } = params?.paths ?? this.paths`);
+        }
+        if (cookies.length > 0) {
+            lines.push(`const cookies = this.cookies`);
+        }
+        return lines.join("\n");
+    }
+    buildApiCall(method, strategy) {
+        const { attributeType, apiType, responseType, bodyType, hasEnumResponse } = method.analyzers.request;
+        const responseTypeStr = hasEnumResponse && responseType ? responseType : method.responseTypeInterface;
+        if (attributeType === "list") {
+            return this.buildListCall(method, responseTypeStr, strategy);
+        }
+        if (attributeType === "entity") {
+            return this.buildEntityCall(method, responseTypeStr, strategy);
+        }
+        if (apiType === "post" || apiType === "put" || apiType === "patch") {
+            return this.buildFormCall(method, responseTypeStr, bodyType, strategy);
+        }
+        if (apiType === "delete") {
+            return this.buildDeleteCall(method, responseTypeStr, bodyType, strategy);
+        }
+        return { inside: "", outside: "" };
+    }
+    buildListCall(method, responseType, strategy) {
+        const querys = this.joinNames(method.analyzers.props.querys);
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        queryData: { ${querys} }
+      })
+      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
+      this.totalPages = response.totalPages;
+    `;
+        return { inside, outside: "" };
+    }
+    buildEntityCall(method, responseType, strategy) {
+        const rType = method.analyzers.request.responseType;
+        const isPrimitive = method.analyzers.request.isPrimitiveResponse;
+        const querys = this.buildQuerys(method.analyzers.props.querys);
+        const assignment = rType && !isPrimitive
+            ? `${strategy.entityStateAccess(method)} = new ${rType}({ data: response })`
+            : "";
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        ${querys}
+      })
+
+      ${assignment}
+    `;
+        return { inside, outside: "" };
+    }
+    buildFormCall(method, responseType, bodyType, strategy) {
+        const { apiType } = method.analyzers.request;
+        const hasHeaders = method.analyzers.props.headers.length > 0;
+        const hasData = !!bodyType;
+        const outside = [];
+        if (hasData) {
+            outside.push(`const data = ${strategy.formStateAccess(method)}.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(method, responseType, bodyType, strategy) {
+        const hasData = !!bodyType;
+        const outside = hasData ? `const data = ${strategy.formStateAccess(method)}.bundle()` : "";
+        const inside = `
+      const response = await api.delete<${responseType}, unknown>({
+        endpoint,
+        ${hasData ? "data," : ""}
+      })
+    `;
+        return { inside, outside };
+    }
+    buildMethodReturn(method, strategy) {
+        const { attributeType, responseType, hasEnumResponse, isPrimitiveResponse } = method.analyzers.request;
+        if (attributeType === "list")
+            return strategy.listStateAccess(method);
+        if (!responseType)
+            return "null";
+        if (hasEnumResponse)
+            return "response.data";
+        if (isPrimitiveResponse)
+            return "response";
+        return `new ${responseType}({ data: response })`;
+    }
+    joinNames(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/generators/CallStrategy.d.ts

@@ -0,0 +1,30 @@
+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;
+    analyzers: MethodAnalyzers;
+}
+/**
+ * Differences between the two flavors of generated `call` method
+ * (per-endpoint Api class vs Module `_methodName` protected method).
+ */
+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` / `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 */
+    formStateAccess(method: CallMethodInput): string;
+}

package/dist/core/generators/CallStrategy.js

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

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

@@ -0,0 +1,9 @@
+import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
+export declare class ModuleCallStrategy implements CallStrategy {
+    listStateAccess(method: CallMethodInput): string;
+    buildSignature(method: CallMethodInput): string;
+    entityStateAccess(method: CallMethodInput): string;
+    formStateAccess(method: CallMethodInput): string;
+    private buildParamsType;
+    private buildPathsBlock;
+}

package/dist/core/generators/ModuleCallStrategy.js

@@ -0,0 +1,43 @@
+import { treatByUppercase } from "../../helpers/helpers.js";
+export class ModuleCallStrategy {
+    listStateAccess(method) {
+        return `this.list${method.stateSuffix}`;
+    }
+    buildSignature(method) {
+        const paramsType = this.buildParamsType(method);
+        return `protected async _${method.name}(params?: ${paramsType})`;
+    }
+    entityStateAccess(method) {
+        const rType = method.analyzers.request.responseType ?? "";
+        return `this.${treatByUppercase(rType)}`;
+    }
+    formStateAccess(method) {
+        return `this.forms.${method.name}`;
+    }
+    buildParamsType(method) {
+        const behaviorType = `Behavior<${method.responseTypeInterface}, ApiErrorResponse>`;
+        const pathsBlock = this.buildPathsBlock(method);
+        if (pathsBlock) {
+            return `{
+        behavior?: ${behaviorType};${pathsBlock}
+      }`;
+        }
+        return `{
+      behavior?: ${behaviorType};
+    }`;
+    }
+    buildPathsBlock(method) {
+        const paths = method.analyzers.props.paths;
+        if (paths.length === 0)
+            return undefined;
+        return `
+    paths?: {
+      ${paths
+            .map((p) => {
+            const type = p.rawType ?? p.type;
+            return `${p.name}: ${type}`;
+        })
+            .join("\n")}
+    }`;
+    }
+}

package/dist/core/index.d.ts

@@ -6,8 +6,11 @@ export { ModuleConstructorBuilder, type Form } from "./module/ModuleConstructorB
 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 { CallMethodGenerator } from "./generators/CallMethodGenerator.js";
+export { ApiCallStrategy } from "./generators/ApiCallStrategy.js";
+export { ModuleCallStrategy } from "./generators/ModuleCallStrategy.js";
+export type { CallStrategy } from "./generators/CallStrategy.js";
 export { Method } from "./method/Method.js";
 export { MethodBuilder } from "./method/MethodBuilder.js";
 export { MethodApiTypeAnalyzer } from "./method/MethodApiTypeAnalyzer.js";

package/dist/core/index.js

@@ -8,8 +8,11 @@ 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";
+// Shared generators
+export { CallMethodGenerator } from "./generators/CallMethodGenerator.js";
+export { ApiCallStrategy } from "./generators/ApiCallStrategy.js";
+export { ModuleCallStrategy } from "./generators/ModuleCallStrategy.js";
 // Method-related exports
 export { Method } from "./method/Method.js";
 export { MethodBuilder } from "./method/MethodBuilder.js";