@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/cjs/cli/generator.js

@@ -49,128 +49,129 @@ var pluginGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(pluginGener
 const runtimeGenerator_js_namespaceObject = require("../utils/runtimeGenerator.js");
 var runtimeGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(runtimeGenerator_js_namespaceObject);
 const external_prefix_js_namespaceObject = require("./prefix.js");
-const external_serverGlobalVars_js_namespaceObject = require("./serverGlobalVars.js");
 const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
 const createBffGenerator = (api)=>{
-    const compileApi = ()=>Promise.resolve().then(()=>{
-            const { appDirectory, distDirectory, apiDirectory, bffRuntimeFramework, sharedDirectory, moduleType } = api.getAppContext();
-            const modernConfig = api.getNormalizedConfig();
-            const distDir = utils_namespaceObject.upath.resolve(distDirectory);
-            const apiDir = apiDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.API_DIR);
-            const sharedDir = sharedDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
-            const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDirectory, modernConfig?.server?.tsconfigPath);
-            const sourceDirs = [];
-            return utils_namespaceObject.fs.pathExists(apiDir).then((apiDirectoryExists)=>{
-                if (apiDirectoryExists) sourceDirs.push(apiDir);
-                return utils_namespaceObject.fs.pathExists(sharedDir);
-            }).then((sharedDirectoryExists)=>{
-                if (sharedDirectoryExists) sourceDirs.push(sharedDir);
-                if (0 === sourceDirs.length) return;
-                const { alias, globalVars } = modernConfig.source;
-                const { alias: resolveAlias } = modernConfig.resolve;
-                const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
-                const serializedGlobalVars = (0, external_serverGlobalVars_js_namespaceObject.serializeServerGlobalVars)(globalVars);
-                return (0, server_utils_namespaceObject.compile)(appDirectory, {
-                    alias: combinedAlias
-                }, {
-                    sourceDirs,
-                    distDir,
-                    tsconfigPath,
-                    moduleType,
-                    throwErrorInsteadOfExit: true
-                }).then(()=>(0, external_serverGlobalVars_js_namespaceObject.transformServerGlobalVars)(sourceDirs.map((sourceDir)=>utils_namespaceObject.upath.resolve(distDir, utils_namespaceObject.upath.relative(appDirectory, sourceDir))), serializedGlobalVars)).then(async ()=>{
-                    if ('effect' !== bffRuntimeFramework) return;
-                    const { bundleBuiltEffectEntryForNode } = await import("@modern-js/plugin-bff-extensions/client-generator");
-                    return bundleBuiltEffectEntryForNode({
-                        appDir: appDirectory,
-                        apiDir,
-                        distDir,
-                        effectEntry: modernConfig.bff?.effect?.entry,
-                        format: 'module' === moduleType ? 'esm' : 'cjs'
-                    });
-                });
-            });
+    const compileApi = async ()=>{
+        const { appDirectory, distDirectory, apiDirectory, sharedDirectory, moduleType } = api.getAppContext();
+        const config = api.getNormalizedConfig();
+        const distDir = utils_namespaceObject.upath.resolve(distDirectory);
+        const apiDir = apiDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.API_DIR);
+        const sharedDir = sharedDirectory || utils_namespaceObject.upath.resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
+        const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDirectory, config.server?.tsconfigPath);
+        const sourceDirs = [];
+        for (const directory of [
+            apiDir,
+            sharedDir
+        ])if (await utils_namespaceObject.fs.pathExists(directory)) sourceDirs.push(directory);
+        if (0 === sourceDirs.length) return;
+        const combinedAlias = [].concat(config.source.alias ?? []).concat(config.resolve.alias ?? []);
+        const context = {
+            appDirectory,
+            apiDirectory: apiDir,
+            sourceDirectories: sourceDirs,
+            outputDirectories: sourceDirs.map((directory)=>utils_namespaceObject.upath.resolve(distDir, utils_namespaceObject.upath.relative(appDirectory, directory))),
+            distDirectory: distDir,
+            tsconfigPath,
+            moduleType
+        };
+        const hooks = api.getHooks();
+        await hooks.onBeforeBffCompile.call(context);
+        await (0, server_utils_namespaceObject.compile)(appDirectory, {
+            alias: combinedAlias
+        }, {
+            sourceDirs,
+            distDir,
+            tsconfigPath,
+            moduleType,
+            excludeFiles: api.getAppContext().serverCompileExcludedFiles,
+            throwErrorInsteadOfExit: true
         });
-    const generate = ()=>Promise.resolve().then(async ()=>{
-            const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework, packageName } = api.getAppContext();
-            const modernConfig = api.getNormalizedConfig();
-            const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
-            const { bff } = modernConfig || {};
-            const prefix = (0, external_prefix_js_namespaceObject.getPrimaryPrefix)(bff?.prefix);
-            const httpMethodDecider = bff?.httpMethodDecider;
-            const apiRouter = new bff_core_namespaceObject.ApiRouter({
-                apiDir: apiDirectory,
-                appDir: appDirectory,
-                lambdaDir: lambdaDirectory,
-                prefix,
-                httpMethodDecider,
-                isBuild: true
-            });
-            const lambdaDir = apiRouter.getLambdaDir();
-            const existLambda = apiRouter.isExistLambda();
-            const packageJson = utils_namespaceObject.fs.readJSONSync(utils_namespaceObject.upath.resolve(appDirectory, 'package.json'));
-            const requestId = bff?.requestId || packageJson.name || packageName || 'default';
-            const operationContractsPromise = 'effect' !== bffRuntimeFramework && existLambda ? apiRouter.getApiHandlers().then((handlers)=>(0, bff_core_namespaceObject.buildOperationContractMap)({
-                    handlers,
-                    requestId,
-                    operationVersion: (0, bff_core_namespaceObject.deriveOperationVersion)(packageJson.version)
-                })) : Promise.resolve({});
-            const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
-            const relativeApiPath = utils_namespaceObject.upath.relative(appDirectory, apiDirectory);
-            const relativeLambdaPath = utils_namespaceObject.upath.relative(appDirectory, lambdaDir);
-            const { sourceEffectEntry, relativeEffectEntry } = 'effect' === bffRuntimeFramework ? (await import("@modern-js/plugin-bff-extensions/client-generator")).resolveEffectEntryPaths({
-                appDir: appDirectory,
-                apiDir: apiDirectory,
-                effectEntry: bff?.effect?.entry
-            }) : {
-                sourceEffectEntry: void 0,
-                relativeEffectEntry: ''
-            };
-            const clientGenerationPromise = clientGenerator_js_default()({
-                prefix,
-                appDir: appDirectory,
-                apiDir: apiDirectory,
-                lambdaDir,
-                existLambda,
-                port,
-                requestId,
-                requestCreator: bff?.requestCreator,
-                httpMethodDecider,
-                relativeDistPath,
-                relativeApiPath,
-                apiFiles: apiRouter.getApiFiles(),
-                bffRuntimeFramework,
-                effectEntry: bff?.effect?.entry,
-                effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
-            });
-            return Promise.all([
-                operationContractsPromise,
-                clientGenerationPromise
-            ]).then(([lambdaContracts, generatedEffectClient])=>{
-                if ('effect' === bffRuntimeFramework && null === generatedEffectClient) throw new Error(`Effect cross-project client generation failed for ${sourceEffectEntry ?? apiDirectory}.`);
-                const operationContracts = 'effect' === bffRuntimeFramework ? generatedEffectClient?.operationContracts ?? {} : lambdaContracts;
-                return pluginGenerator_js_default()({
-                    prefix,
-                    appDirectory,
-                    requestId,
-                    relativeDistPath,
-                    relativeApiPath,
-                    relativeLambdaPath,
-                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect',
-                    relativeEffectEntry,
-                    operationContracts
-                }).then(()=>runtimeGenerator_js_default()({
-                        runtime,
-                        appDirectory,
-                        relativeDistPath
-                    }));
-            });
+        await hooks.onAfterBffCompile.call(context);
+    };
+    const generate = async ()=>{
+        const { appDirectory, apiDirectory, lambdaDirectory, port, packageName } = api.getAppContext();
+        const config = api.getNormalizedConfig();
+        const relativeDistPath = config.output?.distPath?.root || 'dist';
+        const bff = config.bff;
+        const prefix = (0, external_prefix_js_namespaceObject.getPrimaryPrefix)(bff?.prefix);
+        const apiRouter = new bff_core_namespaceObject.ApiRouter({
+            apiDir: apiDirectory,
+            appDir: appDirectory,
+            lambdaDir: lambdaDirectory,
+            prefix,
+            httpMethodDecider: bff?.httpMethodDecider,
+            isBuild: true
         });
-    const handleCrossProjectInvocation = (isBuild = false)=>Promise.resolve().then(()=>{
-            const { bff } = api.getNormalizedConfig();
-            if (bff?.crossProject !== true) return;
-            return isBuild ? generate() : compileApi().then(()=>generate());
+        const lambdaDir = apiRouter.getLambdaDir();
+        const packageJson = await utils_namespaceObject.fs.readJSON(utils_namespaceObject.upath.resolve(appDirectory, 'package.json'));
+        const generation = {
+            appDirectory,
+            apiDirectory,
+            lambdaDirectory: lambdaDir,
+            existLambda: apiRouter.isExistLambda(),
+            apiFiles: apiRouter.getApiFiles(),
+            relativeDistPath,
+            prefix,
+            port,
+            requestId: bff?.requestId || packageJson.name || packageName || 'default',
+            requestCreator: bff?.requestCreator,
+            httpMethodDecider: bff?.httpMethodDecider
+        };
+        const pluginOptions = {
+            prefix,
+            appDirectory,
+            relativeDistPath,
+            relativeApiPath: utils_namespaceObject.upath.relative(appDirectory, apiDirectory),
+            relativeLambdaPath: utils_namespaceObject.upath.relative(appDirectory, lambdaDir)
+        };
+        const runtimeOptions = {
+            runtime: bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST,
+            appDirectory,
+            relativeDistPath
+        };
+        const hooks = api.getHooks();
+        await clientGenerator_js_default()({
+            prefix,
+            appDir: appDirectory,
+            apiDir: apiDirectory,
+            lambdaDir,
+            existLambda: generation.existLambda,
+            apiFiles: [
+                ...generation.apiFiles
+            ],
+            port,
+            requestId: generation.requestId,
+            requestCreator: generation.requestCreator,
+            clientCodegenPlugin: bff?.clientCodegenPlugin,
+            httpMethodDecider: generation.httpMethodDecider,
+            relativeDistPath,
+            relativeApiPath: pluginOptions.relativeApiPath
+        }, {
+            generation,
+            modifyArtifacts: async (context)=>{
+                const result = await hooks.modifyBffClientArtifacts.call(context);
+                if (result.generation !== generation) throw new Error('modifyBffClientArtifacts must preserve generation identity.');
+                return result;
+            },
+            beforePublish: async ()=>{
+                const entries = await hooks.modifyBffGeneratedEntries.call({
+                    generation,
+                    plugin: await (0, pluginGenerator_js_namespaceObject.renderBffPlugin)(pluginOptions),
+                    runtime: (0, runtimeGenerator_js_namespaceObject.renderBffRuntime)(runtimeOptions),
+                    packageDependencies: {}
+                });
+                if (entries.generation !== generation) throw new Error('modifyBffGeneratedEntries must preserve generation identity.');
+                await pluginGenerator_js_default()(pluginOptions, entries.plugin);
+                await runtimeGenerator_js_default()(runtimeOptions, entries.runtime);
+                return entries.packageDependencies;
+            }
         });
+    };
+    const handleCrossProjectInvocation = async (isBuild = false)=>{
+        if (api.getNormalizedConfig().bff?.crossProject !== true) return;
+        if (!isBuild) await compileApi();
+        await generate();
+    };
     return {
         compileApi,
         generate,

package/dist/cjs/cli.js

@@ -41,6 +41,7 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>cli
 });
 const bff_core_namespaceObject = require("@modern-js/bff-core");
+const plugin_namespaceObject = require("@modern-js/plugin");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
@@ -50,13 +51,19 @@ const prefix_js_namespaceObject = require("./cli/prefix.js");
 const watch_js_namespaceObject = require("./cli/watch.js");
 const bffPlugin = ()=>({
         name: '@modern-js/plugin-bff',
+        registryHooks: {
+            onBeforeBffCompile: (0, plugin_namespaceObject.createAsyncHook)(),
+            onAfterBffCompile: (0, plugin_namespaceObject.createAsyncHook)(),
+            modifyBffClientArtifacts: (0, plugin_namespaceObject.createAsyncHook)(),
+            modifyBffGeneratedEntries: (0, plugin_namespaceObject.createAsyncHook)()
+        },
         setup: (api)=>{
             {
                 const appContext = api.getAppContext();
                 const userRuntimeFramework = api.getConfig()?.bff?.runtimeFramework;
                 api.updateAppContext({
                     ...appContext,
-                    bffRuntimeFramework: 'hono' === userRuntimeFramework ? 'hono' : 'effect'
+                    bffRuntimeFramework: userRuntimeFramework ?? 'hono'
                 });
             }
             const { compileApi, handleCrossProjectInvocation } = (0, generator_js_namespaceObject.createBffGenerator)(api);
@@ -74,7 +81,7 @@ const bffPlugin = ()=>({
                             compress
                         },
                         bundlerChain: (chain, { CHAIN_ID, isServer })=>{
-                            const { port, appDirectory, apiDirectory, lambdaDirectory, bffRuntimeFramework } = api.getAppContext();
+                            const { port, appDirectory, apiDirectory, lambdaDirectory } = api.getAppContext();
                             const modernConfig = api.getNormalizedConfig();
                             const { bff } = modernConfig || {};
                             const prefix = (0, prefix_js_namespaceObject.getPrimaryPrefix)(bff?.prefix);
@@ -104,10 +111,8 @@ const bffPlugin = ()=>({
                                 requestId: bff?.requestId,
                                 target: name,
                                 requestCreator: bff?.requestCreator,
-                                httpMethodDecider,
-                                bffRuntimeFramework,
-                                effectEntry: bff?.effect?.entry,
-                                effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                                clientCodegenPlugin: bff?.clientCodegenPlugin,
+                                httpMethodDecider
                             });
                         }
                     }

package/dist/cjs/loader.js

@@ -1,14 +1,5 @@
 "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, getters, values)=>{
         var define = (defs, kind)=>{
@@ -40,67 +31,14 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>src_loader
 });
 const bff_core_namespaceObject = require("@modern-js/bff-core");
-const effect_source_loader_namespaceObject = require("@modern-js/plugin-bff-extensions/effect-source-loader");
 const utils_namespaceObject = require("@modern-js/utils");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const EFFECT_BFF_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
-const EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY = 'modern-bff-runtime-source';
 const createErrorModule = (message)=>`throw new Error(${JSON.stringify(message)});`;
-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: 'es2024'
-        },
-        module: {
-            type: 'es6'
-        }
-    });
-    return result.code;
-}
 async function loader(source) {
     this.cacheable();
     const { resourcePath } = this;
     delete require.cache[resourcePath];
     const callback = this.async();
     const draftOptions = this.getOptions();
-    const resourceQueries = new URLSearchParams(this.resourceQuery);
-    const effectEntryFile = (0, effect_source_loader_namespaceObject.resolveEffectEntryFile)({
-        appDir: draftOptions.appDir,
-        apiDir: draftOptions.apiDir,
-        effectEntry: draftOptions.effectEntry
-    });
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY)) {
-        const code = await transformEffectRuntimeSource(source, resourcePath);
-        callback(void 0, code);
-        return;
-    }
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_QUERY)) return void callback(void 0, await (0, effect_source_loader_namespaceObject.generateEffectWorkerRuntimeWrapper)(this, draftOptions, resourcePath));
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath)) {
-        const code = await (0, effect_source_loader_namespaceObject.generateEffectClientCode)({
-            appDir: draftOptions.appDir,
-            apiDir: draftOptions.apiDir,
-            resourcePath,
-            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-            port: Number(draftOptions.port),
-            target: draftOptions.target,
-            requestId: draftOptions.requestId,
-            requestCreator: draftOptions.requestCreator,
-            httpMethodDecider: draftOptions.httpMethodDecider,
-            dataPlatformBatch: draftOptions.effectDataPlatformBatch,
-            onDependency: (dependency)=>this.addDependency(dependency)
-        });
-        if (code) return void callback(void 0, code);
-        callback(new Error(`Failed to generate Effect client for ${resourcePath}`));
-        return;
-    }
     const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
     if (!draftOptions.existLambda) {
         utils_namespaceObject.logger.warn(warning);
@@ -116,7 +54,9 @@ async function loader(source) {
         port: Number(draftOptions.port),
         source,
         resourcePath,
-        httpMethodDecider: draftOptions.httpMethodDecider
+        httpMethodDecider: draftOptions.httpMethodDecider,
+        clientCodegenPlugin: draftOptions.clientCodegenPlugin,
+        requestId: draftOptions.requestId
     };
     const { lambdaDir } = draftOptions;
     if (!resourcePath.startsWith(lambdaDir)) {
@@ -127,8 +67,12 @@ async function loader(source) {
     if (draftOptions.fetcher) options.fetcher = draftOptions.fetcher;
     if (draftOptions.requestCreator) options.requestCreator = draftOptions.requestCreator;
     options.requireResolve = require.resolve;
-    const result = await (0, bff_core_namespaceObject.generateClient)(options);
-    callback(void 0, result.isOk ? result.value : createErrorModule(result.value));
+    try {
+        const result = await (0, bff_core_namespaceObject.generateClient)(options);
+        callback(void 0, result.isOk ? result.value : createErrorModule(result.value));
+    } catch (error) {
+        callback(error instanceof Error ? error : new Error(String(error)));
+    }
 }
 const src_loader = loader;
 exports["default"] = __webpack_exports__["default"];

package/dist/cjs/runtime/create-request/index.js

@@ -30,21 +30,15 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     configure: ()=>create_request_namespaceObject.configure,
     createRequest: ()=>create_request_namespaceObject.createRequest,
-    createRequestContextHeaders: ()=>create_request_namespaceObject.createRequestContextHeaders,
-    createRequestContextSnapshot: ()=>create_request_namespaceObject.createRequestContextSnapshot,
     createUploader: ()=>create_request_namespaceObject.createUploader
 });
 const create_request_namespaceObject = require("@modern-js/create-request");
 exports.configure = __webpack_exports__.configure;
 exports.createRequest = __webpack_exports__.createRequest;
-exports.createRequestContextHeaders = __webpack_exports__.createRequestContextHeaders;
-exports.createRequestContextSnapshot = __webpack_exports__.createRequestContextSnapshot;
 exports.createUploader = __webpack_exports__.createUploader;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "configure",
     "createRequest",
-    "createRequestContextHeaders",
-    "createRequestContextSnapshot",
     "createUploader"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -39,9 +39,6 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     HonoAdapter: ()=>HonoAdapter
 });
-const cross_project_policy_namespaceObject = require("@modern-js/plugin-bff-extensions/cross-project-policy");
-const hono_namespaceObject = require("@modern-js/plugin-bff-extensions/hono");
-const utils_namespaceObject = require("@modern-js/utils");
 const createHonoRoutes_js_namespaceObject = require("../../utils/createHonoRoutes.js");
 var createHonoRoutes_js_default = /*#__PURE__*/ __webpack_require__.n(createHonoRoutes_js_namespaceObject);
 const before = [
@@ -50,7 +47,8 @@ const before = [
     'render'
 ];
 class HonoAdapter {
-    constructor(api){
+    constructor(api, createRouteBinder){
+        this.createRouteBinder = createRouteBinder;
         this.apiMiddleware = [];
         this.isHono = true;
         this.setHandlers = async ()=>{
@@ -58,25 +56,23 @@ class HonoAdapter {
             const { apiHandlerInfos } = this.api.getServerContext();
             const handlers = apiHandlerInfos ?? [];
             const honoHandlers = createHonoRoutes_js_default()(handlers);
-            const policy = (0, cross_project_policy_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, handlers);
+            const bindRoute = this.createRouteBinder?.(this.api, handlers);
+            if (this.createRouteBinder && 'function' != typeof bindRoute) throw new TypeError('Hono route binder factory must return a function.');
             this.apiMiddleware = honoHandlers.map(({ path, method, handler })=>({
                     name: 'hono-bff-api',
                     path,
                     method,
-                    handler: (0, hono_namespaceObject.bindHonoRouteHandlers)({
+                    handler: bindRoute ? bindRoute({
                         handler,
-                        policy,
-                        routePath: path,
-                        onError: this.api.getServerConfig()?.onError,
-                        reportError: (error)=>utils_namespaceObject.logger.error(error)
-                    }),
+                        routePath: path
+                    }) : handler,
                     order: 'post',
                     before
                 }));
         };
         this.registerMiddleware = async (_options)=>{
             const { bffRuntimeFramework } = this.api.getServerContext();
-            if ('hono' !== bffRuntimeFramework) {
+            if (void 0 !== bffRuntimeFramework && 'hono' !== bffRuntimeFramework) {
                 this.isHono = false;
                 return;
             }

package/dist/cjs/server.js

@@ -44,17 +44,15 @@ const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const adapter_js_namespaceObject = require("./runtime/hono/adapter.js");
-const RUNTIME_ADAPTER_LOADERS = {
-    hono: async (api)=>[
-            new adapter_js_namespaceObject.HonoAdapter(api)
-        ],
-    effect: async (api)=>{
-        const { EffectAdapter } = await import("@modern-js/plugin-bff-extensions/effect-adapter");
-        return [
-            new EffectAdapter(api)
-        ];
-    }
-};
+async function loadRuntimeAdapters(specifier, api) {
+    if ('string' != typeof specifier || '' === specifier.trim()) throw new Error('The BFF runtime adapter must be a module specifier.');
+    const context = api.getServerContext();
+    const module = await (0, utils_namespaceObject.compatibleRequire)((0, utils_namespaceObject.tryResolve)(specifier, context.appDirectory || context.distDirectory || process.cwd()), false);
+    if (!module || 'function' != typeof module.createRuntimeAdapters) throw new Error(`BFF runtime adapter module "${specifier}" must export createRuntimeAdapters.`);
+    const adapters = await module.createRuntimeAdapters(api);
+    if (!Array.isArray(adapters) || 0 === adapters.length || adapters.some((adapter)=>!adapter || 'function' != typeof adapter.registerMiddleware)) throw new Error(`BFF runtime adapter module "${specifier}" returned invalid adapters.`);
+    return adapters;
+}
 const normalizePrefixList = (prefix)=>{
     if (Array.isArray(prefix)) return prefix.filter(Boolean);
     return [
@@ -62,21 +60,21 @@ const normalizePrefixList = (prefix)=>{
     ];
 };
 const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || '/api';
-function resolveRuntimeFramework(runtimeFramework) {
-    return 'hono' === runtimeFramework ? 'hono' : 'effect';
-}
 class Storage {
     constructor(){
         this.middlewares = [];
     }
 }
-const server = ()=>({
+const server = (options = {})=>({
         name: '@modern-js/plugin-bff',
         setup: (api)=>{
             const storage = new Storage();
             let apiRouter = null;
             const appContext = api.getServerContext();
-            const runtimeFramework = resolveRuntimeFramework(appContext.bffRuntimeFramework);
+            const runtimeFramework = appContext.bffRuntimeFramework ?? 'hono';
+            if (options.runtimeAdapters && Object.hasOwn(options.runtimeAdapters, 'hono')) throw new Error('The native Hono BFF adapter cannot be overridden.');
+            const adapterModule = options.runtimeAdapters?.[runtimeFramework];
+            if ('hono' !== runtimeFramework && (!options.runtimeAdapters || !Object.hasOwn(options.runtimeAdapters, runtimeFramework) || 'string' != typeof adapterModule || '' === adapterModule.trim())) throw new Error(`No BFF runtime adapter is registered for "${runtimeFramework}".`);
             api.onPrepare(async ()=>{
                 const appContext = api.getServerContext();
                 const { render } = appContext;
@@ -122,9 +120,19 @@ const server = ()=>({
                         ]
                     });
                 }
-                const runtimeAdapters = await RUNTIME_ADAPTER_LOADERS[runtimeFramework](api);
+                let createHonoRouteBinder;
+                if ('hono' === runtimeFramework && void 0 !== options.honoRouteBinder) {
+                    if ('string' != typeof options.honoRouteBinder || '' === options.honoRouteBinder.trim()) throw new Error('The Hono BFF route binder must be a module specifier.');
+                    const context = api.getServerContext();
+                    const module = await (0, utils_namespaceObject.compatibleRequire)((0, utils_namespaceObject.tryResolve)(options.honoRouteBinder, context.appDirectory || context.distDirectory || process.cwd()), false);
+                    if (!module || 'function' != typeof module.createHonoRouteBinder) throw new Error(`BFF route binder module "${options.honoRouteBinder}" must export createHonoRouteBinder.`);
+                    createHonoRouteBinder = module.createHonoRouteBinder;
+                }
+                const runtimeAdapters = 'hono' === runtimeFramework ? [
+                    new adapter_js_namespaceObject.HonoAdapter(api, createHonoRouteBinder)
+                ] : await loadRuntimeAdapters(adapterModule, api);
                 await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
-                        prefix: 'effect' === runtimeFramework ? prefixList : prefix,
+                        prefix: 'hono' === runtimeFramework ? prefix : prefixList,
                         enableHandleWeb
                     })));
             });

package/dist/cjs/utils/client-generator/files.js

@@ -71,7 +71,7 @@ function createFileDetails(options) {
     const relativePath = external_path_default().relative(baseDirectory, resourcePath);
     const parsedPath = external_path_default().parse(relativePath);
     const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
-    const absTargetDir = external_path_default().resolve(targetDir);
+    const absTargetDir = external_path_default().resolve(appDirectory, targetDir);
     const relativePathFromAppDirectory = external_path_default().relative(appDirectory, external_path_default().dirname(resourcePath));
     const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
     return {