@pepys/testing 0.1.0 → 0.1.1

package/README.md

@@ -28,6 +28,9 @@ Set the compiler options from the [kit's README](../kit/README.md#configuration)
 ## Features
 
 - `createTestStore`: apply facts or write rows, then run a query, read rows and read links.
+- `applyFactLog`: apply the facts that `createIngest` of `@pepys/ingest` stored in a memory fact log
+  to a test store, in place of the host. A second call applies only the records the log stored after
+  the first.
 - `applyInBothOrders`: apply facts in two orders and compare the stores.
 - The memory adapter of the store reader, for a test of a core query.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pepys/testing",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Test a pepys plug-in on Bun: an in-memory store that runs its consumers and queries",
   "license": "MIT",
   "repository": {
@@ -19,8 +19,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pepys/kit": "0.1.0",
-    "@pepys/kysely-turso": "0.1.0",
+    "@pepys/ingest": "0.1.1",
+    "@pepys/kit": "0.1.1",
+    "@pepys/kysely-turso": "0.1.1",
     "@tursodatabase/database": "0.8.3",
     "kysely": "0.29.8",
     "tiny-invariant": "1.3.3",

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

@@ -0,0 +1,58 @@
+import type { MemoryFactLog } from '@pepys/ingest';
+import { toStreamName, toStreamOffset } from '@pepys/kit';
+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';
+
+// 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
+// moves no offset, so the next call reads the same records again.
+export async function applyFactLog(
+  store: TestStore,
+  log: MemoryFactLog,
+  deployment: CheckedDeployment,
+): Promise<void> {
+  const hooks = storeHooks.get(store);
+
+  if (hooks === undefined) {
+    throw new Error('the store is not the object that createTestStore returned');
+  }
+
+  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);
+
+    if (!tail.ok) {
+      throw new Error(`the fact log has no stream ${declared}, which a consumer reads`);
+    }
+
+    if (tail.value === from) {
+      continue;
+    }
+
+    const read = await log.read(stream, toStreamOffset(from), tail.value - from);
+
+    invariant(read.ok, 'a stream with a tail can be read');
+
+    for (const stored of read.value) {
+      records.push({ stream, envelope: stored.fact });
+    }
+
+    tails.set(stream, tail.value);
+  }
+
+  await hooks.applyEnvelopes(records);
+
+  for (const [stream, tail] of tails) {
+    hooks.nextOffsets.set(stream, tail);
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export { applyFactLog } from './fact-log/apply-fact-log.ts';
 export { applyInBothOrders } from './orders/apply-in-both-orders.ts';
 export type { OrderReport, StoreSnapshot } from './orders/apply-in-both-orders.ts';
 export type { MemoryStoreReader } from './memory-store-reader/create-memory-store-reader.ts';

package/src/test-store/create-test-store.ts

@@ -11,6 +11,8 @@ import { ApplyError } from '../utils/apply-error.ts';
 import { parseAppliedFacts } from './parse-applied-facts.ts';
 import { runConsumers } from './run-consumers.ts';
 import type { AppliedFactIDs } from './run-consumers.ts';
+import { storeHooks } from './store-hooks.ts';
+import type { StoreHooks } from './store-hooks.ts';
 import type { TestStore } from './types.ts';
 
 interface TestStoreOptions {
@@ -48,7 +50,19 @@ export async function createTestStore(options: TestStoreOptions): Promise<TestSt
     return table;
   };
 
-  return {
+  const applyEnvelopes: StoreHooks['applyEnvelopes'] = async (records) => {
+    const next = buildFactIndex(index, records);
+
+    applied = await db
+      .transaction()
+      .execute((transaction) =>
+        runConsumers(transaction, deployment.consumers, { ...next, applied }),
+      );
+
+    index = next.index;
+  };
+
+  const testStore: TestStore = {
     writeRows: async (_consumer, table, rows) => {
       for (const row of rows) {
         await writeRow(db, table, getTable(table), row);
@@ -61,15 +75,7 @@ export async function createTestStore(options: TestStoreOptions): Promise<TestSt
         throw new ApplyError(envelopes.failure);
       }
 
-      const next = buildFactIndex(index, envelopes.value);
-
-      applied = await db
-        .transaction()
-        .execute((transaction) =>
-          runConsumers(transaction, deployment.consumers, { ...next, applied }),
-        );
-
-      index = next.index;
+      await applyEnvelopes(envelopes.value);
     },
     query: async (query, input) => {
       const parsed = query.input.parse(input);
@@ -91,4 +97,8 @@ export async function createTestStore(options: TestStoreOptions): Promise<TestSt
     reader,
     [Symbol.asyncDispose]: () => db.destroy(),
   };
+
+  storeHooks.set(testStore, { applyEnvelopes, nextOffsets: new Map() });
+
+  return testStore;
 }

package/src/test-store/store-hooks.ts

@@ -0,0 +1,16 @@
+import type { FactEnvelope, StreamName } from '@pepys/kit';
+import type { TestStore } from './types.ts';
+
+export interface StoreHooks {
+  // Runs the consumers on the records as one batch in one transaction. A refusal throws an
+  // ApplyError, and the batch then writes nothing.
+  applyEnvelopes: (
+    records: readonly { stream: string; envelope: FactEnvelope<unknown> }[],
+  ) => Promise<void>;
+
+  // the offset of the next record to apply from a fact log, by stream
+  nextOffsets: Map<StreamName, number>;
+}
+
+// What a test store gives the package's own functions and keeps out of its public type.
+export const storeHooks = new WeakMap<TestStore, StoreHooks>();