@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

package/dist/esm/server.mjs

@@ -1,15 +1,17 @@
 import { ApiRouter } from "@modern-js/bff-core";
 import { API_DIR, isFunction, isWebOnly } from "@modern-js/utils";
 import path from "path";
-import { EffectAdapter } from "./runtime/effect/adapter.mjs";
 import { HonoAdapter } from "./runtime/hono/adapter.mjs";
-const RUNTIME_ADAPTER_FACTORIES = {
-    hono: [
-        (api)=>new HonoAdapter(api)
-    ],
-    effect: [
-        (api)=>new EffectAdapter(api)
-    ]
+const RUNTIME_ADAPTER_LOADERS = {
+    hono: async (api)=>[
+            new HonoAdapter(api)
+        ],
+    effect: async (api)=>{
+        const { EffectAdapter } = await import("./runtime/effect/adapter.mjs");
+        return [
+            new EffectAdapter(api)
+        ];
+    }
 };
 const normalizePrefixList = (prefix)=>{
     if (Array.isArray(prefix)) return prefix.filter(Boolean);
@@ -22,9 +24,6 @@ function resolveRuntimeFramework(runtimeFramework) {
     return 'hono' === runtimeFramework ? 'hono' : 'effect';
 }
 class Storage {
-    reset() {
-        this.middlewares = [];
-    }
     constructor(){
         this.middlewares = [];
     }
@@ -36,7 +35,6 @@ const server = ()=>({
             let apiRouter = null;
             const appContext = api.getServerContext();
             const runtimeFramework = resolveRuntimeFramework(appContext.bffRuntimeFramework);
-            const runtimeAdapters = RUNTIME_ADAPTER_FACTORIES[runtimeFramework].map((createAdapter)=>createAdapter(api));
             api.onPrepare(async ()=>{
                 const appContext = api.getServerContext();
                 const { render } = appContext;
@@ -82,29 +80,20 @@ const server = ()=>({
                         ]
                     });
                 }
+                const runtimeAdapters = await RUNTIME_ADAPTER_LOADERS[runtimeFramework](api);
                 await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
                         prefix,
                         enableHandleWeb
                     })));
             });
             api.onReset(async ({ event })=>{
-                storage.reset();
-                const appContext = api.getServerContext();
-                const { middlewares } = storage;
-                api.updateServerContext({
-                    ...appContext,
-                    apiMiddlewares: middlewares
-                });
-                if ('file-change' === event.type) {
-                    if ('hono' === runtimeFramework && apiRouter) {
-                        const apiHandlerInfos = await apiRouter.getApiHandlers();
-                        const appContext = api.getServerContext();
-                        api.updateServerContext({
-                            ...appContext,
-                            apiHandlerInfos
-                        });
-                    }
-                    await Promise.all(runtimeAdapters.map((adapter)=>adapter.onApiHandlersUpdated?.()));
+                if ('file-change' === event.type && apiRouter) {
+                    const appContext = api.getServerContext();
+                    const apiHandlerInfos = await apiRouter.getApiHandlers();
+                    api.updateServerContext({
+                        ...appContext,
+                        apiHandlerInfos
+                    });
                 }
             });
             const prepareApiServer = async (input, next)=>{

package/dist/esm/utils/client-generator/write-package.mjs

@@ -69,6 +69,6 @@ async function setPackage(files, appDirectory, relativeDistPath) {
         }
     });
     mergePackageJson(packageJson, addFiles, typesVersions, exports, relativeDistPath);
-    await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+    await fs.promises.writeFile(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
 }
 export { setPackage, writeClientModuleBoundary };

package/dist/esm/utils/crossProjectApiPlugin.mjs

@@ -5,6 +5,8 @@ const API_DIR = '{apiDirectory}';
 const LAMBDA_DIR = '{lambdaDirectory}';
 const DIST_DIR = '{distDirectory}';
 const RUNTIME_FRAMEWORK = '{runtimeFramework}';
+const EFFECT_ENTRY = '{effectEntry}';
+const OPERATION_CONTRACTS_JSON = '{operationContracts}';
 const NODE_MODULES = 'node_modules';
 const crossProjectApiPlugin = ()=>({
         name: '@modern-js/plugin-independent-bff',
@@ -16,7 +18,8 @@ const crossProjectApiPlugin = ()=>({
                 const { appDirectory: originAppDirectory } = api.getAppContext();
                 const sdkPath = path.join(originAppDirectory, NODE_MODULES, PACKAGE_NAME);
                 const sdkDistPath = path.join(sdkPath, DIST_DIR);
-                const apiDirectory = path.join(sdkDistPath, API_DIR);
+                const effectEntry = EFFECT_ENTRY ? path.join(sdkDistPath, EFFECT_ENTRY) : void 0;
+                const apiDirectory = effectEntry ? path.dirname(effectEntry) : path.join(sdkDistPath, API_DIR);
                 const lambdaDirectory = path.resolve(sdkDistPath, LAMBDA_DIR);
                 api.updateAppContext({
                     apiDirectory,
@@ -31,10 +34,16 @@ const crossProjectApiPlugin = ()=>({
                 }
                 const configuredRuntimeFramework = config?.bff?.runtimeFramework;
                 if (configuredRuntimeFramework && configuredRuntimeFramework !== RUNTIME_FRAMEWORK) throw new Error(`[${PACKAGE_NAME}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${RUNTIME_FRAMEWORK}".`);
+                resolvedConfig.bff ??= {};
                 resolvedConfig.bff.prefix = PREFIX;
                 resolvedConfig.bff.runtimeFramework = RUNTIME_FRAMEWORK;
+                if (EFFECT_ENTRY) resolvedConfig.bff.effect = {
+                    ...resolvedConfig.bff.effect,
+                    entry: effectEntry
+                };
                 resolvedConfig.bff.isCrossProjectServer = true;
                 resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || PACKAGE_NAME || 'default';
+                const generatedOperationContracts = "{operationContracts}" === OPERATION_CONTRACTS_JSON ? {} : JSON.parse(OPERATION_CONTRACTS_JSON);
                 resolvedConfig.bff.crossProjectPolicy = {
                     ...resolvedConfig.bff.crossProjectPolicy || {},
                     enabled: resolvedConfig.bff.crossProjectPolicy?.enabled ?? true,
@@ -43,7 +52,11 @@ const crossProjectApiPlugin = ()=>({
                     requireOperationContextDetails: resolvedConfig.bff.crossProjectPolicy?.requireOperationContextDetails ?? true,
                     requireOperationSchemaHash: resolvedConfig.bff.crossProjectPolicy?.requireOperationSchemaHash ?? true,
                     requireOperationVersion: resolvedConfig.bff.crossProjectPolicy?.requireOperationVersion ?? true,
-                    allowUnknownOperations: resolvedConfig.bff.crossProjectPolicy?.allowUnknownOperations ?? false
+                    allowUnknownOperations: resolvedConfig.bff.crossProjectPolicy?.allowUnknownOperations ?? false,
+                    expectedOperationContracts: {
+                        ...resolvedConfig.bff.crossProjectPolicy?.expectedOperationContracts || {},
+                        ...generatedOperationContracts
+                    }
                 };
                 return resolvedConfig;
             });
@@ -51,4 +64,4 @@ const crossProjectApiPlugin = ()=>({
     });
 const utils_crossProjectApiPlugin = crossProjectApiPlugin;
 export default utils_crossProjectApiPlugin;
-export { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };
+export { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK, crossProjectApiPlugin };

package/dist/esm/utils/effect-client-generator/generator.mjs

@@ -2,26 +2,27 @@ import { logger } from "@modern-js/utils";
 import { collectEffectEndpoints } from "../../runtime/effect/endpoint-contracts.mjs";
 import { renderEffectClientCode, renderEffectClientDeclaration } from "./rendering.mjs";
 import { getHttpApiRuntime, loadEffectApi } from "./runtime.mjs";
-async function generateEffectClient(options) {
-    const api = await loadEffectApi({
+function generateEffectClient(options) {
+    return loadEffectApi({
         appDir: options.appDir,
         resourcePath: options.resourcePath,
         onDependency: options.onDependency
+    }).then((api)=>{
+        if (null === api) {
+            logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+            return null;
+        }
+        return getHttpApiRuntime().then((httpApiRuntime)=>{
+            const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
+            return {
+                code: renderEffectClientCode(endpoints, options),
+                declaration: renderEffectClientDeclaration(endpoints),
+                endpoints
+            };
+        });
     });
-    if (!api) {
-        logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-        return null;
-    }
-    const httpApiRuntime = await getHttpApiRuntime();
-    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
-    return {
-        code: renderEffectClientCode(endpoints, options),
-        declaration: renderEffectClientDeclaration(endpoints),
-        endpoints
-    };
 }
-async function generateEffectClientCode(options) {
-    const artifacts = await generateEffectClient(options);
-    return artifacts ? artifacts.code : null;
+function generateEffectClientCode(options) {
+    return generateEffectClient(options).then((artifacts)=>null === artifacts ? null : artifacts.code);
 }
 export { generateEffectClient, generateEffectClientCode };

package/dist/esm/utils/effect-client-generator/paths.mjs

@@ -1,5 +1,4 @@
-import { findExists, fs } from "@modern-js/utils";
-import path from "path";
+import { findExists, fs, upath } from "@modern-js/utils";
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -13,13 +12,13 @@ const JS_OR_TS_EXTS = [
 function resolveEffectEntryFile(options) {
     const { appDir, apiDir, effectEntry } = options;
     const resolveEntry = (entryWithoutExt)=>{
-        if (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        if ('' !== upath.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
         return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
     };
-    if (effectEntry) {
-        const entryWithoutExt = path.isAbsolute(effectEntry) ? effectEntry : path.resolve(appDir, effectEntry);
+    if (void 0 !== effectEntry && '' !== effectEntry) {
+        const entryWithoutExt = upath.isAbsolute(effectEntry) ? effectEntry : upath.resolve(appDir, effectEntry);
         return resolveEntry(entryWithoutExt);
     }
-    return resolveEntry(path.resolve(apiDir, 'index'));
+    return resolveEntry(upath.resolve(apiDir, 'index'));
 }
 export { resolveEffectEntryFile };

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

@@ -1,6 +1,5 @@
 import { deriveOperationVersion } from "@modern-js/bff-core";
-import { fs } from "@modern-js/utils";
-import path from "path";
+import { fs, upath } from "@modern-js/utils";
 import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix } from "../../runtime/effect/endpoint-contracts.mjs";
 const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
 const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
@@ -13,17 +12,17 @@ function isAbsoluteUrl(value) {
     }
 }
 function resolveBatchEndpoint(prefix, endpoint) {
-    const value = endpoint || '/_data/batch';
+    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 ('' === normalizedPrefix) return normalizedEndpoint;
     if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
     return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
 }
 function getPackageInfo(appDir) {
     try {
-        const packageJsonPath = path.resolve(appDir, './package.json');
+        const packageJsonPath = upath.resolve(appDir, './package.json');
         const packageJson = fs.readJSONSync(packageJsonPath);
         return {
             name: packageJson.name,
@@ -38,9 +37,9 @@ function renderEffectClientCode(endpoints, options) {
     const httpMethodDecider = options.httpMethodDecider || 'functionName';
     const packageInfo = getPackageInfo(options.appDir);
     const packageName = packageInfo.name;
-    const dataPlatformAppNamespace = packageName || 'unknown-app';
-    const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
-    const normalizedRequestId = requestId || 'default';
+    const dataPlatformAppNamespace = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
+    const requestId = 'bundle' === options.target ? 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);
@@ -57,7 +56,7 @@ function renderEffectClientCode(endpoints, options) {
     };
     const config = {
         appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
+        ...void 0 !== requestId && '' !== requestId ? {
             requestId
         } : {},
         port: options.port,
@@ -71,7 +70,7 @@ function renderEffectClientCode(endpoints, options) {
             maxBatchSize: batchConfig?.maxBatchSize ?? 16,
             maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
             requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
+            allowedMethods: batchConfig?.allowedMethods !== void 0 && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
                 'GET'
             ]
         }

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

@@ -1,34 +1,27 @@
-import { compatibleRequire } from "@modern-js/utils";
-import path from "path";
+import { compatibleRequire, upath } from "@modern-js/utils";
 import { extractHttpApiFromModule } from "../../runtime/effect/endpoint-contracts.mjs";
 import { loadEffectSourceModule } from "../effectSourceLoader.mjs";
 let httpApiRuntimePromise;
 function isRecord(value) {
     return 'object' == typeof value && null !== value;
 }
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await 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 = path.join(path.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await compatibleRequire(effectHttpApiRuntimePath, false);
-        }
-        if (isRecord(mod) && isRecord(mod.HttpApi)) {
-            const maybeHttpApi = mod.HttpApi;
-            if ('function' == typeof maybeHttpApi.isHttpApi && 'function' == typeof maybeHttpApi.reflect) return maybeHttpApi;
-        }
+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;
 }
-async function loadEffectApi(options) {
-    const httpApiRuntime = await getHttpApiRuntime();
-    const mod = await loadEffectSourceModule(options);
-    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
+function loadEffectApi(options) {
+    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
 }
 export { getHttpApiRuntime, loadEffectApi };

package/dist/esm/utils/effectSourceLoader.mjs

@@ -1,6 +1,6 @@
 import node_crypto from "node:crypto";
 import node_fs from "node:fs";
-import { builtinModules } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import node_path from "node:path";
 import { pathToFileURL } from "node:url";
 import { build, transform } from "esbuild";
@@ -75,10 +75,29 @@ const nodeBuiltins = new Set([
     ...builtinModules.map((name)=>`node:${name}`)
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+async function isEsmOnlyFile(filename) {
+    const extension = node_path.extname(filename).toLowerCase();
+    if ('.mjs' === extension || '.mts' === extension) return true;
+    if ('.cjs' === extension || '.cts' === extension) return false;
+    let directory = node_path.dirname(filename);
+    while(true){
+        const packagePath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(await node_fs.promises.readFile(packagePath, 'utf8'));
+            return 'module' === packageJson.type;
+        } catch (error) {
+            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
+        }
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return false;
+        directory = parent;
+    }
+}
 function isBareSpecifier(specifier) {
     return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
 }
-function externalizeInstalledDependencies() {
+function externalizeInstalledDependencies(options) {
+    const runtimeRequire = createRequire(node_path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
     return {
         name: 'modern-js-effect-installed-dependencies',
         setup (buildApi) {
@@ -108,19 +127,46 @@ function externalizeInstalledDependencies() {
                     path: args.path
                 };
                 const realPath = await node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) return {
-                    external: true,
-                    path: args.path
-                };
+                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) {
+                    const runtimeResolution = await buildApi.resolve(args.path, {
+                        importer: '',
+                        kind: args.kind,
+                        namespace: 'file',
+                        pluginData: {
+                            [dependencyResolutionMarker]: true
+                        },
+                        resolveDir: options.runtimeResolveDir
+                    });
+                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
+                        if ('cjs' === options.format) {
+                            let requiredPath;
+                            try {
+                                requiredPath = runtimeRequire.resolve(args.path);
+                            } catch  {
+                                requiredPath = runtimeResolution.path;
+                            }
+                            if (await isEsmOnlyFile(requiredPath)) return {
+                                namespace: resolution.namespace,
+                                path: resolution.path,
+                                pluginData: resolution.pluginData,
+                                sideEffects: resolution.sideEffects,
+                                suffix: resolution.suffix,
+                                warnings: resolution.warnings
+                            };
+                        }
+                        return {
+                            external: true,
+                            path: args.path
+                        };
+                    }
+                }
                 return {
                     namespace: resolution.namespace,
                     path: resolution.path,
                     pluginData: resolution.pluginData,
                     sideEffects: resolution.sideEffects,
                     suffix: resolution.suffix,
-                    warnings: resolution.warnings,
-                    watchDirs: resolution.watchDirs,
-                    watchFiles: resolution.watchFiles
+                    warnings: resolution.warnings
                 };
             });
         }
@@ -139,7 +185,10 @@ async function bundleEffectEntryForNode(options) {
         outfile: options.entryPath,
         platform: 'node',
         plugins: [
-            externalizeInstalledDependencies(),
+            externalizeInstalledDependencies({
+                format: options.format,
+                runtimeResolveDir: options.appDir
+            }),
             preserveSourceModuleSemantics()
         ],
         target: 'node20'
@@ -155,6 +204,11 @@ function normalizeImportedModule(module) {
     if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
     return module;
 }
+async function loadEffectBuiltModule(resourcePath) {
+    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
+    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
+    return normalizeImportedModule(await dynamicImport(pathToFileURL(canonicalPath).href));
+}
 async function loadEffectSourceModule(options) {
     const resourcePath = node_path.resolve(options.resourcePath);
     const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
@@ -181,7 +235,10 @@ async function loadEffectSourceModule(options) {
         outfile: outputPath,
         platform: 'node',
         plugins: [
-            externalizeInstalledDependencies(),
+            externalizeInstalledDependencies({
+                format: 'esm',
+                runtimeResolveDir: appDir
+            }),
             preserveSourceModuleSemantics()
         ],
         sourcemap: 'inline',
@@ -196,4 +253,4 @@ async function loadEffectSourceModule(options) {
     const revision = node_crypto.createHash('sha256').update(output).digest('hex');
     return normalizeImportedModule(await dynamicImport(`${pathToFileURL(outputPath).href}?v=${revision}`));
 }
-export { bundleEffectEntryForNode, loadEffectSourceModule };
+export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

package/dist/esm/utils/pluginGenerator.mjs

@@ -1,18 +1,18 @@
 import { fs, logger, normalizeToPosixPath } from "@modern-js/utils";
 import path from "path";
-import { API_DIR, DIST_DIR, LAMBDA_DIR, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
-function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework) {
-    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath)).replace(new RegExp(RUNTIME_FRAMEWORK, 'g'), runtimeFramework);
+import { API_DIR, DIST_DIR, EFFECT_ENTRY, LAMBDA_DIR, OPERATION_CONTRACTS_JSON, PACKAGE_NAME, PREFIX, RUNTIME_FRAMEWORK } from "./crossProjectApiPlugin.mjs";
+function replaceContent(source, packageName, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts) {
+    const updatedSource = source.replace(new RegExp(PACKAGE_NAME, 'g'), packageName).replace(new RegExp(PREFIX, 'g'), prefix).replace(new RegExp(DIST_DIR, 'g'), normalizeToPosixPath(relativeDistPath)).replace(new RegExp(API_DIR, 'g'), normalizeToPosixPath(relativeApiPath)).replace(new RegExp(LAMBDA_DIR, 'g'), normalizeToPosixPath(relativeLambdaPath)).replace(new RegExp(RUNTIME_FRAMEWORK, 'g'), runtimeFramework).replace(new RegExp(EFFECT_ENTRY, 'g'), normalizeToPosixPath(relativeEffectEntry)).replace(`'${OPERATION_CONTRACTS_JSON}'`, ()=>JSON.stringify(JSON.stringify(operationContracts)));
     return updatedSource;
 }
-async function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework }) {
+async function pluginGenerator({ prefix, appDirectory, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts }) {
     try {
         const packageContent = await fs.readFile(path.resolve(appDirectory, './package.json'), 'utf8');
         const packageJson = JSON.parse(packageContent);
         const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'plugin');
         const pluginPath = path.join(pluginDir, 'index.js');
         const pluginTemplate = await fs.readFile(path.resolve(__dirname, 'crossProjectApiPlugin.js'), 'utf8');
-        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework);
+        const updatedPlugin = replaceContent(pluginTemplate, packageJson.name, prefix, relativeDistPath, relativeApiPath, relativeLambdaPath, runtimeFramework, relativeEffectEntry, operationContracts);
         await fs.ensureFile(pluginPath);
         await fs.writeFile(pluginPath, updatedPlugin);
         const typeContent = `import type { AppTools, CliPlugin } from '@modern-js/app-tools';

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

@@ -1,7 +1,7 @@
 import "node:module";
 import { normalizePrefixList } from "./prefix.mjs";
 const createCompressConfig = (devServer, prefix)=>{
-    if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+    if (void 0 === devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
     const { compress } = devServer;
     if (void 0 === compress || true === compress) {
         const prefixes = normalizePrefixList(prefix);