@pepys/testing 0.3.1 → 0.4.0

package/README.md

@@ -25,25 +25,30 @@ bun add -d @pepys/testing
 
 Set the compiler options from the [kit's README](../kit/README.md#configuration).
 
-Then test a query on rows written for the test:
+Then apply facts, and test a query on the rows that the plug-in's consumers write from them. A query
+test that seeds through the consumers fails when a consumer changes the shape of its rows:
 
 ```ts
 import { expect, test } from 'bun:test';
-import type { EntityID } from '@pepys/kit';
 import { createTestStore } from '@pepys/testing';
-import { toTagged } from '@zgeoff/std';
-import { shelfBookConsumer, shelfPlugin, shelfTitleQuery } from './shelf-plugin.ts';
+import { shelfPlugin, shelfSource, shelfTitleQuery } from './shelf-plugin.ts';
 
-test('it answers a query from rows written for the test', async () => {
+test('it answers a query from the row that a shelved fact gives', async () => {
   await using store = await createTestStore({ plugins: [shelfPlugin] });
 
-  await store.writeRows(shelfBookConsumer, 'shelf_book', [
-    { id: toTagged<EntityID>('shelf:book:atlas'), title: 'The Coral Atlas' },
+  await store.apply(shelfSource, [
+    {
+      type: 'shelf.book.shelved',
+      event: 'evt-1',
+      entity: 'shelf:book:atlas',
+      at: '2026-11-01T08:00:00.000Z',
+      payload: { title: 'The Coral Atlas' },
+    },
   ]);
 
-  expect(await store.query(shelfTitleQuery, { id: 'shelf:book:atlas' })).toStrictEqual({
-    title: 'The Coral Atlas',
-  });
+  const answer = await store.query(shelfTitleQuery, { id: 'shelf:book:atlas' });
+
+  expect(answer).toStrictEqual({ title: 'The Coral Atlas' });
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pepys/testing",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Test a pepys plug-in on Bun: an in-memory store that runs its consumers and queries",
   "license": "MIT",
   "repository": {
@@ -11,7 +11,8 @@
   "files": [
     "src",
     "!src/**/*.test.ts",
-    "!src/**/test-utils"
+    "!src/**/test-utils",
+    "!src/ledger"
   ],
   "type": "module",
   "exports": "./src/index.ts",
@@ -19,9 +20,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pepys/ingest": "0.3.1",
-    "@pepys/kit": "0.3.1",
-    "@pepys/kysely-turso": "0.3.1",
+    "@pepys/ingest": "0.4.0",
+    "@pepys/kit": "0.4.0",
+    "@pepys/kysely-turso": "0.4.0",
     "@tursodatabase/database": "0.8.3",
     "kysely": "0.29.8",
     "tiny-invariant": "1.3.3",

package/src/fact-log/apply-fact-log.ts

@@ -4,6 +4,7 @@ import type { CheckedDeployment, FactEnvelope, StreamName } from '@pepys/kit';
 import invariant from 'tiny-invariant';
 import { storeHooks } from '../test-store/store-hooks.ts';
 import type { TestStore } from '../test-store/types.ts';
+import { collectStreamRanges } from './collect-stream-ranges.ts';
 
 // The host's part for a test: the records of every stream a consumer reads go to the store as one
 // batch, whole streams in the order the consumers name them. A refusal throws an ApplyError and
@@ -20,39 +21,34 @@ export async function applyFactLog(
   }
 
   const streams = new Set(deployment.consumers.flatMap((consumer) => consumer.input.streams));
-
-  const records: { stream: StreamName; envelope: FactEnvelope<unknown> }[] = [];
-
   const tails = new Map<StreamName, number>();
 
   for (const declared of streams) {
-    const stream = toStreamName(declared);
-    const from = hooks.nextOffsets.get(stream) ?? 0;
-
-    const tail = await log.readTail(stream);
+    const tail = await log.readTail(toStreamName(declared));
 
     if (!tail.ok) {
       throw new Error(`the fact log has no stream ${declared}, which a consumer reads`);
     }
 
-    if (tail.value === from) {
-      continue;
-    }
+    tails.set(toStreamName(declared), tail.value);
+  }
+
+  const ranges = collectStreamRanges(tails, hooks.nextOffsets);
+  const records: { stream: StreamName; envelope: FactEnvelope<unknown> }[] = [];
 
-    const read = await log.read(stream, toStreamOffset(from), tail.value - from);
+  for (const range of ranges) {
+    const read = await log.read(range.stream, toStreamOffset(range.from), range.tail - range.from);
 
     invariant(read.ok, 'a stream with a tail can be read');
 
     for (const stored of read.value) {
-      records.push({ stream, envelope: stored.fact });
+      records.push({ stream: range.stream, envelope: stored.fact });
     }
-
-    tails.set(stream, tail.value);
   }
 
   await hooks.applyEnvelopes(records);
 
-  for (const [stream, tail] of tails) {
-    hooks.nextOffsets.set(stream, tail);
+  for (const range of ranges) {
+    hooks.nextOffsets.set(range.stream, range.tail);
   }
 }

package/src/fact-log/collect-stream-ranges.ts

@@ -0,0 +1,20 @@
+import type { StreamName } from '@pepys/kit';
+
+export interface StreamRange {
+  stream: StreamName;
+  from: number;
+  tail: number;
+}
+
+// The records each stream holds past the offset the store applied up to, in the order of `tails`.
+// A stream whose tail is that offset has nothing new, and no range.
+export function collectStreamRanges(
+  tails: ReadonlyMap<StreamName, number>,
+  nextOffsets: ReadonlyMap<StreamName, number>,
+): StreamRange[] {
+  return [...tails].flatMap(([stream, tail]) => {
+    const from = nextOffsets.get(stream) ?? 0;
+
+    return tail === from ? [] : [{ stream, from, tail }];
+  });
+}

package/src/test-store/collect-dirty-scopes.ts

@@ -0,0 +1,18 @@
+import { parseEntityID } from '@pepys/kit';
+import type { EntityID } from '@pepys/kit';
+import type { LoggedFact } from '../fact-index/types.ts';
+import { compareCodePoints } from '../utils/compare-code-points.ts';
+
+// The entities of the batch's facts that have the scope kind, each once, in sorted order. A copy of
+// a fact marks its scope dirty too, and the replace then finds no change.
+export function collectDirtyScopes(facts: readonly LoggedFact[], scopeKind: string): EntityID[] {
+  const scopes = facts
+    .map((record) => record.envelope.entity)
+    .filter((entity) => {
+      const parsed = parseEntityID(entity);
+
+      return parsed.ok && `${parsed.value.source}:${parsed.value.kind}` === scopeKind;
+    });
+
+  return [...new Set(scopes)].toSorted(compareCodePoints);
+}

package/src/test-store/collect-new-facts.ts

@@ -0,0 +1,21 @@
+import type { FactID } from '@pepys/kit';
+import type { LoggedFact } from '../fact-index/types.ts';
+
+// The facts a fact-mode consumer has yet to apply, in batch order: a fact ID it applied before, or
+// one an earlier fact of the batch holds, is a copy and runs no second time.
+export function collectNewFacts(
+  facts: readonly LoggedFact[],
+  applied: ReadonlySet<FactID>,
+): LoggedFact[] {
+  const seen = new Set(applied);
+
+  return facts.filter((record) => {
+    if (seen.has(record.envelope.id)) {
+      return false;
+    }
+
+    seen.add(record.envelope.id);
+
+    return true;
+  });
+}

package/src/test-store/run-consumers.ts

@@ -1,4 +1,3 @@
-import { parseEntityID } from '@pepys/kit';
 import type { ConsumerDeclaration, FactID } from '@pepys/kit';
 import invariant from 'tiny-invariant';
 import { buildReadFunctions } from '../consumer-entries/build-read-functions.ts';
@@ -11,7 +10,8 @@ import { parseOperations } from '../operations/parse-operations.ts';
 import { replaceScope } from '../scope-replace/replace-scope.ts';
 import type { StoreDatabase } from '../store-database/types.ts';
 import { ApplyError } from '../utils/apply-error.ts';
-import { compareCodePoints } from '../utils/compare-code-points.ts';
+import { collectDirtyScopes } from './collect-dirty-scopes.ts';
+import { collectNewFacts } from './collect-new-facts.ts';
 
 // The fact IDs each fact-mode consumer has applied, by consumer name.
 export type AppliedFactIDs = ReadonlyMap<string, ReadonlySet<FactID>>;
@@ -59,15 +59,7 @@ async function runFactConsumer(
   facts: readonly LoggedFact[],
   applied: ReadonlySet<FactID>,
 ): Promise<ReadonlySet<FactID>> {
-  const seen = new Set(applied);
-
-  for (const record of facts) {
-    if (seen.has(record.envelope.id)) {
-      continue;
-    }
-
-    seen.add(record.envelope.id);
-
+  for (const record of collectNewFacts(facts, applied)) {
     const host = await readRowFunctions(db, consumer);
     const output = await runEntry(consumer, 'applyFact', JSON.stringify(record.envelope), host);
 
@@ -80,11 +72,9 @@ async function runFactConsumer(
     await applyFactOperations(db, consumer, operations.value);
   }
 
-  return seen;
+  return new Set([...applied, ...facts.map((record) => record.envelope.id)]);
 }
 
-// The dirty scopes are the entities of the batch's facts that have the scope kind, each once, in
-// sorted order. A copy of a fact marks its scope dirty too, and the replace then finds no change.
 async function runScopeConsumer(
   db: StoreDatabase,
   consumer: ConsumerDeclaration,
@@ -93,21 +83,7 @@ async function runScopeConsumer(
 ): Promise<void> {
   invariant(consumer.input.mode === 'scope', 'only a scope consumer has a scope kind');
 
-  const scopeKind = consumer.input.scopeKind;
-
-  const scopes = [
-    ...new Set(
-      facts
-        .map((record) => record.envelope.entity)
-        .filter((entity) => {
-          const parsed = parseEntityID(entity);
-
-          return parsed.ok && `${parsed.value.source}:${parsed.value.kind}` === scopeKind;
-        }),
-    ),
-  ].toSorted(compareCodePoints);
-
-  for (const scope of scopes) {
+  for (const scope of collectDirtyScopes(facts, consumer.input.scopeKind)) {
     const scopeFacts = JSON.stringify(collectScopeFacts(index, scope, consumer.input.streams));
     const host = buildReadFunctions('readScopeFacts', new Map([[scope, scopeFacts]]), 'trap');