feat(node): add initial lib for ssr

Author: manfredsteyer

libs/native-federation-node/.eslintrc.json

@@ -0,0 +1,25 @@
+{
+  "extends": ["../../.eslintrc.base.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": "error"
+      }
+    }
+  ]
+}

libs/native-federation-node/README.md

@@ -0,0 +1,11 @@
+# native-federation-node
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build native-federation-node` to build the library.
+
+## Running unit tests
+
+Run `nx test native-federation-node` to execute the unit tests via [Jest](https://jestjs.io).

libs/native-federation-node/jest.config.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: 'native-federation-node',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/libs/native-federation-node',
+};

libs/native-federation-node/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@softarc/native-federation-node",
+  "version": "0.0.1"
+}

libs/native-federation-node/project.json

@@ -0,0 +1,33 @@
+{
+  "name": "native-federation-node",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/native-federation-node/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "generatorOptions": {
+        "packageRoot": "dist/{projectRoot}",
+        "currentVersionResolver": "git-tag"
+      }
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/native-federation-node",
+        "tsConfig": "libs/native-federation-node/tsconfig.lib.json",
+        "packageJson": "libs/native-federation-node/package.json",
+        "main": "libs/native-federation-node/src/index.ts",
+        "assets": ["libs/native-federation-node/*.md"]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

libs/native-federation-node/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/node/init-node-federation';

libs/native-federation-node/src/lib/node/federation-resolver.ts

@@ -0,0 +1,48 @@
+import { URL } from 'url';
+import { resolveAndComposeImportMap } from '../utils/import-map-utils';
+
+console.log('resolveAndComposeImportMap', resolveAndComposeImportMap);
+
+interface ResolveContext {
+  conditions: string[];
+  importAssertions: Record<string, string>;
+  parentURL?: string;
+}
+
+interface LoadContext {
+  format: string | null;
+  importAssertions: Record<string, string>;
+}
+
+interface ResolveResult {
+  url: string;
+}
+
+interface LoadResult {
+  format: string;
+  source: string | ArrayBuffer | Uint8Array;
+}
+
+type ResolveFunction = (
+  specifier: string,
+  context: ResolveContext,
+  defaultResolve: (specifier: string, context: ResolveContext) => Promise<ResolveResult>
+) => Promise<ResolveResult>;
+
+type LoadFunction = (
+  url: string,
+  context: LoadContext,
+  defaultLoad: (url: string, context: LoadContext) => Promise<LoadResult>
+) => Promise<LoadResult>;
+
+export const resolve: ResolveFunction = async (specifier, context, defaultResolve) => {
+  console.log(`Resolving: ${specifier}`);
+  
+  return defaultResolve(specifier, context);
+};
+
+export const load: LoadFunction = async (url, context, defaultLoad) => {
+  console.log(`Loading: ${url}`);
+
+  return defaultLoad(url, context);
+};

libs/native-federation-node/src/lib/node/import-map-store.ts

@@ -0,0 +1,11 @@
+import { ImportMap } from "@softarc/native-federation-runtime";
+
+let _importMap: ImportMap;
+
+export function setImportMap(importMap: ImportMap): void {
+    _importMap = importMap;
+}
+
+export function getImportMap(): ImportMap {
+   return _importMap;
+}

libs/native-federation-node/src/lib/node/init-node-federation.ts

@@ -0,0 +1,57 @@
+import { register } from "node:module";
+import { pathToFileURL } from "node:url";
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { processHostInfo, processRemoteInfos, FederationInfo } from "@softarc/native-federation-runtime";
+import { ImportMap, mergeImportMaps } from "@softarc/native-federation-runtime";
+import { setImportMap } from "./import-map-store";
+
+export type InitNodeFederationOptions = {
+  relBundlePath: string;
+};
+
+export async function initNodeFederation(
+  remotesOrManifestUrl: Record<string, string> | string = {},
+  options: InitNodeFederationOptions
+): Promise<void> {
+  const importMap = await createNodeImportMap(remotesOrManifestUrl, options);
+  setImportMap(importMap);
+  register(pathToFileURL('./federation-resolver.js').href);
+}
+
+async function createNodeImportMap(
+  remotesOrManifestUrl: Record<string, string> | string = {},
+  options: InitNodeFederationOptions
+): Promise<ImportMap> {
+  const remotes =
+    typeof remotesOrManifestUrl === 'object'
+      ? remotesOrManifestUrl
+      : await loadFsManifest(options.relBundlePath, remotesOrManifestUrl);
+
+  const hostInfo = await loadFsFederationInfo(options.relBundlePath);
+  const hostImportMap = await processHostInfo(hostInfo, options.relBundlePath);
+  const remotesImportMap = await processRemoteInfos(remotes);
+
+  const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
+
+  return importMap;
+}
+
+async function loadFsManifest(
+  relBundlePath: string,
+  manifestName: string
+): Promise<Record<string, string>> {
+  const manifestPath = path.join(relBundlePath, manifestName);
+  const content = await fs.readFile(manifestPath, 'utf-8');
+  const manifest = JSON.parse(content) as Record<string, string>;
+  return manifest;
+}
+
+async function loadFsFederationInfo(
+  relBundlePath: string
+): Promise<FederationInfo> {
+  const manifestPath = path.join(relBundlePath, 'remoteEntry.json');
+  const content = await fs.readFile(manifestPath, 'utf-8');
+  const manifest = JSON.parse(content) as FederationInfo;
+  return manifest;
+}