@boxxy/dispatch 0.1.1 → 0.1.3

package/src/test-utils/claim-store-exclusive-cases.ts

@@ -1,6 +1,7 @@
 import { setImmediate } from 'node:timers/promises';
 import { brandSchemas } from '@boxxy/model';
-import { buildMockItemRow } from '@boxxy/model/test-utils/build-mock-item-row';
+import { buildMockItemRules } from '@boxxy/model/test-utils/build-mock-item-rules';
+import { buildMockV1ItemRow } from '@boxxy/model/test-utils/build-mock-v1-item-row';
 import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
 import type { ClaimStoreCase } from './types.ts';
 
@@ -38,7 +39,7 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
   [
     '#exclusive leaves the state as it was when work throws',
     async (store) => {
-      const item = buildMockItemRow();
+      const item = buildMockV1ItemRow();
 
       const writing = store.exclusive(async (transaction) => {
         await transaction.applyChange(buildMockFileItemChange(item));
@@ -49,7 +50,7 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
       await writing.catch(() => null);
 
       const snapshot: unknown = await store.read((transaction) =>
-        transaction.readSnapshot(brandSchemas.instant.parse(5000), new Map()),
+        transaction.readSnapshot(brandSchemas.instant.parse(5000), buildMockItemRules()),
       );
 
       return {
@@ -57,9 +58,10 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
         expected: {
           storeVersion: 0,
           items: [],
-          links: [],
+          relations: [],
           levers: [],
-          freeSlots: {},
+          limits: [],
+          wakes: [],
         },
       };
     },
@@ -82,7 +84,7 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
   [
     '#exclusive runs a later call after an earlier call throws',
     async (store) => {
-      const item = buildMockItemRow();
+      const item = buildMockV1ItemRow();
 
       const failing = store.exclusive(() => {
         throw new Error('the work failed');
@@ -95,7 +97,7 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
       );
 
       const read = await store.read((transaction) =>
-        transaction.readItem(item.id, brandSchemas.instant.parse(5000), new Map()),
+        transaction.readItem(item.id, brandSchemas.instant.parse(5000), buildMockItemRules()),
       );
 
       return { received: read?.id, expected: item.id };
@@ -104,8 +106,8 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
   [
     '#read during a running exclusive call sees the last committed state',
     async (store) => {
-      const committed = buildMockItemRow({ filedAt: brandSchemas.instant.parse(1000) });
-      const pending = buildMockItemRow({ filedAt: brandSchemas.instant.parse(2000) });
+      const committed = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+      const pending = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(2000) });
       const gate = Promise.withResolvers<void>();
       const written = Promise.withResolvers<void>();
 
@@ -124,7 +126,7 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
       await written.promise;
 
       const seen = await store.read((transaction) =>
-        transaction.listItems({}, brandSchemas.instant.parse(5000), new Map()),
+        transaction.listItems({}, brandSchemas.instant.parse(5000), buildMockItemRules()),
       );
 
       gate.resolve();
@@ -137,19 +139,27 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
   [
     '#read keeps one snapshot across a commit made during the call',
     async (store) => {
-      const committed = buildMockItemRow({ filedAt: brandSchemas.instant.parse(1000) });
-      const later = buildMockItemRow({ filedAt: brandSchemas.instant.parse(2000) });
+      const committed = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+      const later = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(2000) });
 
       await store.exclusive((transaction) =>
         transaction.applyChange(buildMockFileItemChange(committed)),
       );
 
       const seen: unknown = await store.read(async (transaction) => {
-        const before = await transaction.listItems({}, brandSchemas.instant.parse(5000), new Map());
+        const before = await transaction.listItems(
+          {},
+          brandSchemas.instant.parse(5000),
+          buildMockItemRules(),
+        );
 
         await store.exclusive((writer) => writer.applyChange(buildMockFileItemChange(later)));
 
-        const after = await transaction.listItems({}, brandSchemas.instant.parse(5000), new Map());
+        const after = await transaction.listItems(
+          {},
+          brandSchemas.instant.parse(5000),
+          buildMockItemRules(),
+        );
 
         return { before: before.map((item) => item.id), after: after.map((item) => item.id) };
       });
@@ -157,10 +167,44 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
       return { received: seen, expected: { before: [committed.id], after: [committed.id] } };
     },
   ],
+  [
+    '#read rejects with the error work throws',
+    async (store) => {
+      const reading = store.read(() => {
+        throw new Error('the read failed');
+      });
+
+      const settled = await reading.then(
+        () => 'resolved',
+        (error: unknown) => error,
+      );
+
+      return { received: settled, expected: new Error('the read failed') };
+    },
+  ],
+  [
+    '#read runs a read started inside another read',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+
+      await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockFileItemChange(item)),
+      );
+
+      const seen = await store.read(() =>
+        store.read((transaction) =>
+          transaction.readItem(item.id, brandSchemas.instant.parse(5000), buildMockItemRules()),
+        ),
+      );
+
+      return { received: seen?.id, expected: item.id };
+    },
+  ],
   [
     '#applyChange writes the rows and the outbox facts of a change',
     async (store) => {
-      const item = buildMockItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+      const item = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+      const { keptSession: _keptSession, ...filed } = item;
       const change = buildMockFileItemChange(item);
 
       await store.exclusive((transaction) => transaction.applyChange(change));
@@ -177,21 +221,23 @@ export const claimStoreExclusiveCases: readonly ClaimStoreCase[] = [
             entity: `boxxy:item:${item.id}`,
             actor: 'boxxy:owner:local',
             at: 1000,
-            payload: { ...item },
+            payload: filed,
             sentAt: null,
+            parkedAt: null,
+            parkedReason: null,
           },
         ],
       };
     },
   ],
   [
-    '#applyChange returns applied with no slot for a change that takes none',
+    '#applyChange returns applied for a change that it writes',
     async (store) => {
-      const change = buildMockFileItemChange(buildMockItemRow());
+      const change = buildMockFileItemChange(buildMockV1ItemRow());
 
       const result = await store.exclusive((transaction) => transaction.applyChange(change));
 
-      return { received: result, expected: { kind: 'applied', slot: null } };
+      return { received: result, expected: { kind: 'applied' } };
     },
   ],
 ];

package/src/test-utils/claim-store-guard-cases.ts

@@ -1,7 +1,8 @@
 import { brandSchemas } from '@boxxy/model';
-import { buildMockAttemptRow } from '@boxxy/model/test-utils/build-mock-attempt-row';
 import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
-import { buildMockItemRow } from '@boxxy/model/test-utils/build-mock-item-row';
+import { buildMockItemRules } from '@boxxy/model/test-utils/build-mock-item-rules';
+import { buildMockV1AttemptRow } from '@boxxy/model/test-utils/build-mock-v1-attempt-row';
+import { buildMockV1ItemRow } from '@boxxy/model/test-utils/build-mock-v1-item-row';
 import { buildMockBindChange } from './build-mock-bind-change.ts';
 import { buildMockClaimChange } from './build-mock-claim-change.ts';
 import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
@@ -11,81 +12,83 @@ import type { ClaimStoreCase } from './types.ts';
 
 export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
-    '#applyChange returns stale-generation for a settle under an old slot gen',
+    '#applyChange returns stale-generation and keeps the seats for a settle under an old hold gen',
     async (store) => {
-      const first = buildMockItemRow();
-      const second = buildMockItemRow();
-      const settled = buildMockAttemptRow({ item: first.id, state: 'starting' });
-      const holder = buildMockAttemptRow({ item: second.id, state: 'starting' });
+      const workers = brandSchemas.limitName.parse('workers');
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting', holdGen: 2 });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: settled.pool, slots: 1 }]);
-        await transaction.applyChange(buildMockFileItemChange(first));
-        await transaction.applyChange(buildMockFileItemChange(second));
-        await transaction.applyChange(buildMockClaimChange(settled));
-
-        await transaction.applyChange(
-          buildMockSettleChange({
-            attempt: { ...settled, slot: 1, slotGen: 1 },
-            state: 'succeeded',
-          }),
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
         );
 
-        await transaction.applyChange(buildMockClaimChange(holder));
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt, [workers]));
       });
 
       const result = await store.exclusive((transaction) =>
         transaction.applyChange(
-          buildMockSettleChange({ attempt: { ...holder, slot: 1, slotGen: 1 }, state: 'failed' }),
+          buildMockSettleChange({ attempt: { ...attempt, holdGen: 1 }, state: 'failed' }),
         ),
       );
 
-      const slots = await store.read((transaction) => transaction.listPoolSlots());
+      const seats = await store.read((transaction) => transaction.listLimitSeats());
 
       return {
-        received: { result, slots },
+        received: { result, seats },
         expected: {
           result: { kind: 'stale-generation' },
-          slots: [{ pool: holder.pool, slot: 1, holder: holder.id, gen: 2, retired: false }],
+          seats: [
+            {
+              limit: 'workers',
+              attempt: attempt.id,
+              holdGen: 2,
+              overCap: false,
+              takenAt: attempt.claimedAt,
+              releasedAt: null,
+            },
+          ],
         },
       };
     },
   ],
   [
-    '#applyChange releases both leases of a settle under the live generations',
+    '#applyChange releases the lease and the seats of a settle under the live generations',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const workers = brandSchemas.limitName.parse('workers');
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
         await transaction.applyChange(buildMockFileItemChange(item));
-        await transaction.applyChange(buildMockClaimChange(attempt));
+        await transaction.applyChange(buildMockClaimChange(attempt, [workers]));
       });
 
       const result = await store.exclusive((transaction) =>
-        transaction.applyChange(
-          buildMockSettleChange({
-            attempt: { ...attempt, slot: 1, slotGen: 1 },
-            state: 'succeeded',
-          }),
-        ),
+        transaction.applyChange(buildMockSettleChange({ attempt, state: 'succeeded' })),
       );
 
       const snapshot = await store.read((transaction) =>
-        transaction.readSnapshot(brandSchemas.instant.parse(5000), new Map()),
+        transaction.readSnapshot(brandSchemas.instant.parse(5000), buildMockItemRules()),
       );
 
       return {
         received: {
           result,
-          freeSlots: snapshot.freeSlots,
+          limits: snapshot.limits,
           derived: snapshot.items[0]?.derived,
         },
         expected: {
-          result: { kind: 'applied', slot: null },
-          freeSlots: { [attempt.pool]: 1 },
-          derived: { state: 'waiting', reason: 'no PR linked' },
+          result: { kind: 'applied' },
+          limits: [{ name: 'workers', max: 1, counts: {}, held: 0 }],
+          derived: { state: 'waiting', reason: 'no pull request linked' },
         },
       };
     },
@@ -93,11 +96,10 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange returns stale-generation and writes no fact under a stale lease generation',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
         await transaction.applyChange(buildMockFileItemChange(item));
         await transaction.applyChange(buildMockClaimChange(attempt));
       });
@@ -125,17 +127,13 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange returns stale-generation under a released lease',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
         await transaction.applyChange(buildMockFileItemChange(item));
         await transaction.applyChange(buildMockClaimChange(attempt));
-
-        await transaction.applyChange(
-          buildMockSettleChange({ attempt: { ...attempt, slot: 1, slotGen: 1 }, state: 'failed' }),
-        );
+        await transaction.applyChange(buildMockSettleChange({ attempt, state: 'failed' }));
       });
 
       const result = await store.exclusive((transaction) =>
@@ -148,11 +146,10 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange applies a change under the live lease generation',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
         await transaction.applyChange(buildMockFileItemChange(item));
         await transaction.applyChange(buildMockClaimChange(attempt));
         await transaction.applyChange(buildMockStartChange(attempt));
@@ -166,7 +163,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange returns guard-mismatch and writes nothing when an expect fails',
     async (store) => {
-      const item = buildMockItemRow();
+      const item = buildMockV1ItemRow();
 
       await store.exclusive((transaction) =>
         transaction.applyChange(buildMockFileItemChange(item)),
@@ -197,7 +194,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
               type: 'boxxy.item.closed',
               entity: `boxxy:item:${item.id}`,
               actor: 'boxxy:owner:local',
-              payload: { reason: 'done by hand' },
+              payload: { reason: 'done by hand', byAttempt: null, ended: [] },
             },
           ],
         }),
@@ -207,7 +204,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
         const read = await transaction.readItem(
           item.id,
           brandSchemas.instant.parse(5000),
-          new Map(),
+          buildMockItemRules(),
         );
 
         const facts = await transaction.readUnsentFacts(10);
@@ -219,7 +216,14 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
         received: { result, state },
         expected: {
           result: { kind: 'guard-mismatch', table: 'items', key: { id: item.id } },
-          state: { item: { ...item, derived: { state: 'ready' } }, facts: 1 },
+          state: {
+            item: {
+              ...item,
+              derived: { state: 'ready' },
+              position: { kind: 'phase', phase: 'build', round: 1 },
+            },
+            facts: 1,
+          },
         },
       };
     },
@@ -227,7 +231,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange returns guard-mismatch for an update that finds no row',
     async (store) => {
-      const item = buildMockItemRow();
+      const item = buildMockV1ItemRow();
 
       const result = await store.exclusive((transaction) =>
         transaction.applyChange({
@@ -247,7 +251,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
               type: 'boxxy.item.edited',
               entity: `boxxy:item:${item.id}`,
               actor: 'boxxy:owner:local',
-              payload: { title: 'Mend the gate' },
+              payload: { title: 'Mend the gate', byAttempt: null },
             },
           ],
         }),
@@ -272,7 +276,7 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
         evidence: [],
       };
 
-      const item = buildMockItemRow({ acceptance: [criterion] });
+      const item = buildMockV1ItemRow({ acceptance: [criterion] });
 
       await store.exclusive((transaction) =>
         transaction.applyChange(buildMockFileItemChange(item)),
@@ -300,24 +304,23 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
               type: 'boxxy.item.edited',
               entity: `boxxy:item:${item.id}`,
               actor: 'boxxy:owner:local',
-              payload: { title: 'Mend the gate' },
+              payload: { title: 'Mend the gate', byAttempt: null },
             },
           ],
         }),
       );
 
-      return { received: result, expected: { kind: 'applied', slot: null } };
+      return { received: result, expected: { kind: 'applied' } };
     },
   ],
   [
     '#findAttemptByAgentSession returns the attempt that holds an agent session id',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
       const agentSession = brandSchemas.agentSessionId.parse('agent-session-1');
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
         await transaction.applyChange(buildMockFileItemChange(item));
         await transaction.applyChange(buildMockClaimChange(attempt));
         await transaction.applyChange(buildMockBindChange({ attempt, agentSession }));
@@ -341,33 +344,40 @@ export const claimStoreGuardCases: readonly ClaimStoreCase[] = [
     },
   ],
   [
-    '#applyChange throws on a second attempt row for one agent session id',
+    '#findAttemptByAgentSession returns the later of two attempts bound to one agent session',
     async (store) => {
-      const first = buildMockItemRow();
-      const second = buildMockItemRow();
-      const holder = buildMockAttemptRow({ item: first.id, state: 'starting' });
-      const other = buildMockAttemptRow({ item: second.id, state: 'starting' });
+      const item = buildMockV1ItemRow();
       const agentSession = brandSchemas.agentSessionId.parse('agent-session-1');
 
-      await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: holder.pool, slots: 2 }]);
-        await transaction.applyChange(buildMockFileItemChange(first));
-        await transaction.applyChange(buildMockFileItemChange(second));
-        await transaction.applyChange(buildMockClaimChange(holder));
-        await transaction.applyChange(buildMockClaimChange(other));
-        await transaction.applyChange(buildMockBindChange({ attempt: holder, agentSession }));
+      const earlier = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        claimedAt: brandSchemas.instant.parse(1000),
       });
 
-      const binding = store.exclusive((transaction) =>
-        transaction.applyChange(buildMockBindChange({ attempt: other, agentSession })),
-      );
+      const later = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        number: 2,
+        leaseGen: 2,
+        atcSession: earlier.atcSession,
+        claimedAt: brandSchemas.instant.parse(4000),
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(earlier));
+        await transaction.applyChange(buildMockBindChange({ attempt: earlier, agentSession }));
+        await transaction.applyChange(buildMockSettleChange({ attempt: earlier, state: 'failed' }));
+        await transaction.applyChange(buildMockClaimChange(later));
+        await transaction.applyChange(buildMockBindChange({ attempt: later, agentSession }));
+      });
 
-      const settled = await binding.then(
-        () => 'bound',
-        () => 'thrown',
+      const found = await store.read((transaction) =>
+        transaction.findAttemptByAgentSession(agentSession),
       );
 
-      return { received: settled, expected: 'thrown' };
+      return { received: found, expected: later.id };
     },
   ],
 ];