@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

package/dist/esm-node/runtime/effect/backend-federation-manifest/metadata.mjs

@@ -1,43 +0,0 @@
-import "node:module";
-import { backendFederationMetadata, backendFederationVersionBoundary } from "@modern-js/utils/universal";
-function stringValue(value) {
-    return 'string' == typeof value && value.length > 0 ? value : void 0;
-}
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function recordField(value, field) {
-    const fieldValue = value?.[field];
-    return isRecord(fieldValue) ? fieldValue : void 0;
-}
-function resolveRemoteEntryFromMetadata(manifest) {
-    const metaData = recordField(manifest, 'metaData');
-    const remoteEntry = recordField(metaData, 'remoteEntry');
-    const publicPath = stringValue(metaData?.publicPath) ?? stringValue(metaData?.ssrPublicPath);
-    const entryName = stringValue(remoteEntry?.name);
-    if (!publicPath || !entryName) return;
-    const entryPath = stringValue(remoteEntry?.path) ?? '';
-    const normalizedBase = publicPath.replace(/\/+$/u, '');
-    const normalizedPath = entryPath.replace(/^\/+|\/+$/gu, '');
-    return [
-        normalizedBase,
-        normalizedPath,
-        entryName
-    ].filter(Boolean).join('/');
-}
-function metadata_backendFederationMetadata(manifest) {
-    return backendFederationMetadata(manifest);
-}
-function versionBoundaryMetadata(manifest) {
-    return backendFederationVersionBoundary(manifest);
-}
-function deliveryUnitMetadata(record) {
-    return recordField(record, 'deliveryUnit');
-}
-function manifestDeliveryUnit(backendFederation, boundary) {
-    return {
-        boundary: deliveryUnitMetadata(boundary),
-        top: deliveryUnitMetadata(backendFederation)
-    };
-}
-export { deliveryUnitMetadata, isRecord, manifestDeliveryUnit, metadata_backendFederationMetadata as backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue, versionBoundaryMetadata };

package/dist/esm-node/runtime/effect/backend-federation-manifest/reference.mjs

@@ -1,77 +0,0 @@
-import "node:module";
-import { BACKEND_FEDERATION_MANIFEST_FILE } from "../backend-federation.mjs";
-import { BackendFederationManifestAdapterError, assertManifestAdapter } from "./errors.mjs";
-import { isRecord } from "./metadata.mjs";
-function getProcessEnv() {
-    return "u" > typeof process ? process.env : void 0;
-}
-function resolveManifestReferenceSource(options) {
-    if (options.manifestPath) return 'path';
-    if (options.manifestUrl) return 'url';
-    if (options.manifestEnv) return 'env';
-}
-function resolveBackendFederationManifestReference(options) {
-    if (options.manifestPath) return options.manifestPath;
-    if (options.manifestUrl) return options.manifestUrl;
-    if (!options.manifestEnv) return;
-    return options.env?.[options.manifestEnv] ?? getProcessEnv()?.[options.manifestEnv];
-}
-function assertExpectedIdentityForReference(options, source) {
-    if (void 0 === source || 'path' === source || options.allowLegacyManifest) return;
-    if (options.expected?.unitId && options.expected.buildMarker) return;
-    throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${source} manifest references require expected.unitId and expected.buildMarker. Pass allowLegacyManifest: true to load legacy manifest references.`, void 0, {
-        label: 'expected.deliveryUnit',
-        expected: 'unitId + buildMarker',
-        received: options.expected,
-        referenceSource: source
-    });
-}
-function isHttpUrl(value) {
-    return /^https?:\/\//iu.test(value);
-}
-async function readFileReference(reference) {
-    const [{ fileURLToPath }, fs] = await Promise.all([
-        import("node:url"),
-        import("node:fs/promises")
-    ]);
-    const filePath = reference.startsWith('file:') ? fileURLToPath(reference) : reference;
-    return fs.readFile(filePath, 'utf8');
-}
-async function withTimeout(promise, timeoutMs, label) {
-    if (!timeoutMs || timeoutMs <= 0) return promise;
-    let timeout;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject)=>{
-                timeout = setTimeout(()=>{
-                    reject(new BackendFederationManifestAdapterError('timeout', `[BFF][Effect] ${label} timed out after ${timeoutMs}ms.`));
-                }, timeoutMs);
-            })
-        ]);
-    } finally{
-        if (timeout) clearTimeout(timeout);
-    }
-}
-async function loadBackendFederationManifest(options) {
-    if (options.manifest) return options.manifest;
-    const reference = resolveBackendFederationManifestReference(options);
-    if (!reference) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest reference is missing. Pass manifest, manifestPath, manifestUrl, or manifestEnv for ${BACKEND_FEDERATION_MANIFEST_FILE}.`);
-    assertExpectedIdentityForReference(options, resolveManifestReferenceSource(options));
-    try {
-        const source = isHttpUrl(reference) ? await (async ()=>{
-            const fetchManifest = options.fetch ?? globalThis.fetch;
-            if (!fetchManifest) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} requires a fetch implementation.`);
-            const response = await withTimeout(fetchManifest(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
-            if (!response.ok) throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`);
-            return response.text();
-        })() : await withTimeout(readFileReference(reference), options.timeoutMs, `Backend federation manifest ${reference}`);
-        const manifest = JSON.parse(source);
-        assertManifestAdapter(isRecord(manifest), 'manifest_invalid', `[BFF][Effect] Backend federation manifest ${reference} must be a JSON object.`);
-        return manifest;
-    } catch (error) {
-        if (error instanceof BackendFederationManifestAdapterError) throw error;
-        throw new BackendFederationManifestAdapterError('manifest_unavailable', `[BFF][Effect] Backend federation manifest ${reference} could not be loaded.`, error);
-    }
-}
-export { loadBackendFederationManifest, resolveBackendFederationManifestReference, withTimeout };

package/dist/esm-node/runtime/effect/backend-federation-manifest/remote.mjs

@@ -1,31 +0,0 @@
-import "node:module";
-import { backendFederationExposeNames } from "@modern-js/utils/universal";
-import { BACKEND_FEDERATION_EFFECT_EXPOSE } from "../backend-federation.mjs";
-import { assertManifestAdapter } from "./errors.mjs";
-import { backendFederationMetadata, recordField, resolveRemoteEntryFromMetadata, stringValue } from "./metadata.mjs";
-function resolveBackendFederationRemoteFromManifest(manifest, remoteOverride = {}) {
-    const backendFederation = backendFederationMetadata(manifest);
-    const entry = recordField(manifest, 'entry');
-    const metaData = recordField(manifest, 'metaData');
-    const remoteEntry = recordField(metaData, 'remoteEntry');
-    const remoteName = remoteOverride.name ?? stringValue(backendFederation?.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id);
-    const remoteEntryUrl = remoteOverride.entry ?? stringValue(backendFederation?.containerEntry) ?? stringValue(entry?.url) ?? resolveRemoteEntryFromMetadata(manifest);
-    const remoteType = remoteOverride.type ?? stringValue(backendFederation?.remoteType) ?? stringValue(entry?.type) ?? stringValue(remoteEntry?.type) ?? 'module';
-    const expose = remoteOverride.expose ?? backendFederationExposeNames(backendFederation)[0] ?? BACKEND_FEDERATION_EFFECT_EXPOSE;
-    assertManifestAdapter(remoteName, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a remote name.');
-    assertManifestAdapter(remoteEntryUrl, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare a backend remote entry URL.');
-    assertManifestAdapter(expose === BACKEND_FEDERATION_EFFECT_EXPOSE, 'manifest_invalid', `[BFF][Effect] Backend federation manifest expose must be ${BACKEND_FEDERATION_EFFECT_EXPOSE}.`);
-    return {
-        name: remoteName,
-        entry: remoteEntryUrl,
-        type: remoteType,
-        ...remoteOverride.entryGlobalName ? {
-            entryGlobalName: remoteOverride.entryGlobalName
-        } : {},
-        expose,
-        ...remoteOverride.shareScope ? {
-            shareScope: remoteOverride.shareScope
-        } : {}
-    };
-}
-export { resolveBackendFederationRemoteFromManifest };

package/dist/esm-node/runtime/effect/backend-federation-manifest/types.mjs

@@ -1 +0,0 @@
-import "node:module";

package/dist/esm-node/runtime/effect/backend-federation-manifest/validation.mjs

@@ -1,66 +0,0 @@
-import "node:module";
-import { formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
-import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "../backend-federation.mjs";
-import { BackendFederationManifestAdapterError, assertConsistentValue, assertManifestAdapter, assertVersionValue } from "./errors.mjs";
-import { backendFederationMetadata, manifestDeliveryUnit, recordField, stringValue, versionBoundaryMetadata } from "./metadata.mjs";
-function resolveExpectedBuildMarker(expected) {
-    if (void 0 !== expected.buildVersion && void 0 !== expected.buildMarker && expected.buildVersion !== expected.buildMarker) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation expected buildVersion/buildMarker mismatch: buildVersion ${expected.buildVersion}, buildMarker ${expected.buildMarker}.`, void 0, {
-        label: 'expected.buildVersion/buildMarker',
-        expected: expected.buildVersion,
-        received: expected.buildMarker
-    });
-    return expected.buildMarker;
-}
-function validation_validateBackendFederationManifest(manifest, expected = {}) {
-    const expectedBuildMarker = resolveExpectedBuildMarker(expected);
-    const backendFederation = backendFederationMetadata(manifest);
-    assertManifestAdapter(backendFederation, 'manifest_invalid', '[BFF][Effect] Backend federation manifest must declare backendFederation metadata.');
-    const manifestShape = validateBackendFederationManifest(manifest, {
-        expectedContractVersion: false,
-        expectedNodeAdapterVersion: false,
-        validateDeliveryUnit: false
-    });
-    assertManifestAdapter(manifestShape.ok, 'manifest_invalid', `[BFF][Effect] Backend federation manifest schema invalid: ${formatBackendFederationValidationErrors(manifestShape.errors)}.`);
-    assertManifestAdapter('effect' === backendFederation.runtimeFramework, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare runtimeFramework: "effect".');
-    assertManifestAdapter(true === backendFederation.strictEffectApproach, 'strict_effect_required', '[BFF][Effect] Backend federation manifest must declare strictEffectApproach: true.');
-    assertVersionValue(stringValue(backendFederation.contractVersion), expected.contractVersion ?? BACKEND_FEDERATION_CONTRACT_VERSION, 'manifest contractVersion');
-    assertVersionValue(stringValue(backendFederation.nodeAdapterVersion), expected.nodeAdapterVersion ?? BACKEND_FEDERATION_NODE_ADAPTER_VERSION, 'manifest nodeAdapterVersion');
-    const boundary = versionBoundaryMetadata(manifest);
-    assertVersionValue(stringValue(backendFederation.name) ?? stringValue(manifest.name) ?? stringValue(manifest.id), expected.remoteName, 'manifest remoteName');
-    assertVersionValue(stringValue(boundary?.packageName), expected.packageName, 'versionBoundary.packageName');
-    assertVersionValue(stringValue(boundary?.version), expected.version, 'versionBoundary.version');
-    assertVersionValue(stringValue(boundary?.buildVersion), expected.buildVersion, 'versionBoundary.buildVersion');
-    assertConsistentValue(stringValue(manifest.version), stringValue(boundary?.version), 'manifest versionBoundary.version');
-    assertConsistentValue(stringValue(manifest.buildVersion), stringValue(boundary?.buildVersion), 'manifest versionBoundary.buildVersion');
-    const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
-    assertConsistentValue(stringValue(deliveryUnit.boundary?.buildMarker), stringValue(boundary?.buildVersion), 'versionBoundary.deliveryUnit.buildMarker vs versionBoundary.buildVersion');
-    assertConsistentValue(stringValue(deliveryUnit.top?.unitId), stringValue(deliveryUnit.boundary?.unitId), 'backendFederation.deliveryUnit.unitId vs versionBoundary.deliveryUnit.unitId');
-    const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
-    assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
-    assertVersionValue(stringValue(deliveryUnit.boundary?.buildMarker), expectedBuildMarker, 'deliveryUnit.buildMarker');
-}
-function validateLoadedBackendFederationContract(loaded, manifest, remote) {
-    const loadedContract = loaded.backendFederationContract;
-    const backendFederation = backendFederationMetadata(manifest);
-    const boundary = versionBoundaryMetadata(manifest);
-    const compatibility = recordField(loadedContract, 'compatibility');
-    assertManifestAdapter(compatibility, 'version_mismatch', `[BFF][Effect] Backend federation expose ${remote.name}/${remote.expose?.replace(/^\.\//u, '')} must declare compatibility metadata.`);
-    assertVersionValue(stringValue(loadedContract?.role), 'microvertical-server', 'expose role');
-    assertVersionValue(stringValue(loadedContract?.name), remote.name, 'expose name');
-    assertVersionValue(stringValue(compatibility.contractVersion), stringValue(backendFederation?.contractVersion), 'expose contractVersion');
-    assertVersionValue(stringValue(compatibility.nodeAdapterVersion), stringValue(backendFederation?.nodeAdapterVersion), 'expose nodeAdapterVersion');
-    assertVersionValue(stringValue(compatibility.packageName), stringValue(boundary?.packageName), 'expose packageName');
-    assertVersionValue(stringValue(compatibility.build), stringValue(boundary?.buildVersion), 'expose buildVersion');
-    const deliveryUnit = manifestDeliveryUnit(backendFederation, boundary);
-    const manifestUnitId = stringValue(deliveryUnit.boundary?.unitId) ?? stringValue(deliveryUnit.top?.unitId);
-    const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
-    assertConsistentValue(manifestUnitId, stringValue(compatibility.unitId), 'deliveryUnit.unitId vs expose compatibility.unitId');
-    assertConsistentValue(manifestBuildMarker, stringValue(compatibility.build), 'deliveryUnit.buildMarker vs expose compatibility.build');
-}
-function classifyLoadError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes('delivery-unit identity mismatch')) return 'version_mismatch';
-    if (message.includes('strictEffectApproach') || message.includes('runtimeFramework')) return 'strict_effect_required';
-    return 'remote_unavailable';
-}
-export { classifyLoadError, validateLoadedBackendFederationContract, validation_validateBackendFederationManifest as validateBackendFederationManifest };

package/dist/esm-node/runtime/effect/backend-federation-manifest.mjs

@@ -1,2 +0,0 @@
-import "node:module";
-export * from "./backend-federation-manifest/index.mjs";

package/dist/esm-node/runtime/effect/backend-federation.mjs

@@ -1,6 +0,0 @@
-import "node:module";
-export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "@modern-js/utils/universal";
-export { validateExpectedBackendFederationIdentity } from "./backend-federation/identity.mjs";
-export { loadBackendFederatedEffectApi } from "./backend-federation/load.mjs";
-export { createBackendFederationLoadEntryPlugin } from "./backend-federation/plugin.mjs";
-export { createBackendFederationRuntime } from "./backend-federation/runtime.mjs";

package/dist/esm-node/runtime/effect/context.mjs

@@ -1,14 +0,0 @@
-import "node:module";
-import { AsyncLocalStorage } from "node:async_hooks";
-const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
-const globalStore = globalThis;
-const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new AsyncLocalStorage());
-const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
-const useEffectContext = ()=>{
-    const context = effectContextStorage.getStore();
-    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
-    return context;
-};
-const useOperationContext = ()=>useEffectContext().operationContext;
-export { createEffectOperationContext } from "./operation-context.mjs";
-export { runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/runtime/effect/dispatch.mjs

@@ -1,64 +0,0 @@
-import "node:module";
-import { createSafeFailureResponse } from "../safe-failure.mjs";
-import { createEffectOperationContext } from "./operation-context.mjs";
-function normalizeEffectBffPrefix(prefix) {
-    if (!prefix || '/' === prefix) return '';
-    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-}
-function removeEffectBffPrefixFromPath(pathname, prefix) {
-    const normalized = normalizeEffectBffPrefix(prefix);
-    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
-    const sliced = pathname.slice(normalized.length);
-    return sliced.startsWith('/') ? sliced : `/${sliced}`;
-}
-function matchesEffectBffPrefix(pathname, prefix) {
-    const normalized = normalizeEffectBffPrefix(prefix);
-    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
-}
-function createEffectBffMountedRequest(req, prefix) {
-    const url = new URL(req.url);
-    const nextPath = removeEffectBffPrefixFromPath(url.pathname, prefix);
-    if (nextPath !== url.pathname) {
-        url.pathname = nextPath;
-        return new Request(url, req);
-    }
-    return req;
-}
-function createEffectBffDispatchContext(originalRequest, mountedRequest, options) {
-    const path = options.path ?? new URL(originalRequest.url).pathname;
-    const method = options.method ?? originalRequest.method;
-    const env = options.env ?? {};
-    return {
-        request: mountedRequest,
-        env,
-        path,
-        method,
-        operationContext: createEffectOperationContext({
-            request: mountedRequest,
-            env,
-            path,
-            method
-        })
-    };
-}
-async function dispatchEffectBffRequestWithContext(handler, request, options) {
-    const requestPath = new URL(request.url).pathname;
-    if (!matchesEffectBffPrefix(requestPath, options.prefix)) return new Response('', {
-        status: 404
-    });
-    const mountedRequest = createEffectBffMountedRequest(request, options.prefix);
-    const effectContext = createEffectBffDispatchContext(request, mountedRequest, options);
-    try {
-        const response = await options.runWithEffectContext(effectContext, ()=>handler(mountedRequest, effectContext));
-        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return Response instance.');
-        return new Response(response.body, response);
-    } catch (error) {
-        if (error instanceof Response) return new Response(error.body, error);
-        if (options.onError) {
-            const errorResponse = await options.onError(error, effectContext);
-            if (errorResponse instanceof Response) return errorResponse;
-        }
-        return createSafeFailureResponse(error);
-    }
-}
-export { dispatchEffectBffRequestWithContext };

package/dist/esm-node/runtime/effect/edge-context.mjs

@@ -1,35 +0,0 @@
-import "node:module";
-const kEffectContext = Symbol.for('modernjs.plugin-bff.edgeEffectContext');
-const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.edgeEffectContextStorage');
-const globalStore = globalThis;
-const isPromiseLike = (value)=>'object' == typeof value && null !== value && 'then' in value && 'function' == typeof value.then;
-const getRuntimeStorage = ()=>{
-    if (globalStore[kEffectContextStorage]) return globalStore[kEffectContextStorage];
-    if ('function' == typeof globalStore.AsyncLocalStorage) globalStore[kEffectContextStorage] = new globalStore.AsyncLocalStorage();
-    return globalStore[kEffectContextStorage];
-};
-const runWithEffectContext = (context, cb)=>{
-    const storage = getRuntimeStorage();
-    if (storage) return storage.run(context, cb);
-    const previous = globalStore[kEffectContext];
-    globalStore[kEffectContext] = context;
-    try {
-        const result = cb();
-        if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
-            globalStore[kEffectContext] = previous;
-        });
-        globalStore[kEffectContext] = previous;
-        return result;
-    } catch (error) {
-        globalStore[kEffectContext] = previous;
-        throw error;
-    }
-};
-const useEffectContext = ()=>{
-    const context = getRuntimeStorage()?.getStore() ?? globalStore[kEffectContext];
-    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
-    return context;
-};
-const useOperationContext = ()=>useEffectContext().operationContext;
-export { createEffectOperationContext } from "./operation-context.mjs";
-export { runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm-node/runtime/effect/endpoint-contracts.mjs

@@ -1,69 +0,0 @@
-import "node:module";
-import { createOperationContractHash } from "@modern-js/bff-core";
-import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
-function resolveEffectEndpointName(endpoint) {
-    if ('string' == typeof endpoint.identifier && endpoint.identifier) return endpoint.identifier;
-    if ('string' == typeof endpoint.name && endpoint.name) return endpoint.name;
-    return '';
-}
-function ensureLeadingSlash(pathname) {
-    return pathname.startsWith('/') ? pathname : `/${pathname}`;
-}
-function normalizeEffectPrefix(prefix) {
-    if ('/' === prefix) return '';
-    return ensureLeadingSlash(prefix || '/api');
-}
-function getEffectRoutePath(prefix, endpointPath) {
-    const normalizedPrefix = normalizeEffectPrefix(prefix);
-    const normalizedEndpointPath = ensureLeadingSlash(endpointPath);
-    const finalEndpointPath = '/' === normalizedEndpointPath ? '' : endpointPath;
-    if (!normalizedPrefix && !finalEndpointPath) return '/';
-    return `${normalizedPrefix}${finalEndpointPath || ''}`;
-}
-function resolveEffectApiId(api) {
-    const fallback = 'EffectHttpApi';
-    if ('identifier' in api && 'string' == typeof api.identifier && api.identifier) return api.identifier;
-    return fallback;
-}
-function collectEffectEndpoints(reflect, api, prefix) {
-    const endpoints = [];
-    const apiId = resolveEffectApiId(api);
-    reflect(api, {
-        onGroup: ()=>{},
-        onEndpoint: ({ group, endpoint })=>{
-            endpoints.push({
-                apiId,
-                groupName: String(group.identifier),
-                endpointName: resolveEffectEndpointName(endpoint),
-                method: String(endpoint.method).toUpperCase(),
-                routePath: getEffectRoutePath(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);
-    });
-}
-function toOperationContractSources(endpoints) {
-    return endpoints.map(createEffectOperationContractSource);
-}
-function createEffectOperationContractSource(endpoint) {
-    return {
-        name: endpoint.endpointName,
-        httpMethod: endpoint.method,
-        routePath: endpoint.routePath
-    };
-}
-async function extractHttpApiFromModule(mod, isHttpApi) {
-    const facts = classifyEffectBffEntryModule(mod, {
-        isRequestHandler: (value)=>'function' == typeof value,
-        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
-        isHttpApi
-    });
-    return !facts?.legacyShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
-}
-function createEffectEndpointContractHash(endpoint, requestId) {
-    return createOperationContractHash(createEffectOperationContractSource(endpoint), requestId);
-}
-export { collectEffectEndpoints, createEffectEndpointContractHash, ensureLeadingSlash, extractHttpApiFromModule, normalizeEffectPrefix, toOperationContractSources };

package/dist/esm-node/runtime/effect/entry-shape.mjs

@@ -1,37 +0,0 @@
-import "node:module";
-const EFFECT_VALIDATOR_AWARE_FACTORY = Symbol.for('modernjs.effect.validatorAware');
-function isValidatorAwareHandlerFactory(factory) {
-    return Boolean('function' == typeof factory && factory[EFFECT_VALIDATOR_AWARE_FACTORY]);
-}
-const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.';
-function isEffectEntryRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function classifyEffectBffEntryModule(value, predicates) {
-    if (!isEffectEntryRecord(value)) return null;
-    const rootModule = value;
-    if (predicates.isRequestHandler(rootModule.handler)) return createEntryShapeFacts(rootModule, predicates, '`handler` export');
-    const defaultEntry = rootModule.default;
-    if (predicates.isRequestHandler(defaultEntry)) return createEntryShapeFacts(rootModule, predicates, 'default request handler');
-    const module = isEffectEntryRecord(defaultEntry) ? {
-        ...rootModule,
-        ...defaultEntry
-    } : rootModule;
-    if (predicates.isRequestHandler(module.handler)) return createEntryShapeFacts(module, predicates, '`handler` export');
-    return createEntryShapeFacts(module, predicates);
-}
-function createEntryShapeFacts(module, predicates, legacyShape) {
-    const createHandler = 'function' == typeof module.createHandler ? module.createHandler : void 0;
-    const api = predicates.isHttpApi(module.api) ? module.api : void 0;
-    const hasRuntimeLayer = void 0 !== module.layer;
-    return {
-        module,
-        legacyShape,
-        createHandler,
-        createHandlerValidatorAware: void 0 !== createHandler && predicates.isValidatorAwareHandlerFactory(createHandler),
-        api,
-        layer: module.layer,
-        hasRuntimeLayer
-    };
-}
-export { EFFECT_VALIDATOR_AWARE_FACTORY, classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage };

package/dist/esm-node/runtime/effect/handler/batch-handler.mjs

@@ -1,124 +0,0 @@
-import "node:module";
-import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestEnvelopeHeader, isPlainObject, measureTextBytes, normalizeMethod } from "../../data-platform/index.mjs";
-import { createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, promiseWithTimeout, toBatchItemError, toHeaderRecord } from "./batch.mjs";
-import { getMountedPrefixFromContext, removeMountedPrefixFromBatchPath } from "./routing.mjs";
-function createDataPlatformBatchRequestHandler(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 ?? 65536);
-    const batchConcurrency = Math.max(1, dataPlatformBatchOptions?.maxConcurrency ?? 4);
-    const batchItemTimeoutMs = Math.max(0, dataPlatformBatchOptions?.requestTimeoutMs ?? 10000);
-    const batchAllowedMethods = normalizeBatchAllowedMethods(dataPlatformBatchOptions?.allowedMethods);
-    const envelopeHeader = options.dataPlatform?.envelopeHeader || DEFAULT_DATA_ENVELOPE_HEADER;
-    const normalizedEnvelopeHeader = envelopeHeader.toLowerCase();
-    const handle = async (request, context)=>{
-        const mountedPrefix = getMountedPrefixFromContext(request, context);
-        const method = normalizeMethod(request.method);
-        if ('POST' !== method) return createBatchValidationResponse('Batch endpoint only supports POST requests', 405);
-        const contentType = request.headers.get('content-type') || '';
-        if (!contentType.includes('application/json')) return createBatchValidationResponse('Batch endpoint requires application/json content-type', 415);
-        const payloadText = await request.text();
-        if (measureTextBytes(payloadText) > batchMaxBytes) return createBatchValidationResponse(`Batch payload exceeds max size (${String(batchMaxBytes)} bytes)`, 413);
-        let payload;
-        try {
-            payload = JSON.parse(payloadText);
-        } catch  {
-            return createBatchValidationResponse('Invalid batch payload JSON');
-        }
-        if (!isBatchRequestPayload(payload)) return createBatchValidationResponse('Invalid batch payload shape');
-        if (0 === payload.items.length) return createBatchValidationResponse('Batch payload items cannot be empty');
-        if (payload.items.length > batchMaxSize) return createBatchValidationResponse(`Batch item count exceeds max size (${String(batchMaxSize)})`, 413);
-        const responseItems = await mapWithConcurrency(payload.items, batchConcurrency, async (rawItem, index)=>{
-            const fallbackId = `item_${String(index)}`;
-            const itemId = isPlainObject(rawItem) && 'string' == typeof rawItem.id ? rawItem.id : fallbackId;
-            if (!isPlainObject(rawItem)) return toBatchItemError(itemId, 400, 'Invalid batch item; expected object');
-            if ('string' != typeof rawItem.path || 0 === rawItem.path.length) return toBatchItemError(itemId, 400, 'Invalid batch item path');
-            if (!rawItem.path.startsWith('/')) return toBatchItemError(itemId, 400, 'Batch item path must start with "/"');
-            const normalizedItemPath = removeMountedPrefixFromBatchPath(rawItem.path, mountedPrefix);
-            const itemPathname = normalizedItemPath.split('?')[0] || normalizedItemPath;
-            if (itemPathname === batchPath || itemPathname.startsWith(`${batchPath}/`)) return toBatchItemError(itemId, 400, 'Batch item path cannot target batch endpoint');
-            const itemMethod = normalizeMethod('string' == typeof rawItem.method ? rawItem.method : void 0);
-            if (!batchAllowedMethods.has(itemMethod)) return toBatchItemError(itemId, 405, `Batch item method ${itemMethod} is not allowed`);
-            if (void 0 !== rawItem.body && null !== rawItem.body && 'string' != typeof rawItem.body) return toBatchItemError(itemId, 400, 'Batch item body must be a string when provided');
-            if (('GET' === itemMethod || 'HEAD' === itemMethod) && 'string' == typeof rawItem.body) return toBatchItemError(itemId, 400, `${itemMethod} batch item cannot include body`);
-            const normalizedHeaders = {};
-            if (void 0 !== rawItem.headers) {
-                if (!isPlainObject(rawItem.headers)) return toBatchItemError(itemId, 400, 'Batch item headers must be an object');
-                for (const [key, value] of Object.entries(rawItem.headers)){
-                    if ('string' != typeof value) return toBatchItemError(itemId, 400, `Invalid header "${key}" for batch item`);
-                    normalizedHeaders[key.toLowerCase()] = value;
-                }
-            }
-            if (!normalizedHeaders.traceparent) {
-                const encodedEnvelope = normalizedHeaders[normalizedEnvelopeHeader];
-                if ('string' == typeof encodedEnvelope) {
-                    const envelope = decodeRequestEnvelopeHeader(encodedEnvelope);
-                    if (envelope?.traceparent) normalizedHeaders.traceparent = envelope.traceparent;
-                }
-            }
-            if (!normalizedHeaders.traceparent) {
-                const requestTraceparent = request.headers.get('traceparent');
-                if (requestTraceparent) normalizedHeaders.traceparent = requestTraceparent;
-            }
-            const targetUrl = new URL(normalizedItemPath, request.url);
-            const requestHeaders = new Headers(normalizedHeaders);
-            const body = 'GET' === itemMethod || 'HEAD' === itemMethod ? void 0 : rawItem.body;
-            if (void 0 === body) requestHeaders.delete('content-type');
-            const itemRequest = new Request(targetUrl.toString(), {
-                method: itemMethod,
-                headers: requestHeaders,
-                body
-            });
-            try {
-                const itemResponse = await promiseWithTimeout(options.handleItem(itemRequest, context), batchItemTimeoutMs);
-                if (!(itemResponse instanceof Response)) return toBatchItemError(itemId, 500, 'Invalid response returned by batch item handler');
-                const bodyText = await itemResponse.text();
-                const responseItem = {
-                    id: itemId,
-                    status: itemResponse.status,
-                    headers: toHeaderRecord(itemResponse.headers),
-                    ...bodyText ? {
-                        body: bodyText
-                    } : {}
-                };
-                return responseItem;
-            } catch (error) {
-                if (error instanceof Response) {
-                    const bodyText = await error.text();
-                    return {
-                        id: itemId,
-                        status: error.status,
-                        headers: toHeaderRecord(error.headers),
-                        ...bodyText ? {
-                            body: bodyText
-                        } : {}
-                    };
-                }
-                const message = error instanceof Error ? error.message : String(error);
-                return toBatchItemError(itemId, 500, message);
-            }
-        });
-        const responsePayload = {
-            protocolVersion: 1,
-            batchId: payload.batchId,
-            receivedAt: Date.now(),
-            items: responseItems
-        };
-        return new Response(JSON.stringify(responsePayload), {
-            status: 200,
-            headers: {
-                'content-type': 'application/json; charset=utf-8',
-                [DEFAULT_DATA_BATCH_HEADER]: '1',
-                'x-modernjs-data-batch-id': payload.batchId
-            }
-        });
-    };
-    return {
-        enabled: batchEnabled,
-        path: batchPath,
-        handle
-    };
-}
-export { createDataPlatformBatchRequestHandler };