@ws-test-realm/admin-kit 0.2.4-ng16 → 0.2.6-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/generate-module.js

@@ -110,6 +110,13 @@ function registerInAngularJson(workspaceDir, name) {
           main: `projects/${name}/src/main.ts`,
           polyfills: [],
           tsConfig: `projects/${name}/tsconfig.app.json`,
+          // Cross-workspace federation siblings reach this workspace via
+          // admin-kit-managed symlinks at node_modules/<name>; esbuild needs
+          // preserveSymlinks=true to resolve peer imports out of those .d.ts/
+          // .mjs files against THIS workspace's node_modules (where the
+          // peers are installed) rather than walking up from the symlink
+          // target in the fiddle.
+          preserveSymlinks: true,
           styles: [],
           scripts: [],
         },

package/lib/wire-host.js

@@ -51,17 +51,12 @@ 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 workspace-local extends
   // chain. Its sole responsibility is to layer workspace-specific `paths`
@@ -73,7 +68,13 @@ function rebuildFederationTsconfig(workspaceDir) {
   // by bumping admin-kit, no local file edits required.
   const config = {
     extends: "@ws-test-realm/admin-kit/tsconfig.workspace.json",
-    compilerOptions: { paths },
+    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");
@@ -102,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.4-ng16",
+  "version": "0.2.6-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": {

package/template-module/federation.config.js

@@ -8,12 +8,30 @@ module.exports = withNativeFederation({
 		// 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.
-		'./Module': './src/exposed-module.ts',
+		'./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.
-	// Self-share this package so siblings consuming it via bare specifiers
-	// resolve to the same singleton chunk at runtime.
-	shared: { ...share(sharedDescriptors()), __name__: WORKSPACE_LIBS },
+	//
+	// 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'],
 });

package/template-module/tsconfig.app.json

@@ -2,8 +2,21 @@
 	"extends": "../../tsconfig.json",
 	"compilerOptions": {
 		"outDir": "../../out-tsc/app",
-		"types": []
+		"strict": false,
+		"strictNullChecks": false,
+		"noImplicitAny": false,
+		"noImplicitReturns": false,
+		"useDefineForClassFields": false,
+		"skipLibCheck": true,
+		"skipDefaultLibCheck": true,
+		"types": ["node"]
 	},
-	"files": ["src/main.ts", "src/polyfills.ts"],
-	"include": ["src/**/*.d.ts"]
+	"angularCompilerOptions": {
+		"strictTemplates": false,
+		"strictInjectionParameters": false,
+		"strictInputAccessModifiers": false
+	},
+	"files": ["src/main.ts"],
+	"include": ["src/**/*.ts"],
+	"exclude": ["src/**/*.spec.ts", "src/test.ts"]
 }