@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

package/dist/esm-node/utils/effectClientGenerator.mjs

@@ -1,8 +1,9 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { DEFAULT_OPERATION_VERSION, createOperationEntries, createOperationSchemaHash } from "@modern-js/bff-core";
+import { deriveOperationVersion } from "@modern-js/bff-core";
 import { compatibleRequire, findExists, fs, logger } from "@modern-js/utils";
 import path from "path";
+import { collectEffectEndpoints, createEffectEndpointContractHash, ensureLeadingSlash, extractHttpApiFromModule, normalizeEffectPrefix } from "../runtime/effect/endpoint-contracts.mjs";
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -14,18 +15,11 @@ const JS_OR_TS_EXTS = [
     '.cts'
 ];
 const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
-const DEFAULT_DATA_PLATFORM_IMPORT = '@modern-js/plugin-bff/data-platform';
+const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
 let httpApiRuntimePromise;
 function isRecord(value) {
     return 'object' == typeof value && null !== value;
 }
-function ensureLeadingSlash(pathname) {
-    return pathname.startsWith('/') ? pathname : `/${pathname}`;
-}
-function normalizePrefix(prefix) {
-    if ('/' === prefix) return '';
-    return ensureLeadingSlash(prefix || '/api');
-}
 function isAbsoluteUrl(value) {
     try {
         new URL(value);
@@ -37,32 +31,22 @@ function isAbsoluteUrl(value) {
 function resolveBatchEndpoint(prefix, endpoint) {
     const value = endpoint || '/_data/batch';
     if (isAbsoluteUrl(value)) return value;
-    const normalizedPrefix = normalizePrefix(prefix);
+    const normalizedPrefix = normalizeEffectPrefix(prefix);
     const normalizedEndpoint = ensureLeadingSlash(value);
     if (!normalizedPrefix) return normalizedEndpoint;
     if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
     return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
 }
-function getRoutePath(prefix, endpointPath) {
-    const normalizedPrefix = normalizePrefix(prefix);
-    const normalizedEndpointPath = ensureLeadingSlash(endpointPath);
-    const finalEndpointPath = '/' === normalizedEndpointPath ? '' : endpointPath;
-    if (!normalizedPrefix && !finalEndpointPath) return '/';
-    return `${normalizedPrefix}${finalEndpointPath || ''}`;
-}
-function toSafeIdentifier(name) {
-    const sanitized = name.replace(/[^a-zA-Z0-9_$]/g, '_');
-    if (!sanitized) return '_';
-    if (/^[0-9]/.test(sanitized)) return `_${sanitized}`;
-    return sanitized;
-}
-function getPackageName(appDir) {
+function getPackageInfo(appDir) {
     try {
         const packageJsonPath = path.resolve(appDir, './package.json');
         const packageJson = fs.readJSONSync(packageJsonPath);
-        return packageJson.name;
+        return {
+            name: packageJson.name,
+            version: packageJson.version
+        };
     } catch  {
-        return;
+        return {};
     }
 }
 async function getHttpApiRuntime() {
@@ -85,472 +69,66 @@ async function getHttpApiRuntime() {
     })();
     return httpApiRuntimePromise;
 }
-function resolveApiId(api) {
-    const fallback = 'EffectHttpApi';
-    const maybeApi = api;
-    if ('identifier' in maybeApi && 'string' == typeof maybeApi.identifier && maybeApi.identifier) return maybeApi.identifier;
-    return fallback;
-}
-function collectEffectEndpoints(httpApiRuntime, api, prefix) {
-    const endpoints = [];
-    const apiId = resolveApiId(api);
-    httpApiRuntime.reflect(api, {
-        onGroup: ()=>{},
-        onEndpoint: ({ group, endpoint })=>{
-            endpoints.push({
-                apiId,
-                groupName: String(group.identifier),
-                endpointName: String(endpoint.name),
-                method: String(endpoint.method).toUpperCase(),
-                routePath: getRoutePath(prefix, String(endpoint.path))
-            });
-        }
-    });
-    return endpoints.sort((a, b)=>{
-        if (a.groupName === b.groupName) return a.endpointName.localeCompare(b.endpointName);
-        return a.groupName.localeCompare(b.groupName);
-    });
-}
 async function loadEffectApi(resourcePath) {
     const httpApiRuntime = await getHttpApiRuntime();
     const mod = await compatibleRequire(resourcePath, false);
-    if (isRecord(mod) && httpApiRuntime.isHttpApi(mod.api)) return mod.api;
-    if (isRecord(mod) && isRecord(mod.default) && httpApiRuntime.isHttpApi(mod.default.api)) return mod.default.api;
-    if (isRecord(mod) && 'function' == typeof mod.default && 0 === mod.default.length) {
-        const output = await mod.default();
-        if (isRecord(output) && httpApiRuntime.isHttpApi(output.api)) return output.api;
-    }
-    return null;
+    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
 }
 function renderEffectClientCode(endpoints, options) {
-    const senderDeclarations = [];
-    const operationDeclarations = [];
-    const callerDeclarations = [];
-    const groupedCallers = {};
-    const groupedOperations = {};
     const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
-    const dataPlatformImport = DEFAULT_DATA_PLATFORM_IMPORT;
     const httpMethodDecider = options.httpMethodDecider || 'functionName';
-    const portCode = 'server' === options.target ? `process.env.PORT || ${String(options.port)}` : String(options.port);
-    const packageName = getPackageName(options.appDir);
+    const packageInfo = getPackageInfo(options.appDir);
+    const packageName = packageInfo.name;
     const dataPlatformAppNamespace = packageName || 'unknown-app';
     const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
     const normalizedRequestId = requestId || 'default';
-    const operationVersion = 'number' == typeof DEFAULT_OPERATION_VERSION ? DEFAULT_OPERATION_VERSION : 1;
-    const schemaHash = createOperationSchemaHash(createOperationEntries(endpoints.map((endpoint)=>({
-            name: endpoint.endpointName,
-            httpMethod: endpoint.method,
-            routePath: endpoint.routePath
-        }))), normalizedRequestId);
+    const operationVersion = deriveOperationVersion(packageInfo.version);
     const batchConfig = options.dataPlatformBatch;
     const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
-    const batchConfigCode = JSON.stringify({
-        enabled: batchConfig?.enabled ?? true,
-        endpoint: batchEndpoint,
-        flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
-        maxBatchSize: batchConfig?.maxBatchSize ?? 16,
-        maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
-        requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-        allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
-            'GET'
-        ]
-    });
-    endpoints.forEach((endpoint, index)=>{
-        const senderVar = `__sender_${toSafeIdentifier(endpoint.groupName)}_${toSafeIdentifier(endpoint.endpointName)}_${index}`;
-        const callVar = `__call_${toSafeIdentifier(endpoint.groupName)}_${toSafeIdentifier(endpoint.endpointName)}_${index}`;
-        const operationVar = `__operation_${toSafeIdentifier(endpoint.groupName)}_${toSafeIdentifier(endpoint.endpointName)}_${index}`;
-        const operationId = `${endpoint.method}:${endpoint.routePath}`;
-        const operationContextCode = JSON.stringify({
-            operationId,
-            routePath: endpoint.routePath,
-            method: endpoint.method,
-            schemaHash,
-            operationVersion
-        });
-        const createRequestOptions = `{
-      path: ${JSON.stringify(endpoint.routePath)},
-      method: ${JSON.stringify(endpoint.method)},
-      port: ${portCode},
-      operationContext: ${operationContextCode},
-      httpMethodDecider: ${JSON.stringify(httpMethodDecider)}${requestId ? `, requestId: ${JSON.stringify(requestId)}` : ''}
-    }`.replace(/\n\s*/g, '');
-        senderDeclarations.push(`const ${senderVar} = createRequest(${createRequestOptions});`);
-        operationDeclarations.push(`const ${operationVar} = ${JSON.stringify({
-            appNamespace: dataPlatformAppNamespace,
-            apiId: endpoint.apiId,
-            group: endpoint.groupName,
-            endpoint: endpoint.endpointName,
-            operationId,
-            routePath: endpoint.routePath,
-            method: endpoint.method,
-            operationVersion,
-            schemaHash,
-            version: operationVersion
-        })};`);
-        callerDeclarations.push(`const ${callVar} = (request = {}) => ${senderVar}(__prepareEffectRequest(${JSON.stringify(endpoint.method)}, ${JSON.stringify(endpoint.routePath)}, ${operationVar}, request));`);
-        groupedCallers[endpoint.groupName] ??= [];
-        groupedCallers[endpoint.groupName].push({
-            endpointName: endpoint.endpointName,
-            callVar
-        });
-        groupedOperations[endpoint.groupName] ??= [];
-        groupedOperations[endpoint.groupName].push({
-            endpointName: endpoint.endpointName,
-            operationVar
-        });
-    });
-    const groupObjectEntries = Object.entries(groupedCallers).map(([groupName, groupCallers])=>{
-        const endpointEntries = groupCallers.map((caller)=>`${JSON.stringify(caller.endpointName)}: ${caller.callVar}`).join(', ');
-        return `${JSON.stringify(groupName)}: { ${endpointEntries} }`;
-    });
-    const clientObject = groupObjectEntries.length ? `{
-  ${groupObjectEntries.join(',\n  ')}
-}` : '{}';
-    const operationManifestEntries = Object.entries(groupedOperations).map(([groupName, groupOperations])=>{
-        const endpointEntries = groupOperations.map((operation)=>`${JSON.stringify(operation.endpointName)}: ${operation.operationVar}`).join(', ');
-        return `${JSON.stringify(groupName)}: { ${endpointEntries} }`;
-    });
-    const operationManifestObject = operationManifestEntries.length ? `{
-  ${operationManifestEntries.join(',\n  ')}
-}` : '{}';
+    const manifest = {
+        endpoints: endpoints.map((endpoint)=>({
+                apiId: endpoint.apiId,
+                group: endpoint.groupName,
+                endpoint: endpoint.endpointName,
+                method: endpoint.method,
+                routePath: endpoint.routePath,
+                schemaHash: createEffectEndpointContractHash(endpoint, normalizedRequestId),
+                operationVersion
+            }))
+    };
+    const config = {
+        appNamespace: dataPlatformAppNamespace,
+        ...requestId ? {
+            requestId
+        } : {},
+        port: options.port,
+        useEnvPort: 'server' === options.target,
+        defaultOrigin: `http://localhost:${String(options.port)}`,
+        httpMethodDecider,
+        batch: {
+            enabled: batchConfig?.enabled ?? true,
+            endpoint: batchEndpoint,
+            flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
+            maxBatchSize: batchConfig?.maxBatchSize ?? 16,
+            maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
+            requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
+            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+                'GET'
+            ]
+        }
+    };
     return `import * as __requestRuntime from ${JSON.stringify(requestCreator)};
-import {
-  createDataBatchTransport,
-  DEFAULT_DATA_BATCH_HEADER,
-  DEFAULT_DATA_ENVELOPE_HEADER,
-  createRequestEnvelope,
-  encodeRequestEnvelopeHeader,
-} from ${JSON.stringify(dataPlatformImport)};
-
-const createRequest = __requestRuntime.createRequest;
-const __configureRequest =
-  typeof __requestRuntime.configure === 'function'
-    ? __requestRuntime.configure
-    : undefined;
-const __createRequestContextHeaders =
-  typeof __requestRuntime.createRequestContextHeaders === 'function'
-    ? __requestRuntime.createRequestContextHeaders
-    : undefined;
-
-const __METHODS_WITHOUT_BODY = new Set(['GET', 'DELETE', 'HEAD', 'OPTIONS']);
-const __DATA_REQUEST_MODES = new Set(['cache-first', 'stale-while-revalidate', 'network-only']);
-const __DATA_MUTATION_MODES = new Set(['optimistic', 'pessimistic', 'fire-and-forget']);
-const __DEFAULT_APP_NAMESPACE = ${JSON.stringify(dataPlatformAppNamespace)};
-const __DEFAULT_ORIGIN = 'http://localhost:${String(options.port)}';
-const __DEFAULT_BATCH_CONFIG = ${batchConfigCode};
-const __REQUEST_ID = ${requestId ? JSON.stringify(requestId) : 'undefined'};
-const __RUNTIME_FETCH =
-  typeof fetch === 'function' ? fetch.bind(globalThis) : undefined;
-
-if (__REQUEST_ID && __configureRequest) {
-  const __configurePayload = {
-    requestId: __REQUEST_ID,
-    requireEnvelope: true,
-    identityBinding: {
-      enabled: true,
-      strict: true,
-    },
-    operationContract: {
-      enabled: true,
-      strict: true,
-      requireSchemaHash: true,
-      requireOperationVersion: true,
-    },
-    setDomain: () => {
-      if (
-        typeof window !== 'undefined' &&
-        window.location &&
-        typeof window.location.origin === 'string' &&
-        window.location.origin
-      ) {
-        return window.location.origin;
-      }
-
-      if (
-        typeof globalThis !== 'undefined' &&
-        globalThis.location &&
-        typeof globalThis.location.origin === 'string' &&
-        globalThis.location.origin
-      ) {
-        return globalThis.location.origin;
-      }
-
-      return __DEFAULT_ORIGIN;
-    },
-  };
-
-  if (__DEFAULT_BATCH_CONFIG.enabled !== false && __RUNTIME_FETCH) {
-    __configurePayload.request = createDataBatchTransport({
-      fetch: __RUNTIME_FETCH,
-      endpoint: __DEFAULT_BATCH_CONFIG.endpoint,
-      flushIntervalMs: __DEFAULT_BATCH_CONFIG.flushIntervalMs,
-      maxBatchSize: __DEFAULT_BATCH_CONFIG.maxBatchSize,
-      maxBatchBytes: __DEFAULT_BATCH_CONFIG.maxBatchBytes,
-      requestTimeoutMs: __DEFAULT_BATCH_CONFIG.requestTimeoutMs,
-      allowedMethods: __DEFAULT_BATCH_CONFIG.allowedMethods,
-    });
-  }
-
-  __configureRequest(__configurePayload);
-}
-
-const __isRecord = value => typeof value === 'object' && value !== null;
-const __stringOrUndefined = value =>
-  typeof value === 'string' && value.length > 0 ? value : undefined;
-const __isDataRequestMode = value =>
-  typeof value === 'string' && __DATA_REQUEST_MODES.has(value);
-const __isDataMutationMode = value =>
-  typeof value === 'string' && __DATA_MUTATION_MODES.has(value);
-const __normalizeOrigin = value => {
-  if (typeof value !== 'string' || value.length === 0) {
-    return undefined;
-  }
-  try {
-    return new URL(value).origin;
-  } catch {
-    return undefined;
-  }
-};
-
-const __normalizeRequest = (method, request = {}) => {
-  if (!__isRecord(request)) {
-    return {};
-  }
-
-  const payload = { ...request };
-
-  if (__isRecord(request.path) && !__isRecord(payload.params)) {
-    payload.params = request.path;
-  }
-
-  if (__isRecord(request.urlParams) && !__isRecord(payload.query)) {
-    payload.query = request.urlParams;
-  }
-
-  if (__isRecord(request.headers) && !__isRecord(payload.headers)) {
-    payload.headers = request.headers;
-  }
-
-  if ('payload' in request && request.payload !== undefined) {
-    if (request.payload instanceof FormData && !('formData' in payload)) {
-      payload.formData = request.payload;
-    } else if (__METHODS_WITHOUT_BODY.has(method)) {
-      if (__isRecord(request.payload)) {
-        payload.query = __isRecord(payload.query)
-          ? { ...payload.query, ...request.payload }
-          : request.payload;
-      } else if (!('body' in payload)) {
-        payload.body = request.payload;
-      }
-    } else if (__isRecord(request.payload) && !('data' in payload)) {
-      payload.data = request.payload;
-    } else if (!('body' in payload)) {
-      payload.body = request.payload;
-    }
-  }
-
-  return payload;
-};
-
-const __resolveOrigin = () => {
-  if (
-    typeof window !== 'undefined' &&
-    window.location &&
-    typeof window.location.origin === 'string' &&
-    window.location.origin
-  ) {
-    return window.location.origin;
-  }
+import { createGeneratedEffectClient } from ${JSON.stringify(EFFECT_CLIENT_RUNTIME_IMPORT)};
 
-  if (
-    typeof globalThis !== 'undefined' &&
-    globalThis.location &&
-    typeof globalThis.location.origin === 'string' &&
-    globalThis.location.origin
-  ) {
-    return globalThis.location.origin;
-  }
+const __manifest = ${JSON.stringify(manifest, null, 2)};
 
-  return __DEFAULT_ORIGIN;
-};
-
-const __resolveTargetOrigin = dataPlatform => {
-  const explicitTargetOrigin =
-    __stringOrUndefined(dataPlatform.targetOrigin) ||
-    __stringOrUndefined(dataPlatform.endpointOrigin);
-  if (explicitTargetOrigin) {
-    return explicitTargetOrigin;
-  }
-  return __DEFAULT_ORIGIN;
-};
-
-const __shouldAttachEnvelopeHeader = dataPlatform => {
-  if (dataPlatform.allowCrossOriginEnvelope === true) {
-    return true;
-  }
-  const currentOrigin = __normalizeOrigin(__resolveOrigin());
-  const targetOrigin = __normalizeOrigin(__resolveTargetOrigin(dataPlatform));
-  if (!currentOrigin || !targetOrigin) {
-    return true;
-  }
-  return currentOrigin === targetOrigin;
-};
-
-const __toEnvelopeInput = normalizedRequest => {
-  if (!__isRecord(normalizedRequest)) {
-    return {};
-  }
-
-  const payload = {};
-  if (__isRecord(normalizedRequest.params)) {
-    payload.path = normalizedRequest.params;
-  }
-  if (__isRecord(normalizedRequest.query)) {
-    payload.query = normalizedRequest.query;
-  }
-  if ('data' in normalizedRequest && normalizedRequest.data !== undefined) {
-    payload.data = normalizedRequest.data;
-  }
-  if ('body' in normalizedRequest && normalizedRequest.body !== undefined) {
-    payload.body = normalizedRequest.body;
-  }
-  if (
-    typeof FormData !== 'undefined' &&
-    normalizedRequest.formData instanceof FormData
-  ) {
-    payload.formData = Array.from(normalizedRequest.formData.entries()).map(
-      ([key, value]) => [key, String(value)],
-    );
-  }
-  if (
-    typeof URLSearchParams !== 'undefined' &&
-    normalizedRequest.formUrlencoded instanceof URLSearchParams
-  ) {
-    payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
-  }
-  return payload;
-};
-
-const createEffectRequestContext = requestContext => {
-  if (!__isRecord(requestContext)) {
-    return {};
-  }
-
-  const headers = __createRequestContextHeaders
-    ? __createRequestContextHeaders(requestContext)
-    : {};
-
-  return {
-    ...requestContext,
-    headers,
-  };
-};
-
-const __applyRequestContext = (normalizedRequest, request = {}) => {
-  if (!__isRecord(request) || !__isRecord(request.requestContext)) {
-    return normalizedRequest;
-  }
-
-  const requestContext = createEffectRequestContext(request.requestContext);
-  const requestHeaders = __isRecord(requestContext.headers)
-    ? requestContext.headers
-    : {};
-
-  if (Object.keys(requestHeaders).length === 0) {
-    return normalizedRequest;
-  }
-
-  return {
-    ...normalizedRequest,
-    headers: {
-      ...requestHeaders,
-      ...(__isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}),
-    },
-  };
-};
-
-const __prepareEffectRequest = (method, routePath, operation, request = {}) => {
-  const normalizedRequest = __applyRequestContext(
-    __normalizeRequest(method, request),
-    request,
-  );
-  const dataPlatform = __isRecord(request) && __isRecord(request.dataPlatform)
-    ? request.dataPlatform
-    : {};
-  const strictEnvelope =
-    dataPlatform.requireEnvelope === true || dataPlatform.strict === true;
-
-  if (!strictEnvelope && !__shouldAttachEnvelopeHeader(dataPlatform)) {
-    return normalizedRequest;
-  }
+const __config = ${JSON.stringify(config, null, 2)};
 
-  try {
-    const namespace =
-      __stringOrUndefined(dataPlatform.appNamespace) || __DEFAULT_APP_NAMESPACE;
-    const origin = __stringOrUndefined(dataPlatform.origin) || __resolveOrigin();
-    const envelope = createRequestEnvelope({
-      operation: {
-        ...operation,
-        appNamespace: namespace,
-      },
-      scope: {
-        appNamespace: namespace,
-        origin,
-        tenantId: __stringOrUndefined(dataPlatform.tenantId),
-        userId: __stringOrUndefined(dataPlatform.userId),
-        sessionId: __stringOrUndefined(dataPlatform.sessionId),
-      },
-      requestInput: {
-        method,
-        routePath,
-        payload: __toEnvelopeInput(normalizedRequest),
-      },
-      requestMode: __isDataRequestMode(dataPlatform.requestMode)
-        ? dataPlatform.requestMode
-        : undefined,
-      mutationMode: __isDataMutationMode(dataPlatform.mutationMode)
-        ? dataPlatform.mutationMode
-        : undefined,
-      selectionPlan: __isRecord(dataPlatform.selectionPlan)
-        ? dataPlatform.selectionPlan
-        : undefined,
-      traceContext: __isRecord(dataPlatform.traceContext)
-        ? dataPlatform.traceContext
-        : undefined,
-      requireTraceContext: dataPlatform.requireTraceContext === true,
-    });
-
-    const headerName =
-      __stringOrUndefined(dataPlatform.envelopeHeader) ||
-      DEFAULT_DATA_ENVELOPE_HEADER;
-    const headers = __isRecord(normalizedRequest.headers)
-      ? { ...normalizedRequest.headers }
-      : {};
-
-    if (dataPlatform.batch === false) {
-      headers[DEFAULT_DATA_BATCH_HEADER] = 'off';
-    }
-
-    headers[headerName] = encodeRequestEnvelopeHeader(envelope);
-
-    return {
-      ...normalizedRequest,
-      headers,
-    };
-  } catch (error) {
-    if (strictEnvelope) {
-      throw error;
-    }
-    return normalizedRequest;
-  }
-};
+const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
 
-${senderDeclarations.join('\n')}
-${operationDeclarations.join('\n')}
-${callerDeclarations.join('\n')}
-
-const client = ${clientObject};
-const operationManifest = ${operationManifestObject};
+const client = __generated.client;
+const operationManifest = __generated.operationManifest;
+const createEffectRequestContext = __generated.createEffectRequestContext;
 const effectBffModule = {
   client,
   operationManifest,
@@ -561,7 +139,23 @@ export { client, createEffectRequestContext, operationManifest };
 export default effectBffModule;
 `;
 }
-function renderEffectClientDeclaration() {
+function renderClientShape(endpoints, valueType) {
+    if (0 === endpoints.length) return `Record<string, Record<string, ${valueType}>>`;
+    const groups = new Map();
+    for (const endpoint of endpoints){
+        const group = groups.get(endpoint.groupName) || [];
+        group.push(endpoint.endpointName);
+        groups.set(endpoint.groupName, group);
+    }
+    const groupEntries = [
+        ...groups.entries()
+    ].map(([groupName, names])=>{
+        const endpointEntries = names.map((name)=>`    ${JSON.stringify(name)}: ${valueType};`).join('\n');
+        return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
+    });
+    return `{\n${groupEntries.join('\n')}\n}`;
+}
+function renderEffectClientDeclaration(endpoints = []) {
     return `export type EffectClientOperation = (
   request?: unknown,
 ) => Promise<unknown>;
@@ -607,30 +201,40 @@ export type EffectRequestContext = {
   traceId?: string;
   spanId?: string;
 };
+export type GeneratedEffectClient = ${renderClientShape(endpoints, 'EffectClientOperation')};
+export type GeneratedEffectOperationManifest = ${renderClientShape(endpoints, "EffectOperationDescriptor")};
 
-export declare const client: EffectClient;
+export declare const client: GeneratedEffectClient;
 export declare const createEffectRequestContext: (
   requestContext: Record<string, unknown>,
 ) => EffectRequestContext;
-export declare const operationManifest: EffectOperationManifest;
+export declare const operationManifest: GeneratedEffectOperationManifest;
 declare const effectBffModule: {
-  client: EffectClient;
+  client: GeneratedEffectClient;
   createEffectRequestContext: typeof createEffectRequestContext;
-  operationManifest: EffectOperationManifest;
+  operationManifest: GeneratedEffectOperationManifest;
 };
 
 export default effectBffModule;
 `;
 }
-async function generateEffectClientCode(options) {
+async function generateEffectClient(options) {
     const api = await loadEffectApi(options.resourcePath);
     if (!api) {
         logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
         return null;
     }
     const httpApiRuntime = await getHttpApiRuntime();
-    const endpoints = collectEffectEndpoints(httpApiRuntime, api, options.prefix);
-    return renderEffectClientCode(endpoints, options);
+    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
+    return {
+        code: renderEffectClientCode(endpoints, options),
+        declaration: renderEffectClientDeclaration(endpoints),
+        endpoints
+    };
+}
+async function generateEffectClientCode(options) {
+    const artifacts = await generateEffectClient(options);
+    return artifacts ? artifacts.code : null;
 }
 function resolveEffectEntryFile(options) {
     const { appDir, apiDir, effectEntry } = options;
@@ -639,4 +243,4 @@ function resolveEffectEntryFile(options) {
     if (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
     return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
 }
-export { generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile };
+export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile };