@cratis/chronicle 6.31.1 → 6.31.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.31.1",
+    "version": "6.31.2",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -173,25 +173,25 @@
     },
     "dependencies": {
         "@bufbuild/protobuf": "^2.15.0",
-        "@cratis/chronicle.contracts": "19.6.1",
-        "@grpc/grpc-js": "^1.14.4",
+        "@cratis/chronicle.contracts": "19.8.1",
+        "@grpc/grpc-js": "^1.14.5",
         "@opentelemetry/api": "^1.9.1",
         "glob": "^13.0.6",
         "nice-grpc": "^2.1.17",
         "nice-grpc-common": "^2.0.4",
         "reflect-metadata": "^0.2.2",
-        "undici": "^8.10.2"
+        "undici": "^8.11.2"
     },
     "devDependencies": {
-        "@cratis/fundamentals": "7.19.2",
-        "@types/node": "^26.5.1",
+        "@cratis/fundamentals": "7.19.6",
+        "@types/node": "^26.6.3",
         "@typescript/native": "npm:typescript@^7.0.2",
         "esbuild": "^0.28.2",
         "typescript": "npm:@typescript/typescript6@^6.0.2",
-        "vite": "^8.3.0",
-        "vitest": "^5.0.1"
+        "vite": "^8.3.1",
+        "vitest": "^5.0.2"
     },
     "peerDependencies": {
-        "@cratis/fundamentals": "^7.19.2"
+        "@cratis/fundamentals": "^7.19.6"
     }
 }

package/reactors/for_Reactors/against_a_kernel/when_replaying_reactors_with_once_only_handlers.integration.spec.ts

@@ -0,0 +1,131 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { randomUUID } from 'node:crypto';
+import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { ChronicleClient } from '../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../ChronicleOptions.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../../events/index.js';
+import type { IEventStore } from '../../../IEventStore.js';
+import { onceOnly } from '../../onceOnly.js';
+import { reactor } from '../../reactor.js';
+import { replay } from '../../replay.js';
+
+chai.should();
+
+// Runs against a real Chronicle kernel; skipped locally unless the connection string is set (see vitest.integration.config.ts).
+// In CI it never skips, so a missing connection string or unreachable kernel fails instead of passing vacuously.
+const connectionString = process.env.CHRONICLE_INTEGRATION_CONNECTION_STRING;
+
+@eventType()
+class MethodOnceOnlyHappened {
+    @field(String) name = '';
+}
+
+@eventType()
+class MethodReplayableHappened {
+    @field(String) name = '';
+}
+
+@eventType()
+class MethodReplayOnceOnlyHappened {
+    @field(String) name = '';
+}
+
+// The client constructs reactor instances; share a sink for assertions across that boundary.
+const invocations: string[] = [];
+
+@reactor()
+class MixedOnceOnlyReactor {
+    @onceOnly()
+    methodOnceOnlyHappened(event: MethodOnceOnlyHappened) { invocations.push(`once-only:${event.name}`); }
+
+    methodReplayableHappened(event: MethodReplayableHappened) { invocations.push(`replayable:${event.name}`); }
+
+    methodReplayOnceOnlyHappened(event: MethodReplayOnceOnlyHappened) { invocations.push(`live:${event.name}`); }
+
+    @replay()
+    @onceOnly()
+    replayMethodReplayOnceOnlyHappened(event: MethodReplayOnceOnlyHappened) { invocations.push(`replay:${event.name}`); }
+}
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [MethodOnceOnlyHappened, MethodReplayableHappened, MethodReplayOnceOnlyHappened],
+    readModels: [],
+    reactors: [MixedOnceOnlyReactor],
+    reducers: [],
+    seeders: [],
+    constraints: [],
+    projections: [],
+    webhooks: [],
+    eventTypeMigrations: [],
+    globalForHandlers: []
+};
+
+async function eventually(accept: () => boolean, timeoutMs = 30_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (!accept()) {
+        if (Date.now() > deadline) throw new Error('Timed out waiting for the kernel');
+        await new Promise(resolve => setTimeout(resolve, 250));
+    }
+}
+
+const isEmptyJobId = (jobId: string | undefined) => /^[0-]*$/.test(jobId ?? '');
+
+describe.skipIf(!connectionString && !process.env.CI)('when replaying a reactor with once-only handlers against a kernel', () => {
+    const storeName = `Method${randomUUID().replaceAll('-', '').slice(0, 12)}`;
+    let client: ChronicleClient;
+    let store: IEventStore;
+    let connection: ChronicleConnection;
+    let jobId: string | undefined;
+    let invocationsBeforeReplay: string[];
+
+    beforeAll(async () => {
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
+            discoveryPatterns: [],
+            clientArtifactsProvider: artifacts
+        }));
+        store = await client.getEventStore(storeName);
+        connection = (store as unknown as { _connection: ChronicleConnection })._connection;
+
+        (await store.eventLog.append(randomUUID(), Object.assign(new MethodOnceOnlyHappened(), { name: 'a' }))).isSuccess.should.be.true;
+        (await store.eventLog.append(randomUUID(), Object.assign(new MethodReplayableHappened(), { name: 'b' }))).isSuccess.should.be.true;
+        (await store.eventLog.append(randomUUID(), Object.assign(new MethodReplayOnceOnlyHappened(), { name: 'c' }))).isSuccess.should.be.true;
+        await eventually(() => invocations.length === 3);
+        invocationsBeforeReplay = [...invocations];
+
+        jobId = (await connection.observers.replay({
+            EventStore: storeName,
+            Namespace: 'Default',
+            ObserverId: 'MixedOnceOnlyReactor',
+            EventSequenceId: 'event-log'
+        })).JobId;
+        await eventually(() => invocations.includes('replayable:b') && invocations.filter(_ => _ === 'replayable:b').length === 2);
+        await new Promise(resolve => setTimeout(resolve, 3_000));
+    });
+
+    afterAll(() => client?.dispose());
+
+    it('should run every handler once before the replay', () => {
+        invocationsBeforeReplay.sort().should.deep.equal(['live:c', 'once-only:a', 'replayable:b']);
+    });
+
+    it('should start the replay', () => {
+        isEmptyJobId(jobId).should.be.false;
+    });
+
+    it('should run the handler that is not once-only again', () => {
+        invocations.filter(_ => _ === 'replayable:b').length.should.equal(2);
+    });
+
+    it('should not run the once-only handler again', () => {
+        invocations.filter(_ => _ === 'once-only:a').length.should.equal(1);
+    });
+
+    it('should run neither the live nor the once-only replay handler again', () => {
+        invocations.filter(_ => _.endsWith(':c')).sort().should.deep.equal(['live:c']);
+    });
+});