@ws-test-realm/admin-kit 0.1.7

package/bin/ws-pack-remote.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// ws-pack-remote — pack a built lib's dist into a deploy-ready
+// federated remote artifact. See README.md for usage.
+
+const fs = require("fs");
+const path = require("path");
+const Module = require("module");
+
+const { resolveIdentity } = require("../lib/identity");
+const { discoverWorkspaceAliases } = require("../lib/alias-discovery");
+const { writeSyntheticEntry, cleanup } = require("../lib/synthetic-entry");
+const { buildSharedMap } = require("../lib/shared-deps");
+const { buildWebpackConfig } = require("../lib/webpack-factory");
+const { emitDescriptor } = require("../lib/emit-descriptor");
+
+function parseArgs(argv) {
+  const aliases = {
+    project: "project",
+    workspace: "workspace",
+    out: "out",
+    id: "id",
+    host: "host",
+    "remote-name": "remoteName",
+    exposes: "exposes",
+    "display-name": "displayName",
+    config: "config",
+  };
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) continue;
+    const key = a.slice(2);
+    const mapped = aliases[key];
+    if (!mapped) {
+      console.error(`Unknown flag: --${key}`);
+      process.exit(1);
+    }
+    const val = argv[i + 1];
+    if (val === undefined || val.startsWith("--")) {
+      args[mapped] = true;
+    } else {
+      args[mapped] = val;
+      i++;
+    }
+  }
+  return args;
+}
+
+function require_(args, key) {
+  if (!args[key]) {
+    console.error(`Missing required flag: --${kebab(key)}`);
+    process.exit(1);
+  }
+  return args[key];
+}
+
+function kebab(s) {
+  return s.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  require_(args, "project");
+  require_(args, "workspace");
+
+  const workspaceDir = path.resolve(args.workspace);
+  const identity = resolveIdentity(args);
+  const outDir = args.out
+    ? path.resolve(args.out)
+    : path.join(workspaceDir, "dist", "admin-remotes");
+
+  const libDist = path.join(workspaceDir, "dist", identity.id);
+  if (!fs.existsSync(libDist)) {
+    console.error(
+      `Lib dist not found at ${libDist}. Run \`ng build ${identity.id}\` first.`
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    `ws-pack-remote: id=${identity.id} remoteName=${
+      identity.remoteName
+    } → ${path.join(outDir, identity.id)}/`
+  );
+
+  const aliasMap = discoverWorkspaceAliases(workspaceDir);
+  if (!aliasMap[identity.id]) {
+    console.error(
+      `Lib '${identity.id}' not recognized as ng-package output (missing module/main in dist/${identity.id}/package.json).`
+    );
+    process.exit(1);
+  }
+
+  const synthetic = writeSyntheticEntry(identity.id);
+
+  let webpack;
+  try {
+    const requireFromWorkspace = Module.createRequire(
+      path.join(workspaceDir, "package.json")
+    );
+    webpack = requireFromWorkspace("webpack");
+  } catch (e) {
+    console.error(
+      `Failed to load webpack from workspace ${workspaceDir}: ${e.message}`
+    );
+    cleanup(synthetic.dir);
+    process.exit(1);
+  }
+
+  try {
+    const sharedMap = buildSharedMap({
+      workspaceDir,
+      aliasMap,
+      selfId: identity.id,
+      sharedExtras: identity.sharedExtras,
+    });
+
+    const config = buildWebpackConfig({
+      workspaceDir,
+      syntheticEntry: synthetic.file,
+      outDir,
+      id: identity.id,
+      remoteName: identity.remoteName,
+      exposes: identity.exposes,
+      aliasMap,
+      sharedMap,
+    });
+
+    await runWebpack(webpack, config);
+
+    // Copy the lib's static assets (i18n JSON, etc.) into the remote
+    // dir so the controller serves them at the same URL space as the
+    // chunks. ng-packagr emits these to `dist/<id>/assets/` per the
+    // lib's ng-package.json `assets` field; the old *-remote projects
+    // mirrored them via angular.json `assets` globs — same effect.
+    const libAssets = path.join(workspaceDir, "dist", identity.id, "assets");
+    if (fs.existsSync(libAssets)) {
+      const targetAssets = path.join(outDir, identity.id, "remote", "assets");
+      fs.cpSync(libAssets, targetAssets, { recursive: true });
+      console.log(`  + assets ${targetAssets}`);
+    }
+
+    const descriptorPath = emitDescriptor({
+      outDir,
+      id: identity.id,
+      hostId: identity.hostId,
+      remoteName: identity.remoteName,
+      exposes: identity.exposes,
+      displayName: identity.displayName,
+    });
+
+    console.log(`  + descriptor ${descriptorPath}`);
+  } finally {
+    cleanup(synthetic.dir);
+  }
+}
+
+function runWebpack(webpack, config) {
+  return new Promise((resolve, reject) => {
+    webpack(config, (err, stats) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const info = stats.toJson({ errors: true, warnings: true });
+      if (stats.hasErrors()) {
+        for (const e of info.errors) {
+          console.error(e.message || e);
+        }
+        reject(new Error("webpack build failed"));
+        return;
+      }
+      if (stats.hasWarnings()) {
+        for (const w of info.warnings) {
+          console.warn(w.message || w);
+        }
+      }
+      console.log(
+        stats.toString({
+          colors: true,
+          modules: false,
+          children: false,
+          chunks: false,
+          chunkModules: false,
+          entrypoints: false,
+        })
+      );
+      resolve();
+    });
+  });
+}
+
+main().catch((e) => {
+  console.error(e.stack || e.message || e);
+  process.exit(1);
+});

package/bin/ws-sync-paths.js

@@ -0,0 +1,35 @@
+#!/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.
+//
+// Usage:
+//   ws-sync-paths
+
+const fs = require("fs");
+const path = require("path");
+const { rebuildFederationTsconfig } = require("../lib/wire-host");
+
+function main() {
+  const cwd = process.cwd();
+  if (!fs.existsSync(path.join(cwd, "angular.json"))) {
+    console.error(`No angular.json in ${cwd} (not a workspace).`);
+    process.exit(1);
+  }
+  try {
+    const r = rebuildFederationTsconfig(cwd);
+    const siblings = Object.keys(r.paths).filter((k) => k !== "@ws-remote/*");
+    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>)"}`
+    );
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/ws-wire-host.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// ws-wire-host — write/merge the wpm-root pointer into <pwd>/wsconfig.json.
+// Re-runnable to re-point an existing workspace at a different wpm project.
+//
+// The admin project itself is derived at consumption time from
+// `<wpmRoot>/modules.json` (adminBuildFolder field), so we record only the
+// wpm root here.
+//
+// Usage:
+//   ws-wire-host <wpm-root-path> [--host-id <id>]
+//
+// Defaults:
+//   --host-id  admin
+
+const { applyWpmRoot } = require("../lib/wire-host");
+
+function parseArgs(argv) {
+  const aliases = { "host-id": "hostId" };
+  const args = {};
+  const positional = [];
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const mapped = aliases[key];
+      if (!mapped) {
+        console.error(`Unknown flag: --${key}`);
+        process.exit(1);
+      }
+      const val = argv[i + 1];
+      if (val === undefined || val.startsWith("--")) {
+        args[mapped] = true;
+      } else {
+        args[mapped] = val;
+        i++;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  args.wpmRoot = positional[0];
+  return args;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (!args.wpmRoot) {
+    console.error("Usage: ws-wire-host <wpm-root-path> [--host-id <id>]");
+    process.exit(1);
+  }
+  const hostId =
+    args.hostId && args.hostId !== true ? args.hostId : "admin";
+  try {
+    const result = applyWpmRoot(process.cwd(), args.wpmRoot, hostId);
+    console.log(
+      `Wired wsconfig.json:\n  wpmRoot = ${result.wpmRoot}\n  hostId  = ${result.hostId}`
+    );
+    console.log(
+      `Wrote tsconfig.federation.json:\n  @ws-remote/* -> ${result.federationTarget}`
+    );
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/ws-wire-pom.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// ws-wire-pom — record a pom path for one of the workspace's projects.
+//
+// Usage:
+//   ws-wire-pom [<module-name>] <pom-path>
+//
+// <pom-path> may be absolute or relative to PWD. The script resolves it,
+// validates it points at a real pom file within the workspace's module scope
+// (parent dir of the workspace), then writes `wsmodules.pom` into the matching
+// `projects/<name>/package.json` as a path relative to that project dir.
+//
+// If the workspace has exactly one project in angular.json, the module name
+// argument can be omitted (it's implied). With more than one project it must
+// be specified explicitly.
+
+const fs = require("fs");
+const path = require("path");
+const {
+  validatePomPath,
+  relativeFromProject,
+  readArtifactId,
+  getScopeRoot,
+} = require("../lib/pom");
+
+function parseArgs(argv) {
+  const positional = [];
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      console.error(`Unknown flag: ${a}`);
+      process.exit(1);
+    }
+    positional.push(a);
+  }
+  return positional;
+}
+
+function resolveProjectName(workspaceDir, explicit) {
+  const angularJsonPath = path.join(workspaceDir, "angular.json");
+  if (!fs.existsSync(angularJsonPath)) {
+    throw new Error(`No angular.json in ${workspaceDir} (not a workspace).`);
+  }
+  const projects = Object.keys(
+    JSON.parse(fs.readFileSync(angularJsonPath, "utf8")).projects || {}
+  );
+  if (explicit) {
+    if (!projects.includes(explicit)) {
+      throw new Error(
+        `Unknown project '${explicit}'. Workspace has: ${projects.join(", ") || "(none)"}`
+      );
+    }
+    return explicit;
+  }
+  if (projects.length === 0) {
+    throw new Error(
+      `Workspace has no projects. Run \`npm run generate-module <name>\` first.`
+    );
+  }
+  if (projects.length > 1) {
+    throw new Error(
+      `Multiple projects in workspace (${projects.join(", ")}); specify module name explicitly: ws-wire-pom <name> <pom>`
+    );
+  }
+  return projects[0];
+}
+
+function writePomField(workspaceDir, projectName, relPath) {
+  const pkgPath = path.join(workspaceDir, "projects", projectName, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg.wsmodules = pkg.wsmodules || {};
+  pkg.wsmodules.pom = relPath;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, "\t") + "\n");
+  return pkgPath;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (!args.length || args.length > 2) {
+    console.error(
+      "Usage: ws-wire-pom [<module-name>] <pom-path>\n" +
+        "  Module name is required when the workspace has multiple projects."
+    );
+    process.exit(1);
+  }
+
+  const workspaceDir = process.cwd();
+  const [first, second] = args;
+  const pomArg = second || first;
+  const moduleArg = second ? first : null;
+
+  let projectName;
+  try {
+    projectName = resolveProjectName(workspaceDir, moduleArg);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  const absPom = path.resolve(workspaceDir, pomArg);
+  try {
+    validatePomPath(workspaceDir, absPom);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  // Read artifactId now to fail fast if the target isn't a real pom (wrong
+  // file type, missing top-level <artifactId>, malformed XML, etc.). Avoids
+  // writing a bad wsmodules.pom path that would only surface at deploy time.
+  let artifactId;
+  try {
+    artifactId = readArtifactId(absPom);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  const rel = relativeFromProject(workspaceDir, projectName, absPom);
+  const pkgPath = writePomField(workspaceDir, projectName, rel);
+
+  console.log(`Wired pom for project '${projectName}':`);
+  console.log(`  package.json:   ${pkgPath}`);
+  console.log(`  wsmodules.pom = ${JSON.stringify(rel)}`);
+  console.log(`  resolves to:    ${absPom}`);
+  console.log(`  scope root:     ${getScopeRoot(workspaceDir)}`);
+  if (artifactId) {
+    console.log(`  artifactId:     ${artifactId}`);
+    console.log(`  jar glob:       ${artifactId}-*.jar`);
+  }
+}
+
+main();

package/lib/alias-discovery.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+const path = require("path");
+
+// Scan <workspace>/dist/* for ng-package-style outputs and return a map
+// {<libName>: <absolute path to dist/<libName>>}. An ng-package output is
+// recognized by having a package.json that declares either "module" or
+// "main" — that distinguishes it from the *-remote outputs (which we want
+// to ignore — they are webpack bundles, not consumable libs).
+function discoverWorkspaceAliases(workspaceDir) {
+  const distDir = path.join(workspaceDir, "dist");
+  if (!fs.existsSync(distDir)) return {};
+
+  const aliases = {};
+  for (const name of fs.readdirSync(distDir)) {
+    const dir = path.join(distDir, name);
+    let stat;
+    try {
+      stat = fs.statSync(dir);
+    } catch (e) {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+
+    const pkgPath = path.join(dir, "package.json");
+    if (!fs.existsSync(pkgPath)) continue;
+
+    let pkg;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    } catch (e) {
+      continue;
+    }
+    if (!pkg.module && !pkg.main) continue;
+
+    aliases[name] = dir;
+  }
+  return aliases;
+}
+
+module.exports = { discoverWorkspaceAliases };

package/lib/build-modules.js

@@ -0,0 +1,84 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { buildDependencyGraph, topologicalSort } = require("./topo-sort");
+
+function loadOrder({ workspaceDir, restrictTo, withDeps = false }) {
+  const angularJsonPath = path.join(workspaceDir, "angular.json");
+  if (!fs.existsSync(angularJsonPath)) {
+    throw new Error(`No angular.json in ${workspaceDir} (not a workspace).`);
+  }
+  const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, "utf8"));
+  const { graph } = buildDependencyGraph(workspaceDir, angularJson, restrictTo, { withDeps });
+  const order = topologicalSort(graph);
+  return { order, angularJson };
+}
+
+// A project declares itself a library (not a federated remote) by setting
+// `wsmodules.kind = "library"` in its own package.json. Default kind is
+// "remote": build/pack/deploy all run. Libraries are still built (their dist
+// is consumed by sibling projects) but skip pack/deploy.
+function isLibrary(workspaceDir, name) {
+  const pkgPath = path.join(workspaceDir, "projects", name, "package.json");
+  if (!fs.existsSync(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.wsmodules && pkg.wsmodules.kind === "library";
+  } catch {
+    return false;
+  }
+}
+
+function partitionByKind(workspaceDir, names) {
+  const remotes = [];
+  const libraries = [];
+  for (const n of names) {
+    if (isLibrary(workspaceDir, n)) libraries.push(n);
+    else remotes.push(n);
+  }
+  return { remotes, libraries };
+}
+
+function buildLibs({ workspaceDir, restrictTo = [], withDeps = false }) {
+  const { order } = loadOrder({ workspaceDir, restrictTo, withDeps });
+
+  console.log(`\n=== Build order ===`);
+  order.forEach((n, i) => console.log(`  ${i + 1}. ${n}`));
+
+  for (const name of order) {
+    console.log(`\n=== ng build ${name} ===`);
+    execSync(`npx ng build ${name}`, {
+      cwd: workspaceDir,
+      stdio: "inherit",
+    });
+  }
+
+  console.log(`\nBuilt ${order.length} lib(s).`);
+  return { order };
+}
+
+function packRemotes({ workspaceDir, restrictTo = [], withDeps = false }) {
+  const { order } = loadOrder({ workspaceDir, restrictTo, withDeps });
+  const { remotes, libraries } = partitionByKind(workspaceDir, order);
+
+  console.log(`\n=== Pack order ===`);
+  remotes.forEach((n, i) => console.log(`  ${i + 1}. ${n}`));
+  if (libraries.length) {
+    console.log(
+      `  (skipping libraries: ${libraries.join(", ")} — wsmodules.kind=library)`
+    );
+  }
+
+  for (const name of remotes) {
+    console.log(`\n=== ws-pack-remote ${name} ===`);
+    execSync(
+      `ws-pack-remote --project projects/${name} --workspace .`,
+      { cwd: workspaceDir, stdio: "inherit" }
+    );
+  }
+
+  console.log(`\nPacked ${remotes.length} remote(s).`);
+  return { order: remotes, libraries };
+}
+
+module.exports = { buildLibs, packRemotes, loadOrder, isLibrary, partitionByKind };

package/lib/cli-args.js

@@ -0,0 +1,55 @@
+// Shared CLI arg parsing + selection-mode resolution for ws-build-libs,
+// ws-pack-remotes, ws-deploy-remotes.
+//
+// Selection modes:
+//   inert  — no positional args; print usage, do nothing
+//   all    — single positional `all`; operate on every project
+//   named  — one or more project names; operate on exactly those
+// `--with-deps` expands the named set to include each name's transitive
+// in-workspace deps. `--skip-install` is build-libs-specific.
+
+function parseArgv(argv) {
+	const positional = [];
+	const flags = {};
+	for (let i = 2; i < argv.length; i++) {
+		const a = argv[i];
+		if (a.startsWith("--")) flags[a.slice(2)] = true;
+		else positional.push(a);
+	}
+	return { positional, flags };
+}
+
+function resolveSelection(positional) {
+	if (!positional.length) return { mode: "inert" };
+	if (positional.includes("all")) {
+		if (positional.length > 1) {
+			throw new Error("`all` cannot be combined with project names");
+		}
+		return { mode: "all", restrictTo: [] };
+	}
+	return { mode: "named", restrictTo: positional };
+}
+
+// Pack/deploy that run as `postbuild` lifecycle hooks of `npm run build` can
+// re-derive the original args from npm's `npm_config_argv` env var. Returns
+// the trailing positional+flag tokens from the parent command, or null if
+// not running as a postbuild hook (or env var missing/malformed).
+function inheritArgsFromPostbuild() {
+	if (process.env.npm_lifecycle_event !== "postbuild") return null;
+	const raw = process.env.npm_config_argv;
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		const orig = parsed.original || [];
+		// orig looks like ["run", "build", "crm", "db-login", "--with-deps"]
+		// Drop the leading `run|run-script <script>` pair.
+		if (orig[0] === "run" || orig[0] === "run-script") {
+			return orig.slice(2);
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+module.exports = { parseArgv, resolveSelection, inheritArgsFromPostbuild };