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

package/dist/esm/runtime/effect/adapter.mjs

@@ -0,0 +1,267 @@
+import { API_DIR, compatibleRequire, findExists, fs, isProd, logger } from "@modern-js/utils";
+import { HttpApi } from "effect/unstable/httpapi";
+import path from "path";
+import { runWithEffectContext } from "./context.mjs";
+import { createHttpApiHandler } from "./index.mjs";
+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.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 = path.resolve(appDirectory || process.cwd(), apiDirectory || API_DIR, 'effect', 'index');
+        const entryWithoutExt = configuredEntry ? path.isAbsolute(configuredEntry) ? configuredEntry : path.resolve(appDirectory || process.cwd(), configuredEntry) : defaultEntry;
+        return 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)) {
+            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 = 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 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 compatibleRequire(entryFile, false);
+        } catch (error) {
+            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) {
+            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) {
+            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 logger.error(error);
+        } catch (configError) {
+            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: 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 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 || isProd()) return;
+            await this.reloadHandler();
+        };
+        this.api = api;
+    }
+}
+export { EffectAdapter };

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

@@ -0,0 +1,11 @@
+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;
+};
+export { runWithEffectContext, useEffectContext };