@ultimat3/testing 30.1.0 → 30.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/testing",
-  "version": "30.1.0",
+  "version": "30.2.0",
   "description": "Test harness: cloned template DBs per worker, frozen clock, sealed network, 6 test types",
   "keywords": [
     "ultimate",
@@ -46,21 +46,21 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "30.1.0",
-    "@ultimat3/cache": "30.1.0",
-    "@ultimat3/core": "30.1.0",
-    "@ultimat3/db": "30.1.0",
-    "@ultimat3/entity": "30.1.0",
-    "@ultimat3/http": "30.1.0",
-    "@ultimat3/i18n": "30.1.0",
-    "@ultimat3/jobs": "30.1.0",
-    "@ultimat3/mail": "30.1.0",
-    "@ultimat3/policy": "30.1.0",
-    "@ultimat3/pwa": "30.1.0",
-    "@ultimat3/query": "30.1.0",
-    "@ultimat3/realtime": "30.1.0",
-    "@ultimat3/render": "30.1.0",
-    "@ultimat3/schema": "30.1.0",
-    "@ultimat3/time": "30.1.0"
+    "@ultimat3/action": "30.2.0",
+    "@ultimat3/cache": "30.2.0",
+    "@ultimat3/core": "30.2.0",
+    "@ultimat3/db": "30.2.0",
+    "@ultimat3/entity": "30.2.0",
+    "@ultimat3/http": "30.2.0",
+    "@ultimat3/i18n": "30.2.0",
+    "@ultimat3/jobs": "30.2.0",
+    "@ultimat3/mail": "30.2.0",
+    "@ultimat3/policy": "30.2.0",
+    "@ultimat3/pwa": "30.2.0",
+    "@ultimat3/query": "30.2.0",
+    "@ultimat3/realtime": "30.2.0",
+    "@ultimat3/render": "30.2.0",
+    "@ultimat3/schema": "30.2.0",
+    "@ultimat3/time": "30.2.0"
   }
 }

package/src/exercise.ts

@@ -441,6 +441,7 @@ export async function runExercisePass(
     main: graph,
     seed: passSeed,
     room,
+    factories: options.overrides?.factories,
     setup: async (subject, sized, tenant, self) => {
       const full = chosen.find((one) => one.name === subject.name);
       return full === undefined

package/src/scale-sweep-graph.ts

@@ -3,7 +3,7 @@
 // every reference to one is pointed at the pass's own row in the same position. Pure.
 
 import { seedGraph } from './seed-graph';
-import type { SeedGraph } from './seed-graph-plan';
+import type { SeedFactory, SeedGraph } from './seed-graph-plan';
 import type { SeedEntity } from './seed-graph-shape';
 
 export interface ScaleGraph {
@@ -23,12 +23,18 @@ export interface ScaleGraph {
 export function scaleGraph(
   main: SeedGraph,
   entities: readonly SeedEntity[],
-  options: { readonly perTable: number; readonly seed: number },
+  options: {
+    readonly perTable: number;
+    readonly seed: number;
+    /** The app's `defineExercise` factories: a table only they satisfy is built by them here too. */
+    readonly factories?: Readonly<Record<string, SeedFactory>> | undefined;
+  },
 ): ScaleGraph {
   const sized = seedGraph(Object.fromEntries(entities.map((entity) => [entity.$name, entity])), {
     tenants: 1,
     perTable: options.perTable,
     seed: options.seed,
+    ...(options.factories === undefined ? {} : { factories: options.factories }),
   });
   const shared = (graph: SeedGraph) => graph.inserts.filter((insert) => insert.tenant === null);
   const theirs = shared(main);

package/src/scale-sweep-run.ts

@@ -10,7 +10,7 @@ import { testJobs } from './fixture-jobs';
 import type { ScaleProof, StatementTally } from './scale-sweep';
 import { judgeScale, SCALE_SIZES } from './scale-sweep';
 import { scaleGraph } from './scale-sweep-graph';
-import type { SeedGraph, SeedWriter } from './seed-graph-plan';
+import type { SeedFactory, SeedGraph, SeedWriter } from './seed-graph-plan';
 import { insertSeedGraph } from './seed-graph-plan';
 import type { SeedEntity } from './seed-graph-shape';
 
@@ -45,6 +45,8 @@ export interface ScaleSweepOptions {
   readonly seed: number;
   readonly room: ExerciseRoom;
   readonly setup: ScaleSetup;
+  /** `defineExercise`'s factories, handed to every sized graph as to the pass's own. */
+  readonly factories?: Readonly<Record<string, SeedFactory>> | undefined;
 }
 
 type Call = { readonly shapes: readonly StatementTally[] } | { readonly failed: string };
@@ -88,6 +90,7 @@ export async function scaleSweep(
     scaleGraph(options.main, options.entities, {
       perTable,
       seed: fnv1a(`scale:${options.seed}:${i}`) || 1,
+      factories: options.factories,
     }),
   );
   try {

package/src/seed-graph-plan.ts

@@ -6,6 +6,13 @@
 export interface SeedFactory {
   build(): object;
   reset(): void;
+  /**
+   * Columns that follow from what the GRAPH chose — its keys and references, which no factory
+   * builds: `memorial_templates.scopeKey` from `ownerOrgId`. Called on each candidate row before
+   * its rules are judged; what it answers wins. A `defineFactory` with it:
+   * `{ build: () => f.build(), reset: () => f.reset(), derive: (row) => ({ … }) }`.
+   */
+  derive?(row: Readonly<Record<string, unknown>>): object;
 }
 
 export interface SeedGraphOptions {

package/src/seed-graph-row.ts

@@ -17,6 +17,8 @@ export interface RowProblem {
   readonly uniques: readonly (readonly string[])[];
   /** Per entry of `uniques`, the keys earlier rows already hold. */
   readonly taken: readonly ReadonlySet<string>[];
+  /** A factory's `derive`: columns that follow from the picked ones, applied before any rule. */
+  readonly derive?: ((row: Readonly<Record<string, unknown>>) => object) | undefined;
 }
 
 export type RowSolution =
@@ -77,7 +79,7 @@ const build = (problem: RowProblem, picks: readonly number[]): Record<string, un
   problem.columns.forEach(([property, candidates], index) => {
     row[property] = candidates[picks[index] ?? 0];
   });
-  return row;
+  return problem.derive === undefined ? row : { ...row, ...problem.derive(row) };
 };
 
 /** Odometer over the varied columns, last one fastest: deterministic and exhaustive up to the cap. */

package/src/seed-graph-shape.ts

@@ -26,6 +26,12 @@ export interface EntityShape {
   readonly references: ReadonlyMap<string, ReferenceDescription>;
   readonly checks: readonly RowCheck[];
   readonly uniques: readonly (readonly string[])[];
+  /**
+   * The uniques with a `where`: SQL the generator cannot evaluate, so held as total — stricter than
+   * the table — unless a factory builds every one of their columns, when the database judges them.
+   * `orgs: unique(kind) where kind = 'staff'` otherwise ran an enum out of values (`X_SEED_GRAPH_UNSATISFIED`).
+   */
+  readonly partialUniques: readonly (readonly string[])[];
   /**
    * The soft-delete property, or `null`. Seeded null unless a factory builds it: a row born deleted
    * is invisible to every read.
@@ -83,15 +89,25 @@ export function shapeOf(entity: SeedEntity): EntityShape {
         holds: (row) => invariant.holds(row),
       }),
     );
-  // A partial unique (`where`) is treated as total: stricter than the table, never looser.
   const uniques = dedupe([
     entity.$primaryKey,
     ...description.columns.filter((column) => column.unique).map((c) => toProperties([c.column])),
     ...entity.$invariants
-      .filter((invariant) => invariant.kind === 'unique')
+      .filter((invariant) => invariant.kind === 'unique' && invariant.where === undefined)
       .map((invariant) => toProperties(invariant.columns)),
-    ...description.indexes.filter((index) => index.unique).map((i) => toProperties(i.columns)),
+    ...description.indexes
+      .filter((index) => index.unique && index.where === null)
+      .map((i) => toProperties(i.columns)),
   ]);
+  const total = new Set(uniques.map((set) => set.join('\u0000')));
+  const partialUniques = dedupe([
+    ...entity.$invariants
+      .filter((invariant) => invariant.kind === 'unique' && invariant.where !== undefined)
+      .map((invariant) => toProperties(invariant.columns)),
+    ...description.indexes
+      .filter((index) => index.unique && index.where !== null)
+      .map((i) => toProperties(i.columns)),
+  ]).filter((set) => !total.has(set.join('\u0000')));
   return {
     entity,
     name: entity.$name,
@@ -99,6 +115,7 @@ export function shapeOf(entity: SeedEntity): EntityShape {
     references: new Map(entity.$references().map((reference) => [reference.property, reference])),
     checks,
     uniques,
+    partialUniques,
     softDelete: description.softDelete ? SEED_SOFT_DELETE_PROPERTY : null,
   };
 }

package/src/seed-graph.ts

@@ -135,7 +135,8 @@ export function seedGraph(
     const factory = options.factories?.[name];
     const rows: Placed[] = [];
     placed.set(name, rows);
-    const taken = shape.uniques.map(() => new Set<string>());
+    const allUniques = [...shape.uniques, ...shape.partialUniques];
+    const taken = allUniques.map(() => new Set<string>());
     const rootProperty = roots.get(name);
     const buckets: readonly (string | null)[] = scoped(name) ? tenants : [null];
     let ordinal = 0;
@@ -176,11 +177,19 @@ export function seedGraph(
             candidates.length === 0 ? refuseEmpty(shape, property, tenant) : candidates,
           ] as const;
         });
+        // A partial unique whose every column the factory built is the database's to judge.
+        const held = allUniques
+          .map((set, i) => [set, taken[i] as Set<string>] as const)
+          .filter(
+            ([set], i) =>
+              i < shape.uniques.length || !set.every((property) => Object.hasOwn(built, property)),
+          );
         const problem: RowProblem = {
           columns,
           checks: shape.checks,
-          uniques: shape.uniques,
-          taken,
+          uniques: held.map(([set]) => set),
+          taken: held.map(([, set]) => set),
+          derive: factory?.derive?.bind(factory),
         };
         const solved = solveRow(problem);
         if (!solved.ok) {
@@ -197,7 +206,7 @@ export function seedGraph(
           });
         }
         const row = { ...solved.row };
-        shape.uniques.forEach((set, i) => {
+        allUniques.forEach((set, i) => {
           const key = uniqueKey(row, set);
           if (key !== undefined) taken[i]?.add(key);
         });

package/src/subject-proof.ts

@@ -8,7 +8,7 @@ import { ctxOf, finiteOption, runWithContext, serviceActor } from '@ultimat3/cor
 import type { Subject, SubjectPlan } from '@ultimat3/jobs';
 import { memoryStepStore, planSubject, stepRunner, subjectEraseTables } from '@ultimat3/jobs';
 import { seedGraph } from './seed-graph';
-import type { SeedGraph, SeedWriter } from './seed-graph-plan';
+import type { SeedFactory, SeedGraph, SeedWriter } from './seed-graph-plan';
 import { insertSeedGraph } from './seed-graph-plan';
 import type { SeedEntity } from './seed-graph-shape';
 import { SubjectEraseIncompleteError } from './subject-proof-error';
@@ -22,6 +22,8 @@ export interface SubjectProofOptions {
   /** Every stored row of one table, as the database holds it, unscoped. */
   readonly read: (entity: SeedEntity) => Promise<readonly Stored[]>;
   readonly seed?: number;
+  /** `defineExercise`'s factories: a table only they satisfy is built by them for the proof too. */
+  readonly factories?: Readonly<Record<string, SeedFactory>> | undefined;
 }
 
 export interface SubjectProofResult {
@@ -107,6 +109,7 @@ export async function subjectProof<I>(
   const graph = seedGraph(Object.fromEntries(entities), {
     seed: finiteOption('subjectProof', 'seed', options.seed ?? 1),
     tenants: 2,
+    ...(options.factories === undefined ? {} : { factories: options.factories }),
   });
   await insertSeedGraph(graph, options.writer);
   const tenant = graph.tenants[0] ?? null;