@workflow/vitest 5.0.0-beta.8 → 5.0.0
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/dist/global-setup.js +2 -2
- package/dist/index.d.ts +45 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +100 -30
- package/dist/options.d.ts +8 -1
- package/dist/options.d.ts.map +1 -1
- package/dist/options.js +27 -4
- package/dist/version-check.d.ts +71 -0
- package/dist/version-check.d.ts.map +1 -0
- package/dist/version-check.js +168 -0
- package/dist/workflow-refs.d.ts +49 -0
- package/dist/workflow-refs.d.ts.map +1 -0
- package/dist/workflow-refs.js +131 -0
- package/package.json +11 -10
package/dist/global-setup.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { buildWorkflowTests } from './index.js';
|
|
2
2
|
import { readProvidedWorkflowTestOptions, WORKFLOW_VITEST_OPTIONS_KEY, } from './options.js';
|
|
3
3
|
export async function setup(project) {
|
|
4
|
-
await buildWorkflowTests(readProvidedWorkflowTestOptions(project.
|
|
4
|
+
await buildWorkflowTests(readProvidedWorkflowTestOptions(project.getProvidedContext()[WORKFLOW_VITEST_OPTIONS_KEY]));
|
|
5
5
|
}
|
|
6
|
-
//# sourceMappingURL=data:application/json;base64,
|
|
6
|
+
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsLXNldHVwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2dsb2JhbC1zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDaEQsT0FBTyxFQUNMLCtCQUErQixFQUMvQiwyQkFBMkIsR0FDNUIsTUFBTSxjQUFjLENBQUM7QUFFdEIsTUFBTSxDQUFDLEtBQUssVUFBVSxLQUFLLENBQUMsT0FBb0I7SUFDOUMsTUFBTSxrQkFBa0IsQ0FDdEIsK0JBQStCLENBQzdCLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLDJCQUEyQixDQUFDLENBQzFELENBQ0YsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFRlc3RQcm9qZWN0IH0gZnJvbSAndml0ZXN0L25vZGUnO1xuaW1wb3J0IHsgYnVpbGRXb3JrZmxvd1Rlc3RzIH0gZnJvbSAnLi9pbmRleC5qcyc7XG5pbXBvcnQge1xuICByZWFkUHJvdmlkZWRXb3JrZmxvd1Rlc3RPcHRpb25zLFxuICBXT1JLRkxPV19WSVRFU1RfT1BUSU9OU19LRVksXG59IGZyb20gJy4vb3B0aW9ucy5qcyc7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzZXR1cChwcm9qZWN0OiBUZXN0UHJvamVjdCkge1xuICBhd2FpdCBidWlsZFdvcmtmbG93VGVzdHMoXG4gICAgcmVhZFByb3ZpZGVkV29ya2Zsb3dUZXN0T3B0aW9ucyhcbiAgICAgIHByb2plY3QuZ2V0UHJvdmlkZWRDb250ZXh0KClbV09SS0ZMT1dfVklURVNUX09QVElPTlNfS0VZXVxuICAgIClcbiAgKTtcbn1cbiJdfQ==
|
package/dist/index.d.ts
CHANGED
|
@@ -1,10 +1,12 @@
|
|
|
1
1
|
import type { Run } from '@workflow/core/runtime';
|
|
2
2
|
import type { Hook } from '@workflow/world';
|
|
3
3
|
import type { Plugin } from 'vite';
|
|
4
|
+
import { type WorkflowRef } from './workflow-refs.js';
|
|
5
|
+
export type { WorkflowRef } from './workflow-refs.js';
|
|
4
6
|
export interface WorkflowTestOptions {
|
|
5
7
|
/**
|
|
6
8
|
* The working directory of the project (where workflows/ lives).
|
|
7
|
-
* Defaults to
|
|
9
|
+
* Defaults to the resolved Vitest project root.
|
|
8
10
|
*/
|
|
9
11
|
cwd?: string;
|
|
10
12
|
/**
|
|
@@ -44,6 +46,10 @@ export declare function workflow(options?: WorkflowTestOptions): Plugin[];
|
|
|
44
46
|
* Build workflow bundles for testing. Run this in vitest globalSetup.
|
|
45
47
|
* This builds the workflow and step bundles to disk so they can be
|
|
46
48
|
* imported by the test workers.
|
|
49
|
+
*
|
|
50
|
+
* Also checks that `@workflow/vitest` and the app under test agree on a
|
|
51
|
+
* Workflow SDK version. globalSetup runs once per Vitest run, so the report
|
|
52
|
+
* is produced once rather than once per worker.
|
|
47
53
|
*/
|
|
48
54
|
export declare function buildWorkflowTests(options?: WorkflowTestOptions): Promise<void>;
|
|
49
55
|
/**
|
|
@@ -58,6 +64,40 @@ export declare function setupWorkflowTests(options?: WorkflowTestOptions): Promi
|
|
|
58
64
|
* Tear down the workflow test world. Call this in afterAll or vitest teardown.
|
|
59
65
|
*/
|
|
60
66
|
export declare function teardownWorkflowTests(): Promise<void>;
|
|
67
|
+
/**
|
|
68
|
+
* Every workflow the test build compiled, read from the manifest written next
|
|
69
|
+
* to the test bundles.
|
|
70
|
+
*
|
|
71
|
+
* Useful for asserting on what a build produced, and for building error
|
|
72
|
+
* messages when a lookup misses.
|
|
73
|
+
*
|
|
74
|
+
* @example
|
|
75
|
+
* ```ts
|
|
76
|
+
* expect(listWorkflowRefs().map((ref) => ref.name)).toContain("approvalWorkflow");
|
|
77
|
+
* ```
|
|
78
|
+
*/
|
|
79
|
+
export declare function listWorkflowRefs(): WorkflowRef[];
|
|
80
|
+
/**
|
|
81
|
+
* Look up a workflow in the test build by name, in the shape `start()` takes.
|
|
82
|
+
*
|
|
83
|
+
* Importing the workflow function is still the better option when a test can
|
|
84
|
+
* do it, because it keeps the argument and return types. Use this when it
|
|
85
|
+
* cannot: the workflow lives in a module the test does not import, or the test
|
|
86
|
+
* drives runs by name. Either way it beats hand-writing the generated id.
|
|
87
|
+
*
|
|
88
|
+
* `query` is an exported workflow name (`"approvalWorkflow"`), or a
|
|
89
|
+
* file-qualified name when one name appears in several files
|
|
90
|
+
* (`"workflows/approval.ts#approvalWorkflow"`, matched by path suffix).
|
|
91
|
+
*
|
|
92
|
+
* @throws If the manifest is missing, nothing matches, or the name is
|
|
93
|
+
* ambiguous. The error lists the workflows the build does contain.
|
|
94
|
+
*
|
|
95
|
+
* @example
|
|
96
|
+
* ```ts
|
|
97
|
+
* const run = await start(getWorkflowRef("approvalWorkflow"), ["doc-1"]);
|
|
98
|
+
* ```
|
|
99
|
+
*/
|
|
100
|
+
export declare function getWorkflowRef(query: string): WorkflowRef;
|
|
61
101
|
export interface WaitOptions {
|
|
62
102
|
/** Maximum time to wait in milliseconds. Defaults to 30000. */
|
|
63
103
|
timeout?: number;
|
|
@@ -90,6 +130,9 @@ export declare function waitForSleep(run: Run<any>, options?: WaitOptions): Prom
|
|
|
90
130
|
* filter that hasn't had a `hook_received` event. Returns the matching hook,
|
|
91
131
|
* which you can then resume with `resumeHook(hook.token, data)`.
|
|
92
132
|
*
|
|
133
|
+
* Pass `notHookId` to explicitly exclude a previously observed hook when a
|
|
134
|
+
* workflow creates several hooks with the same token.
|
|
135
|
+
*
|
|
93
136
|
* @example
|
|
94
137
|
* ```ts
|
|
95
138
|
* const run = await start(myWorkflow, ["doc-1"]);
|
|
@@ -100,5 +143,6 @@ export declare function waitForSleep(run: Run<any>, options?: WaitOptions): Prom
|
|
|
100
143
|
*/
|
|
101
144
|
export declare function waitForHook(run: Run<any>, options?: WaitOptions & {
|
|
102
145
|
token?: string;
|
|
146
|
+
notHookId?: string;
|
|
103
147
|
}): Promise<Hook>;
|
|
104
148
|
//# sourceMappingURL=index.d.ts.map
|
package/dist/index.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAGlD,OAAO,KAAK,EAAS,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAMnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAGlD,OAAO,KAAK,EAAS,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAMnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AASnC,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAyDtD,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,EAAE,CA6BhE;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CASf;AAID;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA4Df;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAI3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAEzD;AAED,MAAM,WAAW,WAAW;IAC1B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA0BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,EACb,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,EACb,OAAO,CAAC,EAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7D,OAAO,CAAC,IAAI,CAAC,CAkCf"}
|
package/dist/index.js
CHANGED
|
@@ -4,8 +4,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
|
|
|
4
4
|
import { BaseBuilder, createBaseBuilderConfig } from '@workflow/builders';
|
|
5
5
|
import { setWorld } from '@workflow/core/runtime';
|
|
6
6
|
import { workflowTransformPlugin } from '@workflow/rollup';
|
|
7
|
-
import {
|
|
8
|
-
import { resolveWorkflowTestOptions, WORKFLOW_VITEST_OPTIONS_KEY, } from './options.js';
|
|
7
|
+
import { createWorld, initDataDir, } from '@workflow/world-local';
|
|
8
|
+
import { getActiveWorkflowTestOptions, resolveWorkflowTestOptions, setActiveWorkflowTestOptions, WORKFLOW_VITEST_OPTIONS_KEY, } from './options.js';
|
|
9
|
+
import { checkWorkflowVersionSkew } from './version-check.js';
|
|
10
|
+
import { readWorkflowRefs, selectWorkflowRef, } from './workflow-refs.js';
|
|
9
11
|
class VitestBuilder extends BaseBuilder {
|
|
10
12
|
#outDir;
|
|
11
13
|
constructor(workingDir, outDir) {
|
|
@@ -23,22 +25,36 @@ class VitestBuilder extends BaseBuilder {
|
|
|
23
25
|
});
|
|
24
26
|
this.#outDir = outDir;
|
|
25
27
|
}
|
|
26
|
-
get shouldLogBaseBuilderInfo() {
|
|
27
|
-
return false;
|
|
28
|
-
}
|
|
29
28
|
async build() {
|
|
30
29
|
const inputFiles = await this.getInputFiles();
|
|
31
30
|
await mkdir(this.#outDir, { recursive: true });
|
|
31
|
+
const flowOutfile = join(this.#outDir, 'combined.mjs');
|
|
32
32
|
// V2: Build combined bundle that includes both step registrations
|
|
33
33
|
// and workflow entrypoint in a single handler.
|
|
34
|
-
await this.createCombinedBundle({
|
|
34
|
+
const result = await this.createCombinedBundle({
|
|
35
35
|
inputFiles,
|
|
36
36
|
stepsOutfile: join(this.#outDir, '__step_registrations.mjs'),
|
|
37
|
-
flowOutfile
|
|
37
|
+
flowOutfile,
|
|
38
38
|
format: 'esm',
|
|
39
39
|
bundleFinalOutput: false,
|
|
40
40
|
externalizeNonSteps: true,
|
|
41
|
+
// The generated bundles are imported directly by Node in the vitest
|
|
42
|
+
// worker (no downstream bundler), so project-local imports must be
|
|
43
|
+
// bundled inline. Externalizing them emits raw `.ts` specifiers that
|
|
44
|
+
// Node's native ESM loader can only handle with erasable-syntax-only
|
|
45
|
+
// type stripping (and not at all on older Node versions).
|
|
46
|
+
bundleTransitiveLocalStepDependencies: true,
|
|
41
47
|
});
|
|
48
|
+
// Emit the same manifest.json every other builder writes, next to the
|
|
49
|
+
// bundles. `getWorkflowRef()` reads it so tests can name a workflow
|
|
50
|
+
// instead of hand-writing the compiler-generated id.
|
|
51
|
+
if (result?.manifest) {
|
|
52
|
+
await this.createManifest({
|
|
53
|
+
workflowBundlePath: flowOutfile,
|
|
54
|
+
manifestDir: this.#outDir,
|
|
55
|
+
manifest: result.manifest,
|
|
56
|
+
});
|
|
57
|
+
}
|
|
42
58
|
}
|
|
43
59
|
}
|
|
44
60
|
/**
|
|
@@ -57,36 +73,45 @@ class VitestBuilder extends BaseBuilder {
|
|
|
57
73
|
* ```
|
|
58
74
|
*/
|
|
59
75
|
export function workflow(options) {
|
|
60
|
-
const
|
|
61
|
-
const { outDir } = resolvedOptions;
|
|
76
|
+
const transformExcludes = [];
|
|
62
77
|
const dir = fileURLToPath(new URL('.', import.meta.url));
|
|
78
|
+
const vitestPlugin = {
|
|
79
|
+
name: 'workflow:vitest',
|
|
80
|
+
config() {
|
|
81
|
+
return {
|
|
82
|
+
test: {
|
|
83
|
+
globalSetup: [join(dir, 'global-setup.js')],
|
|
84
|
+
setupFiles: [join(dir, 'setup-file.js')],
|
|
85
|
+
},
|
|
86
|
+
};
|
|
87
|
+
},
|
|
88
|
+
configureVitest({ project }) {
|
|
89
|
+
const resolvedOptions = resolveWorkflowTestOptions(options, project.config.root);
|
|
90
|
+
transformExcludes.push(`${resolvedOptions.outDir}/`);
|
|
91
|
+
project.provide(WORKFLOW_VITEST_OPTIONS_KEY, resolvedOptions);
|
|
92
|
+
},
|
|
93
|
+
};
|
|
63
94
|
return [
|
|
64
95
|
workflowTransformPlugin({
|
|
65
|
-
exclude:
|
|
96
|
+
exclude: transformExcludes,
|
|
66
97
|
}),
|
|
67
|
-
|
|
68
|
-
name: 'workflow:vitest',
|
|
69
|
-
config() {
|
|
70
|
-
return {
|
|
71
|
-
test: {
|
|
72
|
-
globalSetup: [join(dir, 'global-setup.js')],
|
|
73
|
-
setupFiles: [join(dir, 'setup-file.js')],
|
|
74
|
-
provide: {
|
|
75
|
-
[WORKFLOW_VITEST_OPTIONS_KEY]: resolvedOptions,
|
|
76
|
-
},
|
|
77
|
-
},
|
|
78
|
-
};
|
|
79
|
-
},
|
|
80
|
-
},
|
|
98
|
+
vitestPlugin,
|
|
81
99
|
];
|
|
82
100
|
}
|
|
83
101
|
/**
|
|
84
102
|
* Build workflow bundles for testing. Run this in vitest globalSetup.
|
|
85
103
|
* This builds the workflow and step bundles to disk so they can be
|
|
86
104
|
* imported by the test workers.
|
|
105
|
+
*
|
|
106
|
+
* Also checks that `@workflow/vitest` and the app under test agree on a
|
|
107
|
+
* Workflow SDK version. globalSetup runs once per Vitest run, so the report
|
|
108
|
+
* is produced once rather than once per worker.
|
|
87
109
|
*/
|
|
88
110
|
export async function buildWorkflowTests(options) {
|
|
89
|
-
const
|
|
111
|
+
const resolved = resolveWorkflowTestOptions(options, process.cwd());
|
|
112
|
+
const { cwd, dataDir, outDir } = resolved;
|
|
113
|
+
setActiveWorkflowTestOptions(resolved);
|
|
114
|
+
checkWorkflowVersionSkew({ cwd });
|
|
90
115
|
const builder = new VitestBuilder(cwd, outDir);
|
|
91
116
|
await builder.build();
|
|
92
117
|
// Pre-create the shared data directory so workers don't race on mkdir
|
|
@@ -107,7 +132,9 @@ export async function setupWorkflowTests(options) {
|
|
|
107
132
|
await world.close?.();
|
|
108
133
|
world = undefined;
|
|
109
134
|
}
|
|
110
|
-
const
|
|
135
|
+
const resolved = resolveWorkflowTestOptions(options, process.cwd());
|
|
136
|
+
const { dataDir, outDir } = resolved;
|
|
137
|
+
setActiveWorkflowTestOptions(resolved);
|
|
111
138
|
// Lazy-load bundles on first dispatch instead of eagerly at setup time.
|
|
112
139
|
// Eager native import() during setupFiles loads step dependencies into
|
|
113
140
|
// the module cache before vi.mock() can intercept them, breaking mocks
|
|
@@ -132,7 +159,7 @@ export async function setupWorkflowTests(options) {
|
|
|
132
159
|
// deletes files matching the worker's tag. Recovery stays disabled because
|
|
133
160
|
// tests expect a clean world and register direct handlers after setup begins.
|
|
134
161
|
const poolId = process.env.VITEST_POOL_ID ?? '0';
|
|
135
|
-
world =
|
|
162
|
+
world = createWorld({
|
|
136
163
|
dataDir,
|
|
137
164
|
recoverActiveRuns: false,
|
|
138
165
|
tag: `vitest-${poolId}`,
|
|
@@ -155,6 +182,44 @@ export async function teardownWorkflowTests() {
|
|
|
155
182
|
await world?.close?.();
|
|
156
183
|
world = undefined;
|
|
157
184
|
}
|
|
185
|
+
/**
|
|
186
|
+
* Every workflow the test build compiled, read from the manifest written next
|
|
187
|
+
* to the test bundles.
|
|
188
|
+
*
|
|
189
|
+
* Useful for asserting on what a build produced, and for building error
|
|
190
|
+
* messages when a lookup misses.
|
|
191
|
+
*
|
|
192
|
+
* @example
|
|
193
|
+
* ```ts
|
|
194
|
+
* expect(listWorkflowRefs().map((ref) => ref.name)).toContain("approvalWorkflow");
|
|
195
|
+
* ```
|
|
196
|
+
*/
|
|
197
|
+
export function listWorkflowRefs() {
|
|
198
|
+
return readWorkflowRefs(getActiveWorkflowTestOptions().outDir);
|
|
199
|
+
}
|
|
200
|
+
/**
|
|
201
|
+
* Look up a workflow in the test build by name, in the shape `start()` takes.
|
|
202
|
+
*
|
|
203
|
+
* Importing the workflow function is still the better option when a test can
|
|
204
|
+
* do it, because it keeps the argument and return types. Use this when it
|
|
205
|
+
* cannot: the workflow lives in a module the test does not import, or the test
|
|
206
|
+
* drives runs by name. Either way it beats hand-writing the generated id.
|
|
207
|
+
*
|
|
208
|
+
* `query` is an exported workflow name (`"approvalWorkflow"`), or a
|
|
209
|
+
* file-qualified name when one name appears in several files
|
|
210
|
+
* (`"workflows/approval.ts#approvalWorkflow"`, matched by path suffix).
|
|
211
|
+
*
|
|
212
|
+
* @throws If the manifest is missing, nothing matches, or the name is
|
|
213
|
+
* ambiguous. The error lists the workflows the build does contain.
|
|
214
|
+
*
|
|
215
|
+
* @example
|
|
216
|
+
* ```ts
|
|
217
|
+
* const run = await start(getWorkflowRef("approvalWorkflow"), ["doc-1"]);
|
|
218
|
+
* ```
|
|
219
|
+
*/
|
|
220
|
+
export function getWorkflowRef(query) {
|
|
221
|
+
return selectWorkflowRef(listWorkflowRefs(), query);
|
|
222
|
+
}
|
|
158
223
|
function getWorldOrThrow() {
|
|
159
224
|
if (!world) {
|
|
160
225
|
throw new Error('Workflow test world is not initialized. Call setupWorkflowTests() first.');
|
|
@@ -217,6 +282,9 @@ export async function waitForSleep(run, options) {
|
|
|
217
282
|
* filter that hasn't had a `hook_received` event. Returns the matching hook,
|
|
218
283
|
* which you can then resume with `resumeHook(hook.token, data)`.
|
|
219
284
|
*
|
|
285
|
+
* Pass `notHookId` to explicitly exclude a previously observed hook when a
|
|
286
|
+
* workflow creates several hooks with the same token.
|
|
287
|
+
*
|
|
220
288
|
* @example
|
|
221
289
|
* ```ts
|
|
222
290
|
* const run = await start(myWorkflow, ["doc-1"]);
|
|
@@ -239,11 +307,13 @@ export async function waitForHook(run, options) {
|
|
|
239
307
|
.filter((e) => e.eventType === 'hook_received')
|
|
240
308
|
.map((e) => e.correlationId));
|
|
241
309
|
const pendingHook = hooks.find((h) => !receivedCorrelationIds.has(h.hookId) &&
|
|
242
|
-
(!options?.token || h.token === options.token)
|
|
310
|
+
(!options?.token || h.token === options.token) &&
|
|
311
|
+
// Skip a hook the caller explicitly excluded.
|
|
312
|
+
(!options?.notHookId || h.hookId !== options.notHookId));
|
|
243
313
|
if (pendingHook)
|
|
244
314
|
return pendingHook;
|
|
245
315
|
await new Promise((resolve) => setTimeout(resolve, pollInterval));
|
|
246
316
|
}
|
|
247
|
-
throw new Error(`waitForHook timed out after ${timeout}ms: no pending hook found for run ${run.runId}${options?.token ? ` with token "${options.token}"` : ''}`);
|
|
317
|
+
throw new Error(`waitForHook timed out after ${timeout}ms: no pending hook found for run ${run.runId}${options?.token ? ` with token "${options.token}"` : ''}${options?.notHookId ? ` other than "${options.notHookId}"` : ''}`);
|
|
248
318
|
}
|
|
249
|
-
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { BaseBuilder, createBaseBuilderConfig } from '@workflow/builders';\nimport type { Run } from '@workflow/core/runtime';\nimport { setWorld } from '@workflow/core/runtime';\nimport { workflowTransformPlugin } from '@workflow/rollup';\nimport type { Event, Hook } from '@workflow/world';\nimport {\n  createLocalWorld,\n  initDataDir,\n  type LocalWorld,\n} from '@workflow/world-local';\nimport type { Plugin } from 'vite';\nimport {\n  resolveWorkflowTestOptions,\n  WORKFLOW_VITEST_OPTIONS_KEY,\n} from './options.js';\n\nclass VitestBuilder extends BaseBuilder {\n  #outDir: string;\n\n  constructor(workingDir: string, outDir: string) {\n    super({\n      ...createBaseBuilderConfig({\n        workingDir,\n        dirs: ['.'],\n      }),\n      // 'next' target produces ESM bundles with Node.js-compatible output,\n      // which is what we need for in-process vitest execution.\n      buildTarget: 'next',\n      suppressCreateWorkflowsBundleLogs: true,\n      suppressCreateWebhookBundleLogs: true,\n      suppressCreateManifestLogs: true,\n    });\n    this.#outDir = outDir;\n  }\n\n  protected override get shouldLogBaseBuilderInfo(): boolean {\n    return false;\n  }\n\n  override async build(): Promise<void> {\n    const inputFiles = await this.getInputFiles();\n    await mkdir(this.#outDir, { recursive: true });\n\n    // V2: Build combined bundle that includes both step registrations\n    // and workflow entrypoint in a single handler.\n    await this.createCombinedBundle({\n      inputFiles,\n      stepsOutfile: join(this.#outDir, '__step_registrations.mjs'),\n      flowOutfile: join(this.#outDir, 'combined.mjs'),\n      format: 'esm',\n      bundleFinalOutput: false,\n      externalizeNonSteps: true,\n    });\n  }\n}\n\nexport interface WorkflowTestOptions {\n  /**\n   * The working directory of the project (where workflows/ lives).\n   * Defaults to process.cwd().\n   */\n  cwd?: string;\n  /**\n   * Root directory used for default test artifacts.\n   * When set, `.workflow-data` and `.workflow-vitest` are created here unless\n   * overridden explicitly with `dataDir` or `outDir`.\n   */\n  rootDir?: string;\n  /**\n   * Directory for workflow runtime data written by the test world.\n   * Defaults to `<rootDir>/.workflow-data`.\n   */\n  dataDir?: string;\n  /**\n   * Directory for generated workflow and step bundles.\n   * Defaults to `<rootDir>/.workflow-vitest`.\n   */\n  outDir?: string;\n}\n\n/**\n * Vitest plugin for workflow testing. Handles SWC transforms, bundle building,\n * and in-process handler registration automatically.\n *\n * @example\n * ```ts\n * // vitest.config.ts\n * import { workflow } from '@workflow/vitest';\n * import { defineConfig } from 'vitest/config';\n *\n * export default defineConfig({\n *   plugins: [workflow()],\n * });\n * ```\n */\nexport function workflow(options?: WorkflowTestOptions): Plugin[] {\n  const resolvedOptions = resolveWorkflowTestOptions(options);\n  const { outDir } = resolvedOptions;\n  const dir = fileURLToPath(new URL('.', import.meta.url));\n  return [\n    workflowTransformPlugin({\n      exclude: [outDir + '/'],\n    }),\n    {\n      name: 'workflow:vitest',\n      config() {\n        return {\n          test: {\n            globalSetup: [join(dir, 'global-setup.js')],\n            setupFiles: [join(dir, 'setup-file.js')],\n            provide: {\n              [WORKFLOW_VITEST_OPTIONS_KEY]: resolvedOptions,\n            },\n          },\n        } as Record<string, unknown>;\n      },\n    },\n  ];\n}\n\n/**\n * Build workflow bundles for testing. Run this in vitest globalSetup.\n * This builds the workflow and step bundles to disk so they can be\n * imported by the test workers.\n */\nexport async function buildWorkflowTests(\n  options?: WorkflowTestOptions\n): Promise<void> {\n  const { cwd, dataDir, outDir } = resolveWorkflowTestOptions(options);\n  const builder = new VitestBuilder(cwd, outDir);\n  await builder.build();\n  // Pre-create the shared data directory so workers don't race on mkdir\n  await initDataDir(dataDir);\n}\n\nlet world: LocalWorld | undefined;\n\n/**\n * Set up in-process handler routing for workflow tests.\n * Run this in vitest setupFiles (which executes in each test worker process).\n *\n * Imports the pre-built bundles, creates a local world with direct handlers,\n * and sets it as the global world.\n */\nexport async function setupWorkflowTests(\n  options?: WorkflowTestOptions\n): Promise<void> {\n  // Clean up previous world if re-initialized (e.g. across test files)\n  if (world) {\n    setWorld(undefined);\n    await world.close?.();\n    world = undefined;\n  }\n\n  const { dataDir, outDir } = resolveWorkflowTestOptions(options);\n\n  // Lazy-load bundles on first dispatch instead of eagerly at setup time.\n  // Eager native import() during setupFiles loads step dependencies into\n  // the module cache before vi.mock() can intercept them, breaking mocks\n  // in unit tests that never execute workflows.\n  function createLazyHandler(\n    bundlePath: string\n  ): (req: Request) => Promise<Response> {\n    let handler: ((req: Request) => Promise<Response>) | undefined;\n    let loading: Promise<(req: Request) => Promise<Response>> | undefined;\n\n    return async (req: Request) => {\n      if (!handler) {\n        // If the import rejects (e.g. missing bundle), the rejected promise is\n        // cached so all subsequent calls fail fast with the same error.\n        loading ??= import(\n          /* @vite-ignore */ pathToFileURL(bundlePath).href\n        ).then((mod) => mod.POST as (req: Request) => Promise<Response>);\n        handler = await loading;\n      }\n      return handler(req);\n    };\n  }\n\n  // Each vitest worker uses a unique tag to isolate its test data.\n  // All workers write to the shared .workflow-data directory so runs\n  // are visible to the observability dashboard, but clear() only\n  // deletes files matching the worker's tag. Recovery stays disabled because\n  // tests expect a clean world and register direct handlers after setup begins.\n  const poolId = process.env.VITEST_POOL_ID ?? '0';\n  world = createLocalWorld({\n    dataDir,\n    recoverActiveRuns: false,\n    tag: `vitest-${poolId}`,\n  });\n  await world.clear();\n\n  // V2: Single combined handler for both workflow and step execution.\n  world.registerHandler(\n    '__wkf_workflow_',\n    createLazyHandler(join(outDir, 'combined.mjs'))\n  );\n\n  // Handlers must be registered before start(): if recoverActiveRuns is ever\n  // re-enabled here (or plumbed through from a caller), start() re-enqueues\n  // pending runs and the queue begins dispatching. Registering after start\n  // would race handler installation against that dispatch.\n  await world.start?.();\n  setWorld(world);\n}\n\n/**\n * Tear down the workflow test world. Call this in afterAll or vitest teardown.\n */\nexport async function teardownWorkflowTests(): Promise<void> {\n  setWorld(undefined);\n  await world?.close?.();\n  world = undefined;\n}\n\nexport interface WaitOptions {\n  /** Maximum time to wait in milliseconds. Defaults to 30000. */\n  timeout?: number;\n  /** Polling interval in milliseconds. Defaults to 100. */\n  pollInterval?: number;\n}\n\nfunction getWorldOrThrow(): LocalWorld {\n  if (!world) {\n    throw new Error(\n      'Workflow test world is not initialized. Call setupWorkflowTests() first.'\n    );\n  }\n  return world;\n}\n\nasync function fetchAllEvents(w: LocalWorld, runId: string): Promise<Event[]> {\n  const allEvents: Event[] = [];\n  let cursor: string | null = null;\n  do {\n    const result = await w.events.list({\n      runId,\n      pagination: { limit: 1000, ...(cursor ? { cursor } : {}) },\n      resolveData: 'none',\n    });\n    allEvents.push(...result.data);\n    cursor = result.hasMore ? result.cursor : null;\n  } while (cursor);\n  return allEvents;\n}\n\n/**\n * Wait until the workflow has a pending `sleep()` call.\n *\n * Polls the event log for a `wait_created` event without a corresponding\n * `wait_completed` event. Returns the correlation ID of the pending sleep,\n * which can be passed to `run.wakeUp({ correlationIds: [id] })` to target\n * a specific sleep call.\n *\n * @returns The correlation ID of the first pending sleep.\n *\n * @example\n * ```ts\n * const run = await start(myWorkflow, []);\n * const sleepId = await waitForSleep(run);\n * await run.wakeUp({ correlationIds: [sleepId] });\n * const result = await run.returnValue;\n * ```\n */\nexport async function waitForSleep(\n  run: Run<any>,\n  options?: WaitOptions\n): Promise<string> {\n  const w = getWorldOrThrow();\n  const timeout = options?.timeout ?? 30_000;\n  const pollInterval = options?.pollInterval ?? 100;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const events = await fetchAllEvents(w, run.runId);\n\n    const waitCompletedIds = new Set(\n      events\n        .filter((e) => e.eventType === 'wait_completed')\n        .map((e) => e.correlationId)\n    );\n\n    const pendingSleep = events.find(\n      (e) =>\n        e.eventType === 'wait_created' && !waitCompletedIds.has(e.correlationId)\n    );\n\n    if (pendingSleep?.correlationId) return pendingSleep.correlationId;\n\n    await new Promise((resolve) => setTimeout(resolve, pollInterval));\n  }\n\n  throw new Error(\n    `waitForSleep timed out after ${timeout}ms: no pending sleep found for run ${run.runId}`\n  );\n}\n\n/**\n * Wait until the workflow has created a hook that hasn't been received yet.\n *\n * Polls the hook list and event log for a hook matching the optional `token`\n * filter that hasn't had a `hook_received` event. Returns the matching hook,\n * which you can then resume with `resumeHook(hook.token, data)`.\n *\n * @example\n * ```ts\n * const run = await start(myWorkflow, [\"doc-1\"]);\n * const hook = await waitForHook(run);\n * await resumeHook(hook.token, { approved: true });\n * const result = await run.returnValue;\n * ```\n */\nexport async function waitForHook(\n  run: Run<any>,\n  options?: WaitOptions & { token?: string }\n): Promise<Hook> {\n  const w = getWorldOrThrow();\n  const timeout = options?.timeout ?? 30_000;\n  const pollInterval = options?.pollInterval ?? 100;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const [hooks, events] = await Promise.all([\n      w.hooks.list({ runId: run.runId }).then((r) => r.data),\n      fetchAllEvents(w, run.runId),\n    ]);\n\n    const receivedCorrelationIds = new Set(\n      events\n        .filter((e) => e.eventType === 'hook_received')\n        .map((e) => e.correlationId)\n    );\n\n    const pendingHook = hooks.find(\n      (h) =>\n        !receivedCorrelationIds.has(h.hookId) &&\n        (!options?.token || h.token === options.token)\n    );\n\n    if (pendingHook) return pendingHook;\n\n    await new Promise((resolve) => setTimeout(resolve, pollInterval));\n  }\n\n  throw new Error(\n    `waitForHook timed out after ${timeout}ms: no pending hook found for run ${run.runId}${options?.token ? ` with token \"${options.token}\"` : ''}`\n  );\n}\n"]}
|
|
319
|
+
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { BaseBuilder, createBaseBuilderConfig } from '@workflow/builders';\nimport type { Run } from '@workflow/core/runtime';\nimport { setWorld } from '@workflow/core/runtime';\nimport { workflowTransformPlugin } from '@workflow/rollup';\nimport type { Event, Hook } from '@workflow/world';\nimport {\n  createWorld,\n  initDataDir,\n  type LocalWorld,\n} from '@workflow/world-local';\nimport type { Plugin } from 'vite';\nimport type { VitestPluginContext } from 'vitest/node';\nimport {\n  getActiveWorkflowTestOptions,\n  resolveWorkflowTestOptions,\n  setActiveWorkflowTestOptions,\n  WORKFLOW_VITEST_OPTIONS_KEY,\n} from './options.js';\nimport { checkWorkflowVersionSkew } from './version-check.js';\nimport {\n  readWorkflowRefs,\n  selectWorkflowRef,\n  type WorkflowRef,\n} from './workflow-refs.js';\n\nexport type { WorkflowRef } from './workflow-refs.js';\n\nclass VitestBuilder extends BaseBuilder {\n  #outDir: string;\n\n  constructor(workingDir: string, outDir: string) {\n    super({\n      ...createBaseBuilderConfig({\n        workingDir,\n        dirs: ['.'],\n      }),\n      // 'next' target produces ESM bundles with Node.js-compatible output,\n      // which is what we need for in-process vitest execution.\n      buildTarget: 'next',\n      suppressCreateWorkflowsBundleLogs: true,\n      suppressCreateWebhookBundleLogs: true,\n      suppressCreateManifestLogs: true,\n    });\n    this.#outDir = outDir;\n  }\n\n  override async build(): Promise<void> {\n    const inputFiles = await this.getInputFiles();\n    await mkdir(this.#outDir, { recursive: true });\n\n    const flowOutfile = join(this.#outDir, 'combined.mjs');\n\n    // V2: Build combined bundle that includes both step registrations\n    // and workflow entrypoint in a single handler.\n    const result = await this.createCombinedBundle({\n      inputFiles,\n      stepsOutfile: join(this.#outDir, '__step_registrations.mjs'),\n      flowOutfile,\n      format: 'esm',\n      bundleFinalOutput: false,\n      externalizeNonSteps: true,\n      // The generated bundles are imported directly by Node in the vitest\n      // worker (no downstream bundler), so project-local imports must be\n      // bundled inline. Externalizing them emits raw `.ts` specifiers that\n      // Node's native ESM loader can only handle with erasable-syntax-only\n      // type stripping (and not at all on older Node versions).\n      bundleTransitiveLocalStepDependencies: true,\n    });\n\n    // Emit the same manifest.json every other builder writes, next to the\n    // bundles. `getWorkflowRef()` reads it so tests can name a workflow\n    // instead of hand-writing the compiler-generated id.\n    if (result?.manifest) {\n      await this.createManifest({\n        workflowBundlePath: flowOutfile,\n        manifestDir: this.#outDir,\n        manifest: result.manifest,\n      });\n    }\n  }\n}\n\nexport interface WorkflowTestOptions {\n  /**\n   * The working directory of the project (where workflows/ lives).\n   * Defaults to the resolved Vitest project root.\n   */\n  cwd?: string;\n  /**\n   * Root directory used for default test artifacts.\n   * When set, `.workflow-data` and `.workflow-vitest` are created here unless\n   * overridden explicitly with `dataDir` or `outDir`.\n   */\n  rootDir?: string;\n  /**\n   * Directory for workflow runtime data written by the test world.\n   * Defaults to `<rootDir>/.workflow-data`.\n   */\n  dataDir?: string;\n  /**\n   * Directory for generated workflow and step bundles.\n   * Defaults to `<rootDir>/.workflow-vitest`.\n   */\n  outDir?: string;\n}\n\n/**\n * Vitest plugin for workflow testing. Handles SWC transforms, bundle building,\n * and in-process handler registration automatically.\n *\n * @example\n * ```ts\n * // vitest.config.ts\n * import { workflow } from '@workflow/vitest';\n * import { defineConfig } from 'vitest/config';\n *\n * export default defineConfig({\n *   plugins: [workflow()],\n * });\n * ```\n */\nexport function workflow(options?: WorkflowTestOptions): Plugin[] {\n  const transformExcludes: string[] = [];\n  const dir = fileURLToPath(new URL('.', import.meta.url));\n  const vitestPlugin = {\n    name: 'workflow:vitest',\n    config() {\n      return {\n        test: {\n          globalSetup: [join(dir, 'global-setup.js')],\n          setupFiles: [join(dir, 'setup-file.js')],\n        },\n      } as Record<string, unknown>;\n    },\n    configureVitest({ project }: VitestPluginContext) {\n      const resolvedOptions = resolveWorkflowTestOptions(\n        options,\n        project.config.root\n      );\n      transformExcludes.push(`${resolvedOptions.outDir}/`);\n      project.provide(WORKFLOW_VITEST_OPTIONS_KEY, resolvedOptions);\n    },\n  };\n\n  return [\n    workflowTransformPlugin({\n      exclude: transformExcludes,\n    }),\n    vitestPlugin,\n  ];\n}\n\n/**\n * Build workflow bundles for testing. Run this in vitest globalSetup.\n * This builds the workflow and step bundles to disk so they can be\n * imported by the test workers.\n *\n * Also checks that `@workflow/vitest` and the app under test agree on a\n * Workflow SDK version. globalSetup runs once per Vitest run, so the report\n * is produced once rather than once per worker.\n */\nexport async function buildWorkflowTests(\n  options?: WorkflowTestOptions\n): Promise<void> {\n  const resolved = resolveWorkflowTestOptions(options, process.cwd());\n  const { cwd, dataDir, outDir } = resolved;\n  setActiveWorkflowTestOptions(resolved);\n  checkWorkflowVersionSkew({ cwd });\n  const builder = new VitestBuilder(cwd, outDir);\n  await builder.build();\n  // Pre-create the shared data directory so workers don't race on mkdir\n  await initDataDir(dataDir);\n}\n\nlet world: LocalWorld | undefined;\n\n/**\n * Set up in-process handler routing for workflow tests.\n * Run this in vitest setupFiles (which executes in each test worker process).\n *\n * Imports the pre-built bundles, creates a local world with direct handlers,\n * and sets it as the global world.\n */\nexport async function setupWorkflowTests(\n  options?: WorkflowTestOptions\n): Promise<void> {\n  // Clean up previous world if re-initialized (e.g. across test files)\n  if (world) {\n    setWorld(undefined);\n    await world.close?.();\n    world = undefined;\n  }\n\n  const resolved = resolveWorkflowTestOptions(options, process.cwd());\n  const { dataDir, outDir } = resolved;\n  setActiveWorkflowTestOptions(resolved);\n\n  // Lazy-load bundles on first dispatch instead of eagerly at setup time.\n  // Eager native import() during setupFiles loads step dependencies into\n  // the module cache before vi.mock() can intercept them, breaking mocks\n  // in unit tests that never execute workflows.\n  function createLazyHandler(\n    bundlePath: string\n  ): (req: Request) => Promise<Response> {\n    let handler: ((req: Request) => Promise<Response>) | undefined;\n    let loading: Promise<(req: Request) => Promise<Response>> | undefined;\n\n    return async (req: Request) => {\n      if (!handler) {\n        // If the import rejects (e.g. missing bundle), the rejected promise is\n        // cached so all subsequent calls fail fast with the same error.\n        loading ??= import(\n          /* @vite-ignore */ pathToFileURL(bundlePath).href\n        ).then((mod) => mod.POST as (req: Request) => Promise<Response>);\n        handler = await loading;\n      }\n      return handler(req);\n    };\n  }\n\n  // Each vitest worker uses a unique tag to isolate its test data.\n  // All workers write to the shared .workflow-data directory so runs\n  // are visible to the observability dashboard, but clear() only\n  // deletes files matching the worker's tag. Recovery stays disabled because\n  // tests expect a clean world and register direct handlers after setup begins.\n  const poolId = process.env.VITEST_POOL_ID ?? '0';\n  world = createWorld({\n    dataDir,\n    recoverActiveRuns: false,\n    tag: `vitest-${poolId}`,\n  });\n  await world.clear();\n\n  // V2: Single combined handler for both workflow and step execution.\n  world.registerHandler(\n    '__wkf_workflow_',\n    createLazyHandler(join(outDir, 'combined.mjs'))\n  );\n\n  // Handlers must be registered before start(): if recoverActiveRuns is ever\n  // re-enabled here (or plumbed through from a caller), start() re-enqueues\n  // pending runs and the queue begins dispatching. Registering after start\n  // would race handler installation against that dispatch.\n  await world.start?.();\n  setWorld(world);\n}\n\n/**\n * Tear down the workflow test world. Call this in afterAll or vitest teardown.\n */\nexport async function teardownWorkflowTests(): Promise<void> {\n  setWorld(undefined);\n  await world?.close?.();\n  world = undefined;\n}\n\n/**\n * Every workflow the test build compiled, read from the manifest written next\n * to the test bundles.\n *\n * Useful for asserting on what a build produced, and for building error\n * messages when a lookup misses.\n *\n * @example\n * ```ts\n * expect(listWorkflowRefs().map((ref) => ref.name)).toContain(\"approvalWorkflow\");\n * ```\n */\nexport function listWorkflowRefs(): WorkflowRef[] {\n  return readWorkflowRefs(getActiveWorkflowTestOptions().outDir);\n}\n\n/**\n * Look up a workflow in the test build by name, in the shape `start()` takes.\n *\n * Importing the workflow function is still the better option when a test can\n * do it, because it keeps the argument and return types. Use this when it\n * cannot: the workflow lives in a module the test does not import, or the test\n * drives runs by name. Either way it beats hand-writing the generated id.\n *\n * `query` is an exported workflow name (`\"approvalWorkflow\"`), or a\n * file-qualified name when one name appears in several files\n * (`\"workflows/approval.ts#approvalWorkflow\"`, matched by path suffix).\n *\n * @throws If the manifest is missing, nothing matches, or the name is\n * ambiguous. The error lists the workflows the build does contain.\n *\n * @example\n * ```ts\n * const run = await start(getWorkflowRef(\"approvalWorkflow\"), [\"doc-1\"]);\n * ```\n */\nexport function getWorkflowRef(query: string): WorkflowRef {\n  return selectWorkflowRef(listWorkflowRefs(), query);\n}\n\nexport interface WaitOptions {\n  /** Maximum time to wait in milliseconds. Defaults to 30000. */\n  timeout?: number;\n  /** Polling interval in milliseconds. Defaults to 100. */\n  pollInterval?: number;\n}\n\nfunction getWorldOrThrow(): LocalWorld {\n  if (!world) {\n    throw new Error(\n      'Workflow test world is not initialized. Call setupWorkflowTests() first.'\n    );\n  }\n  return world;\n}\n\nasync function fetchAllEvents(w: LocalWorld, runId: string): Promise<Event[]> {\n  const allEvents: Event[] = [];\n  let cursor: string | null = null;\n  do {\n    const result = await w.events.list({\n      runId,\n      pagination: { limit: 1000, ...(cursor ? { cursor } : {}) },\n      resolveData: 'none',\n    });\n    allEvents.push(...result.data);\n    cursor = result.hasMore ? result.cursor : null;\n  } while (cursor);\n  return allEvents;\n}\n\n/**\n * Wait until the workflow has a pending `sleep()` call.\n *\n * Polls the event log for a `wait_created` event without a corresponding\n * `wait_completed` event. Returns the correlation ID of the pending sleep,\n * which can be passed to `run.wakeUp({ correlationIds: [id] })` to target\n * a specific sleep call.\n *\n * @returns The correlation ID of the first pending sleep.\n *\n * @example\n * ```ts\n * const run = await start(myWorkflow, []);\n * const sleepId = await waitForSleep(run);\n * await run.wakeUp({ correlationIds: [sleepId] });\n * const result = await run.returnValue;\n * ```\n */\nexport async function waitForSleep(\n  run: Run<any>,\n  options?: WaitOptions\n): Promise<string> {\n  const w = getWorldOrThrow();\n  const timeout = options?.timeout ?? 30_000;\n  const pollInterval = options?.pollInterval ?? 100;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const events = await fetchAllEvents(w, run.runId);\n\n    const waitCompletedIds = new Set(\n      events\n        .filter((e) => e.eventType === 'wait_completed')\n        .map((e) => e.correlationId)\n    );\n\n    const pendingSleep = events.find(\n      (e) =>\n        e.eventType === 'wait_created' && !waitCompletedIds.has(e.correlationId)\n    );\n\n    if (pendingSleep?.correlationId) return pendingSleep.correlationId;\n\n    await new Promise((resolve) => setTimeout(resolve, pollInterval));\n  }\n\n  throw new Error(\n    `waitForSleep timed out after ${timeout}ms: no pending sleep found for run ${run.runId}`\n  );\n}\n\n/**\n * Wait until the workflow has created a hook that hasn't been received yet.\n *\n * Polls the hook list and event log for a hook matching the optional `token`\n * filter that hasn't had a `hook_received` event. Returns the matching hook,\n * which you can then resume with `resumeHook(hook.token, data)`.\n *\n * Pass `notHookId` to explicitly exclude a previously observed hook when a\n * workflow creates several hooks with the same token.\n *\n * @example\n * ```ts\n * const run = await start(myWorkflow, [\"doc-1\"]);\n * const hook = await waitForHook(run);\n * await resumeHook(hook.token, { approved: true });\n * const result = await run.returnValue;\n * ```\n */\nexport async function waitForHook(\n  run: Run<any>,\n  options?: WaitOptions & { token?: string; notHookId?: string }\n): Promise<Hook> {\n  const w = getWorldOrThrow();\n  const timeout = options?.timeout ?? 30_000;\n  const pollInterval = options?.pollInterval ?? 100;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const [hooks, events] = await Promise.all([\n      w.hooks.list({ runId: run.runId }).then((r) => r.data),\n      fetchAllEvents(w, run.runId),\n    ]);\n\n    const receivedCorrelationIds = new Set(\n      events\n        .filter((e) => e.eventType === 'hook_received')\n        .map((e) => e.correlationId)\n    );\n\n    const pendingHook = hooks.find(\n      (h) =>\n        !receivedCorrelationIds.has(h.hookId) &&\n        (!options?.token || h.token === options.token) &&\n        // Skip a hook the caller explicitly excluded.\n        (!options?.notHookId || h.hookId !== options.notHookId)\n    );\n\n    if (pendingHook) return pendingHook;\n\n    await new Promise((resolve) => setTimeout(resolve, pollInterval));\n  }\n\n  throw new Error(\n    `waitForHook timed out after ${timeout}ms: no pending hook found for run ${run.runId}${options?.token ? ` with token \"${options.token}\"` : ''}${options?.notHookId ? ` other than \"${options.notHookId}\"` : ''}`\n  );\n}\n"]}
|
package/dist/options.d.ts
CHANGED
|
@@ -6,6 +6,13 @@ export type ResolvedWorkflowTestOptions = {
|
|
|
6
6
|
dataDir: string;
|
|
7
7
|
outDir: string;
|
|
8
8
|
};
|
|
9
|
-
export declare function resolveWorkflowTestOptions(options
|
|
9
|
+
export declare function resolveWorkflowTestOptions(options: WorkflowTestOptions | undefined, projectRoot: string): ResolvedWorkflowTestOptions;
|
|
10
10
|
export declare function readProvidedWorkflowTestOptions(value: unknown): ResolvedWorkflowTestOptions;
|
|
11
|
+
export declare function setActiveWorkflowTestOptions(options: ResolvedWorkflowTestOptions): void;
|
|
12
|
+
/**
|
|
13
|
+
* The options in force for this process, falling back to the defaults for
|
|
14
|
+
* `process.cwd()` when nothing has been set up yet.
|
|
15
|
+
*/
|
|
16
|
+
export declare function getActiveWorkflowTestOptions(): ResolvedWorkflowTestOptions;
|
|
17
|
+
export declare function clearActiveWorkflowTestOptions(): void;
|
|
11
18
|
//# sourceMappingURL=options.d.ts.map
|
package/dist/options.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AAErE,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAcF,wBAAgB,0BAA0B,CACxC,OAAO,
|
|
1
|
+
{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AAErE,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAcF,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,WAAW,EAAE,MAAM,GAClB,2BAA2B,CAiB7B;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,GACb,2BAA2B,CAK7B;AAaD,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,2BAA2B,GACnC,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,2BAA2B,CAE1E;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}
|
package/dist/options.js
CHANGED
|
@@ -6,9 +6,9 @@ function getDefinedOptions(options) {
|
|
|
6
6
|
}
|
|
7
7
|
return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
|
|
8
8
|
}
|
|
9
|
-
export function resolveWorkflowTestOptions(options) {
|
|
9
|
+
export function resolveWorkflowTestOptions(options, projectRoot) {
|
|
10
10
|
const mergedOptions = getDefinedOptions(options);
|
|
11
|
-
const cwd = resolve(mergedOptions.cwd ??
|
|
11
|
+
const cwd = resolve(mergedOptions.cwd ?? projectRoot);
|
|
12
12
|
const rootDir = mergedOptions.rootDir
|
|
13
13
|
? resolve(cwd, mergedOptions.rootDir)
|
|
14
14
|
: cwd;
|
|
@@ -24,6 +24,29 @@ export function resolveWorkflowTestOptions(options) {
|
|
|
24
24
|
};
|
|
25
25
|
}
|
|
26
26
|
export function readProvidedWorkflowTestOptions(value) {
|
|
27
|
-
return resolveWorkflowTestOptions(value);
|
|
27
|
+
return resolveWorkflowTestOptions(value, process.cwd());
|
|
28
28
|
}
|
|
29
|
-
|
|
29
|
+
/**
|
|
30
|
+
* Options the most recent `buildWorkflowTests()` / `setupWorkflowTests()` call
|
|
31
|
+
* resolved, so helpers that run inside a test and take no options of their own
|
|
32
|
+
* (such as `getWorkflowRef()`) look in the same directories the plugin used.
|
|
33
|
+
*
|
|
34
|
+
* Module scope is fine here: `@workflow/vitest` runs in the test runner's
|
|
35
|
+
* process, not inside a bundled host server, so there is no per-bundler-layer
|
|
36
|
+
* duplication of this module to worry about.
|
|
37
|
+
*/
|
|
38
|
+
let activeOptions;
|
|
39
|
+
export function setActiveWorkflowTestOptions(options) {
|
|
40
|
+
activeOptions = options;
|
|
41
|
+
}
|
|
42
|
+
/**
|
|
43
|
+
* The options in force for this process, falling back to the defaults for
|
|
44
|
+
* `process.cwd()` when nothing has been set up yet.
|
|
45
|
+
*/
|
|
46
|
+
export function getActiveWorkflowTestOptions() {
|
|
47
|
+
return activeOptions ?? resolveWorkflowTestOptions(undefined, process.cwd());
|
|
48
|
+
}
|
|
49
|
+
export function clearActiveWorkflowTestOptions() {
|
|
50
|
+
activeOptions = undefined;
|
|
51
|
+
}
|
|
52
|
+
//# sourceMappingURL=data:application/json;base64,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
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Version-skew guard for the Vitest test setup.
|
|
3
|
+
*
|
|
4
|
+
* `@workflow/vitest` builds and runs your workflows against the copy of
|
|
5
|
+
* `@workflow/core` it was installed with, not the one your app imports. When
|
|
6
|
+
* the two copies disagree the failures are indirect (a run that never starts,
|
|
7
|
+
* a world that is set on the wrong module instance, a serialization format the
|
|
8
|
+
* other side does not understand), so check the versions up front and say what
|
|
9
|
+
* to install instead.
|
|
10
|
+
*
|
|
11
|
+
* The common way to get here: Workflow 5 is published under the `beta` npm
|
|
12
|
+
* tag, so `npm i -D @workflow/vitest` installs the 4.x line next to a v5 app.
|
|
13
|
+
*/
|
|
14
|
+
/** Environment variable that turns the check off entirely. */
|
|
15
|
+
export declare const VERSION_CHECK_ENV_VAR = "WORKFLOW_VITEST_VERSION_CHECK";
|
|
16
|
+
/** A Workflow package as some directory resolves it. */
|
|
17
|
+
export interface ResolvedPackage {
|
|
18
|
+
name: string;
|
|
19
|
+
version: string;
|
|
20
|
+
/** Directory containing the package's `package.json`. */
|
|
21
|
+
dir: string;
|
|
22
|
+
}
|
|
23
|
+
/** The packages the skew check compares. */
|
|
24
|
+
export interface WorkflowVersions {
|
|
25
|
+
/** `@workflow/core` as `@workflow/vitest` resolves it. */
|
|
26
|
+
harnessCore?: ResolvedPackage;
|
|
27
|
+
/** `@workflow/core` as the project under test resolves it. */
|
|
28
|
+
appCore?: ResolvedPackage;
|
|
29
|
+
/** `@workflow/vitest` itself. */
|
|
30
|
+
vitest?: ResolvedPackage;
|
|
31
|
+
/** The `workflow` package the project depends on, when it has one. */
|
|
32
|
+
appSdk?: ResolvedPackage;
|
|
33
|
+
}
|
|
34
|
+
export interface VersionSkewReport {
|
|
35
|
+
/** `error` fails the test run; `warning` is logged and testing continues. */
|
|
36
|
+
severity: 'error' | 'warning';
|
|
37
|
+
message: string;
|
|
38
|
+
}
|
|
39
|
+
/**
|
|
40
|
+
* Resolve a package as `fromDir` would resolve it, without importing it.
|
|
41
|
+
* Returns `undefined` when the package is not installed there.
|
|
42
|
+
*/
|
|
43
|
+
export declare function resolvePackageFrom(name: string, fromDir: string): ResolvedPackage | undefined;
|
|
44
|
+
/**
|
|
45
|
+
* Collect the versions the skew check compares.
|
|
46
|
+
*
|
|
47
|
+
* @param cwd - Root of the project under test.
|
|
48
|
+
*/
|
|
49
|
+
export declare function collectWorkflowVersions(cwd: string): WorkflowVersions;
|
|
50
|
+
/**
|
|
51
|
+
* Compare the resolved versions and describe the problem, if there is one.
|
|
52
|
+
*
|
|
53
|
+
* Pure: takes what {@link collectWorkflowVersions} found and returns the
|
|
54
|
+
* report, so the policy can be tested without a node_modules tree.
|
|
55
|
+
*/
|
|
56
|
+
export declare function describeVersionSkew(versions: WorkflowVersions): VersionSkewReport | undefined;
|
|
57
|
+
/**
|
|
58
|
+
* Run the skew check for a project. Throws on an incompatible pair, warns on
|
|
59
|
+
* a version mismatch within one major, and is a no-op otherwise.
|
|
60
|
+
*
|
|
61
|
+
* Called from `buildWorkflowTests()` (Vitest `globalSetup`) so the report is
|
|
62
|
+
* produced once per run rather than once per worker.
|
|
63
|
+
*/
|
|
64
|
+
export declare function checkWorkflowVersionSkew({ cwd, env, warn, collect, }: {
|
|
65
|
+
cwd: string;
|
|
66
|
+
env?: NodeJS.ProcessEnv;
|
|
67
|
+
warn?: (message: string) => void;
|
|
68
|
+
/** Seam for tests: where the resolved versions come from. */
|
|
69
|
+
collect?: (cwd: string) => WorkflowVersions;
|
|
70
|
+
}): VersionSkewReport | undefined;
|
|
71
|
+
//# sourceMappingURL=version-check.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"version-check.d.ts","sourceRoot":"","sources":["../src/version-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB,kCAAkC,CAAC;AAErE,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,4CAA4C;AAC5C,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,8DAA8D;IAC9D,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,iCAAiC;IACjC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,sEAAsE;IACtE,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAoCD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,eAAe,GAAG,SAAS,CAQ7B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAerE;AAwBD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,gBAAgB,GACzB,iBAAiB,GAAG,SAAS,CA6C/B;AAOD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,GAAG,EACH,GAAiB,EACjB,IAAiD,EACjD,OAAiC,GAClC,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,6DAA6D;IAC7D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,gBAAgB,CAAC;CAC7C,GAAG,iBAAiB,GAAG,SAAS,CAWhC"}
|
|
@@ -0,0 +1,168 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Version-skew guard for the Vitest test setup.
|
|
3
|
+
*
|
|
4
|
+
* `@workflow/vitest` builds and runs your workflows against the copy of
|
|
5
|
+
* `@workflow/core` it was installed with, not the one your app imports. When
|
|
6
|
+
* the two copies disagree the failures are indirect (a run that never starts,
|
|
7
|
+
* a world that is set on the wrong module instance, a serialization format the
|
|
8
|
+
* other side does not understand), so check the versions up front and say what
|
|
9
|
+
* to install instead.
|
|
10
|
+
*
|
|
11
|
+
* The common way to get here: Workflow 5 is published under the `beta` npm
|
|
12
|
+
* tag, so `npm i -D @workflow/vitest` installs the 4.x line next to a v5 app.
|
|
13
|
+
*/
|
|
14
|
+
import { readFileSync } from 'node:fs';
|
|
15
|
+
import { createRequire } from 'node:module';
|
|
16
|
+
import { dirname, join, parse } from 'node:path';
|
|
17
|
+
import { fileURLToPath } from 'node:url';
|
|
18
|
+
/** Environment variable that turns the check off entirely. */
|
|
19
|
+
export const VERSION_CHECK_ENV_VAR = 'WORKFLOW_VITEST_VERSION_CHECK';
|
|
20
|
+
function readPackageJson(packageJsonPath) {
|
|
21
|
+
try {
|
|
22
|
+
return JSON.parse(readFileSync(packageJsonPath, 'utf8'));
|
|
23
|
+
}
|
|
24
|
+
catch {
|
|
25
|
+
return undefined;
|
|
26
|
+
}
|
|
27
|
+
}
|
|
28
|
+
/**
|
|
29
|
+
* Walk up from a resolved module file to the `package.json` of the package
|
|
30
|
+
* that owns it. Package `exports` maps routinely omit `./package.json`, so
|
|
31
|
+
* resolving the subpath directly is not reliable.
|
|
32
|
+
*/
|
|
33
|
+
function readOwningPackage(moduleFile, expectedName) {
|
|
34
|
+
let dir = dirname(moduleFile);
|
|
35
|
+
const { root } = parse(dir);
|
|
36
|
+
while (true) {
|
|
37
|
+
const pkg = readPackageJson(join(dir, 'package.json'));
|
|
38
|
+
if (pkg?.name === expectedName && pkg.version) {
|
|
39
|
+
return { name: pkg.name, version: pkg.version, dir };
|
|
40
|
+
}
|
|
41
|
+
if (dir === root)
|
|
42
|
+
return undefined;
|
|
43
|
+
const parent = dirname(dir);
|
|
44
|
+
if (parent === dir)
|
|
45
|
+
return undefined;
|
|
46
|
+
dir = parent;
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
/**
|
|
50
|
+
* Resolve a package as `fromDir` would resolve it, without importing it.
|
|
51
|
+
* Returns `undefined` when the package is not installed there.
|
|
52
|
+
*/
|
|
53
|
+
export function resolvePackageFrom(name, fromDir) {
|
|
54
|
+
let entry;
|
|
55
|
+
try {
|
|
56
|
+
entry = createRequire(join(fromDir, 'noop.js')).resolve(name);
|
|
57
|
+
}
|
|
58
|
+
catch {
|
|
59
|
+
return undefined;
|
|
60
|
+
}
|
|
61
|
+
return readOwningPackage(entry, name);
|
|
62
|
+
}
|
|
63
|
+
/**
|
|
64
|
+
* Collect the versions the skew check compares.
|
|
65
|
+
*
|
|
66
|
+
* @param cwd - Root of the project under test.
|
|
67
|
+
*/
|
|
68
|
+
export function collectWorkflowVersions(cwd) {
|
|
69
|
+
const here = dirname(fileURLToPath(import.meta.url));
|
|
70
|
+
const vitest = readOwningPackage(join(here, 'index.js'), '@workflow/vitest');
|
|
71
|
+
const harnessCore = resolvePackageFrom('@workflow/core', here);
|
|
72
|
+
// Under pnpm's strict layout `@workflow/core` is not reachable from an app
|
|
73
|
+
// that only depends on `workflow`, so go through `workflow` first and fall
|
|
74
|
+
// back to a direct resolution for hoisted installs (and apps that depend on
|
|
75
|
+
// `@workflow/core` on purpose).
|
|
76
|
+
const appSdk = resolvePackageFrom('workflow', cwd);
|
|
77
|
+
const appCore = (appSdk ? resolvePackageFrom('@workflow/core', appSdk.dir) : undefined) ??
|
|
78
|
+
resolvePackageFrom('@workflow/core', cwd);
|
|
79
|
+
return { harnessCore, appCore, vitest, appSdk };
|
|
80
|
+
}
|
|
81
|
+
function majorOf(version) {
|
|
82
|
+
const match = /^(\d+)(?:\.|$)/.exec(version);
|
|
83
|
+
return match ? Number(match[1]) : undefined;
|
|
84
|
+
}
|
|
85
|
+
function describePackage(label, core, via) {
|
|
86
|
+
const suffix = via ? ` (via ${via.name} ${via.version})` : '';
|
|
87
|
+
return ` ${label} @workflow/core ${core.version}${suffix}\n${' '.repeat(label.length + 3)}${core.dir}`;
|
|
88
|
+
}
|
|
89
|
+
function installHint(appCoreVersion) {
|
|
90
|
+
const major = majorOf(appCoreVersion);
|
|
91
|
+
// Workflow 5 only exists on the `beta` tag; the 4.x line is `latest`.
|
|
92
|
+
return major !== undefined && major >= 5
|
|
93
|
+
? 'npm i -D @workflow/vitest@beta'
|
|
94
|
+
: 'npm i -D @workflow/vitest@latest';
|
|
95
|
+
}
|
|
96
|
+
/**
|
|
97
|
+
* Compare the resolved versions and describe the problem, if there is one.
|
|
98
|
+
*
|
|
99
|
+
* Pure: takes what {@link collectWorkflowVersions} found and returns the
|
|
100
|
+
* report, so the policy can be tested without a node_modules tree.
|
|
101
|
+
*/
|
|
102
|
+
export function describeVersionSkew(versions) {
|
|
103
|
+
const { appCore, harnessCore, vitest, appSdk } = versions;
|
|
104
|
+
// Nothing to compare: either side missing means the failure (if any) will
|
|
105
|
+
// be a plain "cannot find module", which is already clear on its own.
|
|
106
|
+
if (!appCore || !harnessCore)
|
|
107
|
+
return undefined;
|
|
108
|
+
// The same install, or two copies that agree. Two copies of one version are
|
|
109
|
+
// not worth a warning: they run the same code.
|
|
110
|
+
if (appCore.dir === harnessCore.dir)
|
|
111
|
+
return undefined;
|
|
112
|
+
if (appCore.version === harnessCore.version)
|
|
113
|
+
return undefined;
|
|
114
|
+
const appMajor = majorOf(appCore.version);
|
|
115
|
+
const harnessMajor = majorOf(harnessCore.version);
|
|
116
|
+
// An unparseable version is not evidence of incompatibility, so treat it the
|
|
117
|
+
// way a matching major is treated: warn, and let the run continue.
|
|
118
|
+
const incompatible = appMajor !== undefined &&
|
|
119
|
+
harnessMajor !== undefined &&
|
|
120
|
+
appMajor !== harnessMajor;
|
|
121
|
+
const header = incompatible
|
|
122
|
+
? 'Incompatible Workflow SDK versions in the Vitest test setup.'
|
|
123
|
+
: 'Workflow SDK version mismatch in the Vitest test setup.';
|
|
124
|
+
const explanation = incompatible
|
|
125
|
+
? '@workflow/vitest builds and runs your workflows against its own copy of @workflow/core, so it has to be on the same major as the SDK your app imports.'
|
|
126
|
+
: 'Your app and the test harness load two different copies of @workflow/core. That usually still runs, but pin them to the same version to avoid surprises.';
|
|
127
|
+
return {
|
|
128
|
+
severity: incompatible ? 'error' : 'warning',
|
|
129
|
+
message: [
|
|
130
|
+
header,
|
|
131
|
+
'',
|
|
132
|
+
describePackage('app ', appCore, appSdk),
|
|
133
|
+
describePackage('test setup', harnessCore, vitest),
|
|
134
|
+
'',
|
|
135
|
+
explanation,
|
|
136
|
+
'',
|
|
137
|
+
'@workflow/vitest follows the same npm dist-tags as the rest of the SDK: `beta` for the Workflow 5 pre-releases, `latest` for the 4.x line.',
|
|
138
|
+
'',
|
|
139
|
+
` ${installHint(appCore.version)}`,
|
|
140
|
+
'',
|
|
141
|
+
`Set ${VERSION_CHECK_ENV_VAR}=off to skip this check.`,
|
|
142
|
+
].join('\n'),
|
|
143
|
+
};
|
|
144
|
+
}
|
|
145
|
+
function isDisabled(env) {
|
|
146
|
+
const value = env[VERSION_CHECK_ENV_VAR]?.trim().toLowerCase();
|
|
147
|
+
return value === 'off' || value === '0' || value === 'false';
|
|
148
|
+
}
|
|
149
|
+
/**
|
|
150
|
+
* Run the skew check for a project. Throws on an incompatible pair, warns on
|
|
151
|
+
* a version mismatch within one major, and is a no-op otherwise.
|
|
152
|
+
*
|
|
153
|
+
* Called from `buildWorkflowTests()` (Vitest `globalSetup`) so the report is
|
|
154
|
+
* produced once per run rather than once per worker.
|
|
155
|
+
*/
|
|
156
|
+
export function checkWorkflowVersionSkew({ cwd, env = process.env, warn = (message) => console.warn(message), collect = collectWorkflowVersions, }) {
|
|
157
|
+
if (isDisabled(env))
|
|
158
|
+
return undefined;
|
|
159
|
+
const report = describeVersionSkew(collect(cwd));
|
|
160
|
+
if (!report)
|
|
161
|
+
return undefined;
|
|
162
|
+
if (report.severity === 'error') {
|
|
163
|
+
throw new Error(report.message);
|
|
164
|
+
}
|
|
165
|
+
warn(report.message);
|
|
166
|
+
return report;
|
|
167
|
+
}
|
|
168
|
+
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-check.js","sourceRoot":"","sources":["../src/version-check.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Version-skew guard for the Vitest test setup.\n *\n * `@workflow/vitest` builds and runs your workflows against the copy of\n * `@workflow/core` it was installed with, not the one your app imports. When\n * the two copies disagree the failures are indirect (a run that never starts,\n * a world that is set on the wrong module instance, a serialization format the\n * other side does not understand), so check the versions up front and say what\n * to install instead.\n *\n * The common way to get here: Workflow 5 is published under the `beta` npm\n * tag, so `npm i -D @workflow/vitest` installs the 4.x line next to a v5 app.\n */\n\nimport { readFileSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport { dirname, join, parse } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\n/** Environment variable that turns the check off entirely. */\nexport const VERSION_CHECK_ENV_VAR = 'WORKFLOW_VITEST_VERSION_CHECK';\n\n/** A Workflow package as some directory resolves it. */\nexport interface ResolvedPackage {\n  name: string;\n  version: string;\n  /** Directory containing the package's `package.json`. */\n  dir: string;\n}\n\n/** The packages the skew check compares. */\nexport interface WorkflowVersions {\n  /** `@workflow/core` as `@workflow/vitest` resolves it. */\n  harnessCore?: ResolvedPackage;\n  /** `@workflow/core` as the project under test resolves it. */\n  appCore?: ResolvedPackage;\n  /** `@workflow/vitest` itself. */\n  vitest?: ResolvedPackage;\n  /** The `workflow` package the project depends on, when it has one. */\n  appSdk?: ResolvedPackage;\n}\n\nexport interface VersionSkewReport {\n  /** `error` fails the test run; `warning` is logged and testing continues. */\n  severity: 'error' | 'warning';\n  message: string;\n}\n\nfunction readPackageJson(\n  packageJsonPath: string\n): { name?: string; version?: string } | undefined {\n  try {\n    return JSON.parse(readFileSync(packageJsonPath, 'utf8'));\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Walk up from a resolved module file to the `package.json` of the package\n * that owns it. Package `exports` maps routinely omit `./package.json`, so\n * resolving the subpath directly is not reliable.\n */\nfunction readOwningPackage(\n  moduleFile: string,\n  expectedName: string\n): ResolvedPackage | undefined {\n  let dir = dirname(moduleFile);\n  const { root } = parse(dir);\n\n  while (true) {\n    const pkg = readPackageJson(join(dir, 'package.json'));\n    if (pkg?.name === expectedName && pkg.version) {\n      return { name: pkg.name, version: pkg.version, dir };\n    }\n    if (dir === root) return undefined;\n    const parent = dirname(dir);\n    if (parent === dir) return undefined;\n    dir = parent;\n  }\n}\n\n/**\n * Resolve a package as `fromDir` would resolve it, without importing it.\n * Returns `undefined` when the package is not installed there.\n */\nexport function resolvePackageFrom(\n  name: string,\n  fromDir: string\n): ResolvedPackage | undefined {\n  let entry: string;\n  try {\n    entry = createRequire(join(fromDir, 'noop.js')).resolve(name);\n  } catch {\n    return undefined;\n  }\n  return readOwningPackage(entry, name);\n}\n\n/**\n * Collect the versions the skew check compares.\n *\n * @param cwd - Root of the project under test.\n */\nexport function collectWorkflowVersions(cwd: string): WorkflowVersions {\n  const here = dirname(fileURLToPath(import.meta.url));\n  const vitest = readOwningPackage(join(here, 'index.js'), '@workflow/vitest');\n  const harnessCore = resolvePackageFrom('@workflow/core', here);\n\n  // Under pnpm's strict layout `@workflow/core` is not reachable from an app\n  // that only depends on `workflow`, so go through `workflow` first and fall\n  // back to a direct resolution for hoisted installs (and apps that depend on\n  // `@workflow/core` on purpose).\n  const appSdk = resolvePackageFrom('workflow', cwd);\n  const appCore =\n    (appSdk ? resolvePackageFrom('@workflow/core', appSdk.dir) : undefined) ??\n    resolvePackageFrom('@workflow/core', cwd);\n\n  return { harnessCore, appCore, vitest, appSdk };\n}\n\nfunction majorOf(version: string): number | undefined {\n  const match = /^(\\d+)(?:\\.|$)/.exec(version);\n  return match ? Number(match[1]) : undefined;\n}\n\nfunction describePackage(\n  label: string,\n  core: ResolvedPackage,\n  via: ResolvedPackage | undefined\n): string {\n  const suffix = via ? ` (via ${via.name} ${via.version})` : '';\n  return `  ${label} @workflow/core ${core.version}${suffix}\\n${' '.repeat(label.length + 3)}${core.dir}`;\n}\n\nfunction installHint(appCoreVersion: string): string {\n  const major = majorOf(appCoreVersion);\n  // Workflow 5 only exists on the `beta` tag; the 4.x line is `latest`.\n  return major !== undefined && major >= 5\n    ? 'npm i -D @workflow/vitest@beta'\n    : 'npm i -D @workflow/vitest@latest';\n}\n\n/**\n * Compare the resolved versions and describe the problem, if there is one.\n *\n * Pure: takes what {@link collectWorkflowVersions} found and returns the\n * report, so the policy can be tested without a node_modules tree.\n */\nexport function describeVersionSkew(\n  versions: WorkflowVersions\n): VersionSkewReport | undefined {\n  const { appCore, harnessCore, vitest, appSdk } = versions;\n\n  // Nothing to compare: either side missing means the failure (if any) will\n  // be a plain \"cannot find module\", which is already clear on its own.\n  if (!appCore || !harnessCore) return undefined;\n  // The same install, or two copies that agree. Two copies of one version are\n  // not worth a warning: they run the same code.\n  if (appCore.dir === harnessCore.dir) return undefined;\n  if (appCore.version === harnessCore.version) return undefined;\n\n  const appMajor = majorOf(appCore.version);\n  const harnessMajor = majorOf(harnessCore.version);\n  // An unparseable version is not evidence of incompatibility, so treat it the\n  // way a matching major is treated: warn, and let the run continue.\n  const incompatible =\n    appMajor !== undefined &&\n    harnessMajor !== undefined &&\n    appMajor !== harnessMajor;\n\n  const header = incompatible\n    ? 'Incompatible Workflow SDK versions in the Vitest test setup.'\n    : 'Workflow SDK version mismatch in the Vitest test setup.';\n\n  const explanation = incompatible\n    ? '@workflow/vitest builds and runs your workflows against its own copy of @workflow/core, so it has to be on the same major as the SDK your app imports.'\n    : 'Your app and the test harness load two different copies of @workflow/core. That usually still runs, but pin them to the same version to avoid surprises.';\n\n  return {\n    severity: incompatible ? 'error' : 'warning',\n    message: [\n      header,\n      '',\n      describePackage('app       ', appCore, appSdk),\n      describePackage('test setup', harnessCore, vitest),\n      '',\n      explanation,\n      '',\n      '@workflow/vitest follows the same npm dist-tags as the rest of the SDK: `beta` for the Workflow 5 pre-releases, `latest` for the 4.x line.',\n      '',\n      `  ${installHint(appCore.version)}`,\n      '',\n      `Set ${VERSION_CHECK_ENV_VAR}=off to skip this check.`,\n    ].join('\\n'),\n  };\n}\n\nfunction isDisabled(env: NodeJS.ProcessEnv): boolean {\n  const value = env[VERSION_CHECK_ENV_VAR]?.trim().toLowerCase();\n  return value === 'off' || value === '0' || value === 'false';\n}\n\n/**\n * Run the skew check for a project. Throws on an incompatible pair, warns on\n * a version mismatch within one major, and is a no-op otherwise.\n *\n * Called from `buildWorkflowTests()` (Vitest `globalSetup`) so the report is\n * produced once per run rather than once per worker.\n */\nexport function checkWorkflowVersionSkew({\n  cwd,\n  env = process.env,\n  warn = (message: string) => console.warn(message),\n  collect = collectWorkflowVersions,\n}: {\n  cwd: string;\n  env?: NodeJS.ProcessEnv;\n  warn?: (message: string) => void;\n  /** Seam for tests: where the resolved versions come from. */\n  collect?: (cwd: string) => WorkflowVersions;\n}): VersionSkewReport | undefined {\n  if (isDisabled(env)) return undefined;\n\n  const report = describeVersionSkew(collect(cwd));\n  if (!report) return undefined;\n\n  if (report.severity === 'error') {\n    throw new Error(report.message);\n  }\n  warn(report.message);\n  return report;\n}\n"]}
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Workflow references read from the manifest the test build already emits.
|
|
3
|
+
*
|
|
4
|
+
* `start()` accepts either an imported workflow function or the metadata
|
|
5
|
+
* object behind it (`{ workflowId }`). Importing the function is the better
|
|
6
|
+
* option when a test can do it, but some tests cannot: the workflow lives in a
|
|
7
|
+
* package the test does not import, the test drives a run by id, or the
|
|
8
|
+
* assertion is about the set of workflows a build produced. The fallback used
|
|
9
|
+
* to be hand-writing the generated id (`workflow//workflows/approval.ts//approvalWorkflow`),
|
|
10
|
+
* which is a compiler-owned string that changes when a file moves.
|
|
11
|
+
*
|
|
12
|
+
* `buildWorkflowTests()` writes the same `manifest.json` every other Workflow
|
|
13
|
+
* builder writes into the test output directory, and these helpers read it.
|
|
14
|
+
*/
|
|
15
|
+
/** Filename `BaseBuilder.createManifest()` writes into the output directory. */
|
|
16
|
+
export declare const MANIFEST_FILENAME = "manifest.json";
|
|
17
|
+
/**
|
|
18
|
+
* A workflow in the test build, in the shape `start()` accepts.
|
|
19
|
+
*
|
|
20
|
+
* @example
|
|
21
|
+
* ```ts
|
|
22
|
+
* const run = await start(getWorkflowRef("approvalWorkflow"), ["doc-1"]);
|
|
23
|
+
* ```
|
|
24
|
+
*/
|
|
25
|
+
export interface WorkflowRef {
|
|
26
|
+
/** Exported name of the workflow function. */
|
|
27
|
+
name: string;
|
|
28
|
+
/** Project-relative path of the file it was compiled from. */
|
|
29
|
+
file: string;
|
|
30
|
+
/** Generated workflow id, the field `start()` reads. */
|
|
31
|
+
workflowId: string;
|
|
32
|
+
}
|
|
33
|
+
/** Drop the parsed-manifest cache. Exported for tests. */
|
|
34
|
+
export declare function clearWorkflowRefCache(): void;
|
|
35
|
+
/**
|
|
36
|
+
* Read every workflow in the test build from `<outDir>/manifest.json`.
|
|
37
|
+
*/
|
|
38
|
+
export declare function readWorkflowRefs(outDir: string): WorkflowRef[];
|
|
39
|
+
/**
|
|
40
|
+
* Find one workflow among `refs`.
|
|
41
|
+
*
|
|
42
|
+
* `query` is either an exported workflow name (`"approvalWorkflow"`) or a
|
|
43
|
+
* file-qualified name (`"workflows/approval.ts#approvalWorkflow"`). The file
|
|
44
|
+
* part matches by path suffix, so `"approval.ts#approvalWorkflow"` also works.
|
|
45
|
+
*
|
|
46
|
+
* Pure, so the matching rules can be tested without a build.
|
|
47
|
+
*/
|
|
48
|
+
export declare function selectWorkflowRef(refs: WorkflowRef[], query: string): WorkflowRef;
|
|
49
|
+
//# sourceMappingURL=workflow-refs.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"workflow-refs.d.ts","sourceRoot":"","sources":["../src/workflow-refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;CACpB;AA4BD,0DAA0D;AAC1D,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAuC9D;AAaD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EAAE,EACnB,KAAK,EAAE,MAAM,GACZ,WAAW,CA8Cb"}
|
|
@@ -0,0 +1,131 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Workflow references read from the manifest the test build already emits.
|
|
3
|
+
*
|
|
4
|
+
* `start()` accepts either an imported workflow function or the metadata
|
|
5
|
+
* object behind it (`{ workflowId }`). Importing the function is the better
|
|
6
|
+
* option when a test can do it, but some tests cannot: the workflow lives in a
|
|
7
|
+
* package the test does not import, the test drives a run by id, or the
|
|
8
|
+
* assertion is about the set of workflows a build produced. The fallback used
|
|
9
|
+
* to be hand-writing the generated id (`workflow//workflows/approval.ts//approvalWorkflow`),
|
|
10
|
+
* which is a compiler-owned string that changes when a file moves.
|
|
11
|
+
*
|
|
12
|
+
* `buildWorkflowTests()` writes the same `manifest.json` every other Workflow
|
|
13
|
+
* builder writes into the test output directory, and these helpers read it.
|
|
14
|
+
*/
|
|
15
|
+
import { readFileSync, statSync } from 'node:fs';
|
|
16
|
+
import { join } from 'node:path';
|
|
17
|
+
/** Filename `BaseBuilder.createManifest()` writes into the output directory. */
|
|
18
|
+
export const MANIFEST_FILENAME = 'manifest.json';
|
|
19
|
+
function flattenManifest(manifest) {
|
|
20
|
+
const refs = [];
|
|
21
|
+
for (const [file, entries] of Object.entries(manifest.workflows ?? {})) {
|
|
22
|
+
for (const [name, entry] of Object.entries(entries ?? {})) {
|
|
23
|
+
if (entry?.workflowId) {
|
|
24
|
+
refs.push({ name, file, workflowId: entry.workflowId });
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
}
|
|
28
|
+
return refs.sort((a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name));
|
|
29
|
+
}
|
|
30
|
+
// Keyed on the manifest's mtime so a watch-mode rebuild is picked up: the
|
|
31
|
+
// worker process outlives the build that wrote the file it read.
|
|
32
|
+
const cache = new Map();
|
|
33
|
+
/** Drop the parsed-manifest cache. Exported for tests. */
|
|
34
|
+
export function clearWorkflowRefCache() {
|
|
35
|
+
cache.clear();
|
|
36
|
+
}
|
|
37
|
+
/**
|
|
38
|
+
* Read every workflow in the test build from `<outDir>/manifest.json`.
|
|
39
|
+
*/
|
|
40
|
+
export function readWorkflowRefs(outDir) {
|
|
41
|
+
const manifestPath = join(outDir, MANIFEST_FILENAME);
|
|
42
|
+
let mtimeMs;
|
|
43
|
+
try {
|
|
44
|
+
mtimeMs = statSync(manifestPath).mtimeMs;
|
|
45
|
+
}
|
|
46
|
+
catch {
|
|
47
|
+
// Fall through to the read below, which reports the missing manifest.
|
|
48
|
+
}
|
|
49
|
+
const cached = cache.get(manifestPath);
|
|
50
|
+
if (cached && mtimeMs !== undefined && cached.mtimeMs === mtimeMs) {
|
|
51
|
+
return cached.refs;
|
|
52
|
+
}
|
|
53
|
+
let contents;
|
|
54
|
+
try {
|
|
55
|
+
contents = readFileSync(manifestPath, 'utf8');
|
|
56
|
+
}
|
|
57
|
+
catch {
|
|
58
|
+
throw new Error(`Workflow test manifest not found at ${manifestPath}. ` +
|
|
59
|
+
'Workflow references are read from the manifest written by the test build, so ' +
|
|
60
|
+
'the workflow() Vitest plugin (or buildWorkflowTests() in globalSetup) has to run first.');
|
|
61
|
+
}
|
|
62
|
+
let parsed;
|
|
63
|
+
try {
|
|
64
|
+
parsed = JSON.parse(contents);
|
|
65
|
+
}
|
|
66
|
+
catch (error) {
|
|
67
|
+
throw new Error(`Workflow test manifest at ${manifestPath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
|
|
68
|
+
}
|
|
69
|
+
const refs = flattenManifest(parsed);
|
|
70
|
+
if (mtimeMs !== undefined)
|
|
71
|
+
cache.set(manifestPath, { mtimeMs, refs });
|
|
72
|
+
return refs;
|
|
73
|
+
}
|
|
74
|
+
function formatQualifiedName(ref) {
|
|
75
|
+
return `${ref.file}#${ref.name}`;
|
|
76
|
+
}
|
|
77
|
+
function formatCandidates(refs, limit = 20) {
|
|
78
|
+
const shown = refs.slice(0, limit).map(formatQualifiedName);
|
|
79
|
+
const remaining = refs.length - shown.length;
|
|
80
|
+
if (remaining > 0)
|
|
81
|
+
shown.push(`…and ${remaining} more`);
|
|
82
|
+
return shown.length > 0 ? shown.join(', ') : '(none)';
|
|
83
|
+
}
|
|
84
|
+
/**
|
|
85
|
+
* Find one workflow among `refs`.
|
|
86
|
+
*
|
|
87
|
+
* `query` is either an exported workflow name (`"approvalWorkflow"`) or a
|
|
88
|
+
* file-qualified name (`"workflows/approval.ts#approvalWorkflow"`). The file
|
|
89
|
+
* part matches by path suffix, so `"approval.ts#approvalWorkflow"` also works.
|
|
90
|
+
*
|
|
91
|
+
* Pure, so the matching rules can be tested without a build.
|
|
92
|
+
*/
|
|
93
|
+
export function selectWorkflowRef(refs, query) {
|
|
94
|
+
const separator = query.lastIndexOf('#');
|
|
95
|
+
const name = separator === -1 ? query : query.slice(separator + 1);
|
|
96
|
+
const file = separator === -1 ? undefined : query.slice(0, separator);
|
|
97
|
+
let matches = refs.filter((ref) => ref.name === name);
|
|
98
|
+
if (file !== undefined) {
|
|
99
|
+
const normalized = file.replace(/^\.\//, '');
|
|
100
|
+
// An exact path always wins. A suffix is a convenience for the common
|
|
101
|
+
// case, but on its own it would make the full manifest path — the one the
|
|
102
|
+
// ambiguity error tells you to use — ambiguous again whenever a shorter
|
|
103
|
+
// path is a suffix of a longer one.
|
|
104
|
+
const exact = matches.filter((ref) => ref.file === normalized);
|
|
105
|
+
matches =
|
|
106
|
+
exact.length > 0
|
|
107
|
+
? exact
|
|
108
|
+
: matches.filter((ref) => ref.file.endsWith(`/${normalized}`));
|
|
109
|
+
}
|
|
110
|
+
if (matches.length === 1)
|
|
111
|
+
return matches[0];
|
|
112
|
+
if (matches.length === 0) {
|
|
113
|
+
// Alphabetical order buries the likely intent once a project has more
|
|
114
|
+
// workflows than the list shows, so lead with near misses on the name.
|
|
115
|
+
const needle = name.toLowerCase();
|
|
116
|
+
const suggestions = refs.filter((ref) => {
|
|
117
|
+
const candidate = ref.name.toLowerCase();
|
|
118
|
+
return candidate.includes(needle) || needle.includes(candidate);
|
|
119
|
+
});
|
|
120
|
+
const didYouMean = suggestions.length > 0
|
|
121
|
+
? ` Did you mean: ${formatCandidates(suggestions, 5)}?`
|
|
122
|
+
: '';
|
|
123
|
+
throw new Error(`No workflow matching "${query}" was found in the test build.${didYouMean} ` +
|
|
124
|
+
`Workflows in this build: ${formatCandidates(refs)}.`);
|
|
125
|
+
}
|
|
126
|
+
throw new Error(`"${query}" matches ${matches.length} workflows in the test build: ` +
|
|
127
|
+
`${formatCandidates(matches)}. ` +
|
|
128
|
+
'Pass a file-qualified name, for example getWorkflowRef("' +
|
|
129
|
+
`${formatQualifiedName(matches[0])}").`);
|
|
130
|
+
}
|
|
131
|
+
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-refs.js","sourceRoot":"","sources":["../src/workflow-refs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Workflow references read from the manifest the test build already emits.\n *\n * `start()` accepts either an imported workflow function or the metadata\n * object behind it (`{ workflowId }`). Importing the function is the better\n * option when a test can do it, but some tests cannot: the workflow lives in a\n * package the test does not import, the test drives a run by id, or the\n * assertion is about the set of workflows a build produced. The fallback used\n * to be hand-writing the generated id (`workflow//workflows/approval.ts//approvalWorkflow`),\n * which is a compiler-owned string that changes when a file moves.\n *\n * `buildWorkflowTests()` writes the same `manifest.json` every other Workflow\n * builder writes into the test output directory, and these helpers read it.\n */\n\nimport { readFileSync, statSync } from 'node:fs';\nimport { join } from 'node:path';\n\n/** Filename `BaseBuilder.createManifest()` writes into the output directory. */\nexport const MANIFEST_FILENAME = 'manifest.json';\n\n/**\n * A workflow in the test build, in the shape `start()` accepts.\n *\n * @example\n * ```ts\n * const run = await start(getWorkflowRef(\"approvalWorkflow\"), [\"doc-1\"]);\n * ```\n */\nexport interface WorkflowRef {\n  /** Exported name of the workflow function. */\n  name: string;\n  /** Project-relative path of the file it was compiled from. */\n  file: string;\n  /** Generated workflow id, the field `start()` reads. */\n  workflowId: string;\n}\n\ntype ManifestShape = {\n  workflows?: {\n    [file: string]: {\n      [name: string]: { workflowId?: string };\n    };\n  };\n};\n\nfunction flattenManifest(manifest: ManifestShape): WorkflowRef[] {\n  const refs: WorkflowRef[] = [];\n  for (const [file, entries] of Object.entries(manifest.workflows ?? {})) {\n    for (const [name, entry] of Object.entries(entries ?? {})) {\n      if (entry?.workflowId) {\n        refs.push({ name, file, workflowId: entry.workflowId });\n      }\n    }\n  }\n  return refs.sort(\n    (a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name)\n  );\n}\n\n// Keyed on the manifest's mtime so a watch-mode rebuild is picked up: the\n// worker process outlives the build that wrote the file it read.\nconst cache = new Map<string, { mtimeMs: number; refs: WorkflowRef[] }>();\n\n/** Drop the parsed-manifest cache. Exported for tests. */\nexport function clearWorkflowRefCache(): void {\n  cache.clear();\n}\n\n/**\n * Read every workflow in the test build from `<outDir>/manifest.json`.\n */\nexport function readWorkflowRefs(outDir: string): WorkflowRef[] {\n  const manifestPath = join(outDir, MANIFEST_FILENAME);\n  let mtimeMs: number | undefined;\n  try {\n    mtimeMs = statSync(manifestPath).mtimeMs;\n  } catch {\n    // Fall through to the read below, which reports the missing manifest.\n  }\n\n  const cached = cache.get(manifestPath);\n  if (cached && mtimeMs !== undefined && cached.mtimeMs === mtimeMs) {\n    return cached.refs;\n  }\n\n  let contents: string;\n  try {\n    contents = readFileSync(manifestPath, 'utf8');\n  } catch {\n    throw new Error(\n      `Workflow test manifest not found at ${manifestPath}. ` +\n        'Workflow references are read from the manifest written by the test build, so ' +\n        'the workflow() Vitest plugin (or buildWorkflowTests() in globalSetup) has to run first.'\n    );\n  }\n\n  let parsed: ManifestShape;\n  try {\n    parsed = JSON.parse(contents);\n  } catch (error) {\n    throw new Error(\n      `Workflow test manifest at ${manifestPath} is not valid JSON: ${\n        error instanceof Error ? error.message : String(error)\n      }`\n    );\n  }\n\n  const refs = flattenManifest(parsed);\n  if (mtimeMs !== undefined) cache.set(manifestPath, { mtimeMs, refs });\n  return refs;\n}\n\nfunction formatQualifiedName(ref: WorkflowRef): string {\n  return `${ref.file}#${ref.name}`;\n}\n\nfunction formatCandidates(refs: WorkflowRef[], limit = 20): string {\n  const shown = refs.slice(0, limit).map(formatQualifiedName);\n  const remaining = refs.length - shown.length;\n  if (remaining > 0) shown.push(`…and ${remaining} more`);\n  return shown.length > 0 ? shown.join(', ') : '(none)';\n}\n\n/**\n * Find one workflow among `refs`.\n *\n * `query` is either an exported workflow name (`\"approvalWorkflow\"`) or a\n * file-qualified name (`\"workflows/approval.ts#approvalWorkflow\"`). The file\n * part matches by path suffix, so `\"approval.ts#approvalWorkflow\"` also works.\n *\n * Pure, so the matching rules can be tested without a build.\n */\nexport function selectWorkflowRef(\n  refs: WorkflowRef[],\n  query: string\n): WorkflowRef {\n  const separator = query.lastIndexOf('#');\n  const name = separator === -1 ? query : query.slice(separator + 1);\n  const file = separator === -1 ? undefined : query.slice(0, separator);\n\n  let matches = refs.filter((ref) => ref.name === name);\n  if (file !== undefined) {\n    const normalized = file.replace(/^\\.\\//, '');\n    // An exact path always wins. A suffix is a convenience for the common\n    // case, but on its own it would make the full manifest path — the one the\n    // ambiguity error tells you to use — ambiguous again whenever a shorter\n    // path is a suffix of a longer one.\n    const exact = matches.filter((ref) => ref.file === normalized);\n    matches =\n      exact.length > 0\n        ? exact\n        : matches.filter((ref) => ref.file.endsWith(`/${normalized}`));\n  }\n\n  if (matches.length === 1) return matches[0];\n\n  if (matches.length === 0) {\n    // Alphabetical order buries the likely intent once a project has more\n    // workflows than the list shows, so lead with near misses on the name.\n    const needle = name.toLowerCase();\n    const suggestions = refs.filter((ref) => {\n      const candidate = ref.name.toLowerCase();\n      return candidate.includes(needle) || needle.includes(candidate);\n    });\n    const didYouMean =\n      suggestions.length > 0\n        ? ` Did you mean: ${formatCandidates(suggestions, 5)}?`\n        : '';\n\n    throw new Error(\n      `No workflow matching \"${query}\" was found in the test build.${didYouMean} ` +\n        `Workflows in this build: ${formatCandidates(refs)}.`\n    );\n  }\n\n  throw new Error(\n    `\"${query}\" matches ${matches.length} workflows in the test build: ` +\n      `${formatCandidates(matches)}. ` +\n      'Pass a file-qualified name, for example getWorkflowRef(\"' +\n      `${formatQualifiedName(matches[0])}\").`\n  );\n}\n"]}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@workflow/vitest",
|
|
3
|
-
"version": "5.0.0
|
|
3
|
+
"version": "5.0.0",
|
|
4
4
|
"description": "Vitest plugin for testing Workflow SDK workflows",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "./dist/index.js",
|
|
@@ -24,21 +24,22 @@
|
|
|
24
24
|
"directory": "packages/vitest"
|
|
25
25
|
},
|
|
26
26
|
"dependencies": {
|
|
27
|
-
"@workflow/builders": "5.0.0
|
|
28
|
-
"@workflow/core": "5.0.0
|
|
29
|
-
"@workflow/rollup": "5.0.0
|
|
30
|
-
"@workflow/world": "5.0.0
|
|
31
|
-
"@workflow/world-local": "5.0.0
|
|
27
|
+
"@workflow/builders": "5.0.0",
|
|
28
|
+
"@workflow/core": "5.0.0",
|
|
29
|
+
"@workflow/rollup": "5.0.0",
|
|
30
|
+
"@workflow/world": "5.0.0",
|
|
31
|
+
"@workflow/world-local": "5.0.0"
|
|
32
32
|
},
|
|
33
33
|
"devDependencies": {
|
|
34
34
|
"@types/node": "22.19.0",
|
|
35
|
-
"
|
|
36
|
-
"
|
|
37
|
-
"
|
|
35
|
+
"@workflow/tsconfig": "5.0.0",
|
|
36
|
+
"typescript": "^6.0.3",
|
|
37
|
+
"vite": "7.3.6",
|
|
38
|
+
"vitest": "^4.1.10"
|
|
38
39
|
},
|
|
39
40
|
"peerDependencies": {
|
|
40
41
|
"vite": ">=6.0.0",
|
|
41
|
-
"vitest": ">=3.
|
|
42
|
+
"vitest": ">=3.1.0"
|
|
42
43
|
},
|
|
43
44
|
"peerDependenciesMeta": {
|
|
44
45
|
"vite": {
|