@intentius/chant 0.38.0 → 0.41.0

package/src/meta/peer-deps.test.ts

@@ -4,26 +4,123 @@ import { fileURLToPath } from "url";
 import { join } from "path";
 
 /**
- * The lexicon packages are published in lockstep with core, so their
- * `@intentius/*` peerDependencies must track the current core version. They were
- * once frozen at `^0.1.0` while shipping at 0.7.0, which made a clean
- * `npm install` fail (#411). This locks the invariant so it can't drift again.
+ * The lexicon packages declare `@intentius/*` peers, and a range frozen at an
+ * old version makes a clean `npm install` fail — they were once stuck at
+ * `^0.1.0` while shipping at 0.7.0 (#411). This locks the invariant so it
+ * cannot drift again.
+ *
+ * The range must track the version of the package that PROVIDES the peer, not
+ * core's version for every peer alike. Two providers exist: core backs
+ * `@intentius/chant`, and `lexicons/github` backs
+ * `@intentius/chant-lexicon-github` (forgejo and gitlab both peer on it).
+ * `just release-lexicon` writes exactly that — `^$core` for the core peer,
+ * `^$github_lexicon` for the github one — because a single-lexicon release
+ * moves one package without moving the others, so pinning every peer to core
+ * would demand a version that was never published.
+ *
+ * Asserting against core for both passed only while the whole workspace
+ * happened to sit on one version. `just release-lexicon github patch` alone is
+ * enough to separate them, and the old assertion then failed on a tree the
+ * release recipe had written correctly.
  */
 const repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
-const coreVersion = JSON.parse(readFileSync(join(repoRoot, "packages/core/package.json"), "utf-8")).version as string;
-const expected = `^${coreVersion}`;
+
+function versionOf(packageDir: string): string {
+  return JSON.parse(readFileSync(join(repoRoot, packageDir, "package.json"), "utf-8")).version as string;
+}
 
 const lexiconsDir = join(repoRoot, "lexicons");
 const lexicons = readdirSync(lexiconsDir).filter((name) => existsSync(join(lexiconsDir, name, "package.json")));
 
-describe("lexicon peerDependencies track the core version", () => {
-  test.each(lexicons)("%s pins @intentius/* peers to the current version", (lexicon) => {
-    const pkg = JSON.parse(readFileSync(join(lexiconsDir, lexicon, "package.json"), "utf-8"));
-    const peers: Record<string, string> = pkg.peerDependencies ?? {};
-    for (const [dep, range] of Object.entries(peers)) {
-      if (dep.startsWith("@intentius/")) {
-        expect(range, `${lexicon}: peer ${dep} should be ${expected}`).toBe(expected);
-      }
+/** Which workspace package publishes each `@intentius/*` peer a lexicon can declare. */
+const providerDir: Record<string, string> = {
+  "@intentius/chant": join("packages", "core"),
+  "@intentius/chant-lexicon-github": join("lexicons", "github"),
+};
+
+function intentiusPeersOf(lexicon: string): [string, string][] {
+  const pkg = JSON.parse(readFileSync(join(lexiconsDir, lexicon, "package.json"), "utf-8"));
+  const peers: Record<string, string> = pkg.peerDependencies ?? {};
+  // Third-party peers (typescript) aren't ours to track.
+  return Object.entries(peers).filter(([dep]) => dep.startsWith("@intentius/"));
+}
+
+describe("lexicon peerDependencies track the version of the package providing them", () => {
+  test.each(lexicons)("%s pins @intentius/* peers to their provider's version", (lexicon) => {
+    for (const [dep, range] of intentiusPeersOf(lexicon)) {
+      const dir = providerDir[dep];
+      expect(
+        dir,
+        `${lexicon} peers ${dep}, which no workspace package is registered as providing — ` +
+          `add it to providerDir so its range is checked`,
+      ).toBeDefined();
+
+      expect(range, `${lexicon}: peer ${dep} should be ^${versionOf(dir)}`).toBe(`^${versionOf(dir)}`);
     }
   });
+
+  test("every @intentius/* peer declared anywhere has a registered provider", () => {
+    // Guards the map itself: a new cross-lexicon peer added without a
+    // providerDir entry would be reported per-lexicon above, but only if that
+    // lexicon is reached — this states the whole set in one place.
+    const declared = new Set(lexicons.flatMap((l) => intentiusPeersOf(l).map(([dep]) => dep)));
+    expect([...declared].sort()).toEqual(Object.keys(providerDir).sort());
+  });
+
+});
+
+/**
+ * The rule itself, over fixtures rather than the real tree — the tree sits on
+ * one version today, so it cannot demonstrate the skew this exists to handle.
+ */
+function rangeViolations(
+  versions: Record<string, string>,
+  peers: Record<string, Record<string, string>>,
+): string[] {
+  const out: string[] = [];
+  for (const [lexicon, declared] of Object.entries(peers)) {
+    for (const [dep, range] of Object.entries(declared)) {
+      if (!dep.startsWith("@intentius/")) continue;
+      if (range !== `^${versions[dep]}`) out.push(`${lexicon}:${dep}`);
+    }
+  }
+  return out;
+}
+
+describe("the provider-aware rule, over fixtures", () => {
+  // `just release-lexicon github patch`: github moves, core does not, and the
+  // recipe rewrites forgejo's github peer to the new github version.
+  const skewed = { "@intentius/chant": "0.38.0", "@intentius/chant-lexicon-github": "0.38.1" };
+
+  test("accepts a provider ahead of core when its dependents track it", () => {
+    expect(
+      rangeViolations(skewed, {
+        forgejo: { "@intentius/chant": "^0.38.0", "@intentius/chant-lexicon-github": "^0.38.1" },
+      }),
+    ).toEqual([]);
+    // This is the case the old core-for-everything assertion rejected: it
+    // demanded ^0.38.0 for the github peer, on a tree release-lexicon wrote.
+    expect(`^${skewed["@intentius/chant-lexicon-github"]}`).not.toBe(`^${skewed["@intentius/chant"]}`);
+  });
+
+  test("still catches a range left behind by its provider", () => {
+    expect(
+      rangeViolations(skewed, {
+        forgejo: { "@intentius/chant": "^0.38.0", "@intentius/chant-lexicon-github": "^0.38.0" },
+      }),
+    ).toEqual(["forgejo:@intentius/chant-lexicon-github"]);
+  });
+
+  test("catches the #411 case — every range frozen at an old version", () => {
+    expect(
+      rangeViolations(skewed, {
+        aws: { "@intentius/chant": "^0.1.0" },
+        k8s: { "@intentius/chant": "^0.1.0" },
+      }),
+    ).toEqual(["aws:@intentius/chant", "k8s:@intentius/chant"]);
+  });
+
+  test("ignores third-party peers", () => {
+    expect(rangeViolations(skewed, { aws: { typescript: ">=5.0.0" } })).toEqual([]);
+  });
 });