@smoothbricks/nx-plugin 0.4.0 → 0.4.2

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.
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'bun:test';
2
2
  import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
3
3
  import { tmpdir } from 'node:os';
4
4
  import { dirname, join } from 'node:path';
5
+ import { Glob } from 'bun';
5
6
 
6
7
  import {
7
8
  attributeCargoWorkspacePackages,
@@ -10,131 +11,276 @@ import {
10
11
  } from './cargo-workspace.js';
11
12
 
12
13
  describe('Cargo workspace layouts', () => {
13
- it('keeps package-rooted workspace discovery and inputs project-relative', async () => {
14
- const root = await mkdtemp(join(tmpdir(), 'nx-plugin-cargo-package-root-'));
14
+ it('discovers root, globbed and implicit members, excludes packages and assigns the deepest owner', async () => {
15
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-members-'));
15
16
  try {
16
- await write(root, 'Cargo.toml', '[workspace]\nmembers = ["crates/ferris-core"]\n');
17
- await write(root, 'Cargo.lock', 'version = 4\n');
18
- await write(root, 'crates/ferris-core/Cargo.toml', '[package]\nname = "ferris-core"\n');
19
-
20
- expect(listCargoWorkspacePackages(root)).toEqual([
21
- { name: 'ferris-core', dir: 'crates/ferris-core', testShards: 1 },
17
+ await write(
18
+ root,
19
+ 'Cargo.toml',
20
+ '[package]\nname="root-app"\n[workspace]\nmembers=[".","packages/*/crates/*"]\nexclude=["packages/*/crates/ignored-*", "vendor/ignored"]\n',
21
+ );
22
+ await write(
23
+ root,
24
+ 'packages/service/crates/api/Cargo.toml',
25
+ '[package]\nname="api"\n[dependencies]\nbase={path="../../../../vendor/base"}\nignored={path="../../../../vendor/ignored"}\n',
26
+ );
27
+ await write(root, 'packages/service/crates/ignored-fixture/Cargo.toml', '[package]\nname="ignored-fixture"\n');
28
+ await write(
29
+ root,
30
+ 'vendor/base/Cargo.toml',
31
+ '[package]\nname="base"\n[dev-dependencies]\napi={path="../../packages/service/crates/api"}\n',
32
+ );
33
+ await write(root, 'vendor/ignored/Cargo.toml', '[package]\nname="ignored"\n');
34
+ const packages = listCargoWorkspacePackages(root);
35
+ expect(packages).toEqual([
36
+ { name: 'api', dir: 'packages/service/crates/api', testShards: 1 },
37
+ { name: 'base', dir: 'vendor/base', testShards: 1 },
38
+ { name: 'root-app', dir: '.', testShards: 1 },
22
39
  ]);
23
- expect(await cargoPackageTestInputs(root, 'crates/ferris-core')).toEqual([
24
- '{projectRoot}/Cargo.toml',
25
- '{projectRoot}/Cargo.lock',
26
- '{projectRoot}/crates/ferris-core/**/*.rs',
27
- '{projectRoot}/crates/ferris-core/Cargo.toml',
28
- '{projectRoot}/**/.cargo/config.toml',
29
- '{projectRoot}/scripts/*.sh',
30
- '!{projectRoot}/**/target/**',
40
+ expect(
41
+ attributeCargoWorkspacePackages(packages, [
42
+ { name: 'root', root: '.' },
43
+ { name: 'service', root: 'packages/service' },
44
+ { name: 'api-project', root: 'packages/service/crates/api' },
45
+ ]).map(({ name, projectName }) => [name, projectName]),
46
+ ).toEqual([
47
+ ['api', 'api-project'],
48
+ ['base', 'root'],
49
+ ['root-app', 'root'],
31
50
  ]);
51
+ expect(listCargoWorkspacePackages(root)).toEqual(packages);
52
+ await write(root, 'Cargo.toml', '[package]\nname="standalone"\n[workspace]\n');
53
+ expect(listCargoWorkspacePackages(root)).toEqual([{ name: 'standalone', dir: '.', testShards: 1 }]);
32
54
  } finally {
33
55
  await rm(root, { recursive: true, force: true });
34
56
  }
35
57
  });
36
58
 
37
- it('expands repo-root member globs and attributes every crate to its containing Nx project', async () => {
38
- const root = await mkdtemp(join(tmpdir(), 'nx-plugin-cargo-repo-root-'));
59
+ it('hashes assets, build scripts and transitive cfg/build/dev dependencies without unrelated package sources', async () => {
60
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-inputs-'));
39
61
  try {
40
62
  await write(
41
63
  root,
42
64
  'Cargo.toml',
43
- [
44
- '[workspace]',
45
- 'members = ["packages/containium", "packages/*/crates/*", "vendor/*/crates/*"]',
46
- 'exclude = ["packages/*/crates/excluded-*", "vendor/ignored"]',
47
- '',
48
- '[workspace.dependencies]',
49
- 'runtime-core = { path = "packages/runtime/crates/runtime-core" }',
50
- '',
51
- ].join('\n'),
65
+ '[workspace]\nmembers=["crates/app"]\nexclude=["crates/excluded"]\n[workspace.dependencies]\nrenamed={package="base",path="crates/base"}\n',
52
66
  );
53
- await write(root, 'Cargo.lock', 'version = 4\n');
54
- await write(root, 'packages/containium/Cargo.toml', '[package]\nname = "containium-cli"\n');
55
- await write(root, 'packages/runtime/crates/runtime-core/Cargo.toml', '[package]\nname = "runtime-core"\n');
56
67
  await write(
57
68
  root,
58
- 'packages/host/crates/host-runtime/Cargo.toml',
59
- '[package]\nname = "host-runtime"\n\n[dependencies]\nruntime-core = { workspace = true }\n',
69
+ 'crates/app/Cargo.toml',
70
+ '[package]\nname="app"\nbuild="build/build.rs"\n[dependencies]\nrenamed={workspace=true}\n[target.\'cfg(unix)\'.build-dependencies]\nbuilder={path="../builder"}\n[target.\'cfg(windows)\'.dev-dependencies]\nfixture={path="../excluded"}\n',
60
71
  );
61
- await write(root, 'packages/host/crates/excluded-fixture/Cargo.toml', '[package]\nname = "excluded-fixture"\n');
62
72
  await write(
63
73
  root,
64
- 'vendor/ignored/crates/excluded-by-parent/Cargo.toml',
65
- '[package]\nname = "excluded-by-parent"\n',
74
+ 'crates/base/Cargo.toml',
75
+ '[package]\nname="base"\n[build-dependencies]\nleaf={path="../leaf"}\n',
66
76
  );
77
+ await write(root, 'crates/leaf/Cargo.toml', '[package]\nname="leaf"\n[dev-dependencies]\napp={path="../app"}\n');
78
+ await write(root, 'crates/builder/Cargo.toml', '[package]\nname="builder"\n');
79
+ await write(root, 'crates/excluded/Cargo.toml', '[package]\nname="excluded"\n');
80
+ await write(root, 'crates/app/nested/Cargo.toml', '[package]\nname="unrelated"\n');
81
+ const request = { workspaceRoot: root, absoluteProjectRoot: root, memberDir: 'crates/app' };
82
+ const inputs = await cargoPackageTestInputs(request);
83
+ for (const path of [
84
+ 'Cargo.toml',
85
+ 'Cargo.lock',
86
+ '.cargo/config',
87
+ '.cargo/config.toml',
88
+ '.config/nextest.toml',
89
+ 'rust-toolchain',
90
+ 'rust-toolchain.toml',
91
+ 'rustfmt.toml',
92
+ '.rustfmt.toml',
93
+ 'clippy.toml',
94
+ 'crates/app/src/lib.rs',
95
+ 'crates/app/src/template.html',
96
+ 'crates/app/build/build.rs',
97
+ 'crates/app/native/header.h',
98
+ 'crates/app/schema/input.proto',
99
+ 'crates/app/tests/fixture.bin',
100
+ 'crates/base/src/lib.rs',
101
+ 'crates/builder/build.rs',
102
+ 'crates/leaf/src/table.csv',
103
+ 'crates/excluded/src/lib.rs',
104
+ ])
105
+ expect(matches(inputs, path)).toBe(true);
106
+ for (const path of [
107
+ 'crates/other/src/lib.rs',
108
+ 'crates/app/nested/src/lib.rs',
109
+ 'target/debug/output',
110
+ 'crates/app/target/generated.rs',
111
+ 'crates/other/.cargo/config.toml',
112
+ 'scripts/unrelated.sh',
113
+ ])
114
+ expect(matches(inputs, path)).toBe(false);
115
+ await write(root, 'crates/app/target/debug/generated.rs', 'generated');
116
+ await write(root, 'crates/app/src/template.html', 'changed asset');
117
+ expect(matches(await cargoPackageTestInputs(request), 'crates/app/target/debug/generated.rs')).toBe(false);
118
+ expect(await cargoPackageTestInputs(request)).toEqual(await cargoPackageTestInputs(request));
119
+ } finally {
120
+ await rm(root, { recursive: true, force: true });
121
+ }
122
+ });
67
123
 
68
- const packages = listCargoWorkspacePackages(root);
69
- expect(packages).toEqual([
70
- { name: 'containium-cli', dir: 'packages/containium', testShards: 1 },
71
- { name: 'host-runtime', dir: 'packages/host/crates/host-runtime', testShards: 1 },
72
- { name: 'runtime-core', dir: 'packages/runtime/crates/runtime-core', testShards: 1 },
73
- ]);
74
- expect(
75
- attributeCargoWorkspacePackages(packages, [
76
- { name: '@axe.sc/codebase', root: '.' },
77
- { name: 'runtime', root: 'packages/runtime' },
78
- { name: 'host', root: 'packages/host' },
79
- { name: 'containium', root: 'packages/containium' },
80
- ]),
81
- ).toEqual([
82
- {
83
- name: 'containium-cli',
84
- dir: 'packages/containium',
85
- testShards: 1,
86
- projectName: 'containium',
87
- projectRoot: 'packages/containium',
88
- },
89
- {
90
- name: 'host-runtime',
91
- dir: 'packages/host/crates/host-runtime',
92
- testShards: 1,
93
- projectName: 'host',
94
- projectRoot: 'packages/host',
95
- },
96
- {
97
- name: 'runtime-core',
98
- dir: 'packages/runtime/crates/runtime-core',
99
- testShards: 1,
100
- projectName: 'runtime',
101
- projectRoot: 'packages/runtime',
102
- },
103
- ]);
104
- expect(await cargoPackageTestInputs(root, 'packages/host/crates/host-runtime', '{workspaceRoot}')).toEqual([
105
- '{workspaceRoot}/Cargo.toml',
106
- '{workspaceRoot}/Cargo.lock',
107
- '{workspaceRoot}/packages/host/crates/host-runtime/**/*.rs',
108
- '{workspaceRoot}/packages/host/crates/host-runtime/Cargo.toml',
109
- '{workspaceRoot}/packages/runtime/crates/runtime-core/**/*.rs',
110
- '{workspaceRoot}/packages/runtime/crates/runtime-core/Cargo.toml',
111
- '{workspaceRoot}/**/.cargo/config.toml',
112
- '{workspaceRoot}/scripts/*.sh',
113
- '!{workspaceRoot}/**/target/**',
114
- ]);
124
+ it('keeps dependencies outside Cargo but inside Nx as ordinary files and includes ancestor config', async () => {
125
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-nested-'));
126
+ try {
127
+ await write(root, 'packages/app/Cargo.toml', '[workspace]\nmembers=["crates/app"]\n');
128
+ await write(
129
+ root,
130
+ 'packages/app/crates/app/Cargo.toml',
131
+ '[package]\nname="app"\n[dependencies]\nbase={path="../../../base"}\n',
132
+ );
133
+ await write(root, 'packages/base/Cargo.toml', '[package]\nname="base"\n');
134
+ const inputs = await cargoPackageTestInputs({
135
+ workspaceRoot: root,
136
+ absoluteProjectRoot: join(root, 'packages/app'),
137
+ memberDir: 'crates/app',
138
+ });
139
+ expect(matches(inputs, 'packages/base/src/lib.rs', 'packages/app')).toBe(true);
140
+ expect(matches(inputs, '.cargo/config.toml', 'packages/app')).toBe(true);
141
+ expect(matches(inputs, 'packages/rust-toolchain.toml', 'packages/app')).toBe(true);
142
+ expect(matches(inputs, 'packages/base/target/debug/output', 'packages/app')).toBe(false);
143
+ expect(inputs).not.toContain('externalRustCrates');
144
+ expect(inputs.some((input) => input.includes('../'))).toBe(false);
115
145
  } finally {
116
146
  await rm(root, { recursive: true, force: true });
117
147
  }
118
148
  });
119
149
 
120
- it('reports member patterns it cannot expand instead of silently omitting crates', async () => {
121
- const root = await mkdtemp(join(tmpdir(), 'nx-plugin-cargo-invalid-glob-'));
150
+ it('resolves inherited dependencies against their own workspace and hashes local patches', async () => {
151
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-inheritance-'));
122
152
  try {
123
- await write(root, 'Cargo.toml', '[workspace]\nmembers = ["packages/**/crates/*"]\n');
124
- expect(() => listCargoWorkspacePackages(root)).toThrow(
125
- 'Cargo workspace member uses an unsupported glob pattern: packages/**/crates/*',
153
+ await write(
154
+ root,
155
+ 'Cargo.toml',
156
+ '[workspace]\nmembers=["app"]\nexclude=["vendor"]\n[patch.crates-io]\npatched={path="patches/base"}\n',
157
+ );
158
+ await write(root, 'app/Cargo.toml', '[package]\nname="app"\n[dependencies]\nbase={path="../vendor/base"}\n');
159
+ await write(
160
+ root,
161
+ 'vendor/Cargo.toml',
162
+ '[workspace]\nmembers=["base","leaf"]\n[workspace.dependencies]\nleaf={path="leaf"}\n',
163
+ );
164
+ await write(
165
+ root,
166
+ 'vendor/base/Cargo.toml',
167
+ '[package]\nname="base"\nworkspace=".."\n[dependencies]\nleaf={workspace=true}\n',
126
168
  );
169
+ await write(root, 'vendor/leaf/Cargo.toml', '[package]\nname="leaf"\n');
170
+ await write(root, 'patches/base/Cargo.toml', '[package]\nname="patched"\n');
171
+ const inputs = await cargoPackageTestInputs({
172
+ workspaceRoot: root,
173
+ absoluteProjectRoot: root,
174
+ memberDir: 'app',
175
+ });
176
+ for (const path of ['vendor/Cargo.toml', 'vendor/leaf/src/lib.rs', 'patches/base/src/lib.rs']) {
177
+ expect(matches(inputs, path)).toBe(true);
178
+ }
179
+ expect(matches(inputs, 'leaf/src/lib.rs')).toBe(false);
180
+ } finally {
181
+ await rm(root, { recursive: true, force: true });
182
+ }
183
+ });
127
184
 
128
- await write(root, 'Cargo.toml', '[workspace]\nmembers = ["packages/*/crates/*"]\n');
129
- expect(() => listCargoWorkspacePackages(root)).toThrow(
130
- 'Cargo workspace member glob matched no directories: packages/*/crates/*',
185
+ it('excludes configured Cargo output directories before or after outputs exist', async () => {
186
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-output-'));
187
+ try {
188
+ await write(root, 'Cargo.toml', '[package]\nname="app"\n[workspace]\n');
189
+ await write(root, '.cargo/config.toml', '[build]\ntarget-dir="cache/cargo"\n');
190
+ const request = { workspaceRoot: root, absoluteProjectRoot: root, memberDir: '.' };
191
+ const before = await cargoPackageTestInputs(request);
192
+ expect(matches(before, 'cache/cargo/debug/generated.rs')).toBe(false);
193
+ expect(matches(before, 'src/data.bin')).toBe(true);
194
+ await write(root, 'cache/cargo/debug/generated.rs', 'generated');
195
+ expect(await cargoPackageTestInputs(request)).toEqual(before);
196
+ } finally {
197
+ await rm(root, { recursive: true, force: true });
198
+ }
199
+ });
200
+
201
+ it('requires externalRustCrates only for paths outside Nx, including absolute and declared build paths', async () => {
202
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-external-'));
203
+ try {
204
+ await write(
205
+ root,
206
+ 'Cargo.toml',
207
+ '[workspace]\nmembers=["crates/app"]\n[workspace.dependencies]\nexternal={path="../external"}\n',
208
+ );
209
+ await write(
210
+ root,
211
+ 'crates/app/Cargo.toml',
212
+ `[package]\nname="app"\nbuild="../../../build.rs"\n[dependencies]\nexternal={workspace=true}\nlocal={path=${JSON.stringify(join(root, 'crates/base'))}}\n[target.'cfg(unix)'.dependencies]\nabsolute={path=${JSON.stringify(join(dirname(root), 'absolute'))}}\n`,
131
213
  );
214
+ await write(root, 'crates/base/Cargo.toml', '[package]\nname="base"\n');
215
+ await write(root, 'nx.json', JSON.stringify({ namedInputs: {} }));
216
+ const request = { workspaceRoot: root, absoluteProjectRoot: root, memberDir: 'crates/app' };
217
+ await expect(cargoPackageTestInputs(request)).rejects.toThrow();
218
+ await write(
219
+ root,
220
+ 'nx.json',
221
+ JSON.stringify({ namedInputs: { externalRustCrates: [{ runtime: 'echo source-digest' }] } }),
222
+ );
223
+ const inputs = await cargoPackageTestInputs(request);
224
+ expect(inputs).toContain('externalRustCrates');
225
+ expect(matches(inputs, 'crates/base/src/lib.rs')).toBe(true);
226
+ expect(inputs.some((input) => input.includes('../'))).toBe(false);
227
+ } finally {
228
+ await rm(root, { recursive: true, force: true });
229
+ }
230
+ });
231
+
232
+ it('uses Cargo.lock for registry and git dependencies, and declared local target paths for source', async () => {
233
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-declared-'));
234
+ try {
235
+ await write(
236
+ root,
237
+ 'Cargo.toml',
238
+ '[workspace]\nmembers=["crates/app"]\n[workspace.dependencies]\nremote={git="https://example.org/source.git",rev="abc123"}\n',
239
+ );
240
+ await write(
241
+ root,
242
+ 'crates/app/Cargo.toml',
243
+ '[package]\nname="app"\nbuild="../../shared/build.rs"\n[lib]\npath="../../shared/lib.rs"\n[dependencies]\nremote={workspace=true}\nregistry="1"\n',
244
+ );
245
+ const inputs = await cargoPackageTestInputs({
246
+ workspaceRoot: root,
247
+ absoluteProjectRoot: root,
248
+ memberDir: 'crates/app',
249
+ });
250
+ expect(matches(inputs, 'Cargo.lock')).toBe(true);
251
+ expect(matches(inputs, 'shared/build.rs')).toBe(true);
252
+ expect(matches(inputs, 'shared/lib.rs')).toBe(true);
253
+ expect(inputs).not.toContain('externalRustCrates');
254
+ } finally {
255
+ await rm(root, { recursive: true, force: true });
256
+ }
257
+ });
258
+
259
+ it('rejects unsupported and empty member glob expansions rather than omitting packages', async () => {
260
+ const root = await mkdtemp(join(tmpdir(), 'nx-cargo-globs-'));
261
+ try {
262
+ await write(root, 'Cargo.toml', '[workspace]\nmembers=["packages/**/crates/*"]\n');
263
+ expect(() => listCargoWorkspacePackages(root)).toThrow();
264
+ await write(root, 'Cargo.toml', '[workspace]\nmembers=["packages/*/crates/*"]\n');
265
+ expect(() => listCargoWorkspacePackages(root)).toThrow();
132
266
  } finally {
133
267
  await rm(root, { recursive: true, force: true });
134
268
  }
135
269
  });
136
270
  });
137
271
 
272
+ function matches(inputs: readonly string[], path: string, projectRoot = ''): boolean {
273
+ const filesets = inputs.filter((input) => input.includes('{projectRoot}') || input.includes('{workspaceRoot}'));
274
+ const match = (input: string): boolean =>
275
+ new Glob(
276
+ input.replace('{projectRoot}/', projectRoot ? `${projectRoot}/` : '').replace('{workspaceRoot}/', ''),
277
+ ).match(path);
278
+ return (
279
+ filesets.some((input) => !input.startsWith('!') && match(input)) &&
280
+ !filesets.some((input) => input.startsWith('!') && match(input.slice(1)))
281
+ );
282
+ }
283
+
138
284
  async function write(root: string, path: string, contents: string): Promise<void> {
139
285
  const absolutePath = join(root, path);
140
286
  await mkdir(dirname(absolutePath), { recursive: true });