@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/src/data-platform/batch/queue.ts

@@ -8,6 +8,7 @@ import type {
   DataTransportRequestInfo,
 } from '../types';
 import { DEFAULT_DATA_BATCH_HEADER } from '../types';
+import { normalizeBatchLimits } from './options';
 import { decodeBatchBody, isNullBodyStatus } from './protocol';
 import {
   createBatchId,
@@ -37,6 +38,9 @@ type NormalizedBatchTransportRequest = {
   endpoint: string;
   method: string;
   headers: Record<string, string>;
+  itemHeaders: Record<string, string>;
+  bucketKey: string;
+  itemPath: string;
   credentials: RequestCredentials;
   body: BodyInit | null;
   hasOpaqueSourceBody: boolean;
@@ -76,7 +80,6 @@ type QueuedBatchRequest = {
 
 type BatchBucket = {
   items: QueuedBatchRequest[];
-  bytes: number;
   batchId: string;
   sentAt: number;
   timer: ReturnType<typeof setTimeout> | null;
@@ -185,7 +188,6 @@ export class BatchBucketRegistry {
 
     const next: BatchBucket = {
       items: [],
-      bytes: 0,
       batchId: createBatchId(),
       sentAt: Date.now(),
       timer: null,
@@ -215,15 +217,9 @@ export function createBatchTransportQueue({
   bucketRegistry,
 }: CreateBatchTransportQueueOptions) {
   const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
-  const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
-  const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 64 * 1024);
+  const { maxBatchSize, maxBatchBytes, allowedMethods } =
+    normalizeBatchLimits(options);
   const requestTimeoutMs = options.requestTimeoutMs;
-  const allowedMethods = new Set(
-    (options.allowedMethods && options.allowedMethods.length > 0
-      ? options.allowedMethods
-      : ['GET']
-    ).map(method => method.toUpperCase()),
-  );
   const onEvent = options.onEvent;
 
   const buckets = bucketRegistry ?? new BatchBucketRegistry();
@@ -284,7 +280,6 @@ export function createBatchTransportQueue({
       return;
     }
     bucket.items.splice(index, 1);
-    bucket.bytes = measurePayload(bucket, bucket.items);
     if (bucket.items.length === 0 && bucket.timer) {
       clearTimeout(bucket.timer);
       bucket.timer = null;
@@ -307,15 +302,14 @@ export function createBatchTransportQueue({
     abortBatchIfUnused?.();
   };
 
-  const runSingle = (request: QueuedBatchRequest) => {
-    return runWithSignal(request.lifetime.signal, async () => {
+  const runSingle = (request: QueuedBatchRequest) =>
+    runWithSignal(request.lifetime.signal, async () => {
       const response = await baseFetch(
         request.requestInput,
         request.requestInit,
       );
       return parseResponseLikeCreateRequest(response);
     });
-  };
 
   const settleRequests = async (
     items: QueuedBatchRequest[],
@@ -348,11 +342,11 @@ export function createBatchTransportQueue({
     return runSingle(request);
   };
 
-  const settleAmbiguousBatchRequests = (
-    items: QueuedBatchRequest[],
-    reason: string,
-  ) =>
-    settleRequests(items, request => runAfterAmbiguousBatch(request, reason));
+  const finishFlush = (bucketKey: string, bucket: BatchBucket) => {
+    bucket.flushing = false;
+    if (bucket.items.length > 0 && !bucket.timer) void flushBucket(bucketKey);
+    buckets.releaseIfIdle(bucketKey, bucket);
+  };
 
   const flushBucket = async (bucketKey: string) => {
     const bucket = buckets.get(bucketKey);
@@ -380,7 +374,6 @@ export function createBatchTransportQueue({
       sentAt: bucket.sentAt,
     };
     bucket.items = [];
-    bucket.bytes = 0;
     rotatePayloadIdentity(bucket);
     const firstItem = items[0];
     if (!firstItem) {
@@ -397,17 +390,28 @@ export function createBatchTransportQueue({
         size: items.length,
         reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : undefined,
       });
-      await settleRequests(items, runSingle);
-      bucket.flushing = false;
-      if (bucket.items.length > 0 && !bucket.timer) {
-        void flushBucket(bucketKey);
+      try {
+        await settleRequests(items, runSingle);
+      } finally {
+        finishFlush(bucketKey, bucket);
       }
-      buckets.releaseIfIdle(bucketKey, bucket);
       return;
     }
 
     const payload = createPayload(payloadIdentity, items);
     const batchId = payload.batchId;
+    const settleAmbiguousBatchRequests = (reason: string) => {
+      emitDataBatchTransportEvent(onEvent, {
+        type: 'fallback',
+        endpoint,
+        batchId,
+        size: items.length,
+        reason,
+      });
+      return settleRequests(items, request =>
+        runAfterAmbiguousBatch(request, reason),
+      );
+    };
 
     emitDataBatchTransportEvent(onEvent, {
       type: 'flush',
@@ -474,20 +478,17 @@ export function createBatchTransportQueue({
             batchId,
             reason: `batch-endpoint-unavailable-${String(response.status)}`,
           });
+          await settleRequests(items, request =>
+            runAfterAmbiguousBatch(
+              request,
+              `batch-response-${String(response.status)}`,
+            ),
+          );
         } else {
-          emitDataBatchTransportEvent(onEvent, {
-            type: 'fallback',
-            endpoint,
-            batchId,
-            size: items.length,
-            reason: `batch-response-${String(response.status)}`,
-          });
+          await settleAmbiguousBatchRequests(
+            `batch-response-${String(response.status)}`,
+          );
         }
-        await settleAmbiguousBatchRequests(
-          items,
-          `batch-response-${String(response.status)}`,
-        );
-        bucket.flushing = false;
         return;
       }
 
@@ -495,28 +496,12 @@ export function createBatchTransportQueue({
         response.json(),
       );
       if (!isBatchResponsePayload(result)) {
-        emitDataBatchTransportEvent(onEvent, {
-          type: 'fallback',
-          endpoint,
-          batchId,
-          size: items.length,
-          reason: 'invalid-batch-response',
-        });
-        await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
-        bucket.flushing = false;
+        await settleAmbiguousBatchRequests('invalid-batch-response');
         return;
       }
 
       if (result.batchId !== batchId) {
-        emitDataBatchTransportEvent(onEvent, {
-          type: 'fallback',
-          endpoint,
-          batchId,
-          size: items.length,
-          reason: 'mismatched-batch-id',
-        });
-        await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
-        bucket.flushing = false;
+        await settleAmbiguousBatchRequests('mismatched-batch-id');
         return;
       }
 
@@ -556,23 +541,12 @@ export function createBatchTransportQueue({
         }
         return;
       }
-      emitDataBatchTransportEvent(onEvent, {
-        type: 'fallback',
-        endpoint,
-        batchId,
-        size: items.length,
-        reason: 'batch-transport-error',
-      });
-      await settleAmbiguousBatchRequests(items, 'batch-transport-error');
+      await settleAmbiguousBatchRequests('batch-transport-error');
     } finally {
       for (const item of items) {
         item.abortBatchIfUnused = undefined;
       }
-      bucket.flushing = false;
-      if (bucket.items.length > 0 && !bucket.timer) {
-        void flushBucket(bucketKey);
-      }
-      buckets.releaseIfIdle(bucketKey, bucket);
+      finishFlush(bucketKey, bucket);
     }
   };
 
@@ -618,7 +592,18 @@ export function createBatchTransportQueue({
       options.endpoint,
     ).toString();
 
+    const itemHeaders = { ...headers };
+    delete itemHeaders.authorization;
+    delete itemHeaders.cookie;
     return {
+      itemHeaders,
+      itemPath: `${requestUrl.pathname}${requestUrl.search}`,
+      bucketKey: stableStringify({
+        endpoint,
+        authorization: headers.authorization ?? null,
+        cookie: headers.cookie ?? null,
+        credentials,
+      }),
       requestUrl,
       endpoint,
       method,
@@ -661,20 +646,11 @@ export function createBatchTransportQueue({
       return undefined;
     }
 
-    const itemHeaders = { ...request.headers };
-    delete itemHeaders.authorization;
-    delete itemHeaders.cookie;
-    const bucketKey = stableStringify({
-      endpoint: request.endpoint,
-      authorization: request.headers.authorization ?? null,
-      cookie: request.headers.cookie ?? null,
-      credentials: request.credentials,
-    });
     return stableStringify({
-      bucketKey,
-      path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+      bucketKey: request.bucketKey,
+      path: request.itemPath,
       method: request.method,
-      headers: itemHeaders,
+      headers: request.itemHeaders,
       body: null,
     });
   };
@@ -705,9 +681,7 @@ export function createBatchTransportQueue({
       .slice(2, 8)}`;
     nextItemId += 1;
 
-    const itemHeaders = { ...request.headers };
-    delete itemHeaders.authorization;
-    delete itemHeaders.cookie;
+    const itemHeaders = { ...request.itemHeaders };
     if (
       preparedBody.body &&
       preparedBody.inferredContentType &&
@@ -717,18 +691,13 @@ export function createBatchTransportQueue({
     }
     const item: DataBatchRequestItem = {
       id: itemId,
-      path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+      path: request.itemPath,
       method: request.method,
       headers: itemHeaders,
       ...(preparedBody.body ? { body: preparedBody.body } : {}),
     };
 
-    const bucketKey = stableStringify({
-      endpoint: request.endpoint,
-      authorization: request.headers.authorization ?? null,
-      cookie: request.headers.cookie ?? null,
-      credentials: request.credentials,
-    });
+    const { bucketKey } = request;
 
     const key = stableStringify({
       bucketKey,
@@ -825,14 +794,16 @@ export function createBatchTransportQueue({
     }
 
     bucket.items.push(queued);
-    bucket.bytes = measurePayload(bucket, bucket.items);
     emitDataBatchTransportEvent(onEvent, {
       type: 'enqueue',
       endpoint: request.endpoint,
       size: bucket.items.length,
     });
 
-    if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) {
+    if (
+      bucket.items.length >= maxBatchSize ||
+      measurePayload(bucket, bucket.items) >= maxBatchBytes
+    ) {
       void flushBucket(bucketKey);
       return queued.promise;
     }

package/src/data-platform/trace.ts

@@ -1,5 +1,5 @@
 // @effect-diagnostics asyncFunction:off globalDate:off globalRandom:off globalTimers:off newPromise:off strictBooleanExpressions:off
-import { parseTraceparent } from '@modern-js/create-request';
+import { parseTraceparent } from '@modern-js/runtime-extensions/request-context';
 
 import type { TraceContext } from './types';
 

package/src/effect/context.ts

@@ -1,10 +1,5 @@
 // @effect-diagnostics strictBooleanExpressions:off
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  type EffectContext,
-  type EffectContextStorage,
-  kEffectContextStorage,
-} from './operation-context';
+import type { EffectContext, EffectContextStorage } from './operation-context';
 
 export {
   type CreateEffectOperationContextOptions,
@@ -12,21 +7,51 @@ export {
   type EffectContext,
 } from './operation-context';
 
+type EffectContextStorageConstructor = new () => EffectContextStorage;
+
+// One storage for every entry: each imports this module as
+// `@modern-js/bff-effect/context`, the request that Module Federation shares
+// and that the BFF bundle keeps external, so the server and its lambdas load
+// the same instance. A backend federation container bundles its own copy and
+// adopts the host's storage in init() instead.
 const globalStore = globalThis as typeof globalThis & {
-  [kEffectContextStorage]?: EffectContextStorage;
+  process?: {
+    getBuiltinModule?: (id: string) => unknown;
+  };
 };
 
-const effectContextStorage =
-  globalStore[kEffectContextStorage] ??
-  (globalStore[kEffectContextStorage] = new AsyncLocalStorage<EffectContext>());
+const asyncHooks = globalStore.process?.getBuiltinModule?.(
+  'node:async_hooks',
+) as { AsyncLocalStorage?: EffectContextStorageConstructor } | undefined;
+const AsyncLocalStorage = asyncHooks?.AsyncLocalStorage;
+if (typeof AsyncLocalStorage !== 'function') {
+  throw new Error(
+    '[BFF][Effect] The edge runtime must provide AsyncLocalStorage. Enable Node.js compatibility or the nodejs_als compatibility flag.',
+  );
+}
+
+/**
+ * Module Federation share through which a backend federation host hands its
+ * request storage to the containers it initializes.
+ */
+export const EFFECT_BFF_CONTEXT_STORAGE_SHARE =
+  '@modern-js/bff-effect/context-storage';
+
+let effectContextStorage: EffectContextStorage = new AsyncLocalStorage();
+let effectContextStorageUsed = false;
+
+const usedEffectContextStorage = () => {
+  effectContextStorageUsed = true;
+  return effectContextStorage;
+};
 
 export const runWithEffectContext = <T>(
   context: EffectContext,
   cb: () => T,
-): T => effectContextStorage.run(context, cb);
+): T => usedEffectContextStorage().run(context, cb);
 
 export const useEffectContext = (): EffectContext => {
-  const context = effectContextStorage.getStore();
+  const context = usedEffectContextStorage().getStore();
   if (!context) {
     throw new Error(`Can't call useEffectContext out of Effect runtime scope`);
   }
@@ -34,4 +59,31 @@ export const useEffectContext = (): EffectContext => {
   return context;
 };
 
+/** @internal The storage a backend federation host shares with containers. */
+export const getEffectContextStorage = (): EffectContextStorage =>
+  effectContextStorage;
+
+/**
+ * @internal Called through `adoptEffectBffShareScope()` from a backend
+ * federation container's `init()`, so its endpoints read the context the
+ * host dispatcher enters.
+ */
+export function adoptEffectContextStorage(storage: unknown): void {
+  const candidate = storage as Partial<EffectContextStorage> | undefined;
+  if (
+    typeof candidate?.run !== 'function' ||
+    typeof candidate.getStore !== 'function'
+  ) {
+    throw new Error(
+      `[BFF][Effect] Share ${EFFECT_BFF_CONTEXT_STORAGE_SHARE} must provide an AsyncLocalStorage.`,
+    );
+  }
+  if (effectContextStorageUsed && candidate !== effectContextStorage) {
+    throw new Error(
+      '[BFF][Effect] A backend federation container received the host request storage after an Effect API already used its own. Evaluate exposes only after container init().',
+    );
+  }
+  effectContextStorage = candidate as EffectContextStorage;
+}
+
 export const useOperationContext = () => useEffectContext().operationContext;

package/src/effect/edge-dispatcher.ts

@@ -1,15 +1,17 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off strictBooleanExpressions:off
+
+import { runWithEffectContext } from '@modern-js/bff-effect/context';
 import {
   evaluateCrossProjectPolicy,
   type NormalizedCrossProjectPolicy,
   resolveCrossProjectRequestObservation,
-} from '@modern-js/bff-core/security/cross-project-policy';
+} from '@modern-js/server-runtime-extensions/bff-policy';
+import * as Effect from 'effect/Effect';
 import { toHeaderRecord } from '../headers';
 import {
   type DispatchEffectBffRequestOptions,
   dispatchEffectBffRequestWithContext,
 } from './dispatch';
-import { runWithEffectContext } from './edge-context';
 import type {
   EffectBffOpenApiConfig,
   EffectDataPlatformValidationOptions,
@@ -21,6 +23,11 @@ import {
 } from './module';
 import type { EffectContext } from './operation-context';
 
+export {
+  runWithEffectContext,
+  useEffectContext,
+  useOperationContext,
+} from '@modern-js/bff-effect/context';
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
@@ -84,14 +91,8 @@ export {
   RpcWorker,
   Utils,
 } from 'effect/unstable/rpc';
-export {
-  runWithEffectContext,
-  useEffectContext,
-  useOperationContext,
-} from './edge-context';
 export type {
   EffectApiClientFromApi,
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffOpenApiConfig,
@@ -285,9 +286,11 @@ export async function createEffectBffEdgeDispatcher(
       disposePromise ??= (async () => {
         acceptingRequests = false;
         if (activeDispatches > 0) {
-          await new Promise<void>(resolve => {
-            resolveDrain = resolve;
-          });
+          await Effect.runPromise(
+            Effect.callback<void>(resume => {
+              resolveDrain = () => resume(Effect.void);
+            }),
+          );
         }
         await loaded.dispose?.();
       })();

package/src/effect/edge.ts

@@ -1 +1,7 @@
+export { EFFECT_BFF_CONTEXT_STORAGE_SHARE } from '@modern-js/bff-effect/context';
 export * from './edge-dispatcher';
+export {
+  adoptEffectBffShareScope,
+  EFFECT_BFF_HANDLER_FACTORY_REGISTRY_SHARE,
+} from './entry-shape';
+export { createEffectBffEdgeDispatcherFactory } from './generated-entry';

package/src/effect/endpoint-contracts.ts

@@ -1,21 +1,9 @@
 // @effect-diagnostics asyncFunction:off strictBooleanExpressions:off
-/**
- * Shared Effect HttpApi endpoint reflection used by BOTH sides of the
- * cross-project contract:
- *
- * - the `@modern-js/plugin-bff-extensions/client-generator` package stamps
- *   each generated operation with a per-endpoint contract hash;
- * - the `@modern-js/plugin-bff-extensions/effect-adapter` package derives the
- *   expected operation-contract map for the cross-project policy from the
- *   same endpoints.
- *
- * Keeping route-path normalization and the endpoint -> contract mapping in
- * one module is what guarantees the two hashes agree.
- */
+/** Shared endpoint normalization and identity hashing for server policy metadata. */
 import {
   createOperationContractHash,
   type OperationContractSource,
-} from '@modern-js/bff-core';
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
 import {
   classifyEffectBffEntryModule,
   isValidatorAwareHandlerFactory,
@@ -38,13 +26,7 @@ type HttpApiGroupLike = {
 };
 
 type HttpApiEndpointLike = {
-  /**
-   * effect 4.0.0-beta.98 renamed the endpoint `name` property to `identifier`,
-   * matching `HttpApiGroup`. `name` is kept as a fallback so reflection over an
-   * older Effect build does not silently degrade to the class name.
-   */
   identifier?: unknown;
-  name?: unknown;
   method?: unknown;
   path?: unknown;
 };
@@ -53,9 +35,6 @@ function resolveEffectEndpointName(endpoint: HttpApiEndpointLike): string {
   if (typeof endpoint.identifier === 'string' && endpoint.identifier) {
     return endpoint.identifier;
   }
-  if (typeof endpoint.name === 'string' && endpoint.name) {
-    return endpoint.name;
-  }
   return '';
 }
 
@@ -168,7 +147,7 @@ export async function extractHttpApiFromModule(
     isValidatorAwareHandlerFactory,
     isHttpApi,
   });
-  return facts?.legacyShape ||
+  return facts?.unsupportedShape ||
     facts?.api === undefined ||
     !facts.hasRuntimeLayer ||
     (facts.createHandler !== undefined && !facts.createHandlerValidatorAware)