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

package/dist/esm-node/cli/generator.mjs

@@ -1,133 +1,134 @@
 import "node:module";
-import { ApiRouter, buildOperationContractMap, deriveOperationVersion } from "@modern-js/bff-core";
+import { ApiRouter } from "@modern-js/bff-core";
 import { compile } from "@modern-js/server-utils";
 import { API_DIR, SHARED_DIR, fs, resolveServerTsconfig, upath } from "@modern-js/utils";
 import clientGenerator from "../utils/clientGenerator.mjs";
-import pluginGenerator from "../utils/pluginGenerator.mjs";
-import runtimeGenerator from "../utils/runtimeGenerator.mjs";
+import pluginGenerator, { renderBffPlugin } from "../utils/pluginGenerator.mjs";
+import runtimeGenerator, { renderBffRuntime } from "../utils/runtimeGenerator.mjs";
 import { getPrimaryPrefix } from "./prefix.mjs";
-import { serializeServerGlobalVars, transformServerGlobalVars } from "./serverGlobalVars.mjs";
 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 = upath.resolve(distDirectory);
-            const apiDir = apiDirectory || upath.resolve(appDirectory, API_DIR);
-            const sharedDir = sharedDirectory || upath.resolve(appDirectory, SHARED_DIR);
-            const tsconfigPath = resolveServerTsconfig(appDirectory, modernConfig?.server?.tsconfigPath);
-            const sourceDirs = [];
-            return fs.pathExists(apiDir).then((apiDirectoryExists)=>{
-                if (apiDirectoryExists) sourceDirs.push(apiDir);
-                return 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 = serializeServerGlobalVars(globalVars);
-                return compile(appDirectory, {
-                    alias: combinedAlias
-                }, {
-                    sourceDirs,
-                    distDir,
-                    tsconfigPath,
-                    moduleType,
-                    throwErrorInsteadOfExit: true
-                }).then(()=>transformServerGlobalVars(sourceDirs.map((sourceDir)=>upath.resolve(distDir, 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 = upath.resolve(distDirectory);
+        const apiDir = apiDirectory || upath.resolve(appDirectory, API_DIR);
+        const sharedDir = sharedDirectory || upath.resolve(appDirectory, SHARED_DIR);
+        const tsconfigPath = resolveServerTsconfig(appDirectory, config.server?.tsconfigPath);
+        const sourceDirs = [];
+        for (const directory of [
+            apiDir,
+            sharedDir
+        ])if (await 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)=>upath.resolve(distDir, upath.relative(appDirectory, directory))),
+            distDirectory: distDir,
+            tsconfigPath,
+            moduleType
+        };
+        const hooks = api.getHooks();
+        await hooks.onBeforeBffCompile.call(context);
+        await 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 = getPrimaryPrefix(bff?.prefix);
-            const httpMethodDecider = bff?.httpMethodDecider;
-            const apiRouter = new ApiRouter({
-                apiDir: apiDirectory,
-                appDir: appDirectory,
-                lambdaDir: lambdaDirectory,
-                prefix,
-                httpMethodDecider,
-                isBuild: true
-            });
-            const lambdaDir = apiRouter.getLambdaDir();
-            const existLambda = apiRouter.isExistLambda();
-            const packageJson = fs.readJSONSync(upath.resolve(appDirectory, 'package.json'));
-            const requestId = bff?.requestId || packageJson.name || packageName || 'default';
-            const operationContractsPromise = 'effect' !== bffRuntimeFramework && existLambda ? apiRouter.getApiHandlers().then((handlers)=>buildOperationContractMap({
-                    handlers,
-                    requestId,
-                    operationVersion: deriveOperationVersion(packageJson.version)
-                })) : Promise.resolve({});
-            const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
-            const relativeApiPath = upath.relative(appDirectory, apiDirectory);
-            const relativeLambdaPath = 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({
-                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({
-                    prefix,
-                    appDirectory,
-                    requestId,
-                    relativeDistPath,
-                    relativeApiPath,
-                    relativeLambdaPath,
-                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect',
-                    relativeEffectEntry,
-                    operationContracts
-                }).then(()=>runtimeGenerator({
-                        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 = getPrimaryPrefix(bff?.prefix);
+        const apiRouter = new 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 fs.readJSON(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: upath.relative(appDirectory, apiDirectory),
+            relativeLambdaPath: upath.relative(appDirectory, lambdaDir)
+        };
+        const runtimeOptions = {
+            runtime: bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST,
+            appDirectory,
+            relativeDistPath
+        };
+        const hooks = api.getHooks();
+        await clientGenerator({
+            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 renderBffPlugin(pluginOptions),
+                    runtime: renderBffRuntime(runtimeOptions),
+                    packageDependencies: {}
+                });
+                if (entries.generation !== generation) throw new Error('modifyBffGeneratedEntries must preserve generation identity.');
+                await pluginGenerator(pluginOptions, entries.plugin);
+                await runtimeGenerator(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/esm-node/cli.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { ApiRouter } from "@modern-js/bff-core";
+import { createAsyncHook } from "@modern-js/plugin";
 import { normalizeOutputPath } from "@modern-js/utils";
 import path from "path";
 import { createCompressConfig } from "./cli/compress.mjs";
@@ -11,13 +12,19 @@ import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const bffPlugin = ()=>({
         name: '@modern-js/plugin-bff',
+        registryHooks: {
+            onBeforeBffCompile: createAsyncHook(),
+            onAfterBffCompile: createAsyncHook(),
+            modifyBffClientArtifacts: createAsyncHook(),
+            modifyBffGeneratedEntries: 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 } = createBffGenerator(api);
@@ -35,7 +42,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 = getPrimaryPrefix(bff?.prefix);
@@ -65,10 +72,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/esm-node/loader.mjs

@@ -1,66 +1,14 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import { generateClient } from "@modern-js/bff-core";
-import { generateEffectClientCode, generateEffectWorkerRuntimeWrapper, resolveEffectEntryFile } from "@modern-js/plugin-bff-extensions/effect-source-loader";
 import { logger } from "@modern-js/utils";
-import path from "path";
-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 = resolveEffectEntryFile({
-        appDir: draftOptions.appDir,
-        apiDir: draftOptions.apiDir,
-        effectEntry: draftOptions.effectEntry
-    });
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.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 && path.resolve(effectEntryFile) === path.resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_QUERY)) return void callback(void 0, await generateEffectWorkerRuntimeWrapper(this, draftOptions, resourcePath));
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath)) {
-        const code = await 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) {
         logger.warn(warning);
@@ -76,7 +24,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)) {
@@ -87,8 +37,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 generateClient(options);
-    callback(void 0, result.isOk ? result.value : createErrorModule(result.value));
+    try {
+        const result = await 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;
 export default src_loader;

package/dist/esm-node/runtime/create-request/index.mjs

@@ -1,2 +1,2 @@
 import "node:module";
-export { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader } from "@modern-js/create-request";
+export { configure, createRequest, createUploader } from "@modern-js/create-request";

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

@@ -1,7 +1,4 @@
 import "node:module";
-import { resolveAdapterCrossProjectPolicy } from "@modern-js/plugin-bff-extensions/cross-project-policy";
-import { bindHonoRouteHandlers } from "@modern-js/plugin-bff-extensions/hono";
-import { logger } from "@modern-js/utils";
 import createHonoRoutes from "../../utils/createHonoRoutes.mjs";
 const before = [
     'custom-server-hook',
@@ -9,7 +6,8 @@ const before = [
     'render'
 ];
 class HonoAdapter {
-    constructor(api){
+    constructor(api, createRouteBinder){
+        this.createRouteBinder = createRouteBinder;
         this.apiMiddleware = [];
         this.isHono = true;
         this.setHandlers = async ()=>{
@@ -17,25 +15,23 @@ class HonoAdapter {
             const { apiHandlerInfos } = this.api.getServerContext();
             const handlers = apiHandlerInfos ?? [];
             const honoHandlers = createHonoRoutes(handlers);
-            const policy = 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: bindHonoRouteHandlers({
+                    handler: bindRoute ? bindRoute({
                         handler,
-                        policy,
-                        routePath: path,
-                        onError: this.api.getServerConfig()?.onError,
-                        reportError: (error)=>logger.error(error)
-                    }),
+                        routePath: path
+                    }) : handler,
                     order: 'post',
                     before: 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/esm-node/server.mjs

@@ -1,19 +1,17 @@
 import "node:module";
 import { ApiRouter } from "@modern-js/bff-core";
-import { API_DIR, isFunction, isWebOnly } from "@modern-js/utils";
+import { API_DIR, compatibleRequire, isFunction, isWebOnly, tryResolve } from "@modern-js/utils";
 import path from "path";
 import { HonoAdapter } from "./runtime/hono/adapter.mjs";
-const RUNTIME_ADAPTER_LOADERS = {
-    hono: async (api)=>[
-            new 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 compatibleRequire(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 [
@@ -21,21 +19,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;
@@ -81,9 +79,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 compatibleRequire(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 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/esm-node/utils/client-generator/files.mjs

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