@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.
Files changed (44) hide show
  1. package/README.md +89 -18
  2. package/dist/bin/smoo-nx-cargo-hash.js +32 -4
  3. package/dist/cargo-source-hash.d.ts +10 -1
  4. package/dist/cargo-source-hash.d.ts.map +1 -1
  5. package/dist/cargo-source-hash.js +251 -41
  6. package/dist/cargo-workspace.d.ts +0 -1
  7. package/dist/cargo-workspace.d.ts.map +1 -1
  8. package/dist/cargo-workspace.js +9 -2
  9. package/dist/ensure-built.d.ts +6 -5
  10. package/dist/ensure-built.d.ts.map +1 -1
  11. package/dist/ensure-built.js +227 -30
  12. package/dist/index.js +18 -10
  13. package/dist/managed-files/ci-workflow.d.ts +20 -0
  14. package/dist/managed-files/ci-workflow.d.ts.map +1 -1
  15. package/dist/managed-files/ci-workflow.js +42 -13
  16. package/dist/managed-files/files.d.ts +1 -1
  17. package/dist/managed-files/files.d.ts.map +1 -1
  18. package/dist/managed-files/files.js +8 -1
  19. package/dist/managed-files/pr-preview-cleanup-workflow.d.ts +37 -0
  20. package/dist/managed-files/pr-preview-cleanup-workflow.d.ts.map +1 -1
  21. package/dist/managed-files/pr-preview-cleanup-workflow.js +34 -6
  22. package/dist/workspace-manifest.d.ts +3 -1
  23. package/dist/workspace-manifest.d.ts.map +1 -1
  24. package/managed/raw/tooling/direnv/setup-environment.ts +23 -91
  25. package/managed/raw/tooling/git-hooks/commit-msg.sh +6 -0
  26. package/managed/raw/tooling/git-hooks/pre-commit.sh +6 -0
  27. package/managed/raw/tooling/git-hooks/pre-push.sh +6 -0
  28. package/managed/templates/github/actions/setup-devenv/action.yml +19 -7
  29. package/package.json +1 -1
  30. package/src/bin/smoo-nx-cargo-hash.ts +29 -5
  31. package/src/cargo-source-hash.test.ts +291 -1
  32. package/src/cargo-source-hash.ts +190 -28
  33. package/src/cargo-workspace.test.ts +17 -10
  34. package/src/cargo-workspace.ts +9 -3
  35. package/src/ensure-built.test.ts +87 -29
  36. package/src/ensure-built.ts +274 -29
  37. package/src/index.test.ts +117 -20
  38. package/src/index.ts +18 -11
  39. package/src/managed-files/ci-workflow.ts +45 -14
  40. package/src/managed-files/files.ts +9 -2
  41. package/src/managed-files/generator.test.ts +5 -1
  42. package/src/managed-files/github-host-cache-isolation.test.ts +32 -6
  43. package/src/managed-files/pr-preview-cleanup-workflow.ts +87 -6
  44. 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
- ### External Rust sources
93
+ ### Cargo source runtime inputs
94
94
 
95
- For a repository-root Cargo workspace, declare the shared input once:
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
- The command queries `cargo metadata --locked --offline` and hashes the resolved external path packages, including
110
- transitive dependencies, Rust sources, target source files, governing Cargo manifests, and Cargo configuration. It also
111
- covers path packages under `node_modules`, which Nx's normal file map ignores. Adding or moving a dependency does not
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. Each member crate gets a cached `cargo-test-<package>` run (30s
180
- per-test timeout like `bun test --timeout=30000`) whose inputs include that crate and its path dependencies, and whose
181
- command is `cargo --frozen nextest run --archive-file <archive> --workspace-remap . -E 'package(<crate>)'`. Runners
182
- therefore execute rather than build: they extract binaries into their own temporary directory, write nothing to
183
- cargo's flocked `target/`, and fan out instead of chaining. `--workspace-remap` is required — an archive records the
184
- producing tree's absolute paths, and without it a restored archive hands tests another checkout's
185
- `CARGO_MANIFEST_DIR`. With it the archive is relocatable, so one cache entry serves every checkout of the same commit;
186
- nextest re-points `CARGO_BIN_EXE_<name>`/`NEXTEST_BIN_EXE_<name>` at the extracted binaries at runtime, but a test
187
- that reads them through the compile-time `env!` macro keeps the producing tree's path. Per-crate runners accept an
188
- empty nextest selection because a valid workspace member may have no tests and a hash partition may legitimately be
189
- empty. `napi-debug` stays behind `cargo-test-compile`, and a crate in the project that builds the debug cdylib runs
190
- after it. A crate declaring `[package.metadata.smoothbricks.wasm-bindgen]` also receives the cacheable `cargo-wasm`
191
- output target in its owning project.
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
- const args = process.argv.slice(2);
5
- if (args.length > 1) {
6
- process.stderr.write('usage: smoo-nx-cargo-hash [Cargo.toml]\n');
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(args[0] ?? 'Cargo.toml'), process.cwd())}\n`);
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 declare function hashCargoPathInputs(manifestPath: string, workspaceRoot: string): Promise<string>;
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":"AAiDA,wBAAsB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgGtG"}
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, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
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[" + _index3 + "]",
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[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
26
+ }, _errorFactory)) && _ao1(elem, _path + ".packages[" + _index5 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
20
27
  method: "typia.json.createAssertParse",
21
- path: _path + ".packages[" + _index3 + "]",
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, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
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[" + _index4 + "]",
69
+ path: _path + ".targets[" + _index6 + "]",
53
70
  expected: "{ src_path: string; }",
54
71
  value: elem
55
- }, _errorFactory)) && _ao2(elem, _path + ".targets[" + _index4 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
72
+ }, _errorFactory)) && _ao2(elem, _path + ".targets[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
56
73
  method: "typia.json.createAssertParse",
57
- path: _path + ".targets[" + _index4 + "]",
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 _io0 = input => Array.isArray(input.packages) && input.packages.every(elem => "object" === typeof elem && null !== elem && _io1(elem)) && "string" === typeof input.workspace_root;
73
- const _io1 = 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)));
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 CARGO_STDIO = ['ignore', 'pipe', 'pipe'];
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: CARGO_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 directories = new Set();
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 directory = dirname(manifest);
139
- const fromRoot = relative(root, directory);
140
- const fromCargo = relative(cargoRoot, directory);
141
- if (fromRoot !== '..' &&
142
- !fromRoot.startsWith(`..${sep}`) &&
143
- !isAbsolute(fromRoot) &&
144
- fromCargo !== '..' &&
145
- !fromCargo.startsWith(`..${sep}`) &&
146
- !isAbsolute(fromCargo) &&
147
- !fromRoot.split(sep).includes('node_modules'))
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: CARGO_STDIO }).trim();
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
- for (const target of pkg.targets)
156
- files.add(await realpath(target.src_path));
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":"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"}
1
+ {"version":3,"file":"cargo-workspace.d.ts","sourceRoot":"","sources":["../src/cargo-workspace.ts"],"names":[],"mappings":"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"}