@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.10 → 3.9.0-ultramodern.12

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;
@@ -347,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);
@@ -379,7 +374,6 @@ export function createBatchTransportQueue({
       sentAt: bucket.sentAt,
     };
     bucket.items = [];
-    bucket.bytes = 0;
     rotatePayloadIdentity(bucket);
     const firstItem = items[0];
     if (!firstItem) {
@@ -396,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',
@@ -473,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;
       }
 
@@ -494,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;
       }
 
@@ -555,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);
     }
   };
 
@@ -617,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,
@@ -660,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,
     });
   };
@@ -704,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 &&
@@ -716,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,
@@ -824,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/effect/handler/batch-handler.ts

@@ -8,6 +8,7 @@ import {
   isPlainObject,
   normalizeMethod as normalizeItemMethod,
 } from '../../data-platform';
+import { normalizeBatchLimits } from '../../data-platform/batch/options';
 import {
   decodeBatchBody,
   isBatchBody,
@@ -18,7 +19,6 @@ import {
   createBatchValidationResponse,
   isBatchRequestPayload,
   mapWithConcurrency,
-  normalizeBatchAllowedMethods,
   normalizeBatchPath,
   promiseWithTimeout,
   toBatchItemError,
@@ -129,14 +129,11 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
   const dataPlatformBatchOptions = options.dataPlatform?.batch;
   const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
   const batchPath = normalizeBatchPath(dataPlatformBatchOptions?.endpoint);
-  const batchMaxSize = Math.max(
-    1,
-    dataPlatformBatchOptions?.maxBatchSize ?? 16,
-  );
-  const batchMaxBytes = Math.max(
-    1024,
-    dataPlatformBatchOptions?.maxBatchBytes ?? 64 * 1024,
-  );
+  const {
+    maxBatchSize: batchMaxSize,
+    maxBatchBytes: batchMaxBytes,
+    allowedMethods: batchAllowedMethods,
+  } = normalizeBatchLimits(dataPlatformBatchOptions);
   const batchConcurrency = Math.max(
     1,
     dataPlatformBatchOptions?.maxConcurrency ?? 4,
@@ -145,9 +142,6 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
     0,
     dataPlatformBatchOptions?.requestTimeoutMs ?? 10_000,
   );
-  const batchAllowedMethods = normalizeBatchAllowedMethods(
-    dataPlatformBatchOptions?.allowedMethods,
-  );
   const envelopeHeader =
     options.dataPlatform?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
   const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();

package/src/effect/handler/batch.ts

@@ -24,16 +24,6 @@ export function normalizeBatchPath(pathname: string | undefined) {
   return pathname as `/${string}`;
 }
 
-export function normalizeBatchAllowedMethods(
-  allowedMethods: string[] | undefined,
-) {
-  const source =
-    Array.isArray(allowedMethods) && allowedMethods.length > 0
-      ? allowedMethods
-      : ['GET'];
-  return new Set(source.map(method => method.toUpperCase()));
-}
-
 type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
   items: unknown[];
 };

package/src/effect-client/cross-project.ts

@@ -2,6 +2,7 @@ import {
   BFF_ENVELOPE_HEADER,
   BFF_OPERATION_CONTEXT_DETAIL_HEADER,
   BFF_OPERATION_CONTEXT_HEADER,
+  digestOperationContract,
   resolveCrossProjectRequestObservation,
 } from '@modern-js/server-runtime-extensions/bff-policy';
 import * as Effect from 'effect/Effect';
@@ -66,22 +67,16 @@ export function withCrossProjectPolicy<
         );
       }
       return Effect.gen(function* () {
-        // Canonical field order matches the server's route-identity SHA-256.
-        const input = encodeJson({
-          httpMethod: contract.method,
-          name: contract.name,
-          requestId: options.requestId,
-          routePath: contract.routePath,
-        });
-        const digest = yield* Effect.promise(() =>
-          globalThis.crypto.subtle.digest(
-            'SHA-256',
-            new TextEncoder().encode(input),
+        const schemaHash = yield* Effect.promise(() =>
+          digestOperationContract(
+            {
+              httpMethod: contract.method,
+              name: contract.name,
+              routePath: contract.routePath,
+            },
+            options.requestId,
           ),
         );
-        const schemaHash = Array.from(new Uint8Array(digest), value =>
-          value.toString(16).padStart(2, '0'),
-        ).join('');
         return request.pipe(
           HttpClientRequest.setHeader(
             BFF_ENVELOPE_HEADER,