@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

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

@@ -0,0 +1,311 @@
+"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, 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__.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__, {
+    EffectAdapter: ()=>EffectAdapter
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_context_js_namespaceObject = require("./context.js");
+const external_index_js_namespaceObject = require("./index.js");
+const before = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function normalizePrefix(prefix) {
+    if ('/' === 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 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 isRequestHandler(value) {
+    return 'function' == typeof value;
+}
+function maybeResponse(value) {
+    return value instanceof Response;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function includesRuntimeExports(value) {
+    return 'api' in value || 'layer' in value || 'createHandler' in value || 'handler' in value;
+}
+function isHttpApiWithProps(value) {
+    return httpapi_namespaceObject.HttpApi.isHttpApi(value) && isRecord(value) && 'string' == typeof value.identifier && isRecord(value.groups);
+}
+function isEffectApiDefinition(module) {
+    return isHttpApiWithProps(module.api) && void 0 !== module.layer;
+}
+class EffectAdapter {
+    resolveEntryFile() {
+        const { appDirectory, apiDirectory } = this.api.getServerContext();
+        const bffConfig = this.api.getServerConfig()?.bff;
+        const configuredEntry = bffConfig?.effect?.entry;
+        const defaultEntry = external_path_default().resolve(appDirectory || process.cwd(), apiDirectory || utils_namespaceObject.API_DIR, 'effect', 'index');
+        const entryWithoutExt = configuredEntry ? external_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_path_default().resolve(appDirectory || process.cwd(), configuredEntry) : defaultEntry;
+        return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
+    }
+    async loadEffectHandlerFromModule(mod) {
+        let normalizedModule = mod;
+        const mergeRuntimeExports = (value)=>{
+            if (!isRecord(value) || !includesRuntimeExports(value)) return;
+            normalizedModule = {
+                ...normalizedModule,
+                ...value
+            };
+        };
+        if (isRequestHandler(normalizedModule.handler)) return {
+            handler: normalizedModule.handler
+        };
+        const entry = normalizedModule.default;
+        if (isRequestHandler(entry)) return {
+            handler: entry
+        };
+        if ('function' == typeof entry && 0 === entry.length) {
+            const out = await entry();
+            if (isRequestHandler(out)) return {
+                handler: out
+            };
+            mergeRuntimeExports(out);
+        }
+        if (isRecord(entry)) normalizedModule = {
+            ...normalizedModule,
+            ...entry
+        };
+        if (isRecord(entry) && 'handler' in entry) {
+            const maybeHandler = entry.handler;
+            if (isRequestHandler(maybeHandler)) normalizedModule = {
+                ...normalizedModule,
+                handler: maybeHandler
+            };
+        }
+        if (isRequestHandler(normalizedModule.handler)) return {
+            handler: normalizedModule.handler
+        };
+        if ('function' == typeof normalizedModule.createHandler) {
+            const webHandler = normalizedModule.createHandler({
+                openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
+                dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform
+            });
+            return {
+                handler: async (request)=>webHandler.handler(request),
+                dispose: async ()=>{
+                    await webHandler.dispose();
+                }
+            };
+        }
+        if (isEffectApiDefinition(normalizedModule)) {
+            utils_namespaceObject.logger.warn('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
+            const webHandler = (0, external_index_js_namespaceObject.createHttpApiHandler)({
+                api: normalizedModule.api,
+                layer: normalizedModule.layer,
+                openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
+                dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform
+            });
+            return {
+                handler: async (request)=>webHandler.handler(request),
+                dispose: async ()=>{
+                    await webHandler.dispose();
+                }
+            };
+        }
+        return null;
+    }
+    async reloadHandler() {
+        if (!this.isEffect) return;
+        const entryFile = this.resolveEntryFile();
+        if (!entryFile) {
+            await this.disposeCurrentHandler();
+            this.handler = null;
+            return;
+        }
+        if (!await utils_namespaceObject.fs.pathExists(entryFile)) {
+            await this.disposeCurrentHandler();
+            this.handler = null;
+            return;
+        }
+        await this.disposeCurrentHandler();
+        const resolvedEntryFile = require.resolve(entryFile);
+        if (Object.hasOwn(require.cache, resolvedEntryFile)) delete require.cache[resolvedEntryFile];
+        let mod;
+        try {
+            mod = await (0, utils_namespaceObject.compatibleRequire)(entryFile, false);
+        } catch (error) {
+            utils_namespaceObject.logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+            this.handler = null;
+            return;
+        }
+        const loaded = await this.loadEffectHandlerFromModule(mod);
+        if (!loaded) {
+            utils_namespaceObject.logger.warn(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export { api, layer } or handler.`);
+            this.handler = null;
+            return;
+        }
+        this.handler = loaded.handler;
+        this.dispose = loaded.dispose || null;
+    }
+    async disposeCurrentHandler() {
+        if (!this.dispose) return;
+        try {
+            await this.dispose();
+        } catch (error) {
+            utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to dispose previous handler: ${String(error)}`);
+        } finally{
+            this.dispose = null;
+        }
+    }
+    async handleRuntimeError(error, c) {
+        try {
+            const serverConfig = this.api.getServerConfig();
+            const onErrorHandler = serverConfig?.onError;
+            if (onErrorHandler) {
+                const onErrorContext = this.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}`);
+        }
+        const status = 'object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status ? error.status : 500;
+        return new Response(JSON.stringify({
+            message: error instanceof Error ? error.message : '[BFF] Internal Server Error'
+        }), {
+            status,
+            headers: {
+                'content-type': 'application/json; charset=utf-8'
+            }
+        });
+    }
+    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, status = 200, extraHeaders)=>{
+                const responseHeaders = new Headers(headers);
+                if (extraHeaders) new Headers(extraHeaders).forEach((value, key)=>{
+                    responseHeaders.set(key, value);
+                });
+                return new Response(JSON.stringify(data), {
+                    status,
+                    headers: responseHeaders
+                });
+            }
+        });
+        return withJson;
+    }
+    constructor(api){
+        this.isEffect = true;
+        this.effectMiddleware = null;
+        this.handler = null;
+        this.dispose = null;
+        this.registerMiddleware = async (options)=>{
+            const { prefix, enableHandleWeb } = options;
+            const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
+            if ('hono' === bffRuntimeFramework) {
+                this.isEffect = false;
+                return;
+            }
+            await this.reloadHandler();
+            this.effectMiddleware = {
+                name: 'effect-bff-handler',
+                path: enableHandleWeb ? '*' : `${prefix}/*`,
+                method: 'all',
+                order: 'post',
+                before,
+                handler: async (c, next)=>{
+                    if (!this.handler) {
+                        if (enableHandleWeb) return void await next();
+                        return this.handleRuntimeError(new Error('[BFF][Effect] Missing Effect entry. Define api/effect/index or configure bff.effect.entry.'), c);
+                    }
+                    let response;
+                    try {
+                        const effectRequest = createRequestForMountedPrefix(c.req.raw, prefix);
+                        const effectContext = {
+                            request: effectRequest,
+                            env: c.env,
+                            path: c.req.path,
+                            method: c.req.method
+                        };
+                        response = await (0, external_context_js_namespaceObject.runWithEffectContext)(effectContext, ()=>this.handler.length > 1 ? this.handler(effectRequest, effectContext) : this.handler(effectRequest));
+                    } catch (error) {
+                        return this.handleRuntimeError(error, c);
+                    }
+                    if (!maybeResponse(response)) return this.handleRuntimeError(new Error('[BFF][Effect] Effect handler must return a Response instance.'), c);
+                    if (404 === response.status && enableHandleWeb) return void await next();
+                    return new Response(response.body, response);
+                }
+            };
+            globalMiddlewares.push(this.effectMiddleware);
+        };
+        this.onApiHandlersUpdated = async ()=>{
+            if (!this.isEffect || (0, utils_namespaceObject.isProd)()) return;
+            await this.reloadHandler();
+        };
+        this.api = api;
+    }
+}
+exports.EffectAdapter = __webpack_exports__.EffectAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EffectAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,48 @@
+"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__.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__, {
+    runWithEffectContext: ()=>runWithEffectContext,
+    useEffectContext: ()=>useEffectContext
+});
+const external_node_async_hooks_namespaceObject = require("node:async_hooks");
+const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
+const globalStore = globalThis;
+const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new external_node_async_hooks_namespaceObject.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;
+};
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runWithEffectContext",
+    "useEffectContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});