@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/dist/cjs/runtime/effect/context.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __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");
     };
 })();
 (()=>{
@@ -24,10 +28,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    createEffectOperationContext: ()=>external_operation_context_js_namespaceObject.createEffectOperationContext,
     runWithEffectContext: ()=>runWithEffectContext,
-    useEffectContext: ()=>useEffectContext
+    useEffectContext: ()=>useEffectContext,
+    useOperationContext: ()=>useOperationContext
 });
 const external_node_async_hooks_namespaceObject = require("node:async_hooks");
+const external_operation_context_js_namespaceObject = require("./operation-context.js");
 const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
 const globalStore = globalThis;
 const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new external_node_async_hooks_namespaceObject.AsyncLocalStorage());
@@ -37,11 +44,16 @@ const useEffectContext = ()=>{
     if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
     return context;
 };
+const useOperationContext = ()=>useEffectContext().operationContext;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
 exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
 exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectOperationContext",
     "runWithEffectContext",
-    "useEffectContext"
+    "useEffectContext",
+    "useOperationContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/effect/edge.js

@@ -0,0 +1,169 @@
+"use strict";
+var __webpack_modules__ = {
+    "../safe-failure" (module) {
+        module.exports = require("../safe-failure.js");
+    },
+    "./handler" (module) {
+        module.exports = require("./handler.js");
+    },
+    "./module" (module) {
+        module.exports = require("./module.js");
+    },
+    "./operation-context" (module) {
+        module.exports = require("./operation-context.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _safe_failure__rspack_import_0 = __webpack_require__("../safe-failure");
+    var _module__rspack_import_1 = __webpack_require__("./module");
+    var _operation_context__rspack_import_2 = __webpack_require__("./operation-context");
+    var _handler__rspack_import_3 = __webpack_require__("./handler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+        "default",
+        "dispatchEffectBffRequest",
+        "createEffectOperationContext",
+        "createEffectBffEdgeHandler"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    function normalizePrefix(prefix) {
+        if (!prefix || '/' === prefix) return '';
+        return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    }
+    function removePrefixFromPath(pathname, prefix) {
+        const normalized = normalizePrefix(prefix);
+        if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
+        const sliced = pathname.slice(normalized.length);
+        return sliced.startsWith('/') ? sliced : `/${sliced}`;
+    }
+    function matchesPrefix(pathname, prefix) {
+        const normalized = normalizePrefix(prefix);
+        return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
+    }
+    function createRequestForMountedPrefix(req, prefix) {
+        const url = new URL(req.url);
+        const nextPath = removePrefixFromPath(url.pathname, prefix);
+        if (nextPath === url.pathname) return req;
+        url.pathname = nextPath;
+        return new Request(url, req);
+    }
+    function createEdgeEffectContext(originalRequest, effectRequest, options) {
+        const originalPath = options.path || new URL(originalRequest.url).pathname;
+        const method = options.method || originalRequest.method;
+        return {
+            request: effectRequest,
+            env: options.env || {},
+            path: originalPath,
+            method,
+            operationContext: (0, _operation_context__rspack_import_2.createEffectOperationContext)({
+                request: effectRequest,
+                env: options.env || {},
+                path: originalPath,
+                method
+            })
+        };
+    }
+    function createRuntimeErrorResponse(error) {
+        return (0, _safe_failure__rspack_import_0.createSafeFailureResponse)(error);
+    }
+    async function dispatchEffectBffRequest(handler, request, options = {}) {
+        const requestPathname = new URL(request.url).pathname;
+        if (!matchesPrefix(requestPathname, options.prefix)) return new Response(null, {
+            status: 404
+        });
+        const effectRequest = createRequestForMountedPrefix(request, options.prefix);
+        const effectContext = createEdgeEffectContext(request, effectRequest, options);
+        try {
+            const response = handler.length > 1 ? await handler(effectRequest, effectContext) : await handler(effectRequest);
+            if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return a 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 createRuntimeErrorResponse(error);
+        }
+    }
+    async function createEffectBffEdgeHandler(options) {
+        const loaded = await (0, _module__rspack_import_1.resolveEffectBffModuleHandler)(options.module, {
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform,
+            onWarning: options.onWarning
+        });
+        if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export { api, layer }, createHandler, or handler.');
+        return {
+            handler: (request, dispatchOptions = {})=>dispatchEffectBffRequest(loaded.handler, request, {
+                    ...dispatchOptions,
+                    prefix: options.prefix,
+                    onError: options.onError
+                }),
+            dispose: async ()=>{
+                await loaded.dispose?.();
+            }
+        };
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        createEffectBffEdgeHandler: ()=>createEffectBffEdgeHandler,
+        createEffectOperationContext: ()=>_operation_context__rspack_import_2.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>dispatchEffectBffRequest
+    });
+})();
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectBffEdgeHandler",
+    "createEffectOperationContext",
+    "dispatchEffectBffRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/endpoint-contracts.js

@@ -0,0 +1,130 @@
+"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__, {
+    collectEffectEndpoints: ()=>collectEffectEndpoints,
+    createEffectEndpointContractHash: ()=>createEffectEndpointContractHash,
+    createEffectOperationContractSource: ()=>createEffectOperationContractSource,
+    ensureLeadingSlash: ()=>ensureLeadingSlash,
+    extractHttpApiFromModule: ()=>extractHttpApiFromModule,
+    getEffectRoutePath: ()=>getEffectRoutePath,
+    normalizeEffectPrefix: ()=>normalizeEffectPrefix,
+    resolveEffectApiId: ()=>resolveEffectApiId,
+    toOperationContractSources: ()=>toOperationContractSources
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+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: String(endpoint.name),
+                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
+    };
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+async function extractHttpApiFromModule(mod, isHttpApi) {
+    if (!isRecord(mod)) return null;
+    if (isHttpApi(mod.api)) return mod.api;
+    const entry = mod.default;
+    if (isRecord(entry) && isHttpApi(entry.api)) return entry.api;
+    if ('function' == typeof entry && 0 === entry.length) {
+        const output = await entry();
+        if (isRecord(output) && isHttpApi(output.api)) return output.api;
+    }
+    return null;
+}
+function createEffectEndpointContractHash(endpoint, requestId) {
+    return (0, bff_core_namespaceObject.createOperationContractHash)(createEffectOperationContractSource(endpoint), requestId);
+}
+exports.collectEffectEndpoints = __webpack_exports__.collectEffectEndpoints;
+exports.createEffectEndpointContractHash = __webpack_exports__.createEffectEndpointContractHash;
+exports.createEffectOperationContractSource = __webpack_exports__.createEffectOperationContractSource;
+exports.ensureLeadingSlash = __webpack_exports__.ensureLeadingSlash;
+exports.extractHttpApiFromModule = __webpack_exports__.extractHttpApiFromModule;
+exports.getEffectRoutePath = __webpack_exports__.getEffectRoutePath;
+exports.normalizeEffectPrefix = __webpack_exports__.normalizeEffectPrefix;
+exports.resolveEffectApiId = __webpack_exports__.resolveEffectApiId;
+exports.toOperationContractSources = __webpack_exports__.toOperationContractSources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectEffectEndpoints",
+    "createEffectEndpointContractHash",
+    "createEffectOperationContractSource",
+    "ensureLeadingSlash",
+    "extractHttpApiFromModule",
+    "getEffectRoutePath",
+    "normalizeEffectPrefix",
+    "resolveEffectApiId",
+    "toOperationContractSources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});