@smoothbricks/nx-plugin 0.4.20 → 0.4.22
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/README.md +89 -18
- package/dist/bin/smoo-nx-cargo-hash.js +32 -4
- package/dist/cargo-source-hash.d.ts +10 -1
- package/dist/cargo-source-hash.d.ts.map +1 -1
- package/dist/cargo-source-hash.js +251 -41
- package/dist/cargo-workspace.d.ts +0 -1
- package/dist/cargo-workspace.d.ts.map +1 -1
- package/dist/cargo-workspace.js +9 -2
- package/dist/ensure-built.d.ts +6 -5
- package/dist/ensure-built.d.ts.map +1 -1
- package/dist/ensure-built.js +227 -30
- package/dist/index.js +18 -10
- package/dist/managed-files/ci-workflow.d.ts +20 -0
- package/dist/managed-files/ci-workflow.d.ts.map +1 -1
- package/dist/managed-files/ci-workflow.js +42 -13
- package/dist/managed-files/files.d.ts +1 -1
- package/dist/managed-files/files.d.ts.map +1 -1
- package/dist/managed-files/files.js +8 -1
- package/dist/managed-files/pr-preview-cleanup-workflow.d.ts +37 -0
- package/dist/managed-files/pr-preview-cleanup-workflow.d.ts.map +1 -1
- package/dist/managed-files/pr-preview-cleanup-workflow.js +34 -6
- package/dist/workspace-manifest.d.ts +3 -1
- package/dist/workspace-manifest.d.ts.map +1 -1
- package/managed/raw/tooling/direnv/setup-environment.ts +23 -91
- package/managed/raw/tooling/git-hooks/commit-msg.sh +6 -0
- package/managed/raw/tooling/git-hooks/pre-commit.sh +6 -0
- package/managed/raw/tooling/git-hooks/pre-push.sh +6 -0
- package/managed/templates/github/actions/setup-devenv/action.yml +19 -7
- package/package.json +1 -1
- package/src/bin/smoo-nx-cargo-hash.ts +29 -5
- package/src/cargo-source-hash.test.ts +291 -1
- package/src/cargo-source-hash.ts +190 -28
- package/src/cargo-workspace.test.ts +17 -10
- package/src/cargo-workspace.ts +9 -3
- package/src/ensure-built.test.ts +87 -29
- package/src/ensure-built.ts +274 -29
- package/src/index.test.ts +117 -20
- package/src/index.ts +18 -11
- package/src/managed-files/ci-workflow.ts +45 -14
- package/src/managed-files/files.ts +9 -2
- package/src/managed-files/generator.test.ts +5 -1
- package/src/managed-files/github-host-cache-isolation.test.ts +32 -6
- package/src/managed-files/pr-preview-cleanup-workflow.ts +87 -6
- package/src/workspace-manifest.ts +3 -1
package/README.md
CHANGED
|
@@ -90,9 +90,9 @@ source replacement, credentials, and toolchain settings; forwarding it with `--c
|
|
|
90
90
|
access may consequently serialize on Cargo's package-cache lock. Clippy's dedicated target directory keeps its check
|
|
91
91
|
artifacts out of the test build directory without splitting one directory per crate.
|
|
92
92
|
|
|
93
|
-
###
|
|
93
|
+
### Cargo source runtime inputs
|
|
94
94
|
|
|
95
|
-
For a repository-root Cargo workspace, declare the
|
|
95
|
+
For inferred Cargo targets in a repository-root Cargo workspace, declare the external-source input once:
|
|
96
96
|
|
|
97
97
|
```json
|
|
98
98
|
{
|
|
@@ -106,12 +106,61 @@ For a package-root Cargo workspace, pass its manifest relative to the Nx root:
|
|
|
106
106
|
`smoo-nx-cargo-hash packages/example/Cargo.toml`. A shared input covering several Cargo workspaces includes one runtime
|
|
107
107
|
entry per manifest.
|
|
108
108
|
|
|
109
|
-
|
|
110
|
-
transitive dependencies, Rust sources, target source files, governing Cargo manifests, and Cargo
|
|
111
|
-
covers path packages under `node_modules`, which Nx's normal file map ignores.
|
|
109
|
+
By default, the command queries `cargo metadata --locked --offline` and hashes the resolved external path packages,
|
|
110
|
+
including transitive dependencies, Rust sources, target source files, governing Cargo manifests, and Cargo
|
|
111
|
+
configuration. It also covers path packages under `node_modules`, which Nx's normal file map ignores. Packages inside
|
|
112
|
+
both the Nx and Cargo workspaces are left to the plugin's inferred file inputs. Adding or moving a dependency does not
|
|
112
113
|
require maintaining a second list of source roots. The command refuses missing dependencies or an unavailable locked
|
|
113
114
|
dependency cache instead of emitting a partial digest.
|
|
114
115
|
|
|
116
|
+
Custom Cargo targets that replace inferred inputs need the in-workspace source closure too. Use
|
|
117
|
+
`smoo-nx-cargo-hash --include-workspace --closure <directory> [Cargo.toml]` to hash the locked, offline resolve closure
|
|
118
|
+
of the local packages under `<directory>`: those packages and every mutable local package they reach through normal,
|
|
119
|
+
build or dev dependencies, inside or outside the Nx workspace. An edit to a workspace member outside that closure leaves
|
|
120
|
+
the digest unchanged. Nx does not substitute `{projectRoot}` into runtime inputs, so each project that owns custom Cargo
|
|
121
|
+
targets declares its own `cargoSources` and names its directory. For a repository-root Cargo workspace, `nx.json`
|
|
122
|
+
declares:
|
|
123
|
+
|
|
124
|
+
```json
|
|
125
|
+
{
|
|
126
|
+
"namedInputs": {
|
|
127
|
+
"externalRustCrates": [{ "runtime": "smoo-nx-cargo-hash" }]
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
```
|
|
131
|
+
|
|
132
|
+
and `packages/example/project.json` (or the `nx` key of its `package.json`) declares:
|
|
133
|
+
|
|
134
|
+
```json
|
|
135
|
+
{
|
|
136
|
+
"namedInputs": {
|
|
137
|
+
"cargoSources": [
|
|
138
|
+
{ "runtime": "smoo-nx-cargo-hash --include-workspace --closure packages/example" },
|
|
139
|
+
"{workspaceRoot}/Cargo.lock",
|
|
140
|
+
"{workspaceRoot}/devenv.lock",
|
|
141
|
+
"{workspaceRoot}/tooling/direnv/devenv.lock"
|
|
142
|
+
]
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
```
|
|
146
|
+
|
|
147
|
+
Name `cargoSources` in each custom Cargo target's `inputs`, alongside its own scripts and non-Rust build inputs. Keep
|
|
148
|
+
`externalRustCrates` for the plugin's external-source inference contract; unrelated TypeScript targets do not need
|
|
149
|
+
`cargoSources`. Without `--closure`, `--include-workspace` hashes every mutable local package in the Cargo workspace.
|
|
150
|
+
For a package-root workspace, pass its manifest last and name that workspace's `Cargo.lock`. An Nx `^production` input
|
|
151
|
+
only follows existing project graph edges; it cannot replace a missing Cargo dependency closure.
|
|
152
|
+
|
|
153
|
+
Files git ignores beneath a package directory are not hashed, matching Nx's own file inputs. A generated source is its
|
|
154
|
+
producer's output: the consuming target depends on the producer and hashes the source through
|
|
155
|
+
`dependentTasksOutputFiles`, so a tree that has not generated it yet hashes like one that has. A package whose own
|
|
156
|
+
directory git ignores, such as one installed under `node_modules`, keeps all of its sources, and a directory outside any
|
|
157
|
+
Git repository ignores nothing.
|
|
158
|
+
|
|
159
|
+
The helper exposes the same choices as
|
|
160
|
+
`hashCargoPathInputs(manifestPath, workspaceRoot, { includeWorkspace: true, closure: 'packages/example' })`, resolving
|
|
161
|
+
`closure` like `manifestPath`. Omitting the options, or setting `includeWorkspace: false`, retains the external-only
|
|
162
|
+
behavior.
|
|
163
|
+
|
|
115
164
|
Git and registry dependencies are identified by `Cargo.lock`; uncommitted changes in a Git repository are not changes to
|
|
116
165
|
a pinned Git dependency. Local `path` dependencies stay live and their source edits change the digest. Build-script data
|
|
117
166
|
and environment inputs outside the Rust/Cargo inputs above still require explicit Nx inputs.
|
|
@@ -176,19 +225,22 @@ Concrete targets come from concrete files:
|
|
|
176
225
|
- A workspace-root `Cargo.toml` provides `cargo-test`, `test`, `cargo-lint`, `mutation`, and `bench`.
|
|
177
226
|
`cargo-test-compile` warms one workspace `cargo test --no-run`. `cargo-test-archive` runs one
|
|
178
227
|
`cargo --frozen nextest archive --workspace` into `target/nextest/archive.tar.zst` and is the only cached cargo BUILD:
|
|
179
|
-
it produces a file rather than a mutable build tree.
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
228
|
+
it produces a file rather than a mutable build tree. Its inputs, like every cargo-derived fileset, are anchored at
|
|
229
|
+
`{workspaceRoot}`: Nx resolves a `{projectRoot}` glob against only the files its project owns, and a nested package
|
|
230
|
+
owns the crates under it, so a root workspace's archive spelled that way hashes none of its members and replays stale
|
|
231
|
+
binaries against edited crates. Each member crate gets a cached `cargo-test-<package>` run (30s per-test timeout like
|
|
232
|
+
`bun test --timeout=30000`) whose inputs include that crate and its path dependencies, and whose command is
|
|
233
|
+
`cargo --frozen nextest run --archive-file <archive> --workspace-remap . -E 'package(<crate>)'`. Runners therefore
|
|
234
|
+
execute rather than build: they extract binaries into their own temporary directory, write nothing to cargo's flocked
|
|
235
|
+
`target/`, and fan out instead of chaining. `--workspace-remap` is required — an archive records the producing tree's
|
|
236
|
+
absolute paths, and without it a restored archive hands tests another checkout's `CARGO_MANIFEST_DIR`. With it the
|
|
237
|
+
archive is relocatable, so one cache entry serves every checkout of the same commit; nextest re-points
|
|
238
|
+
`CARGO_BIN_EXE_<name>`/`NEXTEST_BIN_EXE_<name>` at the extracted binaries at runtime, but a test that reads them
|
|
239
|
+
through the compile-time `env!` macro keeps the producing tree's path. Per-crate runners accept an empty nextest
|
|
240
|
+
selection because a valid workspace member may have no tests and a hash partition may legitimately be empty.
|
|
241
|
+
`napi-debug` stays behind `cargo-test-compile`, and a crate in the project that builds the debug cdylib runs after it.
|
|
242
|
+
A crate declaring `[package.metadata.smoothbricks.wasm-bindgen]` also receives the cacheable `cargo-wasm` output
|
|
243
|
+
target in its owning project.
|
|
192
244
|
- The plugin's own `nextest.toml` is passed as `--tool-config-file "smoo:$PWD/<path>"`, so it is a layer BENEATH the
|
|
193
245
|
repository's `<cargo-workspace>/.config/nextest.toml` rather than a replacement for it: a repository can raise a
|
|
194
246
|
timeout, add a test group, or declare `archive.include` for a cdylib or fixture the archived test binaries need, and
|
|
@@ -270,10 +322,29 @@ through the inferred `typecheck-tests` target, not through `tsc --build`.
|
|
|
270
322
|
hashes. A full hit returns without running tasks or printing output. A miss runs the task graph through Nx's in-process
|
|
271
323
|
runner with streaming output; only a workspace with the daemon disabled falls back to its checkout-local `nx` CLI.
|
|
272
324
|
|
|
325
|
+
An `nx:noop` task, including a command-less target that Nx normalizes to one, runs nothing and so needs no cache record:
|
|
326
|
+
the tasks it aggregates answer in its place, and any outputs it declares are verified like every other task's. Any other
|
|
327
|
+
uncacheable task is a miss on every call, because only running it can say whether its side effects are current.
|
|
328
|
+
|
|
329
|
+
The probe and runner use the workspace's installed Nx and its normal cache configuration. A build performed by the Nx
|
|
330
|
+
CLI can satisfy the next wrapper invocation without re-executing tasks; changed inputs still go through Nx's runner.
|
|
331
|
+
Both invocations must use the same cache location. Relative `NX_CACHE_DIRECTORY` and `NX_WORKSPACE_DATA_DIRECTORY`
|
|
332
|
+
values resolve against the Nx workspace root, so they remain checkout-local when inherited by another shell. Absolute
|
|
333
|
+
paths remain caller-controlled, including deliberately shared CI locations; an absolute path inherited from another
|
|
334
|
+
checkout does not become local merely because the working directory changed.
|
|
335
|
+
|
|
273
336
|
Before hashing, it compares a native snapshot of the workspace with the daemon's file table. A write the daemon's
|
|
274
337
|
watcher has not delivered yet counts as a miss unless every changed path is a declared output of a task in the graph, so
|
|
275
338
|
a build's own artifacts never turn the next call noisy, and an edit made moments before the call never hits stale.
|
|
276
339
|
|
|
340
|
+
The daemon's output records are lossy: they are held in memory, tracked per collapsed directory, and erased by writes it
|
|
341
|
+
processes more than two seconds late — including, on a busy daemon, a restore's own writes. When it cannot vouch for a
|
|
342
|
+
task's outputs, the working tree is compared with Nx's local cache artifact for that exact task hash, entry by entry as
|
|
343
|
+
Nx's restore expands them: each entry must be reachable through real directories and hold the same node types, symlink
|
|
344
|
+
text (never followed), file permission bits and bytes. A tree the restore would leave unchanged is a hit, and the
|
|
345
|
+
daemon's record is re-armed as Nx's runner does after a restore. A missing or empty artifact, any difference, a read
|
|
346
|
+
error, or a write observed during the comparison is a miss.
|
|
347
|
+
|
|
277
348
|
```typescript
|
|
278
349
|
import { ensureBuilt } from '@smoothbricks/nx-plugin/ensure-built';
|
|
279
350
|
|
|
@@ -1,13 +1,41 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
import { resolve } from 'node:path';
|
|
3
3
|
import { hashCargoPathInputs } from '../cargo-source-hash.js';
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
4
|
+
/** Flags first, in any order and at most once each, then at most one manifest; anything else is refused. */
|
|
5
|
+
function parseArguments(args) {
|
|
6
|
+
const options = {};
|
|
7
|
+
let index = 0;
|
|
8
|
+
for (; index < args.length; index += 1) {
|
|
9
|
+
const arg = args[index];
|
|
10
|
+
if (arg === '--include-workspace' && options.includeWorkspace === undefined) {
|
|
11
|
+
options.includeWorkspace = true;
|
|
12
|
+
}
|
|
13
|
+
else if (arg === '--closure' && options.closure === undefined) {
|
|
14
|
+
const directory = args[index + 1];
|
|
15
|
+
if (directory === undefined || directory.startsWith('-'))
|
|
16
|
+
return undefined;
|
|
17
|
+
options.closure = directory;
|
|
18
|
+
index += 1;
|
|
19
|
+
}
|
|
20
|
+
else if (arg?.startsWith('-')) {
|
|
21
|
+
return undefined;
|
|
22
|
+
}
|
|
23
|
+
else {
|
|
24
|
+
break;
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
const rest = args.slice(index);
|
|
28
|
+
if (rest.length > 1)
|
|
29
|
+
return undefined;
|
|
30
|
+
return { manifest: rest[0] ?? 'Cargo.toml', options };
|
|
31
|
+
}
|
|
32
|
+
const parsed = parseArguments(process.argv.slice(2));
|
|
33
|
+
if (parsed === undefined) {
|
|
34
|
+
process.stderr.write('usage: smoo-nx-cargo-hash [--include-workspace] [--closure <directory>] [Cargo.toml]\n');
|
|
7
35
|
process.exit(2);
|
|
8
36
|
}
|
|
9
37
|
try {
|
|
10
|
-
process.stdout.write(`${await hashCargoPathInputs(resolve(
|
|
38
|
+
process.stdout.write(`${await hashCargoPathInputs(resolve(parsed.manifest), process.cwd(), parsed.options)}\n`);
|
|
11
39
|
}
|
|
12
40
|
catch (error) {
|
|
13
41
|
process.stderr.write(`smoo-nx-cargo-hash: ${error instanceof Error ? error.message : String(error)}\n`);
|
|
@@ -1,2 +1,11 @@
|
|
|
1
|
-
export
|
|
1
|
+
export interface CargoPathInputsOptions {
|
|
2
|
+
/** Also hash packages inside both the Nx and Cargo workspaces, for custom targets without inferred Cargo inputs. */
|
|
3
|
+
includeWorkspace?: boolean;
|
|
4
|
+
/**
|
|
5
|
+
* Hash only the resolved dependency closure of the local packages whose manifests lie under this directory
|
|
6
|
+
* (resolved like `manifestPath`), instead of every package in the Cargo workspace.
|
|
7
|
+
*/
|
|
8
|
+
closure?: string;
|
|
9
|
+
}
|
|
10
|
+
export declare function hashCargoPathInputs(manifestPath: string, workspaceRoot: string, options?: CargoPathInputsOptions): Promise<string>;
|
|
2
11
|
//# sourceMappingURL=cargo-source-hash.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"cargo-source-hash.d.ts","sourceRoot":"","sources":["../src/cargo-source-hash.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"cargo-source-hash.d.ts","sourceRoot":"","sources":["../src/cargo-source-hash.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,sBAAsB;IACrC,oHAAoH;IACpH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4CD,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAgHjB"}
|
|
@@ -1,38 +1,55 @@
|
|
|
1
1
|
import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
|
|
2
|
-
import { execFileSync } from 'node:child_process';
|
|
2
|
+
import { execFileSync, spawnSync } from 'node:child_process';
|
|
3
3
|
import { createHash } from 'node:crypto';
|
|
4
|
-
import { statSync } from 'node:fs';
|
|
4
|
+
import { realpathSync, statSync } from 'node:fs';
|
|
5
5
|
import { lstat, readdir, readFile, readlink, realpath } from 'node:fs/promises';
|
|
6
6
|
import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
|
|
7
7
|
import typia from 'typia';
|
|
8
8
|
const parseMetadata = (() => {
|
|
9
|
+
const _ip0 = input => "string" === typeof input["id"];
|
|
10
|
+
const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._assertGuard(_exceptionable, {
|
|
11
|
+
method: "typia.json.createAssertParse",
|
|
12
|
+
path: _path + ".id",
|
|
13
|
+
expected: "string",
|
|
14
|
+
value: input["id"]
|
|
15
|
+
}, _errorFactory);
|
|
9
16
|
const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.packages) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
10
17
|
method: "typia.json.createAssertParse",
|
|
11
18
|
path: _path + ".packages",
|
|
12
|
-
expected: "{ source: string | null; manifest_path: string; targets: { src_path: string; }[]; }[]",
|
|
19
|
+
expected: "{ id: string; source: string | null; manifest_path: string; targets: { src_path: string; }[]; }[]",
|
|
13
20
|
value: input.packages
|
|
14
|
-
}, _errorFactory)) && input.packages.every((elem,
|
|
21
|
+
}, _errorFactory)) && input.packages.every((elem, _index5) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
15
22
|
method: "typia.json.createAssertParse",
|
|
16
|
-
path: _path + ".packages[" +
|
|
17
|
-
expected: "{ source: string | null; manifest_path: string; targets: { src_path: string; }[]; }",
|
|
23
|
+
path: _path + ".packages[" + _index5 + "]",
|
|
24
|
+
expected: "{ id: string; source: string | null; manifest_path: string; targets: { src_path: string; }[]; }",
|
|
18
25
|
value: elem
|
|
19
|
-
}, _errorFactory)) && _ao1(elem, _path + ".packages[" +
|
|
26
|
+
}, _errorFactory)) && _ao1(elem, _path + ".packages[" + _index5 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
20
27
|
method: "typia.json.createAssertParse",
|
|
21
|
-
path: _path + ".packages[" +
|
|
22
|
-
expected: "{ source: string | null; manifest_path: string; targets: { src_path: string; }[]; }",
|
|
28
|
+
path: _path + ".packages[" + _index5 + "]",
|
|
29
|
+
expected: "{ id: string; source: string | null; manifest_path: string; targets: { src_path: string; }[]; }",
|
|
23
30
|
value: elem
|
|
24
31
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
25
32
|
method: "typia.json.createAssertParse",
|
|
26
33
|
path: _path + ".packages",
|
|
27
|
-
expected: "{ source: string | null; manifest_path: string; targets: { src_path: string; }[]; }[]",
|
|
34
|
+
expected: "{ id: string; source: string | null; manifest_path: string; targets: { src_path: string; }[]; }[]",
|
|
28
35
|
value: input.packages
|
|
36
|
+
}, _errorFactory)) && (null === input.resolve || ("object" === typeof input.resolve && null !== input.resolve || _assertGuard_1._assertGuard(_exceptionable, {
|
|
37
|
+
method: "typia.json.createAssertParse",
|
|
38
|
+
path: _path + ".resolve",
|
|
39
|
+
expected: "(null | { nodes: { id: string; deps: { pkg: string; }[]; }[]; })",
|
|
40
|
+
value: input.resolve
|
|
41
|
+
}, _errorFactory)) && _ao3(input.resolve, _path + ".resolve", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
42
|
+
method: "typia.json.createAssertParse",
|
|
43
|
+
path: _path + ".resolve",
|
|
44
|
+
expected: "(null | { nodes: { id: string; deps: { pkg: string; }[]; }[]; })",
|
|
45
|
+
value: input.resolve
|
|
29
46
|
}, _errorFactory)) && ("string" === typeof input.workspace_root || _assertGuard_1._assertGuard(_exceptionable, {
|
|
30
47
|
method: "typia.json.createAssertParse",
|
|
31
48
|
path: _path + ".workspace_root",
|
|
32
49
|
expected: "string",
|
|
33
50
|
value: input.workspace_root
|
|
34
51
|
}, _errorFactory));
|
|
35
|
-
const _ao1 = (input, _path, _exceptionable = true) => (null === input.source || "string" === typeof input.source || _assertGuard_1._assertGuard(_exceptionable, {
|
|
52
|
+
const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (null === input.source || "string" === typeof input.source || _assertGuard_1._assertGuard(_exceptionable, {
|
|
36
53
|
method: "typia.json.createAssertParse",
|
|
37
54
|
path: _path + ".source",
|
|
38
55
|
expected: "(null | string)",
|
|
@@ -47,14 +64,14 @@ const parseMetadata = (() => {
|
|
|
47
64
|
path: _path + ".targets",
|
|
48
65
|
expected: "{ src_path: string; }[]",
|
|
49
66
|
value: input.targets
|
|
50
|
-
}, _errorFactory)) && input.targets.every((elem,
|
|
67
|
+
}, _errorFactory)) && input.targets.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
51
68
|
method: "typia.json.createAssertParse",
|
|
52
|
-
path: _path + ".targets[" +
|
|
69
|
+
path: _path + ".targets[" + _index6 + "]",
|
|
53
70
|
expected: "{ src_path: string; }",
|
|
54
71
|
value: elem
|
|
55
|
-
}, _errorFactory)) && _ao2(elem, _path + ".targets[" +
|
|
72
|
+
}, _errorFactory)) && _ao2(elem, _path + ".targets[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
56
73
|
method: "typia.json.createAssertParse",
|
|
57
|
-
path: _path + ".targets[" +
|
|
74
|
+
path: _path + ".targets[" + _index6 + "]",
|
|
58
75
|
expected: "{ src_path: string; }",
|
|
59
76
|
value: elem
|
|
60
77
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -69,9 +86,60 @@ const parseMetadata = (() => {
|
|
|
69
86
|
expected: "string",
|
|
70
87
|
value: input.src_path
|
|
71
88
|
}, _errorFactory);
|
|
72
|
-
const
|
|
73
|
-
|
|
89
|
+
const _ao3 = (input, _path, _exceptionable = true) => (Array.isArray(input.nodes) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
90
|
+
method: "typia.json.createAssertParse",
|
|
91
|
+
path: _path + ".nodes",
|
|
92
|
+
expected: "{ id: string; deps: { pkg: string; }[]; }[]",
|
|
93
|
+
value: input.nodes
|
|
94
|
+
}, _errorFactory)) && input.nodes.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
95
|
+
method: "typia.json.createAssertParse",
|
|
96
|
+
path: _path + ".nodes[" + _index7 + "]",
|
|
97
|
+
expected: "{ id: string; deps: { pkg: string; }[]; }",
|
|
98
|
+
value: elem
|
|
99
|
+
}, _errorFactory)) && _ao4(elem, _path + ".nodes[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
100
|
+
method: "typia.json.createAssertParse",
|
|
101
|
+
path: _path + ".nodes[" + _index7 + "]",
|
|
102
|
+
expected: "{ id: string; deps: { pkg: string; }[]; }",
|
|
103
|
+
value: elem
|
|
104
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
105
|
+
method: "typia.json.createAssertParse",
|
|
106
|
+
path: _path + ".nodes",
|
|
107
|
+
expected: "{ id: string; deps: { pkg: string; }[]; }[]",
|
|
108
|
+
value: input.nodes
|
|
109
|
+
}, _errorFactory);
|
|
110
|
+
const _ao4 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ((Array.isArray(input.deps) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
111
|
+
method: "typia.json.createAssertParse",
|
|
112
|
+
path: _path + ".deps",
|
|
113
|
+
expected: "{ pkg: string; }[]",
|
|
114
|
+
value: input.deps
|
|
115
|
+
}, _errorFactory)) && input.deps.every((elem, _index8) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
116
|
+
method: "typia.json.createAssertParse",
|
|
117
|
+
path: _path + ".deps[" + _index8 + "]",
|
|
118
|
+
expected: "{ pkg: string; }",
|
|
119
|
+
value: elem
|
|
120
|
+
}, _errorFactory)) && _ao5(elem, _path + ".deps[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
121
|
+
method: "typia.json.createAssertParse",
|
|
122
|
+
path: _path + ".deps[" + _index8 + "]",
|
|
123
|
+
expected: "{ pkg: string; }",
|
|
124
|
+
value: elem
|
|
125
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
126
|
+
method: "typia.json.createAssertParse",
|
|
127
|
+
path: _path + ".deps",
|
|
128
|
+
expected: "{ pkg: string; }[]",
|
|
129
|
+
value: input.deps
|
|
130
|
+
}, _errorFactory));
|
|
131
|
+
const _ao5 = (input, _path, _exceptionable = true) => "string" === typeof input.pkg || _assertGuard_1._assertGuard(_exceptionable, {
|
|
132
|
+
method: "typia.json.createAssertParse",
|
|
133
|
+
path: _path + ".pkg",
|
|
134
|
+
expected: "string",
|
|
135
|
+
value: input.pkg
|
|
136
|
+
}, _errorFactory);
|
|
137
|
+
const _io0 = input => Array.isArray(input.packages) && input.packages.every(elem => "object" === typeof elem && null !== elem && _io1(elem)) && (null === input.resolve || "object" === typeof input.resolve && null !== input.resolve && _io3(input.resolve)) && "string" === typeof input.workspace_root;
|
|
138
|
+
const _io1 = input => _ip0(input) && (null === input.source || "string" === typeof input.source) && "string" === typeof input.manifest_path && (Array.isArray(input.targets) && input.targets.every(elem => "object" === typeof elem && null !== elem && _io2(elem)));
|
|
74
139
|
const _io2 = input => "string" === typeof input.src_path;
|
|
140
|
+
const _io3 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io4(elem));
|
|
141
|
+
const _io4 = input => _ip0(input) && (Array.isArray(input.deps) && input.deps.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
|
|
142
|
+
const _io5 = input => "string" === typeof input.pkg;
|
|
75
143
|
const __is = input => "object" === typeof input && null !== input && _io0(input);
|
|
76
144
|
let _errorFactory;
|
|
77
145
|
const __assert = (input, errorFactory) => {
|
|
@@ -111,50 +179,71 @@ const ancestorInputs = ['Cargo.toml', '.cargo/config', '.cargo/config.toml'];
|
|
|
111
179
|
* patches, and transitive path dependencies. A locked offline query observes
|
|
112
180
|
* that graph without fetching dependencies or changing the lockfile. Git and
|
|
113
181
|
* registry packages are immutable inputs already identified by Cargo.lock.
|
|
182
|
+
* By default, Nx's in-workspace inputs own workspace packages; includeWorkspace
|
|
183
|
+
* also covers those packages for custom targets without inferred Cargo inputs.
|
|
184
|
+
* `closure` narrows the packages to what the local packages under one
|
|
185
|
+
* directory actually depend on, so an edit to an unrelated workspace member
|
|
186
|
+
* leaves the digest alone.
|
|
114
187
|
*
|
|
115
188
|
* This covers Rust sources and Cargo configuration, matching the plugin's
|
|
116
189
|
* in-workspace Rust inputs. Build scripts' other data/environment inputs remain
|
|
117
|
-
* explicit Nx inputs, just as they are for in-workspace crates.
|
|
190
|
+
* explicit Nx inputs, just as they are for in-workspace crates. Files git
|
|
191
|
+
* ignores beneath a package are left out, like Nx's own file inputs: a
|
|
192
|
+
* generated source is its producer's output, which the consuming target hashes
|
|
193
|
+
* through `dependentTasksOutputFiles`, and a tree that has not generated it yet
|
|
194
|
+
* must hash like one that has.
|
|
118
195
|
*/
|
|
119
196
|
// Nx hashes a runtime input's stdout AND stderr. Cargo reports lock contention
|
|
120
197
|
// on stderr ("Blocking waiting for file lock on package cache") a
|
|
121
198
|
// timing-dependent number of times when Nx hashes many tasks at once, which
|
|
122
199
|
// made one unchanged tree produce four different task hashes per run. Cargo's
|
|
123
200
|
// stderr is kept for the failure path only, where execFileSync attaches it to
|
|
124
|
-
// the thrown error.
|
|
125
|
-
const
|
|
126
|
-
export async function hashCargoPathInputs(manifestPath, workspaceRoot) {
|
|
201
|
+
// the thrown error. Git runs under the same rule.
|
|
202
|
+
const CHILD_STDIO = ['ignore', 'pipe', 'pipe'];
|
|
203
|
+
export async function hashCargoPathInputs(manifestPath, workspaceRoot, options) {
|
|
127
204
|
const root = await realpath(workspaceRoot);
|
|
128
|
-
const metadata = parseMetadata(execFileSync('cargo', ['metadata', '--format-version', '1', '--locked', '--offline', '--manifest-path', resolve(manifestPath)], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio:
|
|
205
|
+
const metadata = parseMetadata(execFileSync('cargo', ['metadata', '--format-version', '1', '--locked', '--offline', '--manifest-path', resolve(manifestPath)], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: CHILD_STDIO }));
|
|
129
206
|
const cargoRoot = await realpath(metadata.workspace_root);
|
|
130
|
-
const
|
|
131
|
-
const files = new Set();
|
|
132
|
-
const ancestors = new Set();
|
|
133
|
-
const links = new Map();
|
|
207
|
+
const local = [];
|
|
134
208
|
for (const pkg of metadata.packages) {
|
|
135
209
|
if (pkg.source !== null)
|
|
136
210
|
continue;
|
|
137
211
|
const manifest = await realpath(pkg.manifest_path);
|
|
138
|
-
const
|
|
139
|
-
const
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
212
|
+
const sources = [];
|
|
213
|
+
for (const target of pkg.targets)
|
|
214
|
+
sources.push(await realpath(target.src_path));
|
|
215
|
+
local.push({ id: pkg.id, directory: dirname(manifest), manifest, sources });
|
|
216
|
+
}
|
|
217
|
+
const members = options?.closure === undefined ? undefined : await dependencyClosure(metadata, local, resolve(options.closure));
|
|
218
|
+
const directories = new Set();
|
|
219
|
+
const files = new Set();
|
|
220
|
+
const ancestors = new Set();
|
|
221
|
+
const links = new Map();
|
|
222
|
+
const packageSources = [];
|
|
223
|
+
for (const pkg of local) {
|
|
224
|
+
if (members !== undefined && !members.has(pkg.id))
|
|
148
225
|
continue;
|
|
226
|
+
const directory = pkg.directory;
|
|
227
|
+
if (!options?.includeWorkspace) {
|
|
228
|
+
const fromRoot = relative(root, directory);
|
|
229
|
+
const fromCargo = relative(cargoRoot, directory);
|
|
230
|
+
if (fromRoot !== '..' &&
|
|
231
|
+
!fromRoot.startsWith(`..${sep}`) &&
|
|
232
|
+
!isAbsolute(fromRoot) &&
|
|
233
|
+
fromCargo !== '..' &&
|
|
234
|
+
!fromCargo.startsWith(`..${sep}`) &&
|
|
235
|
+
!isAbsolute(fromCargo) &&
|
|
236
|
+
!fromRoot.split(sep).includes('node_modules'))
|
|
237
|
+
continue;
|
|
238
|
+
}
|
|
149
239
|
directories.add(directory);
|
|
150
|
-
files.add(manifest);
|
|
240
|
+
files.add(pkg.manifest);
|
|
151
241
|
// Cargo resolves explicit package.workspace ownership as well as ancestor
|
|
152
242
|
// workspaces. Metadata's workspace_root describes only the invoking root.
|
|
153
|
-
const governingManifest = execFileSync('cargo', ['locate-project', '--workspace', '--manifest-path', manifest, '--message-format', 'plain'], { cwd: root, encoding: 'utf8', stdio:
|
|
243
|
+
const governingManifest = execFileSync('cargo', ['locate-project', '--workspace', '--manifest-path', pkg.manifest, '--message-format', 'plain'], { cwd: root, encoding: 'utf8', stdio: CHILD_STDIO }).trim();
|
|
154
244
|
files.add(await realpath(governingManifest));
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
// An external member can inherit edition, lint policy, dependencies and
|
|
245
|
+
packageSources.push(...pkg.sources);
|
|
246
|
+
// A member can inherit edition, lint policy, dependencies and
|
|
158
247
|
// profiles from a workspace above its package directory. Those manifests
|
|
159
248
|
// are not descendants of the source roots returned by Cargo metadata.
|
|
160
249
|
for (let ancestor = dirname(directory); !ancestors.has(ancestor); ancestor = dirname(ancestor)) {
|
|
@@ -166,6 +255,10 @@ export async function hashCargoPathInputs(manifestPath, workspaceRoot) {
|
|
|
166
255
|
}
|
|
167
256
|
}
|
|
168
257
|
}
|
|
258
|
+
const ignored = gitIgnoredBeneath([...directories]);
|
|
259
|
+
for (const source of packageSources)
|
|
260
|
+
if (!ignored(source))
|
|
261
|
+
files.add(source);
|
|
169
262
|
// Overlapping packages (a facade root plus its child crates) share one walk.
|
|
170
263
|
const visited = new Set();
|
|
171
264
|
async function walk(directory) {
|
|
@@ -177,6 +270,8 @@ export async function hashCargoPathInputs(manifestPath, workspaceRoot) {
|
|
|
177
270
|
if (ignoredDirectories.has(entry.name))
|
|
178
271
|
continue;
|
|
179
272
|
const path = join(canonical, entry.name);
|
|
273
|
+
if (ignored(path))
|
|
274
|
+
continue;
|
|
180
275
|
if (entry.isSymbolicLink())
|
|
181
276
|
links.set(path, await readlink(path));
|
|
182
277
|
const info = entry.isSymbolicLink() ? await lstat(await realpath(path)) : entry;
|
|
@@ -213,3 +308,118 @@ export async function hashCargoPathInputs(manifestPath, workspaceRoot) {
|
|
|
213
308
|
}
|
|
214
309
|
return hash.digest('hex');
|
|
215
310
|
}
|
|
311
|
+
/**
|
|
312
|
+
* The ids Cargo's resolve graph reaches from the local packages under
|
|
313
|
+
* `directory`, over every dependency kind: a target may build, test or run
|
|
314
|
+
* build scripts, and any of those compiles the edge's source.
|
|
315
|
+
*/
|
|
316
|
+
async function dependencyClosure(metadata, local, directory) {
|
|
317
|
+
const base = await realpath(directory);
|
|
318
|
+
const pending = local
|
|
319
|
+
.filter((pkg) => pkg.directory === base || pkg.directory.startsWith(`${base}${sep}`))
|
|
320
|
+
.map((pkg) => pkg.id);
|
|
321
|
+
if (pending.length === 0)
|
|
322
|
+
throw new Error(`no local Cargo package lies under ${directory}`);
|
|
323
|
+
if (metadata.resolve === null)
|
|
324
|
+
throw new Error('cargo metadata reported no dependency resolution');
|
|
325
|
+
const edges = new Map(metadata.resolve.nodes.map((node) => [node.id, node.deps]));
|
|
326
|
+
const reached = new Set();
|
|
327
|
+
for (let id = pending.pop(); id !== undefined; id = pending.pop()) {
|
|
328
|
+
if (reached.has(id))
|
|
329
|
+
continue;
|
|
330
|
+
reached.add(id);
|
|
331
|
+
for (const dependency of edges.get(id) ?? [])
|
|
332
|
+
pending.push(dependency.pkg);
|
|
333
|
+
}
|
|
334
|
+
return reached;
|
|
335
|
+
}
|
|
336
|
+
/**
|
|
337
|
+
* Whether git ignores a path beneath one of the package directories. A
|
|
338
|
+
* package whose own directory is ignored (an installed dependency, say) keeps
|
|
339
|
+
* every file, and a directory outside any git repository ignores nothing.
|
|
340
|
+
*/
|
|
341
|
+
function gitIgnoredBeneath(directories) {
|
|
342
|
+
const byRepository = new Map();
|
|
343
|
+
for (const directory of directories) {
|
|
344
|
+
const repository = gitRepository(directory);
|
|
345
|
+
if (repository === undefined)
|
|
346
|
+
continue;
|
|
347
|
+
const members = byRepository.get(repository) ?? [];
|
|
348
|
+
members.push(directory);
|
|
349
|
+
byRepository.set(repository, members);
|
|
350
|
+
}
|
|
351
|
+
const files = new Set();
|
|
352
|
+
const trees = [];
|
|
353
|
+
for (const [repository, members] of byRepository) {
|
|
354
|
+
const relativeMembers = members.map((member) => relative(repository, member) || '.');
|
|
355
|
+
// A package whose own directory git ignores is an installed tree, not a source tree with
|
|
356
|
+
// generated files in it. It also stays out of ls-files, which fails outright on a pathspec
|
|
357
|
+
// inside an ignored directory ("directory entry not superset of prefix").
|
|
358
|
+
const ignoredRoots = new Set(gitCheckIgnore(repository, relativeMembers));
|
|
359
|
+
const sourceRoots = relativeMembers.filter((member) => !ignoredRoots.has(member));
|
|
360
|
+
if (sourceRoots.length === 0)
|
|
361
|
+
continue;
|
|
362
|
+
const installed = [...ignoredRoots].map((member) => join(repository, member));
|
|
363
|
+
const listing = execFileSync('git', [
|
|
364
|
+
'--literal-pathspecs',
|
|
365
|
+
'-C',
|
|
366
|
+
repository,
|
|
367
|
+
'ls-files',
|
|
368
|
+
'-z',
|
|
369
|
+
'--others',
|
|
370
|
+
'--ignored',
|
|
371
|
+
'--exclude-standard',
|
|
372
|
+
'--directory',
|
|
373
|
+
'--',
|
|
374
|
+
...sourceRoots,
|
|
375
|
+
], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: CHILD_STDIO });
|
|
376
|
+
for (const entry of listing.split('\0')) {
|
|
377
|
+
if (entry.length === 0)
|
|
378
|
+
continue;
|
|
379
|
+
const path = join(repository, entry);
|
|
380
|
+
if (!entry.endsWith('/')) {
|
|
381
|
+
files.add(path);
|
|
382
|
+
}
|
|
383
|
+
else if (!installed.some((member) => member === path || member.startsWith(`${path}${sep}`))) {
|
|
384
|
+
// An ignored directory holding a nested installed package leaves that package whole.
|
|
385
|
+
trees.push(path);
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
}
|
|
389
|
+
return (path) => files.has(path) || trees.some((tree) => path === tree || path.startsWith(`${tree}${sep}`));
|
|
390
|
+
}
|
|
391
|
+
/** The members of `paths` (relative to `repository`) that git ignores, own patterns or an ancestor's. */
|
|
392
|
+
function gitCheckIgnore(repository, paths) {
|
|
393
|
+
const result = spawnSync('git', ['-C', repository, 'check-ignore', '-z', '--stdin'], {
|
|
394
|
+
input: `${paths.join('\0')}\0`,
|
|
395
|
+
encoding: 'utf8',
|
|
396
|
+
maxBuffer: 64 * 1024 * 1024,
|
|
397
|
+
});
|
|
398
|
+
// check-ignore answers 1 when nothing is ignored; only 0 carries a listing.
|
|
399
|
+
if (result.status === 1)
|
|
400
|
+
return [];
|
|
401
|
+
if (result.status !== 0) {
|
|
402
|
+
throw new Error(`git check-ignore in ${repository} failed (${result.status ?? result.signal}): ${result.stderr}`);
|
|
403
|
+
}
|
|
404
|
+
return result.stdout.split('\0').filter((path) => path.length > 0);
|
|
405
|
+
}
|
|
406
|
+
/** The canonical top level of the git work tree holding `directory`, or undefined outside any repository. */
|
|
407
|
+
function gitRepository(directory) {
|
|
408
|
+
try {
|
|
409
|
+
// The walk compares realpaths, so git's answer is canonicalized the same way.
|
|
410
|
+
return realpathSync(execFileSync('git', ['-C', directory, 'rev-parse', '--show-toplevel'], {
|
|
411
|
+
encoding: 'utf8',
|
|
412
|
+
stdio: CHILD_STDIO,
|
|
413
|
+
}).trim());
|
|
414
|
+
}
|
|
415
|
+
catch (error) {
|
|
416
|
+
if (typeof error === 'object' &&
|
|
417
|
+
error !== null &&
|
|
418
|
+
'status' in error &&
|
|
419
|
+
error.status === 128 &&
|
|
420
|
+
'stderr' in error &&
|
|
421
|
+
String(error.stderr).includes('not a git repository'))
|
|
422
|
+
return undefined;
|
|
423
|
+
throw error;
|
|
424
|
+
}
|
|
425
|
+
}
|
|
@@ -37,7 +37,6 @@ export interface CargoPackageTestInputsOptions {
|
|
|
37
37
|
/** The cargo workspace root holding the top-level `Cargo.toml`. */
|
|
38
38
|
absoluteProjectRoot: string;
|
|
39
39
|
memberDir: string;
|
|
40
|
-
inputRoot?: string;
|
|
41
40
|
/** Shared across every call of one graph computation; see {@link createCargoInputsCache}. */
|
|
42
41
|
cache?: CargoInputsCache;
|
|
43
42
|
}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"cargo-workspace.d.ts","sourceRoot":"","sources":["../src/cargo-workspace.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAE/D,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,+BAAgC,SAAQ,qBAAqB;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,0BAA0B,CAAC,mBAAmB,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAkF/F;AA0ED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,SAAS,qBAAqB,EAAE,EAC1C,QAAQ,EAAE,SAAS,qBAAqB,EAAE,GACzC,+BAA+B,EAAE,CAgBnC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,uBAAuB,CAAC;AAE/D,MAAM,WAAW,6BAA6B;IAC5C,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,
|
|
1
|
+
{"version":3,"file":"cargo-workspace.d.ts","sourceRoot":"","sources":["../src/cargo-workspace.ts"],"names":[],"mappings":"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"}
|