@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.9 → 3.2.0-ultramodern.91

package/dist/esm-node/loader.mjs

@@ -4,6 +4,24 @@ import { generateClient } from "@modern-js/bff-core";
 import { logger } from "@modern-js/utils";
 import path from "path";
 import { generateEffectClientCode, resolveEffectEntryFile } from "./utils/effectClientGenerator.mjs";
+async function transformEffectRuntimeSource(source, filename) {
+    const swc = await import("@swc/core");
+    const result = await swc.transform(source, {
+        filename,
+        sourceMaps: false,
+        jsc: {
+            parser: {
+                syntax: "typescript",
+                tsx: filename.endsWith('.tsx') || filename.endsWith('.jsx')
+            },
+            target: 'es2022'
+        },
+        module: {
+            type: 'es6'
+        }
+    });
+    return result.code;
+}
 async function loader(source) {
     this.cacheable();
     const { resourcePath } = this;
@@ -15,6 +33,11 @@ async function loader(source) {
         apiDir: draftOptions.apiDir,
         effectEntry: draftOptions.effectEntry
     });
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath) && this.resourceQuery.includes('modern-bff-runtime')) {
+        const code = await transformEffectRuntimeSource(source, resourcePath);
+        callback(void 0, code);
+        return;
+    }
     if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath)) {
         const code = await generateEffectClientCode({
             appDir: draftOptions.appDir,

package/dist/esm-node/runtime/data-platform/index.mjs

@@ -1,4 +1,26 @@
 import "node:module";
+import { trace as api_trace } from "@opentelemetry/api";
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    onEvent?.(event);
+    api_trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+}
 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';
@@ -416,7 +438,7 @@ function createDataBatchTransport(options = {}) {
         bucket.items = [];
         bucket.bytes = 0;
         if (1 === items.length || disabledEndpoints.has(endpoint)) {
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: disabledEndpoints.has(endpoint) ? 'fallback' : 'flush',
                 endpoint,
                 size: items.length,
@@ -433,7 +455,7 @@ function createDataBatchTransport(options = {}) {
             sentAt: Date.now(),
             items: items.map((item)=>item.item)
         };
-        onEvent?.({
+        emitDataBatchTransportEvent(onEvent, {
             type: 'flush',
             endpoint,
             batchId,
@@ -460,7 +482,7 @@ function createDataBatchTransport(options = {}) {
                 requestInit.signal = controller.signal;
                 timeoutHandle = setTimeout(()=>{
                     controller.abort();
-                    onEvent?.({
+                    emitDataBatchTransportEvent(onEvent, {
                         type: 'fallback',
                         endpoint,
                         batchId,
@@ -473,13 +495,13 @@ function createDataBatchTransport(options = {}) {
             if (!response.ok) {
                 if (404 === response.status || 405 === response.status) {
                     disabledEndpoints.add(endpoint);
-                    onEvent?.({
+                    emitDataBatchTransportEvent(onEvent, {
                         type: 'disable',
                         endpoint,
                         batchId,
                         reason: `batch-endpoint-unavailable-${String(response.status)}`
                     });
-                } else onEvent?.({
+                } else emitDataBatchTransportEvent(onEvent, {
                     type: 'fallback',
                     endpoint,
                     batchId,
@@ -492,7 +514,7 @@ function createDataBatchTransport(options = {}) {
             }
             const result = await response.json();
             if (!isBatchResponsePayload(result)) {
-                onEvent?.({
+                emitDataBatchTransportEvent(onEvent, {
                     type: 'fallback',
                     endpoint,
                     batchId,
@@ -515,7 +537,7 @@ function createDataBatchTransport(options = {}) {
                 return parseResponseLikeCreateRequest(reconstructedResponse);
             });
         } catch (error) {
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: 'fallback',
                 endpoint,
                 batchId,
@@ -582,7 +604,7 @@ function createDataBatchTransport(options = {}) {
             };
             bucket.items.push(queued);
             bucket.bytes += size;
-            onEvent?.({
+            emitDataBatchTransportEvent(onEvent, {
                 type: 'enqueue',
                 endpoint,
                 size: bucket.items.length
@@ -597,4 +619,4 @@ function createDataBatchTransport(options = {}) {
         return promise;
     };
 }
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, buildQueryKey, buildScopeKey, createDataBatchTransport, createHydrationEnvelope, createInvalidationEvent, createOperationId, createRequestEnvelope, decodeRequestEnvelopeHeader, deriveChildTraceContext, encodeRequestEnvelopeHeader, formatTraceparentHeader, normalizeOrigin, parseTraceparentHeader, shouldApplyInvalidation, stableStringify, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, buildQueryKey, buildScopeKey, createDataBatchTransport, createDataBatchTransportTelemetryAttributes, createHydrationEnvelope, createInvalidationEvent, createOperationId, createRequestEnvelope, decodeRequestEnvelopeHeader, deriveChildTraceContext, emitDataBatchTransportEvent, encodeRequestEnvelopeHeader, formatTraceparentHeader, normalizeOrigin, parseTraceparentHeader, shouldApplyInvalidation, stableStringify, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };

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

@@ -1,10 +1,9 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 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";
+import { createEffectOperationContext, runWithEffectContext } from "./context.mjs";
+import { resolveEffectBffModuleHandler } from "./module.mjs";
 const before = [
     'custom-server-hook',
     'custom-server-middleware',
@@ -37,24 +36,9 @@ function createRequestForMountedPrefix(req, prefix) {
     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();
@@ -65,70 +49,13 @@ class EffectAdapter {
         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;
+        return resolveEffectBffModuleHandler(mod, {
+            openapi: this.api.getServerConfig()?.bff?.effect?.openapi,
+            dataPlatform: this.api.getServerConfig()?.bff?.effect?.dataPlatform,
+            onWarning: (message)=>{
+                logger.warn(message);
+            }
+        });
     }
     async reloadHandler() {
         if (!this.isEffect) return;
@@ -246,7 +173,13 @@ class EffectAdapter {
                             request: effectRequest,
                             env: c.env,
                             path: c.req.path,
-                            method: c.req.method
+                            method: c.req.method,
+                            operationContext: createEffectOperationContext({
+                                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) {

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

@@ -9,4 +9,6 @@ const useEffectContext = ()=>{
     if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
     return context;
 };
-export { runWithEffectContext, useEffectContext };
+const useOperationContext = ()=>useEffectContext().operationContext;
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { runWithEffectContext, useEffectContext, useOperationContext };

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

@@ -0,0 +1,91 @@
+import "node:module";
+import { resolveEffectBffModuleHandler } from "./module.mjs";
+import { createEffectOperationContext } from "./operation-context.mjs";
+export * from "./handler.mjs";
+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: createEffectOperationContext({
+            request: effectRequest,
+            env: options.env || {},
+            path: originalPath,
+            method
+        })
+    };
+}
+function createRuntimeErrorResponse(error) {
+    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'
+        }
+    });
+}
+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 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?.();
+        }
+    };
+}
+export { createEffectBffEdgeHandler, createEffectOperationContext, dispatchEffectBffRequest };