@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

package/dist/cjs/data-platform/batch/options.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function normalizeBatchLimits(options = {}) {
+    return {
+        maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+        maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 65536),
+        allowedMethods: new Set((void 0 !== options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+            'GET'
+        ]).map((method)=>method.toUpperCase()))
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    normalizeBatchLimits: ()=>normalizeBatchLimits
+});
+exports.normalizeBatchLimits = __webpack_exports__.normalizeBatchLimits;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeBatchLimits"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch/queue.js

@@ -33,6 +33,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_codec_js_namespaceObject = require("../codec.js");
 const external_types_js_namespaceObject = require("../types.js");
+const external_options_js_namespaceObject = require("./options.js");
 const external_protocol_js_namespaceObject = require("./protocol.js");
 const external_request_js_namespaceObject = require("./request.js");
 const external_response_js_namespaceObject = require("./response.js");
@@ -111,7 +112,6 @@ class BatchBucketRegistry {
         if (existing) return existing;
         const next = {
             items: [],
-            bytes: 0,
             batchId: (0, external_request_js_namespaceObject.createBatchId)(),
             sentAt: Date.now(),
             timer: null,
@@ -130,12 +130,8 @@ class BatchBucketRegistry {
 }
 function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
     const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
-    const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
-    const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 65536);
+    const { maxBatchSize, maxBatchBytes, allowedMethods } = (0, external_options_js_namespaceObject.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();
     const pendingByKey = new Map();
@@ -168,7 +164,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const index = bucket.items.indexOf(request);
         if (-1 === index) return;
         bucket.items.splice(index, 1);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         if (0 === bucket.items.length && bucket.timer) {
             clearTimeout(bucket.timer);
             bucket.timer = null;
@@ -210,7 +205,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         if (!SAFE_REPLAY_METHODS.has(request.item.method)) throw new Error(`Batch result is unknown for ${request.item.method}; automatic replay is disabled (${reason}).`);
         return runSingle(request);
     };
-    const settleAmbiguousBatchRequests = (items, reason)=>settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+    const finishFlush = (bucketKey, bucket)=>{
+        bucket.flushing = false;
+        if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+        buckets.releaseIfIdle(bucketKey, bucket);
+    };
     const flushBucket = async (bucketKey)=>{
         const bucket = buckets.get(bucketKey);
         if (!bucket || bucket.flushing) return;
@@ -227,7 +226,6 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             sentAt: bucket.sentAt
         };
         bucket.items = [];
-        bucket.bytes = 0;
         rotatePayloadIdentity(bucket);
         const firstItem = items[0];
         if (!firstItem) {
@@ -243,14 +241,25 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 size: items.length,
                 reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
             });
-            await settleRequests(items, runSingle);
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            try {
+                await settleRequests(items, runSingle);
+            } finally{
+                finishFlush(bucketKey, bucket);
+            }
             return;
         }
         const payload = createPayload(payloadIdentity, items);
         const batchId = payload.batchId;
+        const settleAmbiguousBatchRequests = (reason)=>{
+            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason
+            });
+            return settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+        };
         (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
             type: 'flush',
             endpoint,
@@ -301,42 +310,13 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: `batch-response-${String(response.status)}`
-                });
-                await settleAmbiguousBatchRequests(items, `batch-response-${String(response.status)}`);
-                bucket.flushing = false;
+                    await settleRequests(items, (request)=>runAfterAmbiguousBatch(request, `batch-response-${String(response.status)}`));
+                } else await settleAmbiguousBatchRequests(`batch-response-${String(response.status)}`);
                 return;
             }
             const result = await runWithSignal(controller.signal, async ()=>response.json());
-            if (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) {
-                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'invalid-batch-response'
-                });
-                await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
-                bucket.flushing = false;
-                return;
-            }
-            if (result.batchId !== batchId) {
-                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'mismatched-batch-id'
-                });
-                await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
-                bucket.flushing = false;
-                return;
-            }
+            if (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) return void await settleAmbiguousBatchRequests('invalid-batch-response');
+            if (result.batchId !== batchId) return void await settleAmbiguousBatchRequests('mismatched-batch-id');
             const itemMap = new Map();
             for (const item of result.items)itemMap.set(item.id, item);
             await settleRequests(items, async (request)=>{
@@ -360,19 +340,10 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
                 });
                 return;
             }
-            (0, external_telemetry_js_namespaceObject.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 = void 0;
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
-            buckets.releaseIfIdle(bucketKey, bucket);
+            finishFlush(bucketKey, bucket);
         }
     };
     const pendingReadPromises = new Map();
@@ -396,7 +367,20 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
         const requestUrl = (0, external_url_js_namespaceObject.toAbsoluteUrl)(input);
         const endpoint = (0, external_url_js_namespaceObject.normalizeBatchEndpoint)(requestUrl, options.endpoint).toString();
+        const itemHeaders = {
+            ...headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
         return {
+            itemHeaders,
+            itemPath: `${requestUrl.pathname}${requestUrl.search}`,
+            bucketKey: (0, external_codec_js_namespaceObject.stableStringify)({
+                endpoint,
+                authorization: headers.authorization ?? null,
+                cookie: headers.cookie ?? null,
+                credentials
+            }),
             requestUrl,
             endpoint,
             method,
@@ -429,22 +413,11 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             batchEndpoint: request.endpoint,
             requestUrl: request.requestUrl
         })) return;
-        const itemHeaders = {
-            ...request.headers
-        };
-        delete itemHeaders.authorization;
-        delete itemHeaders.cookie;
-        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
         return (0, external_codec_js_namespaceObject.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
         });
     };
@@ -462,26 +435,19 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
         const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
         nextItemId += 1;
         const itemHeaders = {
-            ...request.headers
+            ...request.itemHeaders
         };
-        delete itemHeaders.authorization;
-        delete itemHeaders.cookie;
         if (preparedBody.body && preparedBody.inferredContentType && !itemHeaders['content-type']) itemHeaders['content-type'] = preparedBody.inferredContentType;
         const item = {
             id: itemId,
-            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            path: request.itemPath,
             method: request.method,
             headers: itemHeaders,
             ...preparedBody.body ? {
                 body: preparedBody.body
             } : {}
         };
-        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
-            endpoint: request.endpoint,
-            authorization: request.headers.authorization ?? null,
-            cookie: request.headers.cookie ?? null,
-            credentials: request.credentials
-        });
+        const { bucketKey } = request;
         const key = (0, external_codec_js_namespaceObject.stableStringify)({
             bucketKey,
             path: item.path,
@@ -575,13 +541,12 @@ function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
             }
         }
         bucket.items.push(queued);
-        bucket.bytes = measurePayload(bucket, bucket.items);
         (0, external_telemetry_js_namespaceObject.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) {
             flushBucket(bucketKey);
             return queued.promise;
         }

package/dist/cjs/effect/entry-shape.js

@@ -44,7 +44,10 @@ function createLocalValidatorAwareHandlerFactoryRegistry() {
 }
 function loadNodeValidatorAwareHandlerFactoryRegistry() {
     const moduleUrl = __rslib_import_meta_url__;
-    if ('string' != typeof moduleUrl || !moduleUrl.startsWith('file:')) return createLocalValidatorAwareHandlerFactoryRegistry();
+    if ('string' != typeof moduleUrl || !moduleUrl.startsWith('file:')) {
+        if ("u" > typeof __modernjs_backend_private_capability__) return __modernjs_backend_private_capability__;
+        return createLocalValidatorAwareHandlerFactoryRegistry();
+    }
     const moduleBuiltin = process.getBuiltinModule('node:module');
     try {
         return moduleBuiltin.createRequire(moduleUrl)("#effect-entry-shape-registry");

package/dist/cjs/effect/handler/batch-handler.js

@@ -32,6 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const Effect_namespaceObject = require("effect/Effect");
 const index_js_namespaceObject = require("../../data-platform/index.js");
+const options_js_namespaceObject = require("../../data-platform/batch/options.js");
 const protocol_js_namespaceObject = require("../../data-platform/batch/protocol.js");
 const external_batch_js_namespaceObject = require("./batch.js");
 const external_routing_js_namespaceObject = require("./routing.js");
@@ -123,11 +124,9 @@ function createDataPlatformBatchRequestHandler(options) {
     const dataPlatformBatchOptions = options.dataPlatform?.batch;
     const batchEnabled = dataPlatformBatchOptions?.enabled !== false;
     const batchPath = (0, external_batch_js_namespaceObject.normalizeBatchPath)(dataPlatformBatchOptions?.endpoint);
-    const batchMaxSize = Math.max(1, dataPlatformBatchOptions?.maxBatchSize ?? 16);
-    const batchMaxBytes = Math.max(1024, dataPlatformBatchOptions?.maxBatchBytes ?? 65536);
+    const { maxBatchSize: batchMaxSize, maxBatchBytes: batchMaxBytes, allowedMethods: batchAllowedMethods } = (0, options_js_namespaceObject.normalizeBatchLimits)(dataPlatformBatchOptions);
     const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
     const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
-    const batchAllowedMethods = (0, external_batch_js_namespaceObject.normalizeBatchAllowedMethods)(dataPlatformBatchOptions?.allowedMethods);
     const envelopeHeader = options.dataPlatform?.envelopeHeader || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
     const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
     const handle = async (request, context)=>{

package/dist/cjs/effect/handler/batch.js

@@ -32,7 +32,6 @@ __webpack_require__.d(__webpack_exports__, {
     createBatchValidationResponse: ()=>createBatchValidationResponse,
     isBatchRequestPayload: ()=>isBatchRequestPayload,
     mapWithConcurrency: ()=>mapWithConcurrency,
-    normalizeBatchAllowedMethods: ()=>normalizeBatchAllowedMethods,
     normalizeBatchPath: ()=>normalizeBatchPath,
     prepareJsonRequestBody: ()=>prepareJsonRequestBody,
     promiseWithTimeout: ()=>promiseWithTimeout,
@@ -48,12 +47,6 @@ function normalizeBatchPath(pathname) {
     if (!pathname.startsWith('/')) return `/${pathname}`;
     return pathname;
 }
-function normalizeBatchAllowedMethods(allowedMethods) {
-    const source = Array.isArray(allowedMethods) && allowedMethods.length > 0 ? allowedMethods : [
-        'GET'
-    ];
-    return new Set(source.map((method)=>method.toUpperCase()));
-}
 function isBatchRequestPayload(value) {
     return (0, index_js_namespaceObject.isPlainObject)(value) && 2 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
 }
@@ -154,7 +147,6 @@ exports.BatchItemTimeoutError = __webpack_exports__.BatchItemTimeoutError;
 exports.createBatchValidationResponse = __webpack_exports__.createBatchValidationResponse;
 exports.isBatchRequestPayload = __webpack_exports__.isBatchRequestPayload;
 exports.mapWithConcurrency = __webpack_exports__.mapWithConcurrency;
-exports.normalizeBatchAllowedMethods = __webpack_exports__.normalizeBatchAllowedMethods;
 exports.normalizeBatchPath = __webpack_exports__.normalizeBatchPath;
 exports.prepareJsonRequestBody = __webpack_exports__.prepareJsonRequestBody;
 exports.promiseWithTimeout = __webpack_exports__.promiseWithTimeout;
@@ -165,7 +157,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createBatchValidationResponse",
     "isBatchRequestPayload",
     "mapWithConcurrency",
-    "normalizeBatchAllowedMethods",
     "normalizeBatchPath",
     "prepareJsonRequestBody",
     "promiseWithTimeout",

package/dist/cjs/effect/module.js

@@ -74,6 +74,10 @@ function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
     if (facts.unsupportedShape) {
         if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) return null;
     }
+    if (void 0 !== facts.module.rpc && !facts.createHandlerValidatorAware) {
+        rejectUnsupportedEffectModuleShape(options, 'unbranded RPC runtime');
+        return null;
+    }
     if ('function' == typeof facts.createHandler) {
         if (facts.createHandlerValidatorAware) {
             const factory = facts.createHandler;

package/dist/cjs/effect/operation-context.js

@@ -87,7 +87,7 @@ const createEffectOperationContext = ({ request, path, method })=>{
         } : {},
         routePath: servicePath,
         method: (method || request.method || 'GET').toUpperCase(),
-        source: 'effect-adapter',
+        source: 'effect-server',
         ...path && path !== servicePath ? {
             attributes: {
                 mountedPath: path

package/dist/cjs/effect/rpcSerialization.js

@@ -39,8 +39,6 @@ function getRpcSerializationLayer(serialization) {
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
         case 'ndJsonRpc':
             return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
         default:
             return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
     }

package/dist/cjs/effect-client/cross-project.js

@@ -62,14 +62,11 @@ function withCrossProjectPolicy(api, options, client) {
         const contract = observed && contracts[`${observed.method}:${observed.routePath}`];
         if (void 0 === contract) return Effect_namespaceObject.die(new Error('[BFF][Effect] Request has no matching shared operation contract.'));
         return Effect_namespaceObject.gen(function*() {
-            const input = encodeJson({
-                httpMethod: contract.method,
-                name: contract.name,
-                requestId: options.requestId,
-                routePath: contract.routePath
-            });
-            const digest = yield* Effect_namespaceObject.promise(()=>globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input)));
-            const schemaHash = Array.from(new Uint8Array(digest), (value)=>value.toString(16).padStart(2, '0')).join('');
+            const schemaHash = yield* Effect_namespaceObject.promise(()=>(0, bff_policy_namespaceObject.digestOperationContract)({
+                    httpMethod: contract.method,
+                    name: contract.name,
+                    routePath: contract.routePath
+                }, options.requestId));
             return request.pipe(http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_ENVELOPE_HEADER, encodeJson({
                 requestId: options.requestId
             })), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_HEADER, contract.operationId), http_namespaceObject.HttpClientRequest.setHeader(bff_policy_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER, encodeJson({

package/dist/cjs/microvertical-api.js

@@ -66,7 +66,7 @@ const MicroVerticalOperationSourceSchema = external_effect_namespaceObject.Schem
     'client',
     'server',
     'generated-client',
-    'effect-adapter',
+    'effect-server',
     'data-platform',
     'unknown'
 ]);

package/dist/esm/data-platform/batch/options.mjs

@@ -0,0 +1,10 @@
+function normalizeBatchLimits(options = {}) {
+    return {
+        maxBatchSize: Math.max(1, options.maxBatchSize ?? 16),
+        maxBatchBytes: Math.max(1024, options.maxBatchBytes ?? 65536),
+        allowedMethods: new Set((void 0 !== options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+            'GET'
+        ]).map((method)=>method.toUpperCase()))
+    };
+}
+export { normalizeBatchLimits };