@ws-test-realm/admin-kit 0.2.3-ng16 → 0.2.5-ng16

package/bin/ws-sync-paths.js

@@ -1,16 +1,26 @@
 #!/usr/bin/env node
-// ws-sync-paths — regenerate tsconfig.federation.json from current workspace
-// state. Scans angular.json for sibling-dist aliases and reads wsconfig.json
-// for the @ws-remote/* mapping target. Safe to run any time; written
-// automatically by ws-init-workspace, ws-wire-host, ws-generate-module, and
-// ws-drop-module.
+// ws-sync-paths — refresh the workspace's federation wiring from current
+// state. Does two things:
+//
+//   1. Regenerates `tsconfig.federation.json` from angular.json sibling
+//      projects (workspace-local dist paths).
+//   2. Refreshes `node_modules/<name>` symlinks pointing at the fiddle's
+//      `.federation/<name>/` for each cross-workspace federation sibling
+//      published into the fiddle. Skips any name that's a workspace-local
+//      project (npm-workspaces already owns its symlink). With these symlinks
+//      in place, cross-workspace consumers import federation siblings via
+//      ordinary bare specifiers — no per-workspace package.json file: refs.
+//
+// Safe to run any time. Invoked automatically by ws-init-workspace,
+// ws-wire-host, ws-generate-module, ws-drop-module, and the workspace's
+// postinstall hook.
 //
 // Usage:
 //   ws-sync-paths
 
 const fs = require("fs");
 const path = require("path");
-const { rebuildFederationTsconfig } = require("../lib/wire-host");
+const { rebuildFederationTsconfig, syncFederationSymlinks } = require("../lib/wire-host");
 
 function main() {
   const cwd = process.cwd();
@@ -20,12 +30,20 @@ function main() {
   }
   try {
     const r = rebuildFederationTsconfig(cwd);
-    const siblings = Object.keys(r.paths).filter((k) => k !== "@ws-remote/*");
+    const siblings = Object.keys(r.paths).filter((k) => k !== "*");
     console.log(`Wrote ${r.file}`);
     console.log(`  sibling aliases: ${siblings.length ? siblings.join(", ") : "(none)"}`);
-    console.log(
-      `  @ws-remote/*  -> ${r.federationTarget || "(not wired; run ws-wire-host <wpm-root>)"}`
-    );
+
+    const sym = syncFederationSymlinks(cwd);
+    if (sym.skipped) {
+      console.log(`Federation symlinks: ${sym.skipped}`);
+    } else {
+      const parts = [];
+      if (sym.created.length) parts.push(`created [${sym.created.join(", ")}]`);
+      if (sym.updated.length) parts.push(`updated [${sym.updated.join(", ")}]`);
+      if (sym.kept.length) parts.push(`kept [${sym.kept.join(", ")}]`);
+      console.log(`Federation symlinks: ${parts.length ? parts.join(", ") : "(none)"}`);
+    }
   } catch (e) {
     console.error(e.message);
     process.exit(1);

package/lib/wire-host.js

@@ -51,25 +51,30 @@ function rebuildFederationTsconfig(workspaceDir) {
   if (wsconfig.wpmRoot) {
     const hostDir = resolveHostDir(wsconfig.wpmRoot);
     federationTarget = path.join(hostDir, ".federation", "*");
-    paths["@ws-remote/*"] = [federationTarget];
   }
-  // Catch-all fallback: any unresolved import resolves against this
-  // workspace's own node_modules. Required for cross-workspace federation
-  // siblings (e.g. @ws-remote/ws-framework) whose .d.ts files reference
-  // transitive deps (@angular/material/form-field, etc.) — TS walks up
-  // from the .d.ts file's location to find node_modules, but federation
-  // remotes live under <wpmRoot>/admin/.federation/ outside any consumer
-  // workspace's tree. This catch-all lets TS fall back to the consumer's
-  // node_modules regardless of where the .d.ts lives. Must come AFTER
-  // specific paths so they win on prefix match.
+  // Catch-all fallback: unresolved imports resolve against this workspace's
+  // own node_modules. Cross-workspace federation siblings reach the consumer
+  // via admin-kit-managed symlinks at `node_modules/<name>` pointing at
+  // `<wpmRoot>/admin/.federation/<name>/` (see syncFederationSymlinks); from
+  // the consumer's POV they look like ordinary packages.
   paths["*"] = ["./node_modules/*"];
-  // tsconfig.federation.json is the leaf of the extends chain. Its single
-  // responsibility now is to combine the workspace-local `paths` with the
-  // canonical compiler options from @ws-test-realm/devkit/tsconfig.base.json.
-  // Workspace tsconfig.json sits on top and extends THIS file.
+  // tsconfig.federation.json is the leaf of the workspace-local extends
+  // chain. Its sole responsibility is to layer workspace-specific `paths`
+  // onto the canonical workspace tsconfig shipped by admin-kit. The shipped
+  // file (@ws-test-realm/admin-kit/tsconfig.workspace.json) carries the
+  // federation-canonical compiler options (preserveSymlinks: true + the
+  // devkit base inheritance). Workspace tsconfig.json sits on top and
+  // extends THIS file. Workspaces pick up changes to the canonical settings
+  // by bumping admin-kit, no local file edits required.
   const config = {
-    extends: "@ws-test-realm/devkit/tsconfig.base.json",
-    compilerOptions: { paths },
+    extends: "@ws-test-realm/admin-kit/tsconfig.workspace.json",
+    compilerOptions: {
+      // `paths` are interpreted relative to `baseUrl`; both belong on the
+      // workspace-local layer (this file). TS requires baseUrl when paths
+      // are set.
+      baseUrl: "./",
+      paths,
+    },
   };
   const file = path.join(workspaceDir, "tsconfig.federation.json");
   fs.writeFileSync(file, JSON.stringify(config, null, "\t") + "\n");
@@ -98,9 +103,81 @@ function applyWpmRoot(workspaceDir, wpmRoot, hostId) {
   };
 }
 
+// For each federation lib published into the fiddle's `.federation/<name>/`,
+// ensure a symlink at `<workspace>/node_modules/<name>` points at it. This
+// makes cross-workspace federation siblings indistinguishable from in-workspace
+// ones for everything downstream: TS resolves bare imports through
+// node_modules; native-federation's `getPackageInfo` finds `package.json`;
+// esbuild externalizes via the share map normally; the federation runtime
+// dedupes to a singleton chunk at runtime via `singleton: true`.
+//
+// Skips any name that is itself a workspace-local project (entries in
+// angular.json), because for those the npm-workspaces machinery already
+// owns `node_modules/<name>` and points it at `projects/<name>`.
+//
+// Idempotent: leaves correct existing symlinks untouched, replaces stale
+// ones, creates missing ones.
+function syncFederationSymlinks(workspaceDir) {
+  const wsconfig = readWsconfig(workspaceDir);
+  if (!wsconfig.wpmRoot) {
+    return { skipped: "no wpmRoot wired", created: [], updated: [], kept: [] };
+  }
+  const hostDir = resolveHostDir(wsconfig.wpmRoot);
+  const federationDir = path.join(hostDir, ".federation");
+  if (!fs.existsSync(federationDir)) {
+    return { skipped: `no ${federationDir}`, created: [], updated: [], kept: [] };
+  }
+  const angularJsonPath = path.join(workspaceDir, "angular.json");
+  const localProjects = new Set();
+  if (fs.existsSync(angularJsonPath)) {
+    const angular = JSON.parse(fs.readFileSync(angularJsonPath, "utf8"));
+    for (const k of Object.keys(angular.projects || {})) localProjects.add(k);
+  }
+  const nodeModulesDir = path.join(workspaceDir, "node_modules");
+  fs.mkdirSync(nodeModulesDir, { recursive: true });
+
+  const created = [];
+  const updated = [];
+  const kept = [];
+
+  for (const entry of fs.readdirSync(federationDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    if (localProjects.has(name)) continue;
+    if (!fs.existsSync(path.join(federationDir, name, "package.json"))) continue;
+
+    const target = path.join(federationDir, name);
+    const linkPath = path.join(nodeModulesDir, name);
+
+    if (fs.existsSync(linkPath)) {
+      const stat = fs.lstatSync(linkPath);
+      if (stat.isSymbolicLink()) {
+        const current = fs.readlinkSync(linkPath);
+        const currentAbs = path.isAbsolute(current)
+          ? current
+          : path.resolve(path.dirname(linkPath), current);
+        if (currentAbs === target) {
+          kept.push(name);
+          continue;
+        }
+        fs.unlinkSync(linkPath);
+        fs.symlinkSync(target, linkPath);
+        updated.push(name);
+        continue;
+      }
+      // Real directory or file — don't touch (could be npm-managed).
+      continue;
+    }
+    fs.symlinkSync(target, linkPath);
+    created.push(name);
+  }
+  return { created, updated, kept };
+}
+
 module.exports = {
   readWsconfig,
   writeWsconfig,
   applyWpmRoot,
   rebuildFederationTsconfig,
+  syncFederationSymlinks,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ws-test-realm/admin-kit",
-  "version": "0.2.3-ng16",
+  "version": "0.2.5-ng16",
   "description": "Workflow CLI + scaffolding for Wiresphere admin-modules workspaces (Angular 16 + 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": {
@@ -22,6 +22,7 @@
     "lib",
     "template",
     "template-module",
+    "tsconfig.workspace.json",
     "README.md"
   ],
   "dependencies": {

package/template/tsconfig.json

@@ -1,7 +1,3 @@
 {
-	"extends": "@ws-test-realm/devkit/tsconfig.base.json",
-	"compilerOptions": {
-		"baseUrl": "./",
-		"outDir": "./dist/out-tsc"
-	}
+	"extends": "./tsconfig.federation.json"
 }

package/tsconfig.workspace.json

@@ -0,0 +1,7 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"extends": "@ws-test-realm/devkit/tsconfig.base.json",
+	"compilerOptions": {
+		"preserveSymlinks": true
+	}
+}