@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/src/effect-source-loader/built-entry.ts

@@ -1,8 +1,10 @@
 import { fs, upath as path } from '@modern-js/utils';
 
-import { resolveEffectEntryFile } from './paths';
-
-const BUILT_ENTRY_EXT = /\.(?:[cm]?ts|tsx|jsx)$/u;
+import {
+  emittedEffectEntry,
+  relativeEffectAppPath,
+  resolveEffectEntryFile,
+} from './paths';
 
 export function resolveBuiltEffectEntry(
   appDirectory: string,
@@ -12,15 +14,15 @@ export function resolveBuiltEffectEntry(
   if (sourceEntry === undefined || sourceEntry.length === 0) {
     return undefined;
   }
-  const relativeEntry = path.relative(appDirectory, sourceEntry);
-  if (relativeEntry === '..' || relativeEntry.startsWith(`..${path.sep}`)) {
+  const relativeEntry = relativeEffectAppPath(appDirectory, sourceEntry);
+  if (relativeEntry === undefined) {
     throw new Error(
       `Effect BFF entry must be inside the application directory: ${sourceEntry}`,
     );
   }
-  const builtEntry = path
-    .resolve(distDirectory, relativeEntry)
-    .replace(BUILT_ENTRY_EXT, '.js');
+  const builtEntry = emittedEffectEntry(
+    path.resolve(distDirectory, relativeEntry),
+  );
   return fs.existsSync(builtEntry) ? builtEntry : undefined;
 }
 
@@ -62,7 +64,7 @@ export function resolveEffectEntryPaths(options: {
   });
   const relativeEffectEntry =
     sourceEffectEntry !== undefined && sourceEffectEntry.length > 0
-      ? path.relative(appDir, sourceEffectEntry).replace(BUILT_ENTRY_EXT, '.js')
+      ? emittedEffectEntry(path.relative(appDir, sourceEffectEntry))
       : '';
   return { sourceEffectEntry, relativeEffectEntry };
 }

package/src/effect-source-loader/http-api-runtime.ts

@@ -3,7 +3,8 @@ import {
   type HttpApiLike,
   type HttpApiReflect,
 } from '@modern-js/bff-effect/effect';
-import { HttpApi } from 'effect/unstable/httpapi';
+import { HttpApi } from 'effect/http-api';
+import type { ServerGlobalVarsOptions } from '../server-global-vars';
 import { loadEffectSourceModule } from './loader';
 
 type HttpApiRuntime = {
@@ -29,6 +30,7 @@ export function getHttpApiRuntime(): Promise<HttpApiRuntime> {
 export function loadEffectApi(options: {
   appDir: string;
   resourcePath: string;
+  globalVars?: ServerGlobalVarsOptions;
   onDependency?: (dependency: string) => void;
 }): Promise<HttpApiLike | null> {
   return getHttpApiRuntime().then(httpApiRuntime =>

package/src/effect-source-loader/loader.ts

@@ -12,8 +12,12 @@ import {
   type Plugin,
   transform,
 } from 'esbuild';
+import {
+  type ServerGlobalVarsOptions,
+  serializeServerGlobalVars,
+} from '../server-global-vars';
 
-const NODE_TARGET = 'node26.7';
+const NODE_TARGET = 'node26.10';
 const SOURCE_LOADERS = new Map<string, Loader>([
   ['.js', 'js'],
   ['.jsx', 'jsx'],
@@ -28,6 +32,8 @@ const SOURCE_LOADERS = new Map<string, Loader>([
 export type EffectSourceLoaderOptions = {
   resourcePath: string;
   appDir?: string;
+  /** `source.globalVars`, replaced in the loaded source graph. */
+  globalVars?: ServerGlobalVarsOptions;
   onDependency?: (dependency: string) => void;
 };
 
@@ -79,6 +85,9 @@ const nodeBuiltins = new Set([
   ...builtinModules.map(name => `node:${name}`),
 ]);
 const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
+// The BFF server runs lambdas inside these packages' Effect context storage.
+// A bundled copy would own a second storage that the server never enters.
+const BFF_RUNTIME_PACKAGE = /^@modern-js\/(?:bff-effect|plugin-bff)(?:\/|$)/;
 
 async function isEsmOnlyFile(filename: string) {
   const extension = path.extname(filename).toLowerCase();
@@ -125,10 +134,9 @@ function isBareSpecifier(specifier: string) {
 }
 
 /**
- * Keep installed registry dependencies external while bundling symlinked
- * workspace source packages. Registry packages remain executable from the
- * deployment node_modules tree; workspace TypeScript is bundled so the
- * generated entry is relocatable and directly executable by Node 26.7.
+ * Keep installed executable dependencies external to preserve runtime identity.
+ * Source requiring compilation is bundled even when pnpm injects a workspace
+ * package into node_modules: Node does not strip types inside that directory.
  */
 function externalizeInstalledDependencies(options: {
   runtimeResolveDir: string;
@@ -137,6 +145,9 @@ function externalizeInstalledDependencies(options: {
     name: 'modern-js-effect-installed-dependencies',
     setup(buildApi) {
       buildApi.onResolve({ filter: /.*/ }, async args => {
+        if (BFF_RUNTIME_PACKAGE.test(args.path)) {
+          return { external: true, path: args.path };
+        }
         if (
           !isBareSpecifier(args.path) ||
           nodeBuiltins.has(args.path) ||
@@ -167,7 +178,13 @@ function externalizeInstalledDependencies(options: {
         const realPath = await fs.promises
           .realpath(resolution.path)
           .catch(() => resolution.path);
-        if (realPath.includes(`${path.sep}node_modules${path.sep}`)) {
+        const loader = SOURCE_LOADERS.get(path.extname(realPath).toLowerCase());
+        if (
+          realPath.includes(`${path.sep}node_modules${path.sep}`) &&
+          loader !== 'ts' &&
+          loader !== 'tsx' &&
+          loader !== 'jsx'
+        ) {
           const runtimeResolution = await buildApi.resolve(args.path, {
             importer: '',
             kind: args.kind,
@@ -341,6 +358,7 @@ export async function loadEffectSourceModule(
       js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`,
     },
     bundle: true,
+    define: serializeServerGlobalVars(options.globalVars),
     entryPoints: [resourcePath],
     format: 'esm',
     jsx: 'automatic',

package/src/effect-source-loader/operation-contracts.ts

@@ -4,48 +4,19 @@ import {
 } from '@modern-js/bff-effect/effect';
 import {
   buildOperationContractMap,
-  deriveOperationVersion,
+  resolveOperationProducer,
 } from '@modern-js/server-runtime-extensions/bff-policy/node';
-import { fs, upath as path } from '@modern-js/utils';
+import { upath as path } from '@modern-js/utils';
+import type { ServerGlobalVarsOptions } from '../server-global-vars';
 import { getHttpApiRuntime, loadEffectApi } from './http-api-runtime';
 
-function getPackageInfo(
-  resourcePath: string,
-  appDir: string,
-  onDependency?: (dependency: string) => void,
-): { name?: string; version?: string } {
-  for (const startDir of [path.dirname(resourcePath), appDir]) {
-    let current = path.resolve(startDir);
-    for (let depth = 0; depth < 32; depth += 1) {
-      const packageJsonPath = path.join(current, 'package.json');
-      if (fs.existsSync(packageJsonPath)) {
-        onDependency?.(packageJsonPath);
-        try {
-          const packageJson = fs.readJSONSync(packageJsonPath) as {
-            name?: string;
-            version?: string;
-          };
-          return { name: packageJson.name, version: packageJson.version };
-        } catch {
-          return {};
-        }
-      }
-      const parent = path.dirname(current);
-      if (parent === current) {
-        break;
-      }
-      current = parent;
-    }
-  }
-  return {};
-}
-
 /** Derives server policy metadata without emitting or typing a client. */
 export async function resolveEffectOperationContracts(options: {
   appDir: string;
   resourcePath: string;
   prefix: string;
   requestId?: string;
+  globalVars?: ServerGlobalVarsOptions;
   onDependency?: (dependency: string) => void;
 }) {
   const api = await loadEffectApi(options);
@@ -58,15 +29,12 @@ export async function resolveEffectOperationContracts(options: {
     api,
     options.prefix,
   );
-  const packageInfo = getPackageInfo(
-    options.resourcePath,
-    options.appDir,
-    options.onDependency,
-  );
-  const requestId = options.requestId?.trim() || packageInfo.name || 'default';
   return buildOperationContractMap({
     handlers: toOperationContractSources(endpoints),
-    requestId,
-    operationVersion: deriveOperationVersion(packageInfo.version),
+    ...resolveOperationProducer({
+      directories: [path.dirname(options.resourcePath), options.appDir],
+      requestId: options.requestId,
+      onDependency: options.onDependency,
+    }),
   });
 }

package/src/effect-source-loader/paths.ts

@@ -9,32 +9,66 @@ const JS_OR_TS_EXTS = [
   '.mts',
   '.cjs',
   '.cts',
-] as const;
+];
 
-export function resolveEffectEntryFile(options: {
+export const emittedEffectEntry = (entry: string) =>
+  entry.replace(/\.(?:[cm]?ts|tsx|jsx)$/u, '.js');
+
+export function relativeEffectAppPath(appDir: string, entry: string) {
+  const relative = path.relative(appDir, entry);
+  return relative === '..' ||
+    relative.startsWith('../') ||
+    relative.split('/').includes('node_modules')
+    ? undefined
+    : relative;
+}
+
+function existingEntry(entry: string): string | undefined {
+  return path.extname(entry)
+    ? fs.existsSync(entry)
+      ? entry
+      : undefined
+    : findExists(JS_OR_TS_EXTS.map(ext => `${entry}${ext}`)) || undefined;
+}
+
+type EffectEntryOptions = {
   appDir: string;
   apiDir: string;
   effectEntry?: string;
-}): string | undefined {
-  const { appDir, apiDir, effectEntry } = options;
+};
+export type EffectEntry =
+  | { kind: 'app-source'; path: string | undefined }
+  | { kind: 'built-output'; path: string | undefined }
+  | { kind: 'external-sdk'; path: string | undefined };
 
-  const resolveEntry = (entryWithoutExt: string) => {
-    if (path.extname(entryWithoutExt) !== '') {
-      return fs.existsSync(entryWithoutExt) ? entryWithoutExt : undefined;
-    }
-
-    return (
-      findExists(JS_OR_TS_EXTS.map(ext => `${entryWithoutExt}${ext}`)) ||
-      undefined
-    );
-  };
-
-  if (effectEntry !== undefined && effectEntry !== '') {
-    const entryWithoutExt = path.isAbsolute(effectEntry)
-      ? effectEntry
-      : path.resolve(appDir, effectEntry);
-    return resolveEntry(entryWithoutExt);
+/** Classify ownership before resolving files: production works without source. */
+export function resolveEffectEntry(
+  options: EffectEntryOptions & { distDir?: string },
+): EffectEntry {
+  const { appDir, apiDir, effectEntry, distDir } = options;
+  const entry = path.resolve(appDir, effectEntry || path.join(apiDir, 'index'));
+  if (distDir && relativeEffectAppPath(distDir, entry) !== undefined) {
+    return {
+      kind: 'built-output',
+      path: existingEntry(emittedEffectEntry(entry)),
+    };
   }
+  const relative = relativeEffectAppPath(appDir, entry);
+  if (relative === undefined) {
+    return { kind: 'external-sdk', path: existingEntry(entry) };
+  }
+  return distDir
+    ? {
+        kind: 'built-output',
+        path: existingEntry(
+          emittedEffectEntry(path.resolve(distDir, relative)),
+        ),
+      }
+    : { kind: 'app-source', path: existingEntry(entry) };
+}
 
-  return resolveEntry(path.resolve(apiDir, 'index'));
+export function resolveEffectEntryFile(
+  options: EffectEntryOptions,
+): string | undefined {
+  return resolveEffectEntry(options).path;
 }

package/src/effect-source-loader/rspack-loader.ts

@@ -1,5 +1,4 @@
 import { realpathSync } from 'node:fs';
-import path from 'node:path';
 import type { Rspack } from '@rsbuild/core';
 import {
   bundleEffectWorkerRuntimeSource,

package/src/server-global-vars/index.ts

@@ -0,0 +1,46 @@
+import type {
+  ServerGlobalVars,
+  ServerGlobalVarsContext,
+  ServerSourceConfigExtension,
+} from '@modern-js/runtime-extensions/server-config';
+import { applyOptionsChain } from '@modern-js/utils';
+
+export type ServerGlobalVarsOptions = ServerSourceConfigExtension['globalVars'];
+
+/** Each global name mapped to the JSON source text that replaces it. */
+export type SerializedServerGlobalVars = Record<string, string>;
+
+/**
+ * Resolves `source.globalVars` for BFF server code and serializes every value
+ * to the JSON text that replaces it. Dev source loading and build output use
+ * this one function, so both see the same values. A value without an exact
+ * JSON form (such as `undefined`, a function or a BigInt) is rejected.
+ */
+export const serializeServerGlobalVars = (
+  options: ServerGlobalVarsOptions,
+): SerializedServerGlobalVars => {
+  const globalVars = applyOptionsChain<
+    ServerGlobalVars,
+    ServerGlobalVarsContext
+  >({}, options, { env: 'server', target: 'node' });
+
+  return Object.fromEntries(
+    Object.entries(globalVars).map(([key, value]) => {
+      let serialized: string | undefined;
+      try {
+        serialized = JSON.stringify(value);
+      } catch (error) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF server code.`,
+          { cause: error },
+        );
+      }
+      if (serialized === undefined) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF server code.`,
+        );
+      }
+      return [key, serialized];
+    }),
+  );
+};

package/dist/cjs/backend-federation/entry.js

@@ -1,94 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    loadBackendFederationExpose: ()=>loadBackendFederationExpose
-});
-const backend_federation_security_namespaceObject = require("@modern-js/server-runtime-extensions/backend-federation-security");
-const external_utils_js_namespaceObject = require("./utils.js");
-function decodeDataUrl(url) {
-    const commaIndex = url.indexOf(',');
-    if (commaIndex < 0) throw new Error('[BFF][Effect] Invalid backend federation data URL entry.');
-    return decodeURIComponent(url.slice(commaIndex + 1));
-}
-async function readCommonJsEntrySource(remote) {
-    if (remote.entry.startsWith('data:')) return decodeDataUrl(remote.entry);
-    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
-}
-async function importModuleEntry(remote) {
-    const entry = await import(remote.entry);
-    return entry.default ?? entry;
-}
-async function resolvePluginEntry(remote, plugins) {
-    for (const plugin of plugins ?? []){
-        const loadEntry = plugin.loadEntry;
-        if ('function' != typeof loadEntry) continue;
-        const entry = await loadEntry({
-            remoteInfo: remote
-        });
-        if (entry) return entry;
-    }
-}
-async function loadBackendFederationEntry(remote, options) {
-    const requiresVerification = Boolean(remote.verification || options.entryPolicy?.expected);
-    const isNetworkEntry = /^https?:\/\//iu.test(remote.entry);
-    if (isNetworkEntry && !requiresVerification) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} requires verified entry bytes before network execution.`);
-    if (requiresVerification) return (0, backend_federation_security_namespaceObject.loadVerifiedBackendFederationEntry)({
-        ...options.entryPolicy,
-        remote,
-        ...remote.verification ? {
-            verification: remote.verification
-        } : {}
-    });
-    const pluginEntry = await resolvePluginEntry(remote, options.plugins);
-    if (pluginEntry) return pluginEntry;
-    if (remote.entryGlobalName) {
-        const globalEntry = globalThis[remote.entryGlobalName];
-        if ((0, external_utils_js_namespaceObject.isRecord)(globalEntry)) return globalEntry;
-    }
-    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
-    return (0, backend_federation_security_namespaceObject.evaluateBackendFederationCommonJsEntry)(remote, new TextEncoder().encode(await readCommonJsEntrySource(remote)), options.entryPolicy?.evaluateCommonJs);
-}
-async function loadBackendFederationExpose(remote, expose, options) {
-    const entry = await loadBackendFederationEntry(remote, options);
-    if ('function' == typeof entry.init) await entry.init({
-        hostName: options.hostName
-    });
-    if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
-    const factory = await entry.get(expose);
-    if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)} must load factory function.`);
-    return factory();
-}
-exports.loadBackendFederationExpose = __webpack_exports__.loadBackendFederationExpose;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "loadBackendFederationExpose"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/effect-adapter/entry.js

@@ -1,99 +0,0 @@
-"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)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    resolveEffectAdapterEntryFile: ()=>resolveEffectAdapterEntryFile
-});
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-require("@modern-js/server-runtime-extensions/server-config");
-const utils_namespaceObject = require("@modern-js/utils");
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function resolveJsOrTsEntry(entryWithoutOrWithExt) {
-    const extension = external_node_path_default().extname(entryWithoutOrWithExt);
-    if (JS_OR_TS_EXTS.includes(extension)) return utils_namespaceObject.fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
-    return (0, utils_namespaceObject.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 = external_node_path_default().relative(appDirectory, entryPath);
-    return '..' === relativePath || relativePath.startsWith(`..${external_node_path_default().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 = external_node_path_default().resolve(appDirectory || process.cwd());
-    const productionRoot = (0, utils_namespaceObject.isProd)() && distDirectory ? external_node_path_default().resolve(distDirectory) : void 0;
-    const configuredEntry = api.getServerConfig()?.bff?.effect?.entry;
-    if (configuredEntry) {
-        const sourceEntry = external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appRoot, configuredEntry);
-        if (productionRoot) {
-            const relativeEntry = relativeAppPath(appRoot, sourceEntry);
-            if (void 0 === relativeEntry || isDependencyPath(relativeEntry)) return resolveJsOrTsEntry(sourceEntry);
-            return relativeEntry ? resolveJsOrTsEntry(builtEntryPath(external_node_path_default().resolve(productionRoot, relativeEntry))) : void 0;
-        }
-        return resolveJsOrTsEntry(sourceEntry);
-    }
-    const resolvedApiDirectory = external_node_path_default().resolve(appRoot, apiDirectory || utils_namespaceObject.API_DIR);
-    const productionApiDirectory = productionRoot ? void 0 !== relativeAppPath(productionRoot, resolvedApiDirectory) ? resolvedApiDirectory : (()=>{
-        const relativeApiDirectory = relativeAppPath(appRoot, resolvedApiDirectory);
-        if (isDependencyPath(relativeApiDirectory)) return resolvedApiDirectory;
-        return relativeApiDirectory ? external_node_path_default().resolve(productionRoot, relativeApiDirectory) : void 0;
-    })() : resolvedApiDirectory;
-    return productionApiDirectory ? resolveJsOrTsEntry(external_node_path_default().resolve(productionApiDirectory, 'index')) : void 0;
-}
-exports.resolveEffectAdapterEntryFile = __webpack_exports__.resolveEffectAdapterEntryFile;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "resolveEffectAdapterEntryFile"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});