@ws-test-realm/admin-kit 0.6.6-ng20 → 0.6.8-ng20

package/lib/build-modules.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
 const { buildDependencyGraph, topologicalSort } = require("./topo-sort");
+const { patchRemoteEntryExpects } = require("./patch-remote-entry");
 
 function loadOrder({ workspaceDir, restrictTo, withDeps = false }) {
   const angularJsonPath = path.join(workspaceDir, "angular.json");
@@ -85,6 +86,16 @@ function buildLibs({ workspaceDir, restrictTo = [], withDeps = false }) {
       cwd: workspaceDir,
       stdio: "inherit",
     });
+
+    // Federation wrapper Step 1: augment remoteEntry.json with `expects`.
+    // No-op (returns null) for library-kind projects with no federation
+    // artifact emitted.
+    const patched = patchRemoteEntryExpects({ workspaceDir, id: name });
+    if (patched) {
+      console.log(
+        `  expects:       ${patched.count} entries → ${path.relative(workspaceDir, patched.entryPath)}`
+      );
+    }
   }
 
   console.log(`\nBuilt ${order.length} project(s).`);

package/lib/patch-remote-entry.js

@@ -0,0 +1,71 @@
+const fs = require("fs");
+const path = require("path");
+
+// Augment a project's emitted remoteEntry.json with the `expects` field —
+// the set of bare-specifier imports this remote consumes from other
+// federation members (BOM packages, sibling remotes, contribution-owners).
+// Source of truth: the project's federation.config.js#externals array.
+//
+// Step 1 of the federation wrapper. Native-federation's runtime puts each
+// remote's shares into per-remote scopes keyed by base URL — only the host
+// can put shares into root imports. A consumer remote can't resolve a
+// sibling remote's contribution unless the host knows about it at build
+// time. The wrapper closes the gap by reading every remote's `expects` at
+// boot, building a topology, and synthesizing root-level import-map
+// entries (steps 2 + 3). This step just emits the data.
+//
+// Called from the --build per-project loop right after the
+// native-federation `ng build <name>` step writes
+// `dist/<name>-remote/remoteEntry.json`, before pack/deploy copy it
+// elsewhere.
+function patchRemoteEntryExpects({ workspaceDir, id }) {
+  const cfgPath = path.join(
+    workspaceDir,
+    "projects",
+    id,
+    "federation.config.js"
+  );
+  if (!fs.existsSync(cfgPath)) return null;
+
+  // require() the federation config to get the normalized config object
+  // (output of withNativeFederation). `externals` is on it as an array.
+  // Clear the require cache so re-invocations during dev rebuilds pick up
+  // edits made to the federation.config since the last build.
+  delete require.cache[require.resolve(cfgPath)];
+  let cfg;
+  try {
+    cfg = require(cfgPath);
+  } catch (e) {
+    console.warn(
+      `  [warn] could not require ${path.relative(workspaceDir, cfgPath)}: ${e.message}`
+    );
+    return null;
+  }
+  const expects = Array.isArray(cfg.externals) ? [...cfg.externals] : [];
+
+  // Canonical output location under our dual-build convention.
+  const primary = path.join(
+    workspaceDir,
+    "dist",
+    `${id}-remote`,
+    "remoteEntry.json"
+  );
+  if (fs.existsSync(primary)) return patchAt(primary, expects);
+
+  // Legacy single-build fallbacks (browser-esbuild without nested 'browser/').
+  const fallback1 = path.join(workspaceDir, "dist", id, "browser", "remoteEntry.json");
+  if (fs.existsSync(fallback1)) return patchAt(fallback1, expects);
+  const fallback2 = path.join(workspaceDir, "dist", id, "remoteEntry.json");
+  if (fs.existsSync(fallback2)) return patchAt(fallback2, expects);
+
+  return null;
+}
+
+function patchAt(entryPath, expects) {
+  const entry = JSON.parse(fs.readFileSync(entryPath, "utf8"));
+  entry.expects = expects;
+  fs.writeFileSync(entryPath, JSON.stringify(entry, null, 2));
+  return { entryPath, count: expects.length };
+}
+
+module.exports = { patchRemoteEntryExpects };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ws-test-realm/admin-kit",
-  "version": "0.6.6-ng20",
+  "version": "0.6.8-ng20",
   "description": "Workflow CLI + scaffolding for Wiresphere admin-modules workspaces (Angular 20 + native-federation line). Ships `ws-init-workspace`, `ws-modules` (build+deploy driver), `ws-generate-module`/`ws-drop-module`, `ws-wire-host`, `ws-wire-pom`, `ws-sync-paths`, and `ws-purge`. Depends on @ws-test-realm/devkit (toolchain BOM) + @ws-test-realm/shared (runtime BOM + native-federation share map).",
   "license": "Artistic-2.0",
   "publishConfig": {
@@ -28,7 +28,7 @@
   "dependencies": {
     "@angular-architects/native-federation": "^20.0.0",
     "@ws-test-realm/devkit": "^0.8.0-ng20",
-    "@ws-test-realm/shared": "^0.8.1-ng20",
+    "@ws-test-realm/shared": "^0.8.2-ng20",
     "adm-zip": "^0.5.10",
     "fast-xml-parser": "^4.3.0"
   }

package/template-module/federation.config.js

@@ -1,37 +1,39 @@
 const { withNativeFederation, share } = require('@angular-architects/native-federation/config');
-const { sharedDescriptors, WORKSPACE_LIBS } = require('@ws-test-realm/shared');
+const { remoteShared, remoteExternals } = require('@ws-test-realm/shared');
+
+// Consume-only federation. A new module bundles ONLY its own code by
+// default. Everything else (BOM @angular/* etc., sibling remotes,
+// contribution-owners' packages like tinymce or angular-jwt) is
+// externalized — esbuild emits bare imports; the runtime federation
+// import map (populated by host's initFederation before any module
+// evaluates) resolves to the singleton chunk provided by host /
+// contribution-owner. Missing share at runtime crashes explicitly.
+// See PINNED.md "no module duplication".
+//
+// If THIS module brings in a peer dep that no other remote provides
+// (e.g. db-login owns `@auth0/angular-jwt`), add it to `own` so this
+// module becomes the contribution-owner — it gets bundled here and
+// listed in remoteEntry.json as a share, then other remotes can
+// externalize it.
+const OWN = []; // e.g. ['@some/special-dep']
 
 module.exports = withNativeFederation({
 	name: '__camelName__Module',
 	exposes: {
 		// Thin re-export shim so the exposed chunk delegates to the singleton
-		// shared chunk for this package (declared in `shared` below). Without
-		// the shim, esbuild would inline the whole library here and decorator
-		// side effects would fire a second time on remote load.
+		// shared chunk for this package. Without the shim, esbuild would
+		// inline the whole library here and decorator side effects would
+		// fire a second time on remote load.
 		'./Module': './projects/__name__/src/exposed-module.ts',
 	},
-	// share() expands includeSecondaries against each package's exports field.
-	// withNativeFederation's own share() invocation is commented out upstream.
-	//
-	// Three flavors of entries below the share() spread:
-	//
-	//   1. Self-share `'__name__': WORKSPACE_LIBS` — emits a chunk + import-map
-	//      entry for THIS module so siblings consuming it via bare specifiers
-	//      get the same instance at runtime.
-	//
-	//   2. Cross-workspace siblings (e.g. `'ws-framework': WORKSPACE_LIBS`) —
-	//      add when this module imports from another admin module that lives
-	//      in a different workspace. admin-kit symlinks `node_modules/<name>`
-	//      to the fiddle's `.federation/<name>/` so esbuild can resolve.
-	//
-	//   3. Module-carried federation contributions — runtime libs THIS module
-	//      introduces for the federation, that aren't in `sharedDescriptors()`'s
-	//      default slice. Example: db-login carries `@auth0/angular-jwt`. The
-	//      module's project package.json should list these as
-	//      `peerDependencies` (not `dependencies`); ng-packagr leaves them as
-	//      bare imports, native-federation emits the chunk + share entry, and
-	//      the runtime singleton mechanism dedupes if other consumers ever
-	//      import them.
-	shared: { ...share(sharedDescriptors()), '__name__': WORKSPACE_LIBS },
-	skip: ['rxjs/ajax', 'rxjs/fetch', 'rxjs/testing', 'rxjs/webSocket'],
+	shared: share(remoteShared({ self: '__name__', own: OWN })),
+	externals: remoteExternals({ self: '__name__', own: OWN }),
+	skip: [
+		'rxjs/ajax',
+		'rxjs/fetch',
+		'rxjs/testing',
+		'rxjs/webSocket',
+		'@angular/cdk/testing',
+		'@angular/material/testing',
+	],
 });