@intentius/chant 0.124.99 → 0.124.100
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin/chant +3 -3
- package/dist/cli/commands/carve-emit.js +2 -2
- package/dist/cli/commands/check-lexicon-plugin.d.ts +2 -2
- package/dist/cli/commands/check-lexicon-plugin.js +3 -3
- package/dist/cli/commands/check-lexicon.js +4 -4
- package/dist/cli/commands/init-lexicon/templates/project.d.ts +1 -1
- package/dist/cli/commands/init-lexicon/templates/project.js +4 -4
- package/dist/cli/commands/init.d.ts +13 -0
- package/dist/cli/commands/init.js +30 -2
- package/dist/cli/handlers/release.d.ts +8 -0
- package/dist/cli/handlers/release.js +34 -1
- package/dist/cli/main.js +5 -0
- package/dist/cli/parse-args.js +7 -0
- package/dist/cli/registry.d.ts +2 -0
- package/dist/codegen/pinned-upgrade.js +1 -1
- package/dist/components/capability-plugin.d.ts +1 -1
- package/dist/components/capability-plugin.js +1 -1
- package/dist/config.d.ts +8 -0
- package/dist/config.js +2 -0
- package/dist/dead-guards.d.ts +5 -1
- package/dist/dead-guards.js +34 -23
- package/dist/discovery/sandbox/driver.js +1 -1
- package/dist/discovery/specifier-resolve.js +1 -1
- package/dist/floor-table.d.ts +3 -1
- package/dist/floor-table.data.js +9 -3
- package/dist/floor-table.js +4 -3
- package/dist/module-source.d.ts +2 -2
- package/dist/module-source.js +8 -8
- package/dist/release-floors.d.ts +3 -1
- package/dist/release-floors.js +3 -1
- package/dist/ts-loader.d.ts +1 -1
- package/dist/ts-loader.js +6 -6
- package/dist/wave-runtime.mjs +8 -8
- package/dist/workspace/reason-codes.d.ts +4 -0
- package/dist/workspace/reason-codes.js +5 -0
- package/dist/workspace/release-changed.d.ts +108 -0
- package/dist/workspace/release-changed.js +454 -0
- package/dist/workspace/release-changed.schema.json +188 -0
- package/dist/workspace/search-contract.d.ts +1 -1
- package/package.json +26 -26
|
@@ -320,6 +320,10 @@ export declare const REASONS: {
|
|
|
320
320
|
readonly "ref-update-invalid": "The hook's standard input is not the lines git hands a pre-receive or pre-push hook.";
|
|
321
321
|
readonly "ref-evidence-missing": "No runner evidence for a check the policy at base requires for the ref is attached to the pushed commit.";
|
|
322
322
|
readonly "ref-evidence-stale": "Evidence for a required check verifies, but a record it names changed after it was signed, or it names no records and was signed over another tree.";
|
|
323
|
+
readonly "bump-invalid": "--bump-member is not <member>=major|minor|patch, or names a member the declaration does not have.";
|
|
324
|
+
readonly "paths-changed": "The member has paths changed since its last release, after changes.ignore and generated files, or has no release yet.";
|
|
325
|
+
readonly "needed-by": "A member of the release depends on this one, and this one has changes since its last release.";
|
|
326
|
+
readonly "range-broken-by": "The range this member last published for a dependency does not admit that dependency's next label.";
|
|
323
327
|
readonly "lock-invalid": "The lineage lock can't be read.";
|
|
324
328
|
readonly "manual-step-open": "A scope in the lineage lock has an open manual step.";
|
|
325
329
|
readonly "missing-dir": "The chant member's directory does not exist, so there is nothing to build.";
|
|
@@ -383,6 +383,11 @@ export const REASONS = {
|
|
|
383
383
|
"ref-update-invalid": "The hook's standard input is not the lines git hands a pre-receive or pre-push hook.",
|
|
384
384
|
"ref-evidence-missing": "No runner evidence for a check the policy at base requires for the ref is attached to the pushed commit.",
|
|
385
385
|
"ref-evidence-stale": "Evidence for a required check verifies, but a record it names changed after it was signed, or it names no records and was signed over another tree.",
|
|
386
|
+
// The release-changed read (release changed, #5134): why the read stopped, and why a member is in the release.
|
|
387
|
+
"bump-invalid": "--bump-member is not <member>=major|minor|patch, or names a member the declaration does not have.",
|
|
388
|
+
"paths-changed": "The member has paths changed since its last release, after changes.ignore and generated files, or has no release yet.",
|
|
389
|
+
"needed-by": "A member of the release depends on this one, and this one has changes since its last release.",
|
|
390
|
+
"range-broken-by": "The range this member last published for a dependency does not admit that dependency's next label.",
|
|
386
391
|
// The lineage lock (check).
|
|
387
392
|
"lock-invalid": "The lineage lock can't be read.",
|
|
388
393
|
"manual-step-open": "A scope in the lineage lock has an open manual step.",
|
|
@@ -0,0 +1,108 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The `release-changed` read (#5134, design #5132 decisions 3 and 4): the
|
|
3
|
+
* members of a workspace whose members release separately, that a release at
|
|
4
|
+
* one commit has to cut, in the order to publish them.
|
|
5
|
+
*
|
|
6
|
+
* `chant release changed [--at <sha>] [--bump-member <member>=<level>]... [--json]`
|
|
7
|
+
* prints this document. It runs in the root of the workspace whose `chant`
|
|
8
|
+
* members are the releasable units (the nested `release/` workspace of a
|
|
9
|
+
* repository that publishes many packages), reads local refs and tags only,
|
|
10
|
+
* and never fetches.
|
|
11
|
+
*
|
|
12
|
+
* For each `chant` member it finds the commit of its last release: the newest
|
|
13
|
+
* cut in the member's ledger, else the newest legacy tag, one of the
|
|
14
|
+
* `release.legacyTags` prefixes of the root's `chant.config.ts` followed by a
|
|
15
|
+
* version (`release/npm/0.124.44`, `chant-v0.124.44`). It then lists the
|
|
16
|
+
* paths changed from there to the commit, takes the outer member that holds
|
|
17
|
+
* each (`memberHolding`, the outermost workspace's members, one of which has
|
|
18
|
+
* the member's own name), and drops the paths `changes.ignore` matches and
|
|
19
|
+
* the generated files. A member with paths left, or with no release yet, is
|
|
20
|
+
* `changed`.
|
|
21
|
+
*
|
|
22
|
+
* The closure then runs to a fixed point:
|
|
23
|
+
*
|
|
24
|
+
* - upward: a member of the release also releases each workspace dependency
|
|
25
|
+
* of it, direct or transitive, that is `changed` (`needed-by <member>`; a
|
|
26
|
+
* changed member no other member needs keeps `paths-changed`).
|
|
27
|
+
* Dependencies are the `dependencies`, `peerDependencies` and
|
|
28
|
+
* `optionalDependencies` of the member's package.json at the commit, as
|
|
29
|
+
* `publish_layers` reads them.
|
|
30
|
+
* - downward: a dependent the release does not already take is added when
|
|
31
|
+
* the range its last release's package.json gives a dependency does not
|
|
32
|
+
* admit that dependency's next label (`range-broken-by <member>`). The next
|
|
33
|
+
* label is the last label bumped by `--bump-member` (default patch).
|
|
34
|
+
*
|
|
35
|
+
* Members come in dependency layers, each layer sorted by name.
|
|
36
|
+
*/
|
|
37
|
+
export declare const RELEASE_CHANGED_CONTRACT_VERSION = 1;
|
|
38
|
+
export declare const RELEASE_CHANGED_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/release-changed/v1/release-changed.schema.json";
|
|
39
|
+
/** Why the read stopped. Closed; each code is in `reason-codes.ts`. */
|
|
40
|
+
export declare const RELEASE_CHANGED_ERROR_CODES: readonly ["not-a-git-repository", "declaration-missing", "revision-unknown", "bump-invalid", "ledger-unreadable"];
|
|
41
|
+
/** Why a member is in the release. Closed; each code is in `reason-codes.ts`. */
|
|
42
|
+
export declare const RELEASE_CHANGED_REASON_CODES: readonly ["paths-changed", "needed-by", "range-broken-by"];
|
|
43
|
+
export declare const RELEASE_BUMPS: readonly ["major", "minor", "patch"];
|
|
44
|
+
export type ReleaseBump = (typeof RELEASE_BUMPS)[number];
|
|
45
|
+
export interface ReleaseChangedReason {
|
|
46
|
+
code: (typeof RELEASE_CHANGED_REASON_CODES)[number];
|
|
47
|
+
/** The member that needs this one (`needed-by`) or whose next label breaks its range (`range-broken-by`); null for `changed`. */
|
|
48
|
+
member: string | null;
|
|
49
|
+
}
|
|
50
|
+
export interface LastRelease {
|
|
51
|
+
/** The label of the release, or null when its cut has none. */
|
|
52
|
+
label: string | null;
|
|
53
|
+
/** The full sha it was cut from. */
|
|
54
|
+
commit: string;
|
|
55
|
+
/** `ledger` for a cut in the member's ledger, `legacy` for a legacy tag. */
|
|
56
|
+
source: "ledger" | "legacy";
|
|
57
|
+
}
|
|
58
|
+
export interface ReleaseChangedMember {
|
|
59
|
+
member: string;
|
|
60
|
+
/** The dependency layer, 0 for the members that need no other member of the release. Members of one layer publish together. */
|
|
61
|
+
layer: number;
|
|
62
|
+
reason: ReleaseChangedReason;
|
|
63
|
+
/** The member's last release, or null when it has none. */
|
|
64
|
+
last: LastRelease | null;
|
|
65
|
+
/** The bump applied to `last.label`. */
|
|
66
|
+
bump: ReleaseBump;
|
|
67
|
+
/** The label a release of it would carry, or null when there is no last label to bump. */
|
|
68
|
+
next: string | null;
|
|
69
|
+
/** The changed paths that count, from the outermost workspace root. Empty for a member taken only by the closure. */
|
|
70
|
+
paths: string[];
|
|
71
|
+
}
|
|
72
|
+
export type ReleaseChangedDocument = {
|
|
73
|
+
$schema: string;
|
|
74
|
+
contract: number;
|
|
75
|
+
chant: string;
|
|
76
|
+
/** The full sha the read was made at. */
|
|
77
|
+
at: string;
|
|
78
|
+
/** In publish order: layer, then name. */
|
|
79
|
+
members: ReleaseChangedMember[];
|
|
80
|
+
} | {
|
|
81
|
+
$schema: string;
|
|
82
|
+
contract: number;
|
|
83
|
+
chant: string;
|
|
84
|
+
error: {
|
|
85
|
+
code: (typeof RELEASE_CHANGED_ERROR_CODES)[number];
|
|
86
|
+
message: string;
|
|
87
|
+
};
|
|
88
|
+
};
|
|
89
|
+
export interface ReleaseChangedQuery {
|
|
90
|
+
cwd: string;
|
|
91
|
+
/** The commit to read at; the tip of the trunk without it. */
|
|
92
|
+
at?: string;
|
|
93
|
+
/** `<member>=<level>` bumps; a member with none gets a patch. */
|
|
94
|
+
bump?: string[];
|
|
95
|
+
}
|
|
96
|
+
type Version = [number, number, number];
|
|
97
|
+
/** `1.2.3` (a leading `v` allowed) as numbers, or null. */
|
|
98
|
+
export declare function parseVersion(text: string): Version | null;
|
|
99
|
+
/** The label `bump` makes of `label`, or null when `label` is not a version. */
|
|
100
|
+
export declare function bumpLabel(label: string, bump: ReleaseBump): string | null;
|
|
101
|
+
/**
|
|
102
|
+
* Whether the npm range `range` admits `label`. A range chant does not read
|
|
103
|
+
* (`workspace:*`, a URL, a tag) admits everything: it forces no release.
|
|
104
|
+
*/
|
|
105
|
+
export declare function rangeAdmits(range: string, label: string): boolean;
|
|
106
|
+
/** Read what a release at a commit of the workspace at `query.cwd` has to cut. */
|
|
107
|
+
export declare function releaseChangedDocument(query: ReleaseChangedQuery): Promise<ReleaseChangedDocument>;
|
|
108
|
+
export {};
|
|
@@ -0,0 +1,454 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The `release-changed` read (#5134, design #5132 decisions 3 and 4): the
|
|
3
|
+
* members of a workspace whose members release separately, that a release at
|
|
4
|
+
* one commit has to cut, in the order to publish them.
|
|
5
|
+
*
|
|
6
|
+
* `chant release changed [--at <sha>] [--bump-member <member>=<level>]... [--json]`
|
|
7
|
+
* prints this document. It runs in the root of the workspace whose `chant`
|
|
8
|
+
* members are the releasable units (the nested `release/` workspace of a
|
|
9
|
+
* repository that publishes many packages), reads local refs and tags only,
|
|
10
|
+
* and never fetches.
|
|
11
|
+
*
|
|
12
|
+
* For each `chant` member it finds the commit of its last release: the newest
|
|
13
|
+
* cut in the member's ledger, else the newest legacy tag, one of the
|
|
14
|
+
* `release.legacyTags` prefixes of the root's `chant.config.ts` followed by a
|
|
15
|
+
* version (`release/npm/0.124.44`, `chant-v0.124.44`). It then lists the
|
|
16
|
+
* paths changed from there to the commit, takes the outer member that holds
|
|
17
|
+
* each (`memberHolding`, the outermost workspace's members, one of which has
|
|
18
|
+
* the member's own name), and drops the paths `changes.ignore` matches and
|
|
19
|
+
* the generated files. A member with paths left, or with no release yet, is
|
|
20
|
+
* `changed`.
|
|
21
|
+
*
|
|
22
|
+
* The closure then runs to a fixed point:
|
|
23
|
+
*
|
|
24
|
+
* - upward: a member of the release also releases each workspace dependency
|
|
25
|
+
* of it, direct or transitive, that is `changed` (`needed-by <member>`; a
|
|
26
|
+
* changed member no other member needs keeps `paths-changed`).
|
|
27
|
+
* Dependencies are the `dependencies`, `peerDependencies` and
|
|
28
|
+
* `optionalDependencies` of the member's package.json at the commit, as
|
|
29
|
+
* `publish_layers` reads them.
|
|
30
|
+
* - downward: a dependent the release does not already take is added when
|
|
31
|
+
* the range its last release's package.json gives a dependency does not
|
|
32
|
+
* admit that dependency's next label (`range-broken-by <member>`). The next
|
|
33
|
+
* label is the last label bumped by `--bump-member` (default patch).
|
|
34
|
+
*
|
|
35
|
+
* Members come in dependency layers, each layer sorted by name.
|
|
36
|
+
*/
|
|
37
|
+
import { execFileSync } from "node:child_process";
|
|
38
|
+
import { existsSync, realpathSync } from "node:fs";
|
|
39
|
+
import { dirname, join, relative, resolve, sep } from "node:path";
|
|
40
|
+
// @ts-ignore — picomatch has no types declaration
|
|
41
|
+
import picomatch from "picomatch";
|
|
42
|
+
import { findWorkspaceRoot } from "../project-root.js";
|
|
43
|
+
import { readAllReleases, readCuts } from "../lifecycle/release-store.js";
|
|
44
|
+
import { resolveMemberLedger } from "../lifecycle/member-ledger.js";
|
|
45
|
+
import { readDeclaration, readerVersion } from "./declaration.js";
|
|
46
|
+
import { isGeneratedPath } from "./generated-files.js";
|
|
47
|
+
import { memberHolding } from "./record-assets.js";
|
|
48
|
+
import { workingTree } from "./tree.js";
|
|
49
|
+
export const RELEASE_CHANGED_CONTRACT_VERSION = 1;
|
|
50
|
+
export const RELEASE_CHANGED_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/release-changed/v1/release-changed.schema.json";
|
|
51
|
+
/** Why the read stopped. Closed; each code is in `reason-codes.ts`. */
|
|
52
|
+
export const RELEASE_CHANGED_ERROR_CODES = ["not-a-git-repository", "declaration-missing", "revision-unknown", "bump-invalid", "ledger-unreadable"];
|
|
53
|
+
/** Why a member is in the release. Closed; each code is in `reason-codes.ts`. */
|
|
54
|
+
export const RELEASE_CHANGED_REASON_CODES = ["paths-changed", "needed-by", "range-broken-by"];
|
|
55
|
+
export const RELEASE_BUMPS = ["major", "minor", "patch"];
|
|
56
|
+
class ReadFailure extends Error {
|
|
57
|
+
constructor(code, message) {
|
|
58
|
+
super(message);
|
|
59
|
+
this.code = code;
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
function git(top, args) {
|
|
63
|
+
return execFileSync("git", args, { cwd: top, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 256 * 1024 * 1024 }).trim();
|
|
64
|
+
}
|
|
65
|
+
function tryGit(top, args) {
|
|
66
|
+
try {
|
|
67
|
+
return git(top, args);
|
|
68
|
+
}
|
|
69
|
+
catch {
|
|
70
|
+
return null;
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
const VERSION = /^v?(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
|
|
74
|
+
/** `1.2.3` (a leading `v` allowed) as numbers, or null. */
|
|
75
|
+
export function parseVersion(text) {
|
|
76
|
+
const m = VERSION.exec(text.trim());
|
|
77
|
+
return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
|
|
78
|
+
}
|
|
79
|
+
const compare = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
|
|
80
|
+
/** The label `bump` makes of `label`, or null when `label` is not a version. */
|
|
81
|
+
export function bumpLabel(label, bump) {
|
|
82
|
+
const v = parseVersion(label);
|
|
83
|
+
if (!v)
|
|
84
|
+
return null;
|
|
85
|
+
if (bump === "major")
|
|
86
|
+
return `${v[0] + 1}.0.0`;
|
|
87
|
+
if (bump === "minor")
|
|
88
|
+
return `${v[0]}.${v[1] + 1}.0`;
|
|
89
|
+
return `${v[0]}.${v[1]}.${v[2] + 1}`;
|
|
90
|
+
}
|
|
91
|
+
/** The version a partial like `1`, `1.2` or `1.x` stands for, with the position of its first wildcard. */
|
|
92
|
+
function partial(text) {
|
|
93
|
+
const parts = text.replace(/^v/, "").split(/[-+]/)[0].split(".");
|
|
94
|
+
if (parts.length === 0 || parts.length > 3)
|
|
95
|
+
return null;
|
|
96
|
+
const nums = [];
|
|
97
|
+
let given = 0;
|
|
98
|
+
for (const p of parts) {
|
|
99
|
+
if (/^[xX*]$/.test(p) || p === "")
|
|
100
|
+
break;
|
|
101
|
+
if (!/^\d+$/.test(p))
|
|
102
|
+
return null;
|
|
103
|
+
nums.push(Number(p));
|
|
104
|
+
given++;
|
|
105
|
+
}
|
|
106
|
+
while (nums.length < 3)
|
|
107
|
+
nums.push(0);
|
|
108
|
+
return { v: [nums[0], nums[1], nums[2]], given };
|
|
109
|
+
}
|
|
110
|
+
/** Whether one space-separated comparator set admits `v`. Null when it is not a range chant reads. */
|
|
111
|
+
function setAdmits(set, v) {
|
|
112
|
+
const tokens = set
|
|
113
|
+
.replace(/(>=|<=|>|<|=|\^|~)\s+/g, "$1")
|
|
114
|
+
.split(/\s+/)
|
|
115
|
+
.filter(Boolean);
|
|
116
|
+
if (tokens.length === 0)
|
|
117
|
+
return true;
|
|
118
|
+
for (const token of tokens) {
|
|
119
|
+
const m = /^(>=|<=|>|<|=|\^|~)?(.*)$/.exec(token);
|
|
120
|
+
const op = m[1] ?? "";
|
|
121
|
+
const p = partial(m[2]);
|
|
122
|
+
if (!p)
|
|
123
|
+
return null;
|
|
124
|
+
const lo = p.v;
|
|
125
|
+
let ok;
|
|
126
|
+
if (op === "^") {
|
|
127
|
+
// ^1.2.3 is <2.0.0; ^0.2.3 is <0.3.0; ^0.0.3 is <0.0.4.
|
|
128
|
+
let hi;
|
|
129
|
+
if (lo[0] > 0 || p.given <= 1)
|
|
130
|
+
hi = [lo[0] + 1, 0, 0];
|
|
131
|
+
else if (lo[1] > 0 || p.given <= 2)
|
|
132
|
+
hi = [0, lo[1] + 1, 0];
|
|
133
|
+
else
|
|
134
|
+
hi = [0, 0, lo[2] + 1];
|
|
135
|
+
ok = compare(v, lo) >= 0 && compare(v, hi) < 0;
|
|
136
|
+
}
|
|
137
|
+
else if (op === "~") {
|
|
138
|
+
const hi = p.given <= 1 ? [lo[0] + 1, 0, 0] : [lo[0], lo[1] + 1, 0];
|
|
139
|
+
ok = compare(v, lo) >= 0 && compare(v, hi) < 0;
|
|
140
|
+
}
|
|
141
|
+
else if (op === ">=")
|
|
142
|
+
ok = compare(v, lo) >= 0;
|
|
143
|
+
else if (op === ">")
|
|
144
|
+
ok = p.given >= 3 ? compare(v, lo) > 0 : compare(v, [lo[0], lo[1], lo[2]]) >= 0 && !(p.given === 0) && compare(v, p.given === 1 ? [lo[0] + 1, 0, 0] : [lo[0], lo[1] + 1, 0]) >= 0;
|
|
145
|
+
else if (op === "<=")
|
|
146
|
+
ok = p.given >= 3 ? compare(v, lo) <= 0 : compare(v, p.given === 1 ? [lo[0] + 1, 0, 0] : [lo[0], lo[1] + 1, 0]) < 0;
|
|
147
|
+
else if (op === "<")
|
|
148
|
+
ok = compare(v, lo) < 0;
|
|
149
|
+
else if (p.given >= 3)
|
|
150
|
+
ok = compare(v, lo) === 0;
|
|
151
|
+
else if (p.given === 0)
|
|
152
|
+
ok = true;
|
|
153
|
+
else
|
|
154
|
+
ok = compare(v, lo) >= 0 && compare(v, p.given === 1 ? [lo[0] + 1, 0, 0] : [lo[0], lo[1] + 1, 0]) < 0;
|
|
155
|
+
if (!ok)
|
|
156
|
+
return false;
|
|
157
|
+
}
|
|
158
|
+
return true;
|
|
159
|
+
}
|
|
160
|
+
/**
|
|
161
|
+
* Whether the npm range `range` admits `label`. A range chant does not read
|
|
162
|
+
* (`workspace:*`, a URL, a tag) admits everything: it forces no release.
|
|
163
|
+
*/
|
|
164
|
+
export function rangeAdmits(range, label) {
|
|
165
|
+
const v = parseVersion(label);
|
|
166
|
+
if (!v)
|
|
167
|
+
return true;
|
|
168
|
+
const sets = range.split("||").map((s) => s.trim());
|
|
169
|
+
let unread = false;
|
|
170
|
+
for (const set of sets) {
|
|
171
|
+
const hit = setAdmits(set, v);
|
|
172
|
+
if (hit === null)
|
|
173
|
+
unread = true;
|
|
174
|
+
else if (hit)
|
|
175
|
+
return true;
|
|
176
|
+
}
|
|
177
|
+
return unread;
|
|
178
|
+
}
|
|
179
|
+
function readPackage(top, rev, path) {
|
|
180
|
+
const text = tryGit(top, ["show", `${rev}:${path}`]);
|
|
181
|
+
if (text === null)
|
|
182
|
+
return { name: null, ranges: new Map() };
|
|
183
|
+
let json;
|
|
184
|
+
try {
|
|
185
|
+
json = JSON.parse(text);
|
|
186
|
+
}
|
|
187
|
+
catch {
|
|
188
|
+
return { name: null, ranges: new Map() };
|
|
189
|
+
}
|
|
190
|
+
const ranges = new Map();
|
|
191
|
+
for (const key of ["dependencies", "peerDependencies", "optionalDependencies"]) {
|
|
192
|
+
const block = json[key];
|
|
193
|
+
if (block && typeof block === "object")
|
|
194
|
+
for (const [n, r] of Object.entries(block))
|
|
195
|
+
if (typeof r === "string" && !ranges.has(n))
|
|
196
|
+
ranges.set(n, r);
|
|
197
|
+
}
|
|
198
|
+
return { name: typeof json.name === "string" ? json.name : null, ranges };
|
|
199
|
+
}
|
|
200
|
+
/** The outermost workspace root at or above `dir`. */
|
|
201
|
+
function outermostRoot(dir) {
|
|
202
|
+
let root = dir;
|
|
203
|
+
for (;;) {
|
|
204
|
+
const up = findWorkspaceRoot(dirname(root));
|
|
205
|
+
if (!up || up.dir === root)
|
|
206
|
+
return root;
|
|
207
|
+
root = up.dir;
|
|
208
|
+
}
|
|
209
|
+
}
|
|
210
|
+
const posix = (p) => (sep === "/" ? p : p.split(sep).join("/"));
|
|
211
|
+
/** The member's last release from its ledger, or null. */
|
|
212
|
+
async function ledgerRelease(memberDir) {
|
|
213
|
+
const loc = { cwd: memberDir };
|
|
214
|
+
await resolveMemberLedger(memberDir);
|
|
215
|
+
const { releases } = await readAllReleases(loc);
|
|
216
|
+
const { cuts } = await readCuts(loc);
|
|
217
|
+
const commitOf = new Map(releases.map((r) => [r.releaseDigest, r.commit]));
|
|
218
|
+
let best = null;
|
|
219
|
+
for (const c of cuts) {
|
|
220
|
+
const commit = commitOf.get(c.releaseDigest);
|
|
221
|
+
if (commit === undefined)
|
|
222
|
+
continue;
|
|
223
|
+
if (!best || c.timestamp > best.at)
|
|
224
|
+
best = { at: c.timestamp, label: c.label, commit };
|
|
225
|
+
}
|
|
226
|
+
return best ? { label: best.label, commit: best.commit, source: "ledger" } : null;
|
|
227
|
+
}
|
|
228
|
+
/** The newest legacy tag of `prefixes` that names a version, as a release, or null. */
|
|
229
|
+
function legacyRelease(top, prefixes) {
|
|
230
|
+
let best = null;
|
|
231
|
+
for (const prefix of prefixes) {
|
|
232
|
+
const tags = tryGit(top, ["tag", "-l", `${prefix}[0-9]*`]) ?? "";
|
|
233
|
+
for (const tag of tags.split("\n").filter(Boolean)) {
|
|
234
|
+
const rest = tag.slice(prefix.length);
|
|
235
|
+
const v = parseVersion(rest);
|
|
236
|
+
// `release/npm/core/0.125.0` is a member's tag, not a legacy one: a version has no slash.
|
|
237
|
+
if (!v || rest.includes("/"))
|
|
238
|
+
continue;
|
|
239
|
+
if (!best || compare(v, best.v) > 0)
|
|
240
|
+
best = { v, label: rest.replace(/^v/, ""), tag };
|
|
241
|
+
}
|
|
242
|
+
}
|
|
243
|
+
if (!best)
|
|
244
|
+
return null;
|
|
245
|
+
const commit = tryGit(top, ["rev-list", "-n", "1", best.tag]);
|
|
246
|
+
return commit ? { label: best.label, commit, source: "legacy" } : null;
|
|
247
|
+
}
|
|
248
|
+
async function legacyPrefixes(root) {
|
|
249
|
+
try {
|
|
250
|
+
const { loadChantConfig } = await import("../config.js");
|
|
251
|
+
return [...((await loadChantConfig(root)).config.release?.legacyTags ?? [])];
|
|
252
|
+
}
|
|
253
|
+
catch {
|
|
254
|
+
return [];
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
/** Read what a release at a commit of the workspace at `query.cwd` has to cut. */
|
|
258
|
+
export async function releaseChangedDocument(query) {
|
|
259
|
+
const head = { $schema: RELEASE_CHANGED_SCHEMA_ID, contract: RELEASE_CHANGED_CONTRACT_VERSION, chant: readerVersion() };
|
|
260
|
+
try {
|
|
261
|
+
return { ...head, ...(await read(query)) };
|
|
262
|
+
}
|
|
263
|
+
catch (err) {
|
|
264
|
+
if (err instanceof ReadFailure)
|
|
265
|
+
return { ...head, error: { code: err.code, message: err.message } };
|
|
266
|
+
return { ...head, error: { code: "ledger-unreadable", message: `reading the changed members failed: ${err instanceof Error ? err.message : String(err)}` } };
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
async function read(query) {
|
|
270
|
+
const cwd = resolve(query.cwd);
|
|
271
|
+
const top = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
|
|
272
|
+
if (!top)
|
|
273
|
+
throw new ReadFailure("not-a-git-repository", "the changed members are read from commits and tags, and this directory is not in a git repository");
|
|
274
|
+
const found = findWorkspaceRoot(cwd);
|
|
275
|
+
if (!found)
|
|
276
|
+
throw new ReadFailure("declaration-missing", "release changed reads a workspace of release members, and there is no chant.workspace.json between this directory and the git root");
|
|
277
|
+
const rootDir = realpathSync(found.dir);
|
|
278
|
+
const declaration = readDeclaration(workingTree(rootDir));
|
|
279
|
+
const outerDir = realpathSync(outermostRoot(rootDir));
|
|
280
|
+
const outer = outerDir === rootDir ? declaration : readDeclaration(workingTree(outerDir));
|
|
281
|
+
const outerFromTop = posix(relative(top, outerDir));
|
|
282
|
+
// The commit.
|
|
283
|
+
let at;
|
|
284
|
+
if (query.at !== undefined) {
|
|
285
|
+
at = tryGit(top, ["rev-parse", "--verify", "--quiet", `${query.at}^{commit}`]);
|
|
286
|
+
if (!at)
|
|
287
|
+
throw new ReadFailure("revision-unknown", `--at ${query.at} names no commit in this clone`);
|
|
288
|
+
}
|
|
289
|
+
else {
|
|
290
|
+
const { resolveTrunk } = await import("../lifecycle/release-workstation.js");
|
|
291
|
+
const trunk = resolveTrunk(top, declaration.ci?.green?.branch ?? null);
|
|
292
|
+
at =
|
|
293
|
+
tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/remotes/${trunk.remote}/${trunk.branch}^{commit}`]) ??
|
|
294
|
+
tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/heads/${trunk.branch}^{commit}`]);
|
|
295
|
+
if (!at)
|
|
296
|
+
throw new ReadFailure("revision-unknown", `this clone knows no ${trunk.branch}; fetch it, or name a commit with --at`);
|
|
297
|
+
}
|
|
298
|
+
const members = declaration.members.filter((m) => m.kind === "chant" && m.dir !== ".").map((m) => ({ name: m.name, dir: m.dir }));
|
|
299
|
+
const names = new Set(members.map((m) => m.name));
|
|
300
|
+
const bumps = new Map();
|
|
301
|
+
for (const entry of query.bump ?? []) {
|
|
302
|
+
const [member, level, ...extra] = entry.split("=");
|
|
303
|
+
if (!member || !level || extra.length > 0 || !RELEASE_BUMPS.includes(level))
|
|
304
|
+
throw new ReadFailure("bump-invalid", `--bump-member ${entry} is not <member>=major|minor|patch`);
|
|
305
|
+
if (!names.has(member))
|
|
306
|
+
throw new ReadFailure("bump-invalid", `--bump-member names ${member}, which is not a chant member of this declaration (${[...names].sort().join(", ") || "none"})`);
|
|
307
|
+
bumps.set(member, level);
|
|
308
|
+
}
|
|
309
|
+
// Each member's package, last release and the paths changed since.
|
|
310
|
+
const outerMemberOf = (name) => outer.members.find((m) => m.name === name);
|
|
311
|
+
const pkgDir = (name) => {
|
|
312
|
+
const holder = outerMemberOf(name) ?? declaration.members.find((m) => m.name === name);
|
|
313
|
+
return holder === outerMemberOf(name) ? holder.dir : posix(relative(outerDir, join(rootDir, holder.dir)));
|
|
314
|
+
};
|
|
315
|
+
const legacy = await legacyPrefixes(rootDir);
|
|
316
|
+
const legacyLast = legacy.length > 0 ? legacyRelease(top, legacy) : null;
|
|
317
|
+
const ignore = (outer.changes?.ignore ?? []).map((g) => picomatch(g, { dot: true }));
|
|
318
|
+
const info = new Map();
|
|
319
|
+
for (const m of members) {
|
|
320
|
+
const dir = pkgDir(m.name);
|
|
321
|
+
const memberDir = join(rootDir, m.dir);
|
|
322
|
+
if (!existsSync(memberDir))
|
|
323
|
+
throw new ReadFailure("ledger-unreadable", `member ${m.name} has no directory ${m.dir}`);
|
|
324
|
+
const last = (await ledgerRelease(memberDir)) ?? legacyLast;
|
|
325
|
+
let paths = [];
|
|
326
|
+
if (last) {
|
|
327
|
+
if (tryGit(top, ["cat-file", "-e", `${last.commit}^{commit}`]) === null)
|
|
328
|
+
throw new ReadFailure("ledger-unreadable", `the last release of ${m.name} is at ${last.commit.slice(0, 12)}, which this clone does not have`);
|
|
329
|
+
const diff = tryGit(top, ["diff", "--name-only", "--no-renames", last.commit, at]) ?? "";
|
|
330
|
+
for (const file of diff.split("\n").filter(Boolean)) {
|
|
331
|
+
const path = outerFromTop === "." || outerFromTop === "" ? file : file.startsWith(`${outerFromTop}/`) ? file.slice(outerFromTop.length + 1) : null;
|
|
332
|
+
if (path === null)
|
|
333
|
+
continue;
|
|
334
|
+
if (memberHolding(path, outer.members) !== m.name && !(outerMemberOf(m.name) === undefined && memberHolding(path, declaration.members) === m.name))
|
|
335
|
+
continue;
|
|
336
|
+
if (ignore.some((match) => match(path)))
|
|
337
|
+
continue;
|
|
338
|
+
if (isGeneratedPath(outer, path))
|
|
339
|
+
continue;
|
|
340
|
+
paths.push(path);
|
|
341
|
+
}
|
|
342
|
+
paths = [...new Set(paths)].sort();
|
|
343
|
+
}
|
|
344
|
+
const prefix = outerFromTop === "." || outerFromTop === "" ? "" : `${outerFromTop}/`;
|
|
345
|
+
info.set(m.name, {
|
|
346
|
+
name: m.name,
|
|
347
|
+
dir,
|
|
348
|
+
pkg: readPackage(top, at, `${prefix}${dir}/package.json`),
|
|
349
|
+
last,
|
|
350
|
+
paths,
|
|
351
|
+
changed: last === null || paths.length > 0,
|
|
352
|
+
published: last ? readPackage(top, last.commit, `${prefix}${dir}/package.json`) : null,
|
|
353
|
+
});
|
|
354
|
+
}
|
|
355
|
+
// Dependencies among members, by package name.
|
|
356
|
+
const memberOfPackage = new Map();
|
|
357
|
+
for (const i of info.values())
|
|
358
|
+
if (i.pkg.name)
|
|
359
|
+
memberOfPackage.set(i.pkg.name, i.name);
|
|
360
|
+
const needs = new Map();
|
|
361
|
+
for (const i of info.values())
|
|
362
|
+
needs.set(i.name, [...new Set([...i.pkg.ranges.keys()].map((n) => memberOfPackage.get(n)).filter((n) => n !== undefined && n !== i.name))].sort());
|
|
363
|
+
const nextOf = (name) => {
|
|
364
|
+
const bump = bumps.get(name) ?? "patch";
|
|
365
|
+
const label = info.get(name).last?.label;
|
|
366
|
+
return { bump, next: label ? bumpLabel(label, bump) : null };
|
|
367
|
+
};
|
|
368
|
+
// The closure.
|
|
369
|
+
const chosen = new Map();
|
|
370
|
+
const queue = [];
|
|
371
|
+
for (const i of [...info.values()].sort((a, b) => a.name.localeCompare(b.name))) {
|
|
372
|
+
if (i.changed) {
|
|
373
|
+
chosen.set(i.name, { code: "paths-changed", member: null });
|
|
374
|
+
queue.push(i.name);
|
|
375
|
+
}
|
|
376
|
+
}
|
|
377
|
+
const take = (name, reason) => {
|
|
378
|
+
if (chosen.has(name))
|
|
379
|
+
return;
|
|
380
|
+
chosen.set(name, reason);
|
|
381
|
+
queue.push(name);
|
|
382
|
+
};
|
|
383
|
+
while (queue.length > 0) {
|
|
384
|
+
const m = queue.shift();
|
|
385
|
+
// Upward: a changed dependency, direct or through members that did not change.
|
|
386
|
+
const seen = new Set([m]);
|
|
387
|
+
const walk = [...(needs.get(m) ?? [])];
|
|
388
|
+
while (walk.length > 0) {
|
|
389
|
+
const d = walk.shift();
|
|
390
|
+
if (seen.has(d))
|
|
391
|
+
continue;
|
|
392
|
+
seen.add(d);
|
|
393
|
+
if (info.get(d).changed)
|
|
394
|
+
take(d, { code: "needed-by", member: m });
|
|
395
|
+
walk.push(...(needs.get(d) ?? []));
|
|
396
|
+
}
|
|
397
|
+
// Downward: a dependent whose published range does not admit the next label.
|
|
398
|
+
const { next } = nextOf(m);
|
|
399
|
+
if (next === null)
|
|
400
|
+
continue;
|
|
401
|
+
const pkgName = info.get(m).pkg.name;
|
|
402
|
+
if (pkgName === null)
|
|
403
|
+
continue;
|
|
404
|
+
for (const p of [...info.values()].sort((a, b) => a.name.localeCompare(b.name))) {
|
|
405
|
+
if (chosen.has(p.name) || !(needs.get(p.name) ?? []).includes(m))
|
|
406
|
+
continue;
|
|
407
|
+
const range = p.published?.ranges.get(pkgName);
|
|
408
|
+
if (range !== undefined && !rangeAdmits(range, next))
|
|
409
|
+
take(p.name, { code: "range-broken-by", member: m });
|
|
410
|
+
}
|
|
411
|
+
}
|
|
412
|
+
// Layers: Kahn over the chosen members, with an edge for each dependency reachable through the whole graph.
|
|
413
|
+
const reach = (from) => {
|
|
414
|
+
const out = new Set();
|
|
415
|
+
const stack = [...(needs.get(from) ?? [])];
|
|
416
|
+
while (stack.length > 0) {
|
|
417
|
+
const d = stack.pop();
|
|
418
|
+
if (out.has(d))
|
|
419
|
+
continue;
|
|
420
|
+
out.add(d);
|
|
421
|
+
stack.push(...(needs.get(d) ?? []));
|
|
422
|
+
}
|
|
423
|
+
return out;
|
|
424
|
+
};
|
|
425
|
+
// A changed member another member of the release depends on is there because that member needs it.
|
|
426
|
+
for (const [name, reason] of chosen) {
|
|
427
|
+
if (reason.code !== "paths-changed")
|
|
428
|
+
continue;
|
|
429
|
+
const needer = [...chosen.keys()].sort().find((m) => m !== name && chosen.get(m).code !== "range-broken-by" && reach(m).has(name));
|
|
430
|
+
if (needer !== undefined)
|
|
431
|
+
chosen.set(name, { code: "needed-by", member: needer });
|
|
432
|
+
}
|
|
433
|
+
const before = new Map([...chosen.keys()].map((m) => [m, [...reach(m)].filter((d) => chosen.has(d) && d !== m)]));
|
|
434
|
+
const layerOf = new Map();
|
|
435
|
+
const left = new Set(chosen.keys());
|
|
436
|
+
for (let layer = 0; left.size > 0; layer++) {
|
|
437
|
+
let ready = [...left].filter((m) => !before.get(m).some((d) => left.has(d))).sort();
|
|
438
|
+
// A dependency cycle cannot be ordered; its members share the layer.
|
|
439
|
+
if (ready.length === 0)
|
|
440
|
+
ready = [...left].sort();
|
|
441
|
+
for (const m of ready) {
|
|
442
|
+
layerOf.set(m, layer);
|
|
443
|
+
left.delete(m);
|
|
444
|
+
}
|
|
445
|
+
}
|
|
446
|
+
const out = [...chosen.keys()]
|
|
447
|
+
.sort((a, b) => layerOf.get(a) - layerOf.get(b) || a.localeCompare(b))
|
|
448
|
+
.map((name) => {
|
|
449
|
+
const i = info.get(name);
|
|
450
|
+
const { bump, next } = nextOf(name);
|
|
451
|
+
return { member: name, layer: layerOf.get(name), reason: chosen.get(name), last: i.last, bump, next, paths: i.paths };
|
|
452
|
+
});
|
|
453
|
+
return { at, members: out };
|
|
454
|
+
}
|