@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/cjs/runtime/data-platform/invalidation.js

@@ -0,0 +1,61 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createInvalidationEvent: ()=>createInvalidationEvent,
+    shouldApplyInvalidation: ()=>shouldApplyInvalidation
+});
+const external_codec_js_namespaceObject = require("./codec.js");
+function createInvalidationEvent(input) {
+    return {
+        sourceNamespace: (0, external_codec_js_namespaceObject.sanitizeSegment)(input.sourceOperation.appNamespace),
+        sourceOperationId: (0, external_codec_js_namespaceObject.createOperationId)(input.sourceOperation),
+        scopeKey: (0, external_codec_js_namespaceObject.buildScopeKey)(input.sourceScope),
+        targetNamespaces: input.targetNamespaces?.map((namespace)=>(0, external_codec_js_namespaceObject.sanitizeSegment)(namespace)),
+        targetOperationIds: input.targetOperations?.map((operation)=>(0, external_codec_js_namespaceObject.createOperationId)(operation))
+    };
+}
+function shouldApplyInvalidation(event, subscriber) {
+    if (subscriber.scopeKey && subscriber.scopeKey !== event.scopeKey) return false;
+    const sameNamespace = subscriber.namespace === event.sourceNamespace;
+    const allowedCrossNamespace = true === subscriber.acceptCrossNamespace && event.targetNamespaces?.includes(subscriber.namespace) === true;
+    if (!sameNamespace && !allowedCrossNamespace) return false;
+    if (!subscriber.operationIds || 0 === subscriber.operationIds.length) return true;
+    if (!event.targetOperationIds || 0 === event.targetOperationIds.length) return true;
+    return subscriber.operationIds.some((operationId)=>event.targetOperationIds?.includes(operationId));
+}
+exports.createInvalidationEvent = __webpack_exports__.createInvalidationEvent;
+exports.shouldApplyInvalidation = __webpack_exports__.shouldApplyInvalidation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createInvalidationEvent",
+    "shouldApplyInvalidation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/trace.js

@@ -0,0 +1,73 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    deriveChildTraceContext: ()=>deriveChildTraceContext,
+    formatTraceparentHeader: ()=>formatTraceparentHeader,
+    parseTraceparentHeader: ()=>parseTraceparentHeader
+});
+const create_request_namespaceObject = require("@modern-js/create-request");
+function isAllZeroHex(value) {
+    return /^0+$/.test(value);
+}
+function isValidHex(value, length) {
+    return value.length === length && /^[0-9a-f]+$/.test(value);
+}
+function parseTraceparentHeader(header) {
+    return (0, create_request_namespaceObject.parseTraceparent)(header) ?? null;
+}
+function formatTraceparentHeader(trace) {
+    const traceId = trace.traceId.toLowerCase();
+    const spanId = trace.spanId.toLowerCase();
+    if (!isValidHex(traceId, 32) || !isValidHex(spanId, 16)) throw new Error('Invalid trace context: traceId/spanId format mismatch');
+    if (isAllZeroHex(traceId) || isAllZeroHex(spanId)) throw new Error('Invalid trace context: traceId/spanId cannot be zero');
+    const flags = trace.sampled ? '01' : '00';
+    return `00-${traceId}-${spanId}-${flags}`;
+}
+function deriveChildTraceContext(parent, childSpanId) {
+    const normalizedSpanId = childSpanId.toLowerCase();
+    if (!isValidHex(normalizedSpanId, 16) || isAllZeroHex(normalizedSpanId)) throw new Error('Invalid child span id');
+    return {
+        traceId: parent.traceId.toLowerCase(),
+        spanId: normalizedSpanId,
+        sampled: parent.sampled,
+        parentSpanId: parent.spanId.toLowerCase()
+    };
+}
+exports.deriveChildTraceContext = __webpack_exports__.deriveChildTraceContext;
+exports.formatTraceparentHeader = __webpack_exports__.formatTraceparentHeader;
+exports.parseTraceparentHeader = __webpack_exports__.parseTraceparentHeader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "deriveChildTraceContext",
+    "formatTraceparentHeader",
+    "parseTraceparentHeader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/types.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__);
+const DEFAULT_DATA_ENVELOPE_HEADER = 'x-modernjs-data-envelope';
+const DEFAULT_DATA_BATCH_ENDPOINT = '/_data/batch';
+const DEFAULT_DATA_BATCH_HEADER = 'x-modernjs-data-batch';
+__webpack_require__.d(__webpack_exports__, {}, {
+    DEFAULT_DATA_BATCH_ENDPOINT: DEFAULT_DATA_BATCH_ENDPOINT,
+    DEFAULT_DATA_BATCH_HEADER: DEFAULT_DATA_BATCH_HEADER,
+    DEFAULT_DATA_ENVELOPE_HEADER: DEFAULT_DATA_ENVELOPE_HEADER
+});
+exports.DEFAULT_DATA_BATCH_ENDPOINT = __webpack_exports__.DEFAULT_DATA_BATCH_ENDPOINT;
+exports.DEFAULT_DATA_BATCH_HEADER = __webpack_exports__.DEFAULT_DATA_BATCH_HEADER;
+exports.DEFAULT_DATA_ENVELOPE_HEADER = __webpack_exports__.DEFAULT_DATA_ENVELOPE_HEADER;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_DATA_BATCH_ENDPOINT",
+    "DEFAULT_DATA_BATCH_HEADER",
+    "DEFAULT_DATA_ENVELOPE_HEADER"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/validation.js

@@ -0,0 +1,178 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createHydrationEnvelope: ()=>createHydrationEnvelope,
+    createRequestEnvelope: ()=>createRequestEnvelope,
+    validateHydrationEnvelope: ()=>validateHydrationEnvelope,
+    validateRequestEnvelope: ()=>validateRequestEnvelope,
+    validateSelectionPlan: ()=>validateSelectionPlan
+});
+const external_codec_js_namespaceObject = require("./codec.js");
+const external_trace_js_namespaceObject = require("./trace.js");
+function validateSelectionPlan(plan, options = {}) {
+    const maxDepthLimit = options.maxDepth ?? 8;
+    const maxFieldsLimit = options.maxFields ?? 256;
+    const allowedLeafPaths = options.allowedLeafPaths ? new Set(options.allowedLeafPaths) : null;
+    const errors = [];
+    let maxDepth = 0;
+    let fieldCount = 0;
+    const walk = (node, path)=>{
+        if (!(0, external_codec_js_namespaceObject.isPlainObject)(node)) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" must be an object`);
+        const keys = Object.keys(node);
+        if (0 === keys.length) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" cannot be empty`);
+        for (const key of keys){
+            fieldCount += 1;
+            if (fieldCount > maxFieldsLimit) return void errors.push(`Selection has too many fields: ${String(fieldCount)} > ${String(maxFieldsLimit)}`);
+            const nextPath = [
+                ...path,
+                key
+            ];
+            const depth = nextPath.length;
+            if (depth > maxDepth) maxDepth = depth;
+            if (depth > maxDepthLimit) return void errors.push(`Selection exceeds maxDepth at "${nextPath.join('.')}" (${String(depth)} > ${String(maxDepthLimit)})`);
+            const value = node[key];
+            if (true === value) {
+                if (allowedLeafPaths && !allowedLeafPaths.has(nextPath.join('.'))) errors.push(`Unknown selected field "${nextPath.join('.')}"`);
+                continue;
+            }
+            if (!(0, external_codec_js_namespaceObject.isPlainObject)(value)) {
+                errors.push(`Invalid selection value at "${nextPath.join('.')}"; expected true or nested object`);
+                continue;
+            }
+            walk(value, nextPath);
+        }
+    };
+    walk(plan, []);
+    return {
+        ok: 0 === errors.length,
+        errors,
+        stats: {
+            maxDepth,
+            fieldCount
+        }
+    };
+}
+function createRequestEnvelope(input) {
+    if (input.requireTraceContext && !input.traceContext) throw new Error('Trace context is required for this request envelope');
+    const traceparent = input.traceContext ? (0, external_trace_js_namespaceObject.formatTraceparentHeader)(input.traceContext) : void 0;
+    const envelope = {
+        protocolVersion: input.protocolVersion ?? 1,
+        operationId: (0, external_codec_js_namespaceObject.createOperationId)(input.operation),
+        appNamespace: (0, external_codec_js_namespaceObject.sanitizeSegment)(input.scope.appNamespace),
+        origin: (0, external_codec_js_namespaceObject.normalizeOrigin)(input.scope.origin),
+        requestMode: input.requestMode ?? 'cache-first',
+        mutationMode: input.mutationMode,
+        scopeKey: (0, external_codec_js_namespaceObject.buildScopeKey)(input.scope),
+        input: input.requestInput,
+        inputHash: (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(input.requestInput ?? null)),
+        selectionPlan: input.selectionPlan,
+        selectionHash: input.selectionPlan ? (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(input.selectionPlan)) : void 0,
+        traceparent,
+        timestamp: input.timestamp ?? Date.now()
+    };
+    return envelope;
+}
+function validateRequestEnvelope(envelope, options = {}) {
+    const errors = [];
+    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
+    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
+    if (options.expectedOrigin) {
+        const expectedOrigin = (0, external_codec_js_namespaceObject.normalizeOrigin)(options.expectedOrigin);
+        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
+    }
+    if (!envelope.operationId) errors.push('Missing operationId');
+    if (!envelope.scopeKey) errors.push('Missing scopeKey');
+    if (options.requireTraceContext && !envelope.traceparent) errors.push('Missing trace context');
+    if (envelope.traceparent && !(0, external_trace_js_namespaceObject.parseTraceparentHeader)(envelope.traceparent)) errors.push('Invalid traceparent header');
+    const computedInputHash = (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(envelope.input ?? null));
+    if (computedInputHash !== envelope.inputHash) errors.push('Input hash mismatch');
+    if (envelope.selectionPlan) {
+        const computedSelectionHash = (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(envelope.selectionPlan));
+        if (computedSelectionHash !== envelope.selectionHash) errors.push('Selection hash mismatch');
+    }
+    return {
+        ok: 0 === errors.length,
+        errors
+    };
+}
+function createHydrationEnvelope(input) {
+    const envelopeWithoutChecksum = {
+        protocolVersion: input.protocolVersion ?? 1,
+        runtimeVersion: input.runtimeVersion,
+        appNamespace: (0, external_codec_js_namespaceObject.sanitizeSegment)(input.scope.appNamespace),
+        origin: (0, external_codec_js_namespaceObject.normalizeOrigin)(input.scope.origin),
+        createdAt: input.createdAt ?? Date.now(),
+        payload: input.payload
+    };
+    const checksum = (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(envelopeWithoutChecksum));
+    return {
+        ...envelopeWithoutChecksum,
+        checksum
+    };
+}
+function validateHydrationEnvelope(envelope, options = {}) {
+    const errors = [];
+    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
+    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
+    if (options.expectedOrigin) {
+        const expectedOrigin = (0, external_codec_js_namespaceObject.normalizeOrigin)(options.expectedOrigin);
+        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
+    }
+    if (options.expectedRuntimeVersion && envelope.runtimeVersion !== options.expectedRuntimeVersion) errors.push(`Runtime version mismatch: expected ${options.expectedRuntimeVersion} but received ${envelope.runtimeVersion}`);
+    const checksumBase = {
+        protocolVersion: envelope.protocolVersion,
+        runtimeVersion: envelope.runtimeVersion,
+        appNamespace: envelope.appNamespace,
+        origin: envelope.origin,
+        createdAt: envelope.createdAt,
+        payload: envelope.payload
+    };
+    const checksum = (0, external_codec_js_namespaceObject.hashString)((0, external_codec_js_namespaceObject.stableStringify)(checksumBase));
+    if (checksum !== envelope.checksum) errors.push('Hydration checksum mismatch');
+    return {
+        ok: 0 === errors.length,
+        errors
+    };
+}
+exports.createHydrationEnvelope = __webpack_exports__.createHydrationEnvelope;
+exports.createRequestEnvelope = __webpack_exports__.createRequestEnvelope;
+exports.validateHydrationEnvelope = __webpack_exports__.validateHydrationEnvelope;
+exports.validateRequestEnvelope = __webpack_exports__.validateRequestEnvelope;
+exports.validateSelectionPlan = __webpack_exports__.validateSelectionPlan;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHydrationEnvelope",
+    "createRequestEnvelope",
+    "validateHydrationEnvelope",
+    "validateRequestEnvelope",
+    "validateSelectionPlan"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/adapter/constants.js

@@ -0,0 +1,44 @@
+"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__);
+const before = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    before: before
+});
+exports.before = __webpack_exports__.before;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "before"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/adapter/cross-project-policy.js

@@ -0,0 +1,61 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveEffectAdapterCrossProjectPolicy: ()=>resolveEffectAdapterCrossProjectPolicy
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const crossProjectServerPolicy_js_namespaceObject = require("../../../utils/crossProjectServerPolicy.js");
+const external_endpoint_contracts_js_namespaceObject = require("../endpoint-contracts.js");
+async function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+    let contractSources = [];
+    if (mod) try {
+        const effectApi = await (0, external_endpoint_contracts_js_namespaceObject.extractHttpApiFromModule)(mod, httpapi_namespaceObject.HttpApi.isHttpApi);
+        if (effectApi) {
+            const reflect = (apiValue, handlers)=>httpapi_namespaceObject.HttpApi.reflect(apiValue, {
+                    onGroup: handlers.onGroup ?? (()=>{}),
+                    onEndpoint: handlers.onEndpoint
+                });
+            contractSources = (0, external_endpoint_contracts_js_namespaceObject.toOperationContractSources)((0, external_endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(reflect, effectApi, prefix));
+        }
+    } catch (error) {
+        utils_namespaceObject.logger.warn(`[BFF][Effect] Failed reflect HttpApi endpoints cross-project policy: ${String(error)}`);
+    }
+    const policy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(api, contractSources);
+    if (policy?.enabled && 0 === contractSources.length) utils_namespaceObject.logger.warn('[BFF][Effect] Cross-project policy enabled but no HttpApi endpoints could be reflected; requests fail operation-contract matching unless allowUnknownOperations is enabled.');
+    return policy;
+}
+exports.resolveEffectAdapterCrossProjectPolicy = __webpack_exports__.resolveEffectAdapterCrossProjectPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectAdapterCrossProjectPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/adapter/entry.js

@@ -0,0 +1,77 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveEffectAdapterEntryFile: ()=>resolveEffectAdapterEntryFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function resolveJsOrTsEntry(entryWithoutOrWithExt) {
+    const extension = external_path_default().extname(entryWithoutOrWithExt);
+    if (JS_OR_TS_EXTS.includes(extension)) return utils_namespaceObject.fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
+    return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`));
+}
+function resolveEffectAdapterEntryFile(api) {
+    const { appDirectory, apiDirectory } = api.getServerContext();
+    const bffConfig = api.getServerConfig()?.bff;
+    const configuredEntry = bffConfig?.effect?.entry;
+    if (configuredEntry) {
+        const entryWithoutExt = external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory || process.cwd(), configuredEntry);
+        return resolveJsOrTsEntry(entryWithoutExt);
+    }
+    const apiRoot = external_path_default().resolve(appDirectory || process.cwd(), apiDirectory || utils_namespaceObject.API_DIR);
+    return resolveJsOrTsEntry(external_path_default().resolve(apiRoot, 'index'));
+}
+exports.resolveEffectAdapterEntryFile = __webpack_exports__.resolveEffectAdapterEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectAdapterEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/adapter/error-response.js

@@ -0,0 +1,79 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createEffectAdapterRuntimeErrorResponse: ()=>createEffectAdapterRuntimeErrorResponse
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_safe_failure_js_namespaceObject = require("../../safe-failure.js");
+async function createEffectAdapterRuntimeErrorResponse(api, error, c) {
+    try {
+        const serverConfig = api.getServerConfig();
+        const onErrorHandler = serverConfig?.onError;
+        if (onErrorHandler) {
+            const onErrorContext = ensureJsonContext(c);
+            const result = await onErrorHandler(error instanceof Error ? error : new Error(String(error)), onErrorContext);
+            if (result instanceof Response) return result;
+        } else utils_namespaceObject.logger.error(error);
+    } catch (configError) {
+        utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
+    }
+    return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(error);
+}
+function ensureJsonContext(c) {
+    const maybeJsonContext = c;
+    if ('function' == typeof maybeJsonContext.json) return c;
+    const headers = {
+        'content-type': 'application/json; charset=utf-8'
+    };
+    const withJson = Object.assign({}, c, {
+        json (data, statusOrInit = 200, extraHeaders) {
+            const responseInit = 'number' == typeof statusOrInit ? {
+                status: statusOrInit,
+                headers: extraHeaders
+            } : statusOrInit;
+            const responseHeaders = new Headers(headers);
+            if (responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
+                responseHeaders.set(key, value);
+            });
+            return new Response(JSON.stringify(data), {
+                ...responseInit,
+                headers: responseHeaders
+            });
+        }
+    });
+    return withJson;
+}
+exports.createEffectAdapterRuntimeErrorResponse = __webpack_exports__.createEffectAdapterRuntimeErrorResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectAdapterRuntimeErrorResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});