vest 6.0.0 → 6.0.2

package/src/exports/SuiteSerializer.ts

@@ -16,7 +16,7 @@ type Dumpable = {
 
 export class SuiteSerializer {
   static serialize(suite: Dumpable) {
-    const dump = { ...suite.dump() };
+    const dump = stripMessageFromPassingTests(suite.dump());
 
     return IsolateSerializer.serialize(dump, suiteSerializerReplacer);
   }
@@ -50,6 +50,109 @@ export class SuiteSerializer {
   }
 }
 
+function stripMessageFromPassingTests<T>(node: T): T {
+  const visited = new WeakMap<object, any>();
+  const containsPassingMemo = new WeakMap<object, boolean>();
+  const seen = new WeakSet<object>();
+
+  return strip(node, visited, containsPassingMemo, seen);
+}
+
+// eslint-disable-next-line complexity, max-statements
+function strip<T>(
+  node: T,
+  visited: WeakMap<object, any>,
+  containsPassingMemo: WeakMap<object, boolean>,
+  seen: WeakSet<object>,
+): T {
+  if (!node || typeof node !== 'object') {
+    return node;
+  }
+
+  if (visited.has(node as object)) {
+    return visited.get(node as object);
+  }
+
+  if (!containsPassing(node, seen, containsPassingMemo)) {
+    return node;
+  }
+
+  if (Array.isArray(node)) {
+    const arr: any[] = [];
+    visited.set(node, arr);
+
+    node.forEach(value => {
+      arr.push(strip(value, visited, containsPassingMemo, seen));
+    });
+
+    return arr as T;
+  }
+
+  const root = node as Record<string, any>;
+  const shouldStripMessage = root.testStatus === TestStatus.PASSING;
+  const clonedNode: Record<string, any> = {};
+  visited.set(node, clonedNode);
+
+  for (const [key, value] of Object.entries(root)) {
+    if (shouldStripMessage && key === 'message') {
+      continue;
+    }
+
+    clonedNode[key] = strip(value, visited, containsPassingMemo, seen);
+  }
+
+  return clonedNode as T;
+}
+
+// `strip` calls this with a shared `seen` set that is expected to be empty
+// at call boundaries. Inside this DFS, revisiting a node (`seen.has(node)`) means
+// we've encountered a cycle currently in-flight, so we conservatively return `true`
+// to avoid suppressing message-stripping while still preventing infinite recursion.
+// This is safe because every path that adds to `seen` removes it (`seen.delete`) on
+// return, and `memo` only stores final computed booleans for completed nodes.
+// eslint-disable-next-line complexity, max-statements
+function containsPassing(
+  node: unknown,
+  seen: WeakSet<object>,
+  memo: WeakMap<object, boolean>,
+): boolean {
+  if (!node || typeof node !== 'object') {
+    return false;
+  }
+
+  if (memo.has(node)) {
+    return memo.get(node) ?? false;
+  }
+
+  if (seen.has(node)) {
+    return true;
+  }
+
+  if ((node as Record<string, unknown>).testStatus === TestStatus.PASSING) {
+    memo.set(node, true);
+    return true;
+  }
+
+  seen.add(node);
+
+  const values = Array.isArray(node)
+    ? node
+    : Object.values(node as Record<string, unknown>);
+
+  for (const value of values) {
+    if (containsPassing(value, seen, memo)) {
+      memo.set(node, true);
+      seen.delete(node);
+      return true;
+    }
+  }
+
+  memo.set(node, false);
+  seen.delete(node);
+
+  return false;
+}
+
 function suiteSerializerReplacer(value: any, key: string) {
   if (isStatusKey(key)) {
     return getAllowedStatus(value);

package/src/exports/__tests__/SuiteSerializer.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, expectTypeOf } from 'vitest';
 
 import { SuiteSerializer } from '../SuiteSerializer';
 import * as vest from '../../vest';
@@ -26,6 +26,35 @@ describe('SuiteSerializer', () => {
     const serialized = SuiteSerializer.serialize(suite);
     expect(serialized).toMatchSnapshot();
   });
+
+  it('should strip message from passing tests only', () => {
+    const suite = vest.create(() => {
+      vest.test('passing_field', 'passing_field_message', () => true);
+      vest.test('failing_field', 'failing_field_message', () => false);
+    });
+
+    suite.run();
+
+    const serialized = SuiteSerializer.serialize(suite);
+    const parsed = SuiteSerializer.deserialize(serialized);
+
+    expect(parsed.children).toBeDefined();
+
+    const testChildren = parsed.children?.filter(child => child.data.fieldName);
+    expect(testChildren).toHaveLength(2);
+
+    const passingTest = testChildren?.find(
+      child => child.data.fieldName === 'passing_field',
+    );
+    const failingTest = testChildren?.find(
+      child => child.data.fieldName === 'failing_field',
+    );
+
+    expect(passingTest).toBeDefined();
+    expect(failingTest).toBeDefined();
+    expect(passingTest?.data).not.toHaveProperty('message');
+    expect(failingTest?.data.message).toBe('failing_field_message');
+  });
 });
 
 describe('suite.resume', () => {
@@ -117,3 +146,31 @@ describe('suite.resume', () => {
     });
   });
 });
+
+describe('SuiteSerializer type-compatibility', () => {
+  it('accepts schema-typed suites in resume()', () => {
+    const schema = vest.enforce.shape({
+      username: vest.enforce.isString(),
+    });
+
+    const suite = vest.create(data => {
+      vest.test('username', () => {
+        vest.enforce(data.username).isNotBlank();
+      });
+    }, schema);
+
+    suite.run({ username: '' });
+
+    const serialized = SuiteSerializer.serialize(suite);
+
+    const suite2 = vest.create(data => {
+      vest.test('username', () => {
+        vest.enforce(data.username).isNotBlank();
+      });
+    }, schema);
+
+    expectTypeOf(SuiteSerializer.resume).toBeFunction();
+    SuiteSerializer.resume(suite2, serialized);
+    expect(suite2.hasErrors('username')).toBe(true);
+  });
+});

package/src/exports/__tests__/classnames.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, expectTypeOf, vi } from 'vitest';
 
 import { dummyTest } from '../../testUtils/testDummy';
 import classnames from '../classnames';
@@ -60,6 +60,29 @@ describe('Utility: classnames', () => {
     expect(cn('travelerName')).toContain('invalid');
   });
 
+  it('accepts schema-typed suite results from suite.run() and preserves parser output type', () => {
+    const typedSuite = vest.create(
+      data => {
+        vest.test('travelerName', 'Traveler name is required', () => {
+          vest.enforce(data.travelerName).isNotBlank();
+        });
+      },
+      vest.enforce.shape({
+        travelerName: vest.enforce.isString(),
+      }),
+    );
+
+    const result = typedSuite.run({ travelerName: '' });
+
+    const cn = classnames(result, {
+      warning: 'warning',
+      invalid: 'invalid',
+    });
+
+    expectTypeOf(cn).toEqualTypeOf<(fieldName: string) => string>();
+    expect(cn('travelerName')).toContain('invalid');
+  });
+
   const suite = vest.create(() => {
     vest.mode(Modes.ALL);
     vest.skip('field_1');

package/src/exports/__tests__/parser.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, expectTypeOf } from 'vitest';
 
 import * as suiteDummy from '../../testUtils/suiteDummy';
 import { ser } from '../../testUtils/suiteDummy';
@@ -501,3 +501,25 @@ describe('parser.parse', () => {
     });
   });
 });
+
+describe('parser.parse type-compatibility', () => {
+  it('accepts schema-driven suite.run() results and returns typed selectors', () => {
+    const suite = vest.create(
+      data => {
+        vest.test('email', () => {
+          vest.enforce(data.email).isString();
+        });
+      },
+      vest.enforce.shape({
+        email: vest.enforce.isString(),
+      }),
+    );
+
+    const parsed = parse(suite.run({ email: 'a@b.com' }));
+
+    expectTypeOf(parsed.valid).toEqualTypeOf<
+      (fieldName?: string | undefined) => boolean
+    >();
+    expect(parsed.valid('email')).toBe(true);
+  });
+});

package/src/suite/SuiteTypes.ts

@@ -15,6 +15,16 @@ import { SuiteSelectors } from '../suiteResult/selectors/suiteSelectors';
 
 import { TTypedMethods } from './getTypedMethods';
 
+export type SuiteRunData<
+  S extends TSchema,
+  T extends CB,
+  IsFocused extends boolean = false,
+> = S extends undefined
+  ? Parameters<T>[0]
+  : IsFocused extends true
+    ? Partial<InferSchemaData<S>>
+    : InferSchemaData<S>;
+
 export type SuiteCallbackWithSchema<
   S extends TSchema,
   T extends CB,
@@ -47,17 +57,17 @@ type SuiteMethods<
     ...args: S extends undefined
       ? Parameters<T>
       : [data: InferSchemaData<S>, ...args: any[]]
-  ) => SuiteResult<F, G>;
+  ) => SuiteResult<F, G, S, SuiteRunData<S, T>>;
   runStatic: (
     ...args: S extends undefined
       ? Parameters<T>
       : [data: InferSchemaData<S>, ...args: any[]]
-  ) => SuiteResult<F, G>;
+  ) => SuiteResult<F, G, S, SuiteRunData<S, T>>;
   validate: (
     ...args: S extends undefined
       ? Parameters<T>
       : [data: InferSchemaData<S>, ...args: any[]]
-  ) => SuiteResult<F, G>;
+  ) => SuiteResult<F, G, S, SuiteRunData<S, T>>;
   subscribe: Subscribe;
 } & AfterMethods<F, G, T, S> &
   TTypedMethods<F, G> &
@@ -85,7 +95,7 @@ type FocusedMethods<
     ...args: S extends undefined
       ? Parameters<T>
       : [data: Partial<InferSchemaData<S>>, ...args: any[]]
-  ) => SuiteResult<F, G>;
+  ) => SuiteResult<F, G, S, SuiteRunData<S, T, true>>;
 };
 
 type AfterMethods<
@@ -108,7 +118,7 @@ type AfterMethods<
     ...args: S extends undefined
       ? Parameters<T>
       : [data: InferSchemaData<S>, ...args: any[]]
-  ) => SuiteResult<F, G>;
+  ) => SuiteResult<F, G, S, SuiteRunData<S, T>>;
 };
 
 /**

package/src/suite/__tests__/runSummary.integration.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+
+import { create } from '../../vest';
+
+describe('suite result run summary metadata', () => {
+  it('stores the original run object and timestamp for non-schema suites', () => {
+    const payload = { name: 'alice', meta: { age: 33 } };
+    const suite = create((_data: any) => {});
+
+    const before = Date.now();
+    const result = suite.run(payload);
+    const after = Date.now();
+
+    expect(result.run.data).toBe(payload);
+    expect(Object.prototype.propertyIsEnumerable.call(result, 'run')).toBe(
+      false,
+    );
+    expect(Object.isFrozen(result.run)).toBe(true);
+    expect(result.run.time).toBeInstanceOf(Date);
+    expect(result.run.time.getTime()).toBeGreaterThanOrEqual(before);
+    expect(result.run.time.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  it('stores parsed schema data in run metadata', () => {
+    const schema = {
+      parse: (value: any) => ({ amount: Number(value.amount) }),
+      run: (value: any) => ({ pass: true, type: value }),
+    } as any;
+
+    let callbackValue: unknown;
+    const suite = create((data: any) => {
+      callbackValue = data;
+    }, schema);
+
+    const result = suite.run({ amount: '12' } as any);
+
+    expect(result.run.data).toEqual({ amount: 12 });
+    expect(callbackValue).toEqual(result.run.data);
+  });
+
+  it('falls back to the original data in run metadata when parse fails', () => {
+    const schema = {
+      parse: () => {
+        throw new TypeError('parse failed');
+      },
+      run: (value: any) => ({
+        pass: true,
+        type: value,
+      }),
+    } as any;
+
+    const payload = { amount: '12' };
+    const suite = create(() => {}, schema);
+
+    const result = suite.run(payload);
+
+    expect(result.run.data).toBe(payload);
+  });
+
+  it('captures run.time per run', () => {
+    const suite = create((_data: any) => {});
+
+    const first = suite.run({ count: 1 });
+    const second = suite.run({ count: 2 });
+
+    expect(second.run.time.getTime()).toBeGreaterThanOrEqual(
+      first.run.time.getTime(),
+    );
+    expect(first.run.data).toEqual({ count: 1 });
+    expect(second.run.data).toEqual({ count: 2 });
+  });
+});

package/src/suite/__tests__/schema.types.test.ts

@@ -33,6 +33,10 @@ describe('schema driven suite types', () => {
 
     suite.run({ name: 'john', age: 42 });
 
+    expectTypeOf(suite.run({ name: 'jane', age: 30 }).run.data).toEqualTypeOf<
+      { name: string; age: number } | undefined
+    >();
+
     void (0 as unknown as AssertTrue<
       IsEqual<
         ReturnType<typeof suite.get>['types']['output'],
@@ -140,6 +144,10 @@ describe('schema driven suite types', () => {
 
     suite.run(10, true);
 
+    expectTypeOf(suite.run(10, true).run.data).toEqualTypeOf<
+      number | undefined
+    >();
+
     void (0 as unknown as AssertTrue<
       IsEqual<ReturnType<typeof suite.get>['types'], undefined>
     >);
@@ -158,6 +166,10 @@ describe('schema driven suite types', () => {
 
     suite.run({ name: 'john', age: 42 });
 
+    expectTypeOf(suite.run({ name: 'john', age: 42 }).run.data).toEqualTypeOf<
+      { name: string; age: number } | undefined
+    >();
+
     expectTypeOf(suite.get().types).toBeUndefined();
 
     // @ts-expect-error - requires an argument

package/src/suite/useCreateSuiteRunner.ts

@@ -24,7 +24,11 @@ import {
 } from '../suiteResult/SuiteResultTypes';
 import { useCreateSuiteResult } from '../suiteResult/suiteResult';
 
-import { SuiteModifiers, SuiteCallbackWithSchema } from './SuiteTypes';
+import {
+  SuiteModifiers,
+  SuiteCallbackWithSchema,
+  SuiteRunData,
+} from './SuiteTypes';
 
 type SchemaRunResult = {
   readonly message?: string;
@@ -56,8 +60,10 @@ export function useCreateSuiteRunner<
     ...args: S extends undefined
       ? Parameters<T>
       : [data: InferSchemaData<S>, ...args: any[]]
-  ): SuiteResult<F, G, S> {
-    const { resolve, promise } = withResolvers<SuiteResult<F, G, S>>();
+  ): SuiteResult<F, G, S, SuiteRunData<S, T>> {
+    const runTime = new Date();
+    const { resolve, promise } =
+      withResolvers<SuiteResult<F, G, S, SuiteRunData<S, T>>>();
 
     const schemaInput = args[0];
     const schemaRunResult = shouldRunSchema(schema, transformedModifiers)
@@ -66,46 +72,59 @@ export function useCreateSuiteRunner<
 
     const callbackInput = getCallbackInput(schemaRunResult, schemaInput);
     const callbackArgs = [callbackInput, ...args.slice(1)] as Parameters<T>;
+    const runData = callbackInput as SuiteRunData<S, T> | undefined;
 
-    return assign(
-      promise,
-      SuiteContext.run(
-        {
-          suiteParams: callbackArgs,
-          schema,
-          modifiers: transformedModifiers,
-        },
-        () => {
-          useEmit('SUITE_RUN_STARTED');
-
-          const useResolver = () => {
-            const result = useCreateSuiteResult<F, G, S>(
-              schema,
-              callbackInput,
-              schemaInput,
-            );
-
-            if (!result.isPending()) {
-              resolve(result);
-            }
-
-            return result;
-          };
-
-          return IsolateSuite(
-            useRunSuiteCallback<F, T, S>({
-              args: callbackArgs,
-              modifiers: transformedModifiers,
-              schema,
-              schemaRunResult,
-              suiteCallback,
-              useResolver,
-            }),
+    const suiteResult = SuiteContext.run(
+      {
+        suiteParams: callbackArgs,
+        schema,
+        modifiers: transformedModifiers,
+      },
+      () => {
+        useEmit('SUITE_RUN_STARTED');
+
+        const useResolver = () => {
+          const result = useCreateSuiteResult<F, G, S, SuiteRunData<S, T>>(
+            schema,
+            callbackInput,
+            runData,
+            runTime,
+          );
+
+          if (!result.isPending()) {
+            resolve(result);
+          }
+
+          return result;
+        };
+
+        return IsolateSuite(
+          useRunSuiteCallback<F, T, S, G, SuiteRunData<S, T>>({
+            args: callbackArgs,
+            modifiers: transformedModifiers,
+            schema,
+            schemaRunResult,
+            suiteCallback,
             useResolver,
-          ).output;
-        },
-      ),
+          }),
+          useResolver,
+        ).output;
+      },
     );
+
+    const result = assign(promise, suiteResult);
+
+    Object.defineProperty(result, 'run', {
+      configurable: true,
+      enumerable: false,
+      value: Object.freeze({
+        data: runData,
+        time: runTime,
+      }),
+      writable: true,
+    });
+
+    return result;
   };
 }
 
@@ -131,13 +150,15 @@ function useRunSuiteCallback<
   F extends TFieldName,
   T extends CB = CB,
   S extends TSchema = undefined,
+  G extends TGroupName = TGroupName,
+  D = unknown,
 >(params: {
   args: any[];
   modifiers: ReturnType<typeof useTransformedModifiers<F>>;
   schema: S | undefined;
   schemaRunResult?: SchemaRunResult[];
   suiteCallback: SuiteCallbackWithSchema<S, T>;
-  useResolver: () => SuiteResult<F, any, S>;
+  useResolver: () => SuiteResult<F, G, S, D>;
 }) {
   const {
     args,

package/src/suiteResult/SuiteResultTypes.ts

@@ -17,12 +17,28 @@ export class SummaryBase {
 export class SuiteSummary<
   F extends TFieldName,
   G extends TGroupName,
+  D = unknown,
 > extends SummaryBase {
   public [Severity.ERRORS]: SummaryFailure<F, G>[] = [];
   public [Severity.WARNINGS]: SummaryFailure<F, G>[] = [];
   public groups: Groups<G, F> = {} as Groups<G, F>;
   public tests: Tests<F> = {} as Tests<F>;
+  public run!: { data: D | undefined; time: Date };
   public valid: Nullable<boolean> = null;
+
+  constructor() {
+    super();
+
+    Object.defineProperty(this, 'run', {
+      configurable: true,
+      enumerable: false,
+      value: {
+        data: undefined,
+        time: new Date(0),
+      },
+      writable: true,
+    });
+  }
 }
 
 export type TestsContainer<F extends TFieldName, _G extends TGroupName> =
@@ -75,20 +91,21 @@ type SuiteResultData<
   F extends TFieldName,
   G extends TGroupName,
   S extends TSchema = undefined,
+  D = unknown,
 > =
-  | (Omit<SuiteSummary<F, G>, 'valid'> &
+  | (Omit<SuiteSummary<F, G, D>, 'valid'> &
       SuiteSelectors<F, G> & {
         valid: true;
         value: InferSchemaOutput<S>;
         issues?: undefined;
       })
-  | (Omit<SuiteSummary<F, G>, 'valid'> &
+  | (Omit<SuiteSummary<F, G, D>, 'valid'> &
       SuiteSelectors<F, G> & {
         valid: false;
         issues: ReadonlyArray<StandardSchemaV1.Issue>;
         value?: undefined;
       })
-  | (Omit<SuiteSummary<F, G>, 'valid'> &
+  | (Omit<SuiteSummary<F, G, D>, 'valid'> &
       SuiteSelectors<F, G> & {
         valid: null;
         issues?: undefined;
@@ -102,7 +119,8 @@ export type SuiteResult<
   F extends string = TFieldName,
   G extends string = TGroupName,
   S extends TSchema = undefined,
-> = SuiteResultData<BrandedFieldName<F>, BrandedGroupName<G>, S> & {
+  D = unknown,
+> = SuiteResultData<BrandedFieldName<F>, BrandedGroupName<G>, S, D> & {
   dump: CB<TIsolateSuite>;
   types: S extends undefined
     ? undefined

package/src/suiteResult/selectors/useProduceSuiteSummary.ts

@@ -26,10 +26,11 @@ import {
 export function useProduceSuiteSummary<
   F extends TFieldName,
   G extends TGroupName,
->(): SuiteSummary<F, G> {
+  D = unknown,
+>(): SuiteSummary<F, G, D> {
   const root = VestRuntime.useAvailableRoot<TIsolateSuite>();
 
-  const summary = new SuiteSummary<F, G>();
+  const summary = new SuiteSummary<F, G, D>();
 
   if (isVestIsolate(root)) {
     useProcessTests(root.data.tests, summary);