@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/dist/types/precompress/index.d.ts

@@ -0,0 +1,76 @@
+type BasePluginOptions<T> = {
+  /**
+   * include all assets that pass test assertion
+   */
+  test?: Rules | undefined;
+  /**
+   * include all assets matching any of these conditions
+   */
+  include?: Rules | undefined;
+  /**
+   * exclude all assets matching any of these conditions
+   */
+  exclude?: Rules | undefined;
+  /**
+   * only assets bigger than this size are processed, in bytes
+   */
+  threshold?: number | undefined;
+  /**
+   * only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`)
+   */
+  minRatio?: number | undefined;
+  /**
+   * whether to delete the original assets or not
+   */
+  deleteOriginalAssets?: DeleteOriginalAssets | undefined;
+  /**
+   * the target asset filename
+   */
+  filename?: Filename | undefined;
+};
+type Rules = Rule[] | Rule;
+type Rule = RegExp | string;
+type DeleteOriginalAssets =
+  | boolean
+  | "keep-source-map"
+  | ((name: string) => boolean);
+type Filename = string | ((fileData: PathData) => string);
+type PathData = import('@rsbuild/core').Rspack.PathData;
+type DefinedDefaultAlgorithmAndOptions<T> = T extends ZlibOptions
+  ? {
+      algorithm?: string | AlgorithmFunction<T> | undefined;
+      compressionOptions?: CompressionOptions<T> | undefined;
+    }
+  : {
+      algorithm: string | AlgorithmFunction<T>;
+      compressionOptions?: CompressionOptions<T> | undefined;
+    };
+type ZlibOptions = import("zlib").ZlibOptions;
+type AlgorithmFunction<T> = (
+  input: Buffer,
+  options: CompressionOptions<T>,
+  callback: (
+    error: Error | null | undefined,
+    result:
+      | WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>
+      | Uint8Array
+      | ReadonlyArray<number>
+      | WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>
+      | WithImplicitCoercion<string>
+      | {
+          [Symbol.toPrimitive](hint: "string"): string;
+        },
+  ) => void,
+) => any;
+type CompressionOptions<T> = InferDefaultType<T>;
+type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
+type CustomOptions = {
+  [key: string]: EXPECTED_ANY;
+};
+type EXPECTED_ANY = any;
+type WithImplicitCoercion<T> =
+  | T
+  | {
+      valueOf(): T;
+    };
+export type CompressionPluginOptions = BasePluginOptions<ZlibOptions> & DefinedDefaultAlgorithmAndOptions<ZlibOptions>;

package/package.json

@@ -11,7 +11,7 @@
     "directory": "packages/solutions/app-tools-extensions"
   },
   "license": "MIT",
-  "version": "3.9.0-ultramodern.4",
+  "version": "3.9.0-ultramodern.5",
   "files": [
     "dist",
     "src"
@@ -86,6 +86,26 @@
       "types": "./dist/types/native-type-checker.d.ts",
       "import": "./dist/esm-node/native-type-checker.mjs",
       "require": "./dist/cjs/native-type-checker.js"
+    },
+    "./build-config/precompress/plugin": {
+      "types": "./dist/types/build-config/precompress/plugin.d.ts",
+      "import": "./dist/esm-node/build-config/precompress/plugin.mjs",
+      "require": "./dist/cjs/build-config/precompress/plugin.js"
+    },
+    "./backend-federation-build": {
+      "types": "./dist/types/backend-federation-build/index.d.ts",
+      "import": "./dist/esm-node/backend-federation-build/index.mjs",
+      "require": "./dist/cjs/backend-federation-build/index.js"
+    },
+    "./deploy-output/plugin": {
+      "types": "./dist/types/deploy-output/plugin.d.ts",
+      "import": "./dist/esm-node/deploy-output/plugin.mjs",
+      "require": "./dist/cjs/deploy-output/plugin.js"
+    },
+    "./deploy-output/target": {
+      "types": "./dist/types/deploy-output/target.d.ts",
+      "import": "./dist/esm-node/deploy-output/target.mjs",
+      "require": "./dist/cjs/deploy-output/target.js"
     }
   },
   "typesVersions": {
@@ -93,6 +113,18 @@
       "*": [
         "./dist/types/*",
         "./src/*"
+      ],
+      "build-config/precompress/plugin": [
+        "./dist/types/build-config/precompress/plugin.d.ts"
+      ],
+      "backend-federation-build": [
+        "./dist/types/backend-federation-build/index.d.ts"
+      ],
+      "deploy-output/plugin": [
+        "./dist/types/deploy-output/plugin.d.ts"
+      ],
+      "deploy-output/target": [
+        "./dist/types/deploy-output/target.d.ts"
       ]
     }
   },
@@ -103,17 +135,24 @@
     "@babel/parser": "^8.0.4",
     "@babel/traverse": "^8.0.4",
     "@loadable/component": "5.16.7",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.4",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.4",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.4",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.4",
+    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.0-ultramodern.5",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.5",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.0-ultramodern.5",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.5",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.5",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.5",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.5",
     "@swc/helpers": "^0.5.23",
+    "compression-webpack-plugin": "^12.0.0",
+    "esbuild": "^0.28.2",
     "std-env": "4.2.0"
   },
   "peerDependencies": {
     "@rsbuild/core": "2.2.3"
   },
   "devDependencies": {
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.5",
+    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.0-ultramodern.5",
     "@module-federation/runtime-tools": "2.9.0",
     "@rsbuild/core": "2.2.3",
     "@rslib/core": "1.0.0",
@@ -121,7 +160,9 @@
     "@types/babel__traverse": "7.28.0",
     "@types/node": "^26.4.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "core-js": "^3.50.0"
+    "core-js": "^3.50.0",
+    "effect": "4.0.0-rc.112",
+    "ndepe": "^0.1.13"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -130,7 +171,8 @@
   "scripts": {
     "pretest": "pnpm run build",
     "dev": "rslib build --watch",
-    "build": "rslib build",
-    "test": "rstest"
+    "build": "rslib build && pnpm run verify:public-surface",
+    "test": "rstest",
+    "verify:public-surface": "node ./tests/build-config/verify-public-surface.mjs"
   }
 }

package/src/backend-federation-build/codegen.ts

@@ -0,0 +1,245 @@
+import path from 'node:path';
+import {
+  BACKEND_FEDERATION_EFFECT_EXPOSE as BACKEND_EXPOSE,
+  BACKEND_FEDERATION_MANIFEST_FILE as BACKEND_MANIFEST_FILE,
+  BACKEND_FEDERATION_REMOTE_ENTRY_FILE as BACKEND_REMOTE_ENTRY_FILE,
+  BACKEND_FEDERATION_CONTRACT_VERSION as CONTRACT_VERSION,
+  formatBackendFederationValidationErrors,
+  BACKEND_FEDERATION_NODE_ADAPTER_VERSION as NODE_ADAPTER_VERSION,
+  validateBackendFederationManifest,
+} from '@modern-js/backend-federation-contracts';
+import type { BackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security';
+import { build } from 'esbuild';
+import { type BackendFederationApp, normalizeRelativePath } from './config';
+
+const createRelativeImportSpecifier = (
+  fromDirectory: string,
+  toFile: string,
+) => {
+  const relativePath = normalizeRelativePath(
+    path.relative(fromDirectory, toFile),
+  );
+  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+};
+
+const createPublicPath = (containerEntry: string, fallbackPort: number) => {
+  try {
+    return new URL('.', containerEntry).href;
+  } catch {
+    const slashIndex = containerEntry.lastIndexOf('/');
+    if (slashIndex >= 0) {
+      return containerEntry.slice(0, slashIndex + 1);
+    }
+
+    return `http://localhost:${fallbackPort}/`;
+  }
+};
+
+export const createBackendRemoteEntrySource = async (
+  workspaceRoot: string,
+  app: BackendFederationApp,
+  effectApiPath: string,
+  entryPath: string,
+) => {
+  const effectApiSpecifier = createRelativeImportSpecifier(
+    path.dirname(effectApiPath),
+    effectApiPath,
+  );
+  const containerMetadata = {
+    buildVersion: app.buildVersion,
+    expose: BACKEND_EXPOSE,
+    name: app.backendName,
+    packageName: app.packageName,
+    remoteType: app.remoteType,
+    source: normalizeRelativePath(path.relative(workspaceRoot, effectApiPath)),
+    version: app.version,
+    ...(app.unitId ? { unitId: app.unitId } : {}),
+    ...(app.sourceRevision ? { sourceRevision: app.sourceRevision } : {}),
+  };
+  const compatibility = {
+    build: app.buildVersion,
+    contractVersion: CONTRACT_VERSION,
+    nodeAdapterVersion: NODE_ADAPTER_VERSION,
+    packageName: app.packageName,
+    ...(app.unitId ? { unitId: app.unitId } : {}),
+    ...(app.sourceRevision ? { sourceRevision: app.sourceRevision } : {}),
+  };
+  const source = `// Generated by Modern.js backend federation build.
+import * as exposedNamespace from ${JSON.stringify(effectApiSpecifier)};
+
+const exposedModule = {
+  ...exposedNamespace,
+  backendFederationContract: {
+    ...(exposedNamespace.backendFederationContract ?? {}),
+    compatibility: {
+      ...(exposedNamespace.backendFederationContract?.compatibility ?? {}),
+      ...${JSON.stringify(compatibility)},
+    },
+    name: ${JSON.stringify(app.backendName)},
+    role: 'microvertical-server',
+    runtimeFramework: 'effect',
+    strictEffectApproach: true,
+  },
+};
+const exposedModules = {
+  ${JSON.stringify(BACKEND_EXPOSE)}: () => Promise.resolve(exposedModule),
+};
+const __modernjsBackendFederation = ${JSON.stringify(containerMetadata)};
+
+function init() {}
+
+function get(id) {
+  const load = exposedModules[id];
+  if (!load) {
+    throw new Error(\`Unexpected backend federation expose: \${id}\`);
+  }
+
+  return async () => load();
+}
+
+module.exports = { __modernjsBackendFederation, get, init };
+`;
+  const result = await build({
+    absWorkingDir: path.dirname(effectApiPath),
+    bundle: true,
+    format: 'cjs',
+    logLevel: 'silent',
+    platform: 'node',
+    stdin: {
+      contents: source,
+      loader: 'ts',
+      resolveDir: path.dirname(effectApiPath),
+      sourcefile: path.basename(entryPath),
+    },
+    target: 'node20',
+    write: false,
+  });
+  const output = result.outputFiles[0];
+  if (!output) {
+    throw new Error(
+      '[backend-federation-build] CommonJS backend federation container emitted no output.',
+    );
+  }
+  return output.text;
+};
+
+export const createBackendManifest = (
+  workspaceRoot: string,
+  distDirectory: string,
+  app: BackendFederationApp,
+  entryIntegrity: BackendFederationEntryIntegrity,
+) => {
+  const sourceModule = `${app.directory}/api/effect-api.ts`;
+  const publicPath = createPublicPath(app.containerEntry, app.port);
+
+  const manifest = {
+    schemaVersion: 1,
+    id: app.backendName,
+    name: app.backendName,
+    version: app.version,
+    buildVersion: app.buildVersion,
+    metaData: {
+      name: app.backendName,
+      type: 'backend',
+      buildInfo: {
+        buildVersion: app.buildVersion,
+        buildName: app.packageName,
+      },
+      remoteEntry: {
+        name: BACKEND_REMOTE_ENTRY_FILE,
+        path: '',
+        type: app.remoteType,
+      },
+      globalName: app.backendName,
+      publicPath,
+      ssrRemoteEntry: {
+        name: BACKEND_REMOTE_ENTRY_FILE,
+        path: '',
+        type: app.remoteType,
+      },
+      ssrPublicPath: publicPath,
+    },
+    entry: {
+      ...entryIntegrity,
+      file: BACKEND_REMOTE_ENTRY_FILE,
+      path: normalizeRelativePath(
+        path.relative(
+          workspaceRoot,
+          path.join(distDirectory, BACKEND_REMOTE_ENTRY_FILE),
+        ),
+      ),
+      type: app.remoteType,
+      url: app.containerEntry,
+    },
+    exposes: [
+      {
+        id: `${app.backendName}:${BACKEND_EXPOSE}`,
+        name: BACKEND_EXPOSE,
+        path: '',
+        assets: {
+          js: {
+            async: [],
+            sync: [BACKEND_REMOTE_ENTRY_FILE],
+          },
+          css: {
+            async: [],
+            sync: [],
+          },
+        },
+      },
+    ],
+    shared: [],
+    backendFederation: {
+      role: 'microvertical-server',
+      appId: app.id,
+      name: app.backendName,
+      runtimeFramework: 'effect',
+      strictEffectApproach: true,
+      contractVersion: CONTRACT_VERSION,
+      nodeAdapterVersion: NODE_ADAPTER_VERSION,
+      remoteType: app.remoteType,
+      expose: BACKEND_EXPOSE,
+      manifestUrl: app.manifestUrl,
+      containerEntry: app.containerEntry,
+      source: {
+        module: sourceModule,
+      },
+      readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
+      openapiPath: `${app.apiPrefix}/openapi.json`,
+      ...(app.deliveryUnit ? { deliveryUnit: app.deliveryUnit } : {}),
+      versionBoundary: {
+        invariant: 'web-and-api-same-build',
+        packageName: app.packageName,
+        version: app.version,
+        buildVersion: app.buildVersion,
+        ...(app.uiManifestUrl ? { uiManifestUrl: app.uiManifestUrl } : {}),
+        ...(app.deliveryUnit
+          ? {
+              deliveryUnit: {
+                unitId: app.deliveryUnit.unitId,
+                buildMarker: app.deliveryUnit.buildMarker,
+                sourceRevision: app.deliveryUnit.sourceRevision,
+              },
+            }
+          : {}),
+      },
+    },
+  };
+
+  const validation = validateBackendFederationManifest(manifest, {
+    path: 'backendFederationManifest',
+    requireEffectExpose: true,
+    requireEffectRuntime: true,
+    requireVersionFields: true,
+  });
+
+  if (!validation.ok) {
+    throw new Error(
+      `[backend-federation-build] Invalid backend federation manifest: ${formatBackendFederationValidationErrors(
+        validation.errors,
+      )}.`,
+    );
+  }
+
+  return manifest;
+};