effect-cqrs 0.1.0 → 0.2.0

package/src/SqliteEventStore.ts

@@ -16,7 +16,8 @@ export interface Options {
 
 const EventRow = Schema.Struct({
   ...EventStore.StoredEvent.fields,
-  payload: Schema.fromJsonString(Schema.Json)
+  payload: Schema.fromJsonString(Schema.Json),
+  metadata: Schema.fromJsonString(Schema.JsonObject)
 })
 
 const decodeRows = Schema.decodeUnknownEffect(Schema.Array(EventRow))
@@ -25,6 +26,13 @@ const storeError = (operation: string) => (cause: unknown) => new EventStore.Eve
 
 const isUniqueViolation = (error: SqlError.SqlError) => error.reason._tag === "UniqueViolation"
 
+const addedColumns: ReadonlyArray<readonly [string, string]> = [
+  ["schema_version", "INTEGER NOT NULL DEFAULT 1"],
+  ["correlation_id", "TEXT"],
+  ["causation_id", "TEXT"],
+  ["metadata", "TEXT NOT NULL DEFAULT '{}'"]
+]
+
 export const make = Effect.fnUntraced(function*(options?: Options) {
   const sql = yield* SqlClient.SqlClient
   const events = sql(options?.eventsTable ?? "cqrs_events")
@@ -37,11 +45,29 @@ export const make = Effect.fnUntraced(function*(options?: Options) {
       aggregate_id TEXT NOT NULL,
       version INTEGER NOT NULL,
       type TEXT NOT NULL,
+      schema_version INTEGER NOT NULL DEFAULT 1,
       payload TEXT NOT NULL,
       timestamp INTEGER NOT NULL,
+      correlation_id TEXT,
+      causation_id TEXT,
+      metadata TEXT NOT NULL DEFAULT '{}',
       UNIQUE (aggregate_name, aggregate_id, version)
     )
   `.pipe(Effect.mapError(storeError("initialize")))
+  // Tables created before these columns existed get them here. SQLite has no
+  // `ADD COLUMN IF NOT EXISTS`, so the existing columns are listed first.
+  const existing = yield* sql<{ readonly name: string }>`PRAGMA table_info(${events})`.pipe(
+    Effect.map((rows) => new Set(rows.map(({ name }) => name))),
+    Effect.mapError(storeError("initialize"))
+  )
+  yield* Effect.forEach(
+    addedColumns.filter(([name]) => !existing.has(name)),
+    ([name, definition]) =>
+      sql`ALTER TABLE ${events} ADD COLUMN ${sql(name)} ${sql.literal(definition)}`.pipe(
+        Effect.mapError(storeError("initialize"))
+      ),
+    { discard: true }
+  )
   yield* sql`
     CREATE INDEX IF NOT EXISTS ${sql(`${indexPrefix}_type_idx`)} ON ${events} (type, position)
   `.pipe(Effect.mapError(storeError("initialize")))
@@ -52,8 +78,12 @@ export const make = Effect.fnUntraced(function*(options?: Options) {
     aggregate_id AS "aggregateId",
     version,
     type,
+    schema_version AS "schemaVersion",
     payload,
-    timestamp
+    timestamp,
+    correlation_id AS "correlationId",
+    causation_id AS "causationId",
+    metadata
   `)
 
   const append = (input: EventStore.AppendInput) => {
@@ -71,28 +101,28 @@ export const make = Effect.fnUntraced(function*(options?: Options) {
         return yield* conflict
       }
       const timestamp = yield* Clock.currentTimeMillis
+      const metadata = JSON.stringify(input.metadata ?? {})
       return yield* Effect.forEach(input.events, (event, index) =>
         sql<{ readonly position: number }>`
-          INSERT INTO ${events} (aggregate_name, aggregate_id, version, type, payload, timestamp)
+          INSERT INTO ${events} (
+            aggregate_name, aggregate_id, version, type, schema_version, payload, timestamp, correlation_id, causation_id,
+            metadata
+          )
           VALUES (
             ${input.aggregateName},
             ${input.aggregateId},
             ${input.expectedVersion + index + 1},
             ${event.type},
+            ${event.schemaVersion ?? 1},
             ${JSON.stringify(event.payload)},
-            ${timestamp}
+            ${timestamp},
+            ${input.correlationId ?? null},
+            ${input.causationId ?? null},
+            ${metadata}
           )
           RETURNING position
         `.pipe(
-          Effect.map(([row]): EventStore.StoredEvent => ({
-            position: row!.position,
-            aggregateName: input.aggregateName,
-            aggregateId: input.aggregateId,
-            version: input.expectedVersion + index + 1,
-            type: event.type,
-            payload: event.payload,
-            timestamp: DateTime.makeUnsafe(timestamp)
-          }))
+          Effect.map(([row]) => EventStore.toStored(input, event, index, row!.position, DateTime.makeUnsafe(timestamp)))
         ))
     }).pipe(
       sql.withTransaction,

package/src/ViewModel.ts

@@ -23,6 +23,7 @@ import {
 import type { DateTime } from "effect"
 import type * as Aggregate from "./Aggregate.ts"
 import { makeEventDecoder } from "./AggregateService.ts"
+import * as Causation from "./Causation.ts"
 import { Checkpoints } from "./Checkpoints.ts"
 import { type EventFilter, EventStore, type EventStoreError, type StoredEvent } from "./EventStore.ts"
 
@@ -188,7 +189,8 @@ const makeRunner = Effect.fnUntraced(function*<V extends Any>(viewModel: V, tail
   const handle = (decodeEvent: (stored: StoredEvent) => Effect.Effect<unknown, unknown>) => (stored: StoredEvent) =>
     Effect.gen(function*() {
       const event = yield* decodeEvent(stored)
-      yield* viewModel.handlers[stored.type]!(event as never, stored)
+      // Commands the handler runs record this event as their cause.
+      yield* viewModel.handlers[stored.type]!(event as never, stored).pipe(Causation.causedBy(stored))
     }).pipe(
       Effect.mapError(fail(stored.position)),
       Effect.catchDefect((defect) => Effect.fail(fail(stored.position)(defect)))

package/src/index.ts

@@ -1,8 +1,12 @@
 export * as Aggregate from "./Aggregate.ts"
 export * as AggregateService from "./AggregateService.ts"
+export * as Causation from "./Causation.ts"
 export * as Checkpoints from "./Checkpoints.ts"
 export * as EventStore from "./EventStore.ts"
+export * as EventVersions from "./EventVersions.ts"
 export * as Fixture from "./Fixture.ts"
+export * as Metadata from "./Metadata.ts"
 export * as PostgresEventStore from "./PostgresEventStore.ts"
+export * as Saga from "./Saga.ts"
 export * as SqliteEventStore from "./SqliteEventStore.ts"
 export * as ViewModel from "./ViewModel.ts"