@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.2

package/dist/esm/client-generator/rendering.mjs

@@ -0,0 +1,209 @@
+import { buildOperationContractMap, deriveOperationVersion } from "@modern-js/bff-core";
+import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix, toOperationContractSources } from "@modern-js/bff-effect/effect";
+import { fs, upath } from "@modern-js/utils";
+const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
+const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function resolveBatchEndpoint(prefix, endpoint) {
+    const value = void 0 === endpoint || '' === endpoint ? '/_data/batch' : endpoint;
+    if (isAbsoluteUrl(value)) return value;
+    const normalizedPrefix = normalizeEffectPrefix(prefix);
+    const normalizedEndpoint = ensureLeadingSlash(value);
+    if ('' === normalizedPrefix) return normalizedEndpoint;
+    if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
+    return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
+}
+function getPackageInfo(resourcePath, appDir, onDependency) {
+    for (const startDir of [
+        upath.dirname(resourcePath),
+        appDir
+    ]){
+        let current = upath.resolve(startDir);
+        for(let depth = 0; depth < 32; depth += 1){
+            const packageJsonPath = upath.join(current, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                onDependency?.(packageJsonPath);
+                try {
+                    const packageJson = fs.readJSONSync(packageJsonPath);
+                    return {
+                        name: packageJson.name,
+                        version: packageJson.version
+                    };
+                } catch  {
+                    return {};
+                }
+            }
+            const parent = upath.dirname(current);
+            if (parent === current) break;
+            current = parent;
+        }
+    }
+    return {};
+}
+function renderEffectClientCode(generation) {
+    const { config, manifest } = generation;
+    return `import * as __requestRuntime from ${JSON.stringify(generation.requestCreator)};
+import { createGeneratedEffectClient } from ${JSON.stringify(EFFECT_CLIENT_RUNTIME_IMPORT)};
+
+const __manifest = ${JSON.stringify(manifest, null, 2)};
+
+const __config = ${JSON.stringify(config, null, 2)};
+
+const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
+
+const client = __generated.client;
+const operationManifest = __generated.operationManifest;
+const createEffectRequestContext = __generated.createEffectRequestContext;
+const apiModule = {
+  client,
+  operationManifest,
+  createEffectRequestContext,
+};
+
+export { client, createEffectRequestContext, operationManifest };
+export default apiModule;
+`;
+}
+function createEffectClientGeneration(endpoints, options) {
+    const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
+    const httpMethodDecider = options.httpMethodDecider || 'functionName';
+    const packageInfo = getPackageInfo(options.resourcePath, options.appDir, options.onDependency);
+    const packageName = packageInfo.name;
+    const dataPlatformAppNamespace = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
+    const requestId = 'bundle' === options.target ? void 0 !== options.requestId && '' !== options.requestId.trim() ? options.requestId.trim() : void 0 !== packageName && '' !== packageName ? packageName : void 0 : void 0;
+    const normalizedRequestId = void 0 === requestId || '' === requestId ? 'default' : requestId;
+    const operationVersion = deriveOperationVersion(packageInfo.version);
+    const batchConfig = options.dataPlatformBatch;
+    const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
+    const manifest = {
+        endpoints: endpoints.map((endpoint)=>({
+                apiId: endpoint.apiId,
+                group: endpoint.groupName,
+                endpoint: endpoint.endpointName,
+                method: endpoint.method,
+                routePath: endpoint.routePath,
+                schemaHash: createEffectEndpointContractHash(endpoint, normalizedRequestId),
+                operationVersion
+            }))
+    };
+    const config = {
+        appNamespace: dataPlatformAppNamespace,
+        ...void 0 !== requestId && '' !== requestId ? {
+            requestId
+        } : {},
+        port: options.port,
+        useEnvPort: 'server' === options.target,
+        defaultOrigin: `http://localhost:${String(options.port)}`,
+        httpMethodDecider,
+        batch: {
+            enabled: batchConfig?.enabled ?? true,
+            endpoint: batchEndpoint,
+            flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
+            maxBatchSize: batchConfig?.maxBatchSize ?? 16,
+            maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
+            requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
+            allowedMethods: batchConfig?.allowedMethods !== void 0 && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+                'GET'
+            ]
+        }
+    };
+    return {
+        config,
+        manifest,
+        operationContracts: buildOperationContractMap({
+            handlers: toOperationContractSources(endpoints),
+            requestId: normalizedRequestId,
+            operationVersion
+        }),
+        operationVersion,
+        requestCreator,
+        requestId: normalizedRequestId
+    };
+}
+function renderClientShape(endpoints, valueType) {
+    if (0 === endpoints.length) return `Record<string, Record<string, ${valueType}>>`;
+    const groups = new Map();
+    for (const endpoint of endpoints){
+        const group = groups.get(endpoint.groupName) || [];
+        group.push(endpoint.endpointName);
+        groups.set(endpoint.groupName, group);
+    }
+    const groupEntries = [
+        ...groups.entries()
+    ].map(([groupName, names])=>{
+        const endpointEntries = names.map((name)=>`    ${JSON.stringify(name)}: ${valueType};`).join('\n');
+        return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
+    });
+    return `{\n${groupEntries.join('\n')}\n}`;
+}
+function renderEffectClientDeclaration(endpoints = []) {
+    return `export type EffectClientOperation = (
+  request?: unknown,
+) => Promise<unknown>;
+export type EffectClientGroup = Record<string, EffectClientOperation>;
+export type EffectClient = Record<string, EffectClientGroup>;
+export type EffectOperationDescriptor = {
+  appNamespace: string;
+  apiId: string;
+  group: string;
+  endpoint: string;
+  operationId: string;
+  routePath: string;
+  method: string;
+  operationVersion: number;
+  schemaHash: string;
+  version: number;
+};
+export type EffectOperationManifest = Record<
+  string,
+  Record<string, EffectOperationDescriptor>
+>;
+export type EffectOperationContext = {
+  requestId?: string;
+  operationId?: string;
+  routePath?: string;
+  method?: string;
+  schemaHash?: string;
+  operationVersion?: number;
+  locale?: string;
+  traceparent?: string;
+  traceId?: string;
+  spanId?: string;
+  source?: string;
+  scope?: Record<string, unknown>;
+  sessionClaims?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+};
+export type EffectRequestContext = {
+  headers?: Record<string, string>;
+  locale?: string;
+  operationContext?: EffectOperationContext;
+  traceparent?: string;
+  traceId?: string;
+  spanId?: string;
+};
+export type GeneratedEffectClient = ${renderClientShape(endpoints, 'EffectClientOperation')};
+export type GeneratedEffectOperationManifest = ${renderClientShape(endpoints, "EffectOperationDescriptor")};
+
+export declare const client: GeneratedEffectClient;
+export declare const createEffectRequestContext: (
+  requestContext: Record<string, unknown>,
+) => EffectRequestContext;
+export declare const operationManifest: GeneratedEffectOperationManifest;
+declare const apiModule: {
+  client: GeneratedEffectClient;
+  createEffectRequestContext: typeof createEffectRequestContext;
+  operationManifest: GeneratedEffectOperationManifest;
+};
+
+export default apiModule;
+`;
+}
+export { createEffectClientGeneration, renderEffectClientCode, renderEffectClientDeclaration };

package/dist/esm/client-generator/runtime.mjs

@@ -0,0 +1,27 @@
+import { extractHttpApiFromModule } from "@modern-js/bff-effect/effect";
+import { compatibleRequire, upath } from "@modern-js/utils";
+import { loadEffectSourceModule } from "../effect-source-loader/loader.mjs";
+let httpApiRuntimePromise;
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+function isHttpApiRuntime(value) {
+    return isRecord(value) && 'function' == typeof value.isHttpApi && 'function' == typeof value.reflect;
+}
+function getHttpApiRuntime() {
+    if (void 0 === httpApiRuntimePromise) httpApiRuntimePromise = compatibleRequire('effect/unstable/httpapi', false).catch((error)=>{
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
+        const effectPackageJson = require.resolve('effect/package.json');
+        const effectHttpApiRuntimePath = upath.join(upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
+        return compatibleRequire(effectHttpApiRuntimePath, false);
+    }).then((mod)=>{
+        if (isRecord(mod) && isHttpApiRuntime(mod.HttpApi)) return mod.HttpApi;
+        throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
+    });
+    return httpApiRuntimePromise;
+}
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
+}
+export { getHttpApiRuntime, loadEffectApi };

package/dist/esm/cross-project-generation/index.mjs

@@ -0,0 +1 @@
+export { renderProducerRuntimeDefaults } from "./render.mjs";

package/dist/esm/cross-project-generation/render.mjs

@@ -0,0 +1,15 @@
+const renderProducerRuntimeDefaults = (requestIdValue)=>`{
+      requestId: ${requestIdValue},
+      requireEnvelope: true,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+      },
+    }`;
+export { renderProducerRuntimeDefaults };

package/dist/esm/cross-project-policy/evaluation.mjs

@@ -0,0 +1,34 @@
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+const DENIAL_HEADERS = {
+    'content-type': 'application/json; charset=utf-8'
+};
+const checkCrossProjectPolicyResponse = (headers, policy, observedRequest)=>{
+    if (!policy?.enabled) return null;
+    const violation = evaluateCrossProjectPolicy(headers, policy, observedRequest);
+    if (!violation) return null;
+    return new Response(JSON.stringify({
+        code: violation.code,
+        reason: violation.reason,
+        message: violation.message
+    }), {
+        status: violation.status,
+        headers: DENIAL_HEADERS
+    });
+};
+const checkCrossProjectPolicyForRequest = (request, policy)=>{
+    if (!policy?.enabled) return null;
+    const requestTarget = {
+        method: request.method,
+        pathname: new URL(request.url).pathname
+    };
+    const observedRequest = resolveCrossProjectRequestObservation(requestTarget, policy) ?? {
+        method: requestTarget.method,
+        routePath: requestTarget.pathname
+    };
+    const headers = {};
+    request.headers.forEach((value, key)=>{
+        headers[key] = value;
+    });
+    return checkCrossProjectPolicyResponse(headers, policy, observedRequest);
+};
+export { checkCrossProjectPolicyForRequest, checkCrossProjectPolicyResponse };

package/dist/esm/cross-project-policy/index.mjs

@@ -0,0 +1 @@
+export { resolveAdapterCrossProjectPolicy } from "./node.mjs";

package/dist/esm/cross-project-policy/node.mjs

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+import node_path from "node:path";
+import { deriveOperationVersion, resolveCrossProjectPolicy } from "@modern-js/bff-core";
+const readNearestPackageVersion = (startDir)=>{
+    if (!startDir) return;
+    let current = node_path.resolve(startDir);
+    for(let depth = 0; depth < 10; depth += 1){
+        try {
+            const packageJson = JSON.parse(readFileSync(node_path.join(current, 'package.json'), 'utf8'));
+            if ('string' == typeof packageJson.version) return packageJson.version;
+        } catch  {}
+        const parent = node_path.dirname(current);
+        if (parent === current) break;
+        current = parent;
+    }
+};
+const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+    const bff = api.getServerConfig()?.bff;
+    const { apiDirectory, appDirectory } = api.getServerContext();
+    return resolveCrossProjectPolicy({
+        crossProjectPolicy: bff?.crossProjectPolicy,
+        handlers,
+        requestId: bff?.requestId,
+        isCrossProjectServer: bff?.isCrossProjectServer,
+        operationVersion: deriveOperationVersion(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+    });
+};
+export { resolveAdapterCrossProjectPolicy };

package/dist/esm/effect-adapter/cross-project-policy.mjs

@@ -0,0 +1,26 @@
+import { collectEffectEndpoints, extractHttpApiFromModule, toOperationContractSources } from "@modern-js/bff-effect/effect";
+import { logger } from "@modern-js/utils";
+import { HttpApi } from "effect/unstable/httpapi";
+import { resolveAdapterCrossProjectPolicy } from "../cross-project-policy/index.mjs";
+function resolveEffectAdapterCrossProjectPolicy(api, prefix, mod) {
+    const contractSourcesPromise = null === mod ? Promise.resolve([]) : Promise.resolve().then(()=>extractHttpApiFromModule(mod, HttpApi.isHttpApi)).then((effectApi)=>{
+        if (null === effectApi) return [];
+        const reflect = (apiValue, handlers)=>{
+            if (!HttpApi.isHttpApi(apiValue)) throw new Error('[BFF][Effect] Endpoint reflection received a non-HttpApi value.');
+            HttpApi.reflect(apiValue, {
+                onGroup: handlers.onGroup ?? (()=>{}),
+                onEndpoint: handlers.onEndpoint
+            });
+        };
+        return toOperationContractSources(collectEffectEndpoints(reflect, effectApi, prefix));
+    }).catch((error)=>{
+        logger.warn(`[BFF][Effect] Failed reflect HttpApi endpoints cross-project policy: ${String(error)}`);
+        return [];
+    });
+    return contractSourcesPromise.then((contractSources)=>{
+        const policy = resolveAdapterCrossProjectPolicy(api, contractSources);
+        if (policy?.enabled === true && 0 === contractSources.length) 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;
+    });
+}
+export { resolveEffectAdapterCrossProjectPolicy };

package/dist/esm/effect-adapter/entry.mjs

@@ -0,0 +1,50 @@
+import node_path from "node:path";
+import { API_DIR, findExists, fs, isProd } from "@modern-js/utils";
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function resolveJsOrTsEntry(entryWithoutOrWithExt) {
+    const extension = node_path.extname(entryWithoutOrWithExt);
+    if (JS_OR_TS_EXTS.includes(extension)) return fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
+    return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutOrWithExt}${ext}`)) || void 0;
+}
+function builtEntryPath(entryPath) {
+    return entryPath.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+}
+function relativeAppPath(appDirectory, entryPath) {
+    const relativePath = node_path.relative(appDirectory, entryPath);
+    return '..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) ? void 0 : relativePath;
+}
+function isDependencyPath(relativePath) {
+    return relativePath?.split(/[\\/]/u).includes('node_modules') ?? false;
+}
+function resolveEffectAdapterEntryFile(api) {
+    const { appDirectory, apiDirectory, distDirectory } = api.getServerContext();
+    const appRoot = node_path.resolve(appDirectory || process.cwd());
+    const productionRoot = isProd() && distDirectory ? node_path.resolve(distDirectory) : void 0;
+    const configuredEntry = api.getServerConfig()?.bff?.effect?.entry;
+    if (configuredEntry) {
+        const sourceEntry = node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appRoot, configuredEntry);
+        if (productionRoot) {
+            const relativeEntry = relativeAppPath(appRoot, sourceEntry);
+            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
+            return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(node_path.resolve(productionRoot, relativeEntry))) : void 0;
+        }
+        return resolveJsOrTsEntry(sourceEntry);
+    }
+    const resolvedApiDirectory = node_path.resolve(appRoot, apiDirectory || API_DIR);
+    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
+        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
+        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
+        return relativeApiDirectory ? node_path.resolve(productionRoot, relativeApiDirectory) : void 0;
+    })() : resolvedApiDirectory;
+    return productionApiDirectory ? resolveJsOrTsEntry(node_path.resolve(productionApiDirectory, 'index')) : void 0;
+}
+export { resolveEffectAdapterEntryFile };

package/dist/esm/effect-adapter/error-response.mjs

@@ -0,0 +1,37 @@
+import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
+import { logger } from "@modern-js/utils";
+function createEffectAdapterRuntimeErrorResponse(api, error, context) {
+    try {
+        const onError = api.getServerConfig()?.onError;
+        if (void 0 !== onError) return Promise.resolve(onError(error instanceof Error ? error : new Error(String(error)), ensureJsonContext(context))).then((result)=>result instanceof Response ? result : createSafeFailureResponse(error)).catch((configError)=>{
+            logger.error(`Error in serverConfig.onError handler: ${String(configError)}`);
+            return createSafeFailureResponse(error);
+        });
+        logger.error(error instanceof Error ? error : new Error(String(error)));
+    } catch (configError) {
+        logger.error(`Error in serverConfig.onError handler: ${configError}`);
+    }
+    return Promise.resolve(createSafeFailureResponse(error));
+}
+function ensureJsonContext(context) {
+    if ('json' in context && 'function' == typeof context.json) return context;
+    return Object.assign({}, context, {
+        json (data, statusOrInit = 200, extraHeaders) {
+            const responseInit = 'number' == typeof statusOrInit ? {
+                status: statusOrInit,
+                headers: extraHeaders
+            } : statusOrInit;
+            const responseHeaders = new Headers({
+                'content-type': 'application/json; charset=utf-8'
+            });
+            if (void 0 !== responseInit.headers) new Headers(responseInit.headers).forEach((value, key)=>{
+                responseHeaders.set(key, value);
+            });
+            return new Response(JSON.stringify(data), {
+                ...responseInit,
+                headers: responseHeaders
+            });
+        }
+    });
+}
+export { createEffectAdapterRuntimeErrorResponse };

package/dist/esm/effect-adapter/index.mjs

@@ -0,0 +1,139 @@
+import node_path from "node:path";
+import { dispatchEffectBffRequest, resolveEffectBffModuleHandler, useEffectContext } from "@modern-js/bff-effect/effect";
+import { createDisposableServerRuntimeHandle, registerServerRuntimeDisposer } from "@modern-js/server-runtime-extensions/runtime-lifecycle";
+import { fs, isProd, logger } from "@modern-js/utils";
+import { checkCrossProjectPolicyForRequest } from "../cross-project-policy/evaluation.mjs";
+import { loadEffectBuiltModule, loadEffectSourceModule } from "../effect-source-loader/loader.mjs";
+import { resolveEffectAdapterCrossProjectPolicy } from "./cross-project-policy.mjs";
+import { resolveEffectAdapterEntryFile } from "./entry.mjs";
+import { createEffectAdapterRuntimeErrorResponse } from "./error-response.mjs";
+const EFFECT_MIDDLEWARE_BEFORE = [
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
+];
+class EffectAdapter {
+    async loadHandler() {
+        const entryFile = resolveEffectAdapterEntryFile(this.api);
+        if (!entryFile || !await fs.pathExists(entryFile)) {
+            this.handler = null;
+            return;
+        }
+        let mod;
+        try {
+            const { appDirectory } = this.api.getServerContext();
+            mod = await (isProd() ? loadEffectBuiltModule(entryFile) : loadEffectSourceModule({
+                resourcePath: entryFile,
+                appDir: appDirectory || node_path.dirname(entryFile)
+            }));
+        } catch (error) {
+            logger.error(`[BFF][Effect] Failed to load Effect entry: ${entryFile}\n${String(error)}`);
+            throw error;
+        }
+        const crossProjectPolicies = new Map(await Promise.all(this.prefixes.map(async (prefix)=>[
+                prefix,
+                await resolveEffectAdapterCrossProjectPolicy(this.api, prefix, mod)
+            ])));
+        const effectConfig = this.api.getServerConfig()?.bff?.effect;
+        const loaded = await resolveEffectBffModuleHandler(mod, {
+            openapi: effectConfig?.openapi,
+            dataPlatform: effectConfig?.dataPlatform,
+            validateRequest: (request)=>{
+                const { path: mountedPathname } = useEffectContext();
+                const prefix = this.matchingPrefixes.find((item)=>'/' === item || mountedPathname === item || mountedPathname.startsWith(`${item}/`));
+                if (!prefix) return null;
+                const requestUrl = new URL(request.url);
+                if ('/' !== prefix) requestUrl.pathname = '/' === requestUrl.pathname ? prefix : `${prefix}${requestUrl.pathname}`;
+                return checkCrossProjectPolicyForRequest(new Request(requestUrl, request), crossProjectPolicies.get(prefix));
+            },
+            onWarning: (message)=>logger.warn(message)
+        });
+        if (!loaded) {
+            const error = new Error(`[BFF][Effect] Invalid Effect entry module: ${entryFile}. Export defineEffectBff(...) or a { api, layer } HttpApi module.`);
+            logger.warn(error.message);
+            throw error;
+        }
+        const candidateOwner = {};
+        if (loaded.dispose) registerServerRuntimeDisposer(candidateOwner, loaded.dispose);
+        const candidate = createDisposableServerRuntimeHandle(candidateOwner, loaded.handler);
+        if (this.retired) {
+            await candidate.dispose();
+            throw new Error('Cannot initialize a retired Effect adapter.');
+        }
+        this.handler = candidate;
+    }
+    constructor(api){
+        this.handler = null;
+        this.prefix = '/api';
+        this.prefixes = [
+            '/api'
+        ];
+        this.matchingPrefixes = [
+            '/api'
+        ];
+        this.retired = false;
+        this.registerMiddleware = async (options)=>{
+            const { enableHandleWeb } = options;
+            const { bffRuntimeFramework, middlewares: globalMiddlewares } = this.api.getServerContext();
+            if ('hono' === bffRuntimeFramework) return;
+            const configuredPrefixes = Array.isArray(options.prefix) ? options.prefix.filter(Boolean) : [
+                options.prefix || '/api'
+            ];
+            this.prefixes = [
+                ...new Set(configuredPrefixes.length > 0 ? configuredPrefixes : [
+                    '/api'
+                ])
+            ];
+            this.matchingPrefixes = [
+                ...this.prefixes
+            ].sort((left, right)=>right.length - left.length);
+            this.prefix = this.prefixes[0] || '/api';
+            const { serverBase } = this.api.getServerContext();
+            if (serverBase) this.unregisterRuntimeDisposer = registerServerRuntimeDisposer(serverBase, this.dispose);
+            try {
+                await this.loadHandler();
+            } catch (error) {
+                await this.dispose();
+                throw error;
+            }
+            const middlewarePrefixes = enableHandleWeb ? [
+                this.prefix
+            ] : this.matchingPrefixes;
+            const middlewares = middlewarePrefixes.map((middlewarePrefix)=>({
+                    name: 'effect-api-handler',
+                    path: enableHandleWeb ? '*' : `${middlewarePrefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before: EFFECT_MIDDLEWARE_BEFORE,
+                    handler: async (context, next)=>{
+                        const handler = this.handler;
+                        if (!handler) {
+                            if (enableHandleWeb) return void await next();
+                            return createEffectAdapterRuntimeErrorResponse(this.api, new Error('[BFF][Effect] Missing Effect entry. Define api/index or configure bff.effect.entry.'), context);
+                        }
+                        const prefix = enableHandleWeb ? this.matchingPrefixes.find((item)=>'/' === item || context.req.path === item || context.req.path.startsWith(`${item}/`)) || this.prefix : middlewarePrefix;
+                        const response = await dispatchEffectBffRequest(handler, context.req.raw, {
+                            prefix,
+                            env: context.env,
+                            path: context.req.path,
+                            method: context.req.method,
+                            onError: (error)=>createEffectAdapterRuntimeErrorResponse(this.api, error, context)
+                        });
+                        if (404 === response.status && enableHandleWeb) return void await next();
+                        return new Response(response.body, response);
+                    }
+                }));
+            globalMiddlewares.push(...middlewares);
+        };
+        this.dispose = async ()=>{
+            this.retired = true;
+            this.unregisterRuntimeDisposer?.();
+            this.unregisterRuntimeDisposer = void 0;
+            const previous = this.handler;
+            this.handler = null;
+            await previous?.dispose();
+        };
+        this.api = api;
+    }
+}
+export { EffectAdapter };

package/dist/esm/effect-source-loader/index.mjs

@@ -0,0 +1,3 @@
+export { resolveEffectEntryFile } from "../client-generator/paths.mjs";
+export { bundleEffectEntryForNode } from "./loader.mjs";
+export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper } from "./worker-runtime-wrapper.mjs";