@shivaedev/events 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.1.0 - 2026-11-03
+
+### Added
+
+- Keep optional durable feature history with versioned Effect Schema events, stable request ids and expected stream versions on PostgreSQL. Project through SQL repositories in the append transaction, rebuild read models with database-only projections and upcast historical payloads. Per-stream projection progress keeps late commits eligible for catch-up.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,104 @@
-# Temporary Holding Version
+# @shivaedev/events
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keep durable history for the features that need to explain how they got here. Commands record versioned Effect Schema values and update ordinary SQL repositories together; stored events can rebuild those rows later.
+
+## History with ordinary live queries
+
+A rename can leave both its history and its read model in one commit:
+
+```ts
+yield* notes.append({
+	stream: "note-123",
+	requestId: "rename-456",
+	expectedVersion: 0,
+	events: [{ name: "Published" }],
+});
+```
+
+The projection writes through `@shivaedev/sql`, so existing queries refresh through their usual change keys. Ordinary features can keep using SQL directly.
+
+## Using it
+
+A store groups streams with one event schema and a set of named projections. A stream starts at version zero and advances once per event. The schema version describes the payload format; it is independent of the stream version.
+
+### Set up PostgreSQL
+
+Install the optional package alongside your SQL stack:
+
+```sh
+pnpm add @shivaedev/events @shivaedev/sql effect @effect/sql-pg
+```
+
+Add `postgresMigration` from `@shivaedev/events/postgresMigration.ts` as one entry in your application's native migration loader. Run that loader with `migratePostgres` as usual. This creates the event, request, stream and projection-progress tables. The application owns its read-model migrations and PostgreSQL Layer.
+
+### Define a feature
+
+Describe the current event with Effect Schema, create ordinary repositories, then construct the store in the application's SQL environment:
+
+```ts
+import { Effect, Schema } from "effect";
+import { Model } from "effect/schema";
+import { makeEventStore } from "@shivaedev/events/makeEventStore.ts";
+import { makeRepository } from "@shivaedev/sql/repository.ts";
+
+class Note extends Model.Class<Note>("Note")({
+	id: Schema.String,
+	name: Schema.String,
+}) {}
+
+const Renamed = Schema.Struct({ name: Schema.String });
+
+const makeNotes = Effect.gen(function* () {
+	const rows = yield* makeRepository(Note, {
+		conflictColumns: ["id"],
+		idColumn: "id",
+		spanPrefix: "Note",
+		tableName: "notes",
+	});
+	return yield* makeEventStore({
+		name: "notes",
+		schema: Renamed,
+		version: 1,
+		projections: [
+			{
+				name: "names",
+				apply: ({ stream, value }) => rows.upsert({ id: stream, name: value.name }).pipe(Effect.asVoid),
+				reset: rows.delete({}),
+			},
+		],
+	});
+});
+```
+
+The application creates the `notes` table before acquiring this store. Keep store and projection names stable: they identify durable history and progress. Use a tagged schema union when a feature emits several event types.
+
+Projection `apply` receives `{ stream, streamVersion, requestId, value }`. `apply` and `reset` are database-only Effects: their service requirements allow SQL and Reactivity, with application failures retained in the error channel. Keep HTTP calls, jobs, email and other external effects outside projections, including services captured in closures. Rebuild invokes only `reset` and `apply`; it never runs command handlers. Replay order is stream name followed by stream version, so projections must not depend on a total order across streams.
+
+### Append from a command
+
+Call `append({ stream, requestId, expectedVersion, events })` with a nonempty batch. It returns the resulting stream version. Events, request recognition, projection progress and repository writes share `sql.transact`. A projection failure rolls them all back, including earlier events in the batch. An enclosing transaction must also use `transact`.
+
+Choose a stable request id before retrying a command. It is unique across the store. `AlreadyDone` from `errors.ts` carries the original `stream`, `streamVersion` and `requestId`; handle it as a completed request. It takes precedence over a stale expected version. `StreamConflict` carries `stream`, `expectedVersion` and `actualVersion`; reload the stream and decide the command again. Concurrent PostgreSQL writers use the same checks.
+
+### Read, catch up and rebuild
+
+`read(stream)` returns decoded events in stream-version order. `catchUp` applies events missing from each named projection, tracking progress separately for each stream. Call it when adding a projection or consuming history written by a store configuration without that projection. Calling it again does not reapply events. An event that was uncommitted during a pass remains eligible for the next pass; there is no global sequence high-water mark.
+
+`rebuild` resets the configured read models, clears their progress and replays stored events in one transaction. Its PostgreSQL table lock excludes appends and catch-up writes while rebuilding, across stores sharing these tables. This is an offline rebuild, so schedule it when blocking writes is acceptable. Each projection's reset must clear only the rows it owns.
+
+### Evolve event payloads
+
+Increase the schema version for new writes and provide `upcast` to turn an older encoded payload into the current encoded shape:
+
+```ts
+const options = {
+	name: "notes",
+	schema: Schema.Struct({ name: Schema.String }),
+	version: 2,
+	upcast: ({ payload }: { readonly version: number; readonly payload: unknown }) =>
+		Schema.decodeUnknownEffect(Schema.Struct({ title: Schema.String }))(payload).pipe(Effect.map(({ title }) => ({ name: title }))),
+	projections: [],
+};
+```
+
+The store calls the upcaster only for a different stored version, then decodes its result with the current schema's JSON codec. Without an upcaster it fails with `UnsupportedEventVersion`. For several historical versions, branch on the supplied version and compose the necessary transformations. Upcasters require no services and must perform no external effects. Stored payloads remain unchanged.

package/dist/append.d.ts

@@ -0,0 +1,5 @@
+import { Effect, Schema } from "effect";
+import { AlreadyDone, StreamConflict } from "#errors.ts";
+import type { Append, EventStoreOptions } from "#types.ts";
+export declare const append: <A, E, TUpcastError>(options: EventStoreOptions<A, E, TUpcastError>, command: Append<A>) => Effect.Effect<number, AlreadyDone | Schema.SchemaError | import("effect/sql/SqlError").SqlError | StreamConflict | import("#errors.ts").UnsupportedEventVersion | Exclude<E, import("effect/sql/SqlError").SqlError> | Exclude<TUpcastError, import("effect/sql/SqlError").SqlError>, import("#types.ts").ProjectionServices>;
+//# sourceMappingURL=append.d.ts.map

package/dist/append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../src/append.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAI3D,eAAO,MAAM,MAAM,GAAyC,CAAC,EAAE,CAAC,EAAE,YAAY,sYAoC5E,CAAC"}

package/dist/append.js

@@ -0,0 +1,35 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { transact } from "@shivaedev/sql/transact.ts";
+import { AlreadyDone, StreamConflict } from "#errors.ts";
+import { projectStream } from "#projectStream.ts";
+const Version = Schema.Struct({ version: Schema.Int });
+export const append = Effect.fn("Events.append")(function* (options, command) {
+    return yield* transact(Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        const version = command.expectedVersion + command.events.length;
+        const claimed = yield* sql `insert into events_requests (store, request_id, stream, version)
+				values (${options.name}, ${command.requestId}, ${command.stream}, ${version})
+				on conflict do nothing returning request_id`;
+        if (claimed.length === 0) {
+            const [done] = yield* sql `select stream, version from events_requests
+					where store = ${options.name} and request_id = ${command.requestId}`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.Struct({ stream: Schema.String, version: Schema.Int })))));
+            return yield* Effect.fail(new AlreadyDone({ requestId: command.requestId, stream: done.stream, streamVersion: done.version }));
+        }
+        yield* sql `insert into events_streams (store, stream, version) values (${options.name}, ${command.stream}, 0) on conflict do nothing`;
+        const changed = yield* sql `update events_streams set version = ${version}
+				where store = ${options.name} and stream = ${command.stream} and version = ${command.expectedVersion} returning version`;
+        if (changed.length === 0) {
+            const [current] = yield* sql `select version from events_streams where store = ${options.name} and stream = ${command.stream}`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Version))));
+            return yield* Effect.fail(new StreamConflict({ actualVersion: current.version, expectedVersion: command.expectedVersion, stream: command.stream }));
+        }
+        for (const [index, event] of command.events.entries()) {
+            const payload = yield* Schema.encodeEffect(Schema.toCodecJson(options.schema))(event);
+            yield* sql `insert into events_log (store, stream, stream_version, request_id, event_version, payload)
+					values (${options.name}, ${command.stream}, ${command.expectedVersion + index + 1}, ${command.requestId}, ${options.version}, ${JSON.stringify(payload)}::jsonb)`;
+        }
+        yield* projectStream(options, command.stream);
+        return version;
+    }), { onSqlError: (error) => error });
+});
+//# sourceMappingURL=append.js.map

package/dist/append.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.js","sourceRoot":"","sources":["../src/append.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,28 @@
+declare const AlreadyDone_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AlreadyDone";
+} & Readonly<A>;
+export declare class AlreadyDone extends AlreadyDone_base<{
+    readonly requestId: string;
+    readonly stream: string;
+    readonly streamVersion: number;
+}> {
+}
+declare const StreamConflict_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "StreamConflict";
+} & Readonly<A>;
+export declare class StreamConflict extends StreamConflict_base<{
+    readonly stream: string;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+}> {
+}
+declare const UnsupportedEventVersion_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnsupportedEventVersion";
+} & Readonly<A>;
+export declare class UnsupportedEventVersion extends UnsupportedEventVersion_base<{
+    readonly storedVersion: number;
+    readonly currentVersion: number;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,WAAY,SAAQ,iBAAgC;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B,CAAC;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,oBAAmC;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B,CAAC;CAAG;;;;AAEL,qBAAa,uBAAwB,SAAQ,6BAA4C;IACxF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CAChC,CAAC;CAAG"}

package/dist/errors.js

@@ -0,0 +1,8 @@
+import { Data } from "effect";
+export class AlreadyDone extends Data.TaggedError("AlreadyDone") {
+}
+export class StreamConflict extends Data.TaggedError("StreamConflict") {
+}
+export class UnsupportedEventVersion extends Data.TaggedError("UnsupportedEventVersion") {
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,MAAM,OAAO,WAAY,SAAQ,IAAI,CAAC,WAAW,CAAC,aAAa,CAI7D;CAAG;AAEL,MAAM,OAAO,cAAe,SAAQ,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAInE;CAAG;AAEL,MAAM,OAAO,uBAAwB,SAAQ,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAGrF;CAAG"}

package/dist/makeEventStore.d.ts

@@ -0,0 +1,15 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import type { Append, EventStoreOptions } from "#types.ts";
+export declare const makeEventStore: <A, E = never, TUpcastError = never>(options: EventStoreOptions<A, E, TUpcastError>) => Effect.Effect<{
+    append: (command: Append<A>) => Effect.Effect<number, import("./errors.ts").AlreadyDone | Schema.SchemaError | import("effect/sql/SqlError").SqlError | import("./errors.ts").StreamConflict | import("./errors.ts").UnsupportedEventVersion | Exclude<E, import("effect/sql/SqlError").SqlError> | Exclude<TUpcastError, import("effect/sql/SqlError").SqlError>, import("#types.ts").ProjectionServices>;
+    catchUp: Effect.Effect<void, Schema.SchemaError | import("effect/sql/SqlError").SqlError | import("./errors.ts").UnsupportedEventVersion | Exclude<E, import("effect/sql/SqlError").SqlError> | Exclude<TUpcastError, import("effect/sql/SqlError").SqlError>, import("#types.ts").ProjectionServices>;
+    read: (stream: string) => Effect.Effect<{
+        requestId: string;
+        stream: string;
+        streamVersion: number;
+        value: A;
+    }[], TUpcastError | Schema.SchemaError | import("effect/sql/SqlError").SqlError | import("./errors.ts").UnsupportedEventVersion, SqlClient.SqlClient>;
+    rebuild: Effect.Effect<void, Schema.SchemaError | import("effect/sql/SqlError").SqlError | import("./errors.ts").UnsupportedEventVersion | Exclude<E, import("effect/sql/SqlError").SqlError> | Exclude<TUpcastError, import("effect/sql/SqlError").SqlError>, import("#types.ts").ProjectionServices>;
+}, never, SqlClient.SqlClient>;
+//# sourceMappingURL=makeEventStore.d.ts.map

package/dist/makeEventStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeEventStore.d.ts","sourceRoot":"","sources":["../src/makeEventStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKvC,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAS3D,eAAO,MAAM,cAAc,GAAiD,CAAC,EAAE,CAAC,UAAU,YAAY;sBA6BlF,MAAM,CAAC,CAAC,CAAC;;mBAEZ,MAAM;;;;;;;8BAGrB,CAAC"}

package/dist/makeEventStore.js

@@ -0,0 +1,38 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { transact } from "@shivaedev/sql/transact.ts";
+import { append } from "#append.ts";
+import { projectStream } from "#projectStream.ts";
+import { readEvents } from "#readEvents.ts";
+const streams = Effect.fn("Events.streams")(function* (name) {
+    const sql = yield* SqlClient.SqlClient;
+    return yield* sql `select stream from events_streams where store = ${name} order by stream`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ stream: Schema.String })))));
+});
+export const makeEventStore = Effect.fn("Events.makeEventStore")(function* (options) {
+    const sql = yield* SqlClient.SqlClient;
+    const catchUp = Effect.gen(function* () {
+        for (const { stream } of yield* streams(options.name)) {
+            yield* transact(Effect.gen(function* () {
+                yield* sql `select version from events_streams where store = ${options.name} and stream = ${stream} for update`;
+                yield* projectStream(options, stream);
+            }), { onSqlError: (error) => error });
+        }
+    });
+    const rebuild = transact(Effect.gen(function* () {
+        yield* sql `lock table events_streams in exclusive mode`;
+        for (const projection of options.projections) {
+            yield* projection.reset;
+            yield* sql `delete from events_progress where store = ${options.name} and projection = ${projection.name}`;
+        }
+        for (const { stream } of yield* streams(options.name)) {
+            yield* projectStream(options, stream);
+        }
+    }), { onSqlError: (error) => error });
+    return {
+        append: (command) => append(options, command),
+        catchUp,
+        read: (stream) => readEvents(options, stream),
+        rebuild,
+    };
+});
+//# sourceMappingURL=makeEventStore.js.map

package/dist/makeEventStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeEventStore.js","sourceRoot":"","sources":["../src/makeEventStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG5C,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAY;IAClE,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;IACvC,OAAO,KAAK,CAAC,CAAC,GAAG,CAAA,mDAAmD,IAAI,kBAAkB,CAAC,IAAI,CAC9F,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAClG,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,EAAE,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,EACzE,OAA8C;IAE9C,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnC,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,KAAK,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,KAAK,CAAC,CAAC,QAAQ,CACd,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBACnB,KAAK,CAAC,CAAC,GAAG,CAAA,oDAAoD,OAAO,CAAC,IAAI,iBAAiB,MAAM,aAAa,CAAC;gBAC/G,KAAK,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACvC,CAAC,CAAC,EACF,EAAE,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAChC,CAAC;QACH,CAAC;IACF,CAAC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,QAAQ,CACvB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,KAAK,CAAC,CAAC,GAAG,CAAA,6CAA6C,CAAC;QACxD,KAAK,MAAM,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YAC9C,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;YACxB,KAAK,CAAC,CAAC,GAAG,CAAA,6CAA6C,OAAO,CAAC,IAAI,qBAAqB,UAAU,CAAC,IAAI,EAAE,CAAC;QAC3G,CAAC;QACD,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,KAAK,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,KAAK,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvC,CAAC;IACF,CAAC,CAAC,EACF,EAAE,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAChC,CAAC;IACF,OAAO;QACN,MAAM,EAAE,CAAC,OAAkB,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;QACxD,OAAO;QACP,IAAI,EAAE,CAAC,MAAc,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC;QACrD,OAAO;KACP,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/postgresMigration.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+export declare const postgresMigration: Effect.Effect<void, import("effect/sql/SqlError").SqlError, SqlClient.SqlClient>;
+//# sourceMappingURL=postgresMigration.d.ts.map

package/dist/postgresMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgresMigration.d.ts","sourceRoot":"","sources":["../src/postgresMigration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,eAAO,MAAM,iBAAiB,kFAqB5B,CAAC"}

package/dist/postgresMigration.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+export const postgresMigration = Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `create table events_streams (
+		store text not null, stream text not null, version integer not null,
+		primary key (store, stream)
+	)`;
+    yield* sql `create table events_requests (
+		store text not null, request_id text not null, stream text not null, version integer not null,
+		primary key (store, request_id)
+	)`;
+    yield* sql `create table events_log (
+		store text not null, stream text not null, stream_version integer not null,
+		request_id text not null, event_version integer not null, payload jsonb not null,
+		primary key (store, stream, stream_version),
+		foreign key (store, stream) references events_streams (store, stream)
+	)`;
+    yield* sql `create table events_progress (
+		store text not null, projection text not null, stream text not null, version integer not null,
+		primary key (store, projection, stream),
+		foreign key (store, stream) references events_streams (store, stream)
+	)`;
+});
+//# sourceMappingURL=postgresMigration.js.map

package/dist/postgresMigration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgresMigration.js","sourceRoot":"","sources":["../src/postgresMigration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACpD,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;IACvC,KAAK,CAAC,CAAC,GAAG,CAAA;;;GAGR,CAAC;IACH,KAAK,CAAC,CAAC,GAAG,CAAA;;;GAGR,CAAC;IACH,KAAK,CAAC,CAAC,GAAG,CAAA;;;;;GAKR,CAAC;IACH,KAAK,CAAC,CAAC,GAAG,CAAA;;;;GAIR,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/projectStream.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Schema } from "effect";
+import type { EventStoreOptions } from "#types.ts";
+export declare const projectStream: <A, E, TUpcastError>(options: EventStoreOptions<A, E, TUpcastError>, stream: string) => Effect.Effect<void, E | TUpcastError | Schema.SchemaError | import("effect/sql/SqlError").SqlError | import("./errors.ts").UnsupportedEventVersion, import("#types.ts").ProjectionServices>;
+//# sourceMappingURL=projectStream.d.ts.map

package/dist/projectStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectStream.d.ts","sourceRoot":"","sources":["../src/projectStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD,eAAO,MAAM,aAAa,GAAgD,CAAC,EAAE,CAAC,EAAE,YAAY,gQA6B1F,CAAC"}

package/dist/projectStream.js

@@ -0,0 +1,29 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { readEvents } from "#readEvents.ts";
+export const projectStream = Effect.fn("Events.projectStream")(function* (options, stream) {
+    const sql = yield* SqlClient.SqlClient;
+    const checkpoints = [];
+    for (const projection of options.projections) {
+        yield* sql `insert into events_progress (store, projection, stream, version)
+			values (${options.name}, ${projection.name}, ${stream}, 0) on conflict do nothing`;
+        const progress = yield* sql `select version from events_progress
+			where store = ${options.name} and projection = ${projection.name} and stream = ${stream} for update`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.Struct({ version: Schema.Int })))));
+        checkpoints.push({ projection, version: progress[0].version });
+    }
+    if (checkpoints.length === 0) {
+        return;
+    }
+    const events = yield* readEvents(options, stream, Math.min(...checkpoints.map(({ version }) => version)));
+    for (const event of events) {
+        for (const { projection, version } of checkpoints) {
+            if (event.streamVersion <= version) {
+                continue;
+            }
+            yield* projection.apply(event);
+            yield* sql `update events_progress set version = ${event.streamVersion}
+				where store = ${options.name} and projection = ${projection.name} and stream = ${stream}`;
+        }
+    }
+});
+//# sourceMappingURL=projectStream.js.map

package/dist/projectStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectStream.js","sourceRoot":"","sources":["../src/projectStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG5C,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC,QAAQ,CAAC,EACvE,OAA8C,EAC9C,MAAc;IAEd,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;IACvC,MAAM,WAAW,GAA8F,EAAE,CAAC;IAClH,KAAK,MAAM,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QAC9C,KAAK,CAAC,CAAC,GAAG,CAAA;aACC,OAAO,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,KAAK,MAAM,6BAA6B,CAAC;QACpF,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;mBACV,OAAO,CAAC,IAAI,qBAAqB,UAAU,CAAC,IAAI,iBAAiB,MAAM,aAAa,CAAC,IAAI,CACzG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CACxG,CAAC;QACF,WAAW,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO;IACR,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1G,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,KAAK,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC;YACnD,IAAI,KAAK,CAAC,aAAa,IAAI,OAAO,EAAE,CAAC;gBACpC,SAAS;YACV,CAAC;YACD,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC/B,KAAK,CAAC,CAAC,GAAG,CAAA,wCAAwC,KAAK,CAAC,aAAa;oBACpD,OAAO,CAAC,IAAI,qBAAqB,UAAU,CAAC,IAAI,iBAAiB,MAAM,EAAE,CAAC;QAC5F,CAAC;IACF,CAAC;AACF,CAAC,CAAC,CAAC"}

package/dist/readEvents.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { UnsupportedEventVersion } from "#errors.ts";
+import type { EventStoreOptions } from "#types.ts";
+export declare const readEvents: <A, E, TUpcastError>(options: EventStoreOptions<A, E, TUpcastError>, stream: string, after?: number | undefined) => Effect.Effect<{
+    requestId: string;
+    stream: string;
+    streamVersion: number;
+    value: A;
+}[], TUpcastError | Schema.SchemaError | import("effect/sql/SqlError").SqlError | UnsupportedEventVersion, SqlClient.SqlClient>;
+//# sourceMappingURL=readEvents.d.ts.map

package/dist/readEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readEvents.d.ts","sourceRoot":"","sources":["../src/readEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AASnD,eAAO,MAAM,UAAU,GAA6C,CAAC,EAAE,CAAC,EAAE,YAAY;;;;;+HA0BpF,CAAC"}

package/dist/readEvents.js

@@ -0,0 +1,31 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { UnsupportedEventVersion } from "#errors.ts";
+const Entry = Schema.Struct({
+    eventVersion: Schema.Int,
+    payload: Schema.Unknown,
+    requestId: Schema.String,
+    streamVersion: Schema.Int,
+});
+export const readEvents = Effect.fn("Events.readEvents")(function* (options, stream, after = 0) {
+    const sql = yield* SqlClient.SqlClient;
+    const entries = yield* sql `select event_version as "eventVersion", payload, request_id as "requestId", stream_version as "streamVersion"
+		from events_log where store = ${options.name} and stream = ${stream} and stream_version > ${after}
+		order by stream_version`.withoutTransform.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Entry))));
+    return yield* Effect.forEach(entries, (entry) => Effect.gen(function* () {
+        let payload = entry.payload;
+        if (entry.eventVersion !== options.version) {
+            if (options.upcast === undefined) {
+                return yield* Effect.fail(new UnsupportedEventVersion({ currentVersion: options.version, storedVersion: entry.eventVersion }));
+            }
+            payload = yield* options.upcast({ payload: entry.payload, version: entry.eventVersion });
+        }
+        return {
+            requestId: entry.requestId,
+            stream,
+            streamVersion: entry.streamVersion,
+            value: yield* Schema.decodeUnknownEffect(Schema.toCodecJson(options.schema))(payload),
+        };
+    }));
+});
+//# sourceMappingURL=readEvents.js.map

package/dist/readEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readEvents.js","sourceRoot":"","sources":["../src/readEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC,OAAO;IACvB,SAAS,EAAE,MAAM,CAAC,MAAM;IACxB,aAAa,EAAE,MAAM,CAAC,GAAG;CACzB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAAC,QAAQ,CAAC,EACjE,OAA8C,EAC9C,MAAc,EACd,KAAK,GAAG,CAAC;IAET,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;IACvC,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;kCACO,OAAO,CAAC,IAAI,iBAAiB,MAAM,yBAAyB,KAAK;0BACzE,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACjH,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAC/C,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,IAAI,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC5B,IAAI,KAAK,CAAC,YAAY,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC;YAC5C,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAClC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;YAChI,CAAC;YACD,OAAO,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QAC1F,CAAC;QACD,OAAO;YACN,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,MAAM;YACN,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;SACrF,CAAC;IACH,CAAC,CAAC,CACF,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import type { Effect, Schema } from "effect";
+import type { Reactivity } from "effect/reactivity/Reactivity";
+import type { SqlClient } from "effect/sql";
+export type ProjectionServices = SqlClient.SqlClient | Reactivity;
+export interface StoredEvent {
+    readonly payload: unknown;
+    readonly version: number;
+}
+export interface Event<A> {
+    readonly requestId: string;
+    readonly stream: string;
+    readonly streamVersion: number;
+    readonly value: A;
+}
+export interface Projection<A, E> {
+    readonly apply: (event: Event<A>) => Effect.Effect<void, E, ProjectionServices>;
+    readonly name: string;
+    readonly reset: Effect.Effect<void, E, ProjectionServices>;
+}
+export interface EventStoreOptions<A, E, TUpcastError> {
+    readonly name: string;
+    readonly projections: readonly Projection<A, E>[];
+    readonly schema: Schema.Codec<A, unknown>;
+    readonly upcast?: (event: StoredEvent) => Effect.Effect<unknown, TUpcastError>;
+    readonly version: number;
+}
+export interface Append<A> {
+    readonly events: readonly [A, ...A[]];
+    readonly expectedVersion: number;
+    readonly requestId: string;
+    readonly stream: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC,SAAS,GAAG,UAAU,CAAC;AAElE,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,KAAK,CAAC,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,EAAE,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,kBAAkB,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@shivaedev/events",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Durable event history and rebuildable SQL projections for Effect applications",
+  "keywords": [
+    "effect"
+  ],
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/events#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/events"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/sql": "0.35.0"
+  },
+  "devDependencies": {
+    "@effect/sql-pg": "4.0.6",
+    "@shivaedev/changes": "0.9.0",
+    "@shivaedev/quality": "0.57.1",
+    "@shivaedev/test-sql": "0.18.0",
+    "@shivaedev/test-story": "0.36.0",
+    "@types/node": "24.19.2",
+    "effect": "4.0.6",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.6"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/append.ts

@@ -0,0 +1,46 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { transact } from "@shivaedev/sql/transact.ts";
+import { AlreadyDone, StreamConflict } from "#errors.ts";
+import { projectStream } from "#projectStream.ts";
+import type { Append, EventStoreOptions } from "#types.ts";
+
+const Version = Schema.Struct({ version: Schema.Int });
+
+export const append = Effect.fn("Events.append")(function* <A, E, TUpcastError>(options: EventStoreOptions<A, E, TUpcastError>, command: Append<A>) {
+	return yield* transact(
+		Effect.gen(function* () {
+			const sql = yield* SqlClient.SqlClient;
+			const version = command.expectedVersion + command.events.length;
+			const claimed = yield* sql`insert into events_requests (store, request_id, stream, version)
+				values (${options.name}, ${command.requestId}, ${command.stream}, ${version})
+				on conflict do nothing returning request_id`;
+			if (claimed.length === 0) {
+				const [done] = yield* sql`select stream, version from events_requests
+					where store = ${options.name} and request_id = ${command.requestId}`.pipe(
+					Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.Struct({ stream: Schema.String, version: Schema.Int })))),
+				);
+				return yield* Effect.fail(new AlreadyDone({ requestId: command.requestId, stream: done.stream, streamVersion: done.version }));
+			}
+			yield* sql`insert into events_streams (store, stream, version) values (${options.name}, ${command.stream}, 0) on conflict do nothing`;
+			const changed = yield* sql`update events_streams set version = ${version}
+				where store = ${options.name} and stream = ${command.stream} and version = ${command.expectedVersion} returning version`;
+			if (changed.length === 0) {
+				const [current] = yield* sql`select version from events_streams where store = ${options.name} and stream = ${command.stream}`.pipe(
+					Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Version))),
+				);
+				return yield* Effect.fail(
+					new StreamConflict({ actualVersion: current.version, expectedVersion: command.expectedVersion, stream: command.stream }),
+				);
+			}
+			for (const [index, event] of command.events.entries()) {
+				const payload = yield* Schema.encodeEffect(Schema.toCodecJson(options.schema))(event);
+				yield* sql`insert into events_log (store, stream, stream_version, request_id, event_version, payload)
+					values (${options.name}, ${command.stream}, ${command.expectedVersion + index + 1}, ${command.requestId}, ${options.version}, ${JSON.stringify(payload)}::jsonb)`;
+			}
+			yield* projectStream(options, command.stream);
+			return version;
+		}),
+		{ onSqlError: (error) => error },
+	);
+});

package/src/errors.ts

@@ -0,0 +1,18 @@
+import { Data } from "effect";
+
+export class AlreadyDone extends Data.TaggedError("AlreadyDone")<{
+	readonly requestId: string;
+	readonly stream: string;
+	readonly streamVersion: number;
+}> {}
+
+export class StreamConflict extends Data.TaggedError("StreamConflict")<{
+	readonly stream: string;
+	readonly expectedVersion: number;
+	readonly actualVersion: number;
+}> {}
+
+export class UnsupportedEventVersion extends Data.TaggedError("UnsupportedEventVersion")<{
+	readonly storedVersion: number;
+	readonly currentVersion: number;
+}> {}

package/src/makeEventStore.ts

@@ -0,0 +1,50 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { transact } from "@shivaedev/sql/transact.ts";
+import { append } from "#append.ts";
+import { projectStream } from "#projectStream.ts";
+import { readEvents } from "#readEvents.ts";
+import type { Append, EventStoreOptions } from "#types.ts";
+
+const streams = Effect.fn("Events.streams")(function* (name: string) {
+	const sql = yield* SqlClient.SqlClient;
+	return yield* sql`select stream from events_streams where store = ${name} order by stream`.pipe(
+		Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ stream: Schema.String })))),
+	);
+});
+
+export const makeEventStore = Effect.fn("Events.makeEventStore")(function* <A, E = never, TUpcastError = never>(
+	options: EventStoreOptions<A, E, TUpcastError>,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	const catchUp = Effect.gen(function* () {
+		for (const { stream } of yield* streams(options.name)) {
+			yield* transact(
+				Effect.gen(function* () {
+					yield* sql`select version from events_streams where store = ${options.name} and stream = ${stream} for update`;
+					yield* projectStream(options, stream);
+				}),
+				{ onSqlError: (error) => error },
+			);
+		}
+	});
+	const rebuild = transact(
+		Effect.gen(function* () {
+			yield* sql`lock table events_streams in exclusive mode`;
+			for (const projection of options.projections) {
+				yield* projection.reset;
+				yield* sql`delete from events_progress where store = ${options.name} and projection = ${projection.name}`;
+			}
+			for (const { stream } of yield* streams(options.name)) {
+				yield* projectStream(options, stream);
+			}
+		}),
+		{ onSqlError: (error) => error },
+	);
+	return {
+		append: (command: Append<A>) => append(options, command),
+		catchUp,
+		read: (stream: string) => readEvents(options, stream),
+		rebuild,
+	};
+});

package/src/postgresMigration.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+
+export const postgresMigration = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`create table events_streams (
+		store text not null, stream text not null, version integer not null,
+		primary key (store, stream)
+	)`;
+	yield* sql`create table events_requests (
+		store text not null, request_id text not null, stream text not null, version integer not null,
+		primary key (store, request_id)
+	)`;
+	yield* sql`create table events_log (
+		store text not null, stream text not null, stream_version integer not null,
+		request_id text not null, event_version integer not null, payload jsonb not null,
+		primary key (store, stream, stream_version),
+		foreign key (store, stream) references events_streams (store, stream)
+	)`;
+	yield* sql`create table events_progress (
+		store text not null, projection text not null, stream text not null, version integer not null,
+		primary key (store, projection, stream),
+		foreign key (store, stream) references events_streams (store, stream)
+	)`;
+});

package/src/projectStream.ts

@@ -0,0 +1,35 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { readEvents } from "#readEvents.ts";
+import type { EventStoreOptions } from "#types.ts";
+
+export const projectStream = Effect.fn("Events.projectStream")(function* <A, E, TUpcastError>(
+	options: EventStoreOptions<A, E, TUpcastError>,
+	stream: string,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	const checkpoints: { readonly projection: (typeof options.projections)[number]; readonly version: number }[] = [];
+	for (const projection of options.projections) {
+		yield* sql`insert into events_progress (store, projection, stream, version)
+			values (${options.name}, ${projection.name}, ${stream}, 0) on conflict do nothing`;
+		const progress = yield* sql`select version from events_progress
+			where store = ${options.name} and projection = ${projection.name} and stream = ${stream} for update`.pipe(
+			Effect.flatMap(Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.Struct({ version: Schema.Int })))),
+		);
+		checkpoints.push({ projection, version: progress[0].version });
+	}
+	if (checkpoints.length === 0) {
+		return;
+	}
+	const events = yield* readEvents(options, stream, Math.min(...checkpoints.map(({ version }) => version)));
+	for (const event of events) {
+		for (const { projection, version } of checkpoints) {
+			if (event.streamVersion <= version) {
+				continue;
+			}
+			yield* projection.apply(event);
+			yield* sql`update events_progress set version = ${event.streamVersion}
+				where store = ${options.name} and projection = ${projection.name} and stream = ${stream}`;
+		}
+	}
+});

package/src/readEvents.ts

@@ -0,0 +1,39 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { UnsupportedEventVersion } from "#errors.ts";
+import type { EventStoreOptions } from "#types.ts";
+
+const Entry = Schema.Struct({
+	eventVersion: Schema.Int,
+	payload: Schema.Unknown,
+	requestId: Schema.String,
+	streamVersion: Schema.Int,
+});
+
+export const readEvents = Effect.fn("Events.readEvents")(function* <A, E, TUpcastError>(
+	options: EventStoreOptions<A, E, TUpcastError>,
+	stream: string,
+	after = 0,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	const entries = yield* sql`select event_version as "eventVersion", payload, request_id as "requestId", stream_version as "streamVersion"
+		from events_log where store = ${options.name} and stream = ${stream} and stream_version > ${after}
+		order by stream_version`.withoutTransform.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Entry))));
+	return yield* Effect.forEach(entries, (entry) =>
+		Effect.gen(function* () {
+			let payload = entry.payload;
+			if (entry.eventVersion !== options.version) {
+				if (options.upcast === undefined) {
+					return yield* Effect.fail(new UnsupportedEventVersion({ currentVersion: options.version, storedVersion: entry.eventVersion }));
+				}
+				payload = yield* options.upcast({ payload: entry.payload, version: entry.eventVersion });
+			}
+			return {
+				requestId: entry.requestId,
+				stream,
+				streamVersion: entry.streamVersion,
+				value: yield* Schema.decodeUnknownEffect(Schema.toCodecJson(options.schema))(payload),
+			};
+		}),
+	);
+});

package/src/types.ts

@@ -0,0 +1,38 @@
+import type { Effect, Schema } from "effect";
+import type { Reactivity } from "effect/reactivity/Reactivity";
+import type { SqlClient } from "effect/sql";
+
+export type ProjectionServices = SqlClient.SqlClient | Reactivity;
+
+export interface StoredEvent {
+	readonly payload: unknown;
+	readonly version: number;
+}
+
+export interface Event<A> {
+	readonly requestId: string;
+	readonly stream: string;
+	readonly streamVersion: number;
+	readonly value: A;
+}
+
+export interface Projection<A, E> {
+	readonly apply: (event: Event<A>) => Effect.Effect<void, E, ProjectionServices>;
+	readonly name: string;
+	readonly reset: Effect.Effect<void, E, ProjectionServices>;
+}
+
+export interface EventStoreOptions<A, E, TUpcastError> {
+	readonly name: string;
+	readonly projections: readonly Projection<A, E>[];
+	readonly schema: Schema.Codec<A, unknown>;
+	readonly upcast?: (event: StoredEvent) => Effect.Effect<unknown, TUpcastError>;
+	readonly version: number;
+}
+
+export interface Append<A> {
+	readonly events: readonly [A, ...A[]];
+	readonly expectedVersion: number;
+	readonly requestId: string;
+	readonly stream: string;
+}