@house-rules/event-log 0.0.0-stage → 0.1.0

package/dist/event/options.js

@@ -0,0 +1,28 @@
+import { ConsumerOptions } from "./delivery.js";
+import { Effect, Schema } from "effect";
+import { EventInputInvalid } from "./event.js";
+export const deliveryDefaults = {
+    maxAttempts: 5,
+    backoff: { baseMs: 1000, capMs: 300000 },
+};
+export const validateOptions = Effect.fn("EventLog.validateOptions")(function* (options) {
+    const consumers = yield* Schema.decodeEffect(Schema.Array(ConsumerOptions))(options.consumers).pipe(Effect.mapError(() => new EventInputInvalid({ message: "Invalid event consumer options." })));
+    const names = new Set();
+    for (const consumer of consumers) {
+        if (names.has(consumer.name) ||
+            consumer.kinds.some((kind) => !Object.hasOwn(options.registry, kind)) ||
+            (consumer.backoff !== undefined && consumer.backoff.baseMs > consumer.backoff.capMs)) {
+            return yield* new EventInputInvalid({ message: "Invalid event consumer registration." });
+        }
+        names.add(consumer.name);
+    }
+    return {
+        registry: { ...options.registry },
+        consumers: consumers.map((consumer) => ({
+            ...consumer,
+            kinds: [...new Set(consumer.kinds)],
+            maxAttempts: consumer.maxAttempts ?? deliveryDefaults.maxAttempts,
+            backoff: consumer.backoff ?? deliveryDefaults.backoff,
+        })),
+    };
+});

package/dist/event/permissions.d.ts

@@ -0,0 +1,8 @@
+export declare const EventLogPermissions: {
+    readonly record: "event-log:record";
+    readonly read: "event-log:read";
+    readonly deliver: "event-log:deliver";
+    readonly deadLetters: "event-log:dead-letters";
+    readonly replay: "event-log:replay";
+};
+export type EventLogPermission = (typeof EventLogPermissions)[keyof typeof EventLogPermissions];

package/dist/event/permissions.js

@@ -0,0 +1,7 @@
+export const EventLogPermissions = {
+    record: "event-log:record",
+    read: "event-log:read",
+    deliver: "event-log:deliver",
+    deadLetters: "event-log:dead-letters",
+    replay: "event-log:replay",
+};

package/dist/event/source.d.ts

@@ -0,0 +1,4 @@
+import { EventSource } from "@house-rules/application";
+import { Layer } from "effect";
+import type { EventLogService } from "./event-log.js";
+export declare const eventSource: (log: EventLogService) => Layer.Layer<EventSource, never, never>;

package/dist/event/source.js

@@ -0,0 +1,15 @@
+import { EventSource, EventSourceUnavailable } from "@house-rules/application";
+import { Effect, Layer, Schema, Stream } from "effect";
+import { DeliveryToken } from "./delivery.js";
+export const eventSource = (log) => Layer.unwrap(Effect.gen(function* () {
+    const unavailable = (cause) => new EventSourceUnavailable({ cause });
+    const token = Schema.decodeUnknownEffect(DeliveryToken);
+    return Layer.succeed(EventSource, {
+        consumers: yield* log.consumers(),
+        claimDue: (consumer) => log.claimDue({ consumer }).pipe(Effect.mapError(unavailable)),
+        takeNext: (input) => token(input).pipe(Effect.flatMap(log.takeNext), Effect.map((delivery) => delivery?.event ?? null), Effect.mapError(unavailable)),
+        settleSuccess: (input) => token(input).pipe(Effect.flatMap(log.settleSuccess), Effect.mapError(unavailable)),
+        settleFailure: (input, summary) => token(input).pipe(Effect.flatMap((decoded) => log.settleFailure(decoded, summary)), Effect.mapError(unavailable)),
+        wake: Stream.unwrap(log.wakeups()).pipe(Stream.mapError(unavailable)),
+    });
+}));

package/dist/facade.d.ts

@@ -0,0 +1,278 @@
+import { Effect, Layer } from "effect";
+import { type EventLogOptions } from "./event/options.js";
+import { EventStore } from "./storage.js";
+declare const EventLog_base: import("effect/Context").ServiceClass<EventLog, "event-log", {
+    consumers: () => Effect.Effect<{
+        name: string;
+        kinds: string[];
+    }[], never, never>;
+    record: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    } | null, fact: {
+        readonly kind: string;
+        readonly subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly payload: unknown;
+        readonly scopeId: string | null;
+    }, requestId?: string | null | undefined) => Effect.Effect<{
+        kind: string;
+        subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        scopeId: string | null;
+        id: string;
+        actorId: string | null;
+        occurredAt: number;
+        requestId: string | null;
+        payload: unknown;
+    }, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    read: (query?: {
+        readonly after?: string;
+        readonly kinds?: readonly string[];
+        readonly subject?: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly scopeId?: string;
+        readonly requestId?: string;
+        readonly from?: number;
+        readonly to?: number;
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<{
+        kind: string;
+        subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        scopeId: string | null;
+        id: string;
+        actorId: string | null;
+        occurredAt: number;
+        requestId: string | null;
+        payload: unknown;
+    }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable, never>;
+    due: () => Effect.Effect<{
+        consumer: string;
+    }[], import("./contract.ts").EventStoreUnavailable, never>;
+    claimDue: (query?: {
+        readonly consumer?: string;
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<{
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    takeNext: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }) => Effect.Effect<{
+        event: {
+            kind: string;
+            subject: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            scopeId: string | null;
+            id: string;
+            actorId: string | null;
+            occurredAt: number;
+            requestId: string | null;
+            payload: unknown;
+        };
+        token: {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        };
+    } | null, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    settleSuccess: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }) => Effect.Effect<boolean, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    settleFailure: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }, lastError: string) => Effect.Effect<boolean, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    listDeadLetters: (query?: {
+        readonly consumer?: string;
+        readonly after?: {
+            readonly eventId: string;
+            readonly consumer: string;
+        };
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<readonly {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly lastError: string;
+        readonly attempts: number;
+        readonly failedAt: number;
+    }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable, never>;
+    replay: (consumer: string, eventId: string) => Effect.Effect<"already_queued" | "busy" | "enqueued", import("./contract.ts").DeadLetterNotFound | import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    wakeups: () => Effect.Effect<import("effect/Stream").Stream<void, import("./contract.ts").EventStoreUnavailable, never>, never, never>;
+}> & {
+    readonly id: "event-log";
+} & {
+    readonly make: (options: Readonly<{
+        registry: Readonly<Record<string, import("@house-rules/domain").PlainSchema>>;
+        consumers: ReadonlyArray<import("./contract.ts").ConsumerOptions>;
+    }>) => Effect.Effect<{
+        consumers: () => Effect.Effect<{
+            name: string;
+            kinds: string[];
+        }[], never, never>;
+        record: (actor: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        } | null, fact: {
+            readonly kind: string;
+            readonly subject: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly payload: unknown;
+            readonly scopeId: string | null;
+        }, requestId?: string | null | undefined) => Effect.Effect<{
+            kind: string;
+            subject: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            scopeId: string | null;
+            id: string;
+            actorId: string | null;
+            occurredAt: number;
+            requestId: string | null;
+            payload: unknown;
+        }, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        read: (query?: {
+            readonly after?: string;
+            readonly kinds?: readonly string[];
+            readonly subject?: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            readonly scopeId?: string;
+            readonly requestId?: string;
+            readonly from?: number;
+            readonly to?: number;
+            readonly limit?: number;
+        } | undefined) => Effect.Effect<{
+            kind: string;
+            subject: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            scopeId: string | null;
+            id: string;
+            actorId: string | null;
+            occurredAt: number;
+            requestId: string | null;
+            payload: unknown;
+        }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable, never>;
+        due: () => Effect.Effect<{
+            consumer: string;
+        }[], import("./contract.ts").EventStoreUnavailable, never>;
+        claimDue: (query?: {
+            readonly consumer?: string;
+            readonly limit?: number;
+        } | undefined) => Effect.Effect<{
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        takeNext: (token: {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        }) => Effect.Effect<{
+            event: {
+                kind: string;
+                subject: {
+                    readonly kind: string;
+                    readonly id: string;
+                };
+                scopeId: string | null;
+                id: string;
+                actorId: string | null;
+                occurredAt: number;
+                requestId: string | null;
+                payload: unknown;
+            };
+            token: {
+                readonly consumer: string;
+                readonly eventId: string;
+                readonly attempt: number;
+                readonly replay: boolean;
+                readonly generation: string;
+            };
+        } | null, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        settleSuccess: (token: {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        }) => Effect.Effect<boolean, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        settleFailure: (token: {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        }, lastError: string) => Effect.Effect<boolean, import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        listDeadLetters: (query?: {
+            readonly consumer?: string;
+            readonly after?: {
+                readonly eventId: string;
+                readonly consumer: string;
+            };
+            readonly limit?: number;
+        } | undefined) => Effect.Effect<readonly {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly lastError: string;
+            readonly attempts: number;
+            readonly failedAt: number;
+        }[], import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable, never>;
+        replay: (consumer: string, eventId: string) => Effect.Effect<"already_queued" | "busy" | "enqueued", import("./contract.ts").DeadLetterNotFound | import("./contract.ts").EventInputInvalid | import("./contract.ts").EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+        wakeups: () => Effect.Effect<import("effect/Stream").Stream<void, import("./contract.ts").EventStoreUnavailable, never>, never, never>;
+    }, import("./contract.ts").EventInputInvalid, EventStore>;
+    readonly layer: (options: Readonly<{
+        registry: Readonly<Record<string, import("@house-rules/domain").PlainSchema>>;
+        consumers: ReadonlyArray<import("./contract.ts").ConsumerOptions>;
+    }>) => import("@house-rules/domain").ModuleLayer<EventLog, import("./contract.ts").EventInputInvalid, EventStore>;
+};
+export declare class EventLog extends EventLog_base {
+    static readonly source: Layer.Layer<import("@house-rules/application").EventSource, never, EventLog>;
+    static readonly presets: {
+        readonly default: {
+            readonly maxAttempts: 5;
+            readonly backoff: {
+                readonly baseMs: 1000;
+                readonly capMs: 300000;
+            };
+        };
+    };
+    static readonly layerMemory: (options: EventLogOptions) => Layer.Layer<EventLog, import("./contract.ts").EventInputInvalid, never>;
+    static readonly layerPostgres: (options: EventLogOptions) => Layer.Layer<EventLog, import("./contract.ts").EventInputInvalid, import("@effect/sql-pg/PgClient").PgClient>;
+}
+export {};

package/dist/facade.js

@@ -0,0 +1,19 @@
+import { defineModule } from "@house-rules/domain";
+import { Effect, Layer } from "effect";
+import { memoryEventStore } from "./adapters/memory/event.js";
+import { postgresEventStore } from "./adapters/postgres/event.js";
+import { makeEventLog } from "./event/event-log.js";
+import { validateOptions, deliveryDefaults } from "./event/options.js";
+import { EventStore } from "./storage.js";
+import { eventSource } from "./event/source.js";
+export class EventLog extends defineModule()("event-log", {
+    make: (options) => Effect.gen(function* () {
+        const settings = yield* validateOptions(options);
+        return makeEventLog(yield* EventStore, settings);
+    }),
+}) {
+    static source = Layer.unwrap(Effect.map(EventLog, eventSource));
+    static presets = { default: deliveryDefaults };
+    static layerMemory = (options) => this.layer(options).pipe(Layer.provide(memoryEventStore()));
+    static layerPostgres = (options) => this.layer(options).pipe(Layer.provide(postgresEventStore));
+}

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+import { EventLog } from "./facade.js";
+import { bindEventLog } from "./event/bind-event-log.js";
+export declare const EventLogMount: {
+    map: {
+        name: string;
+        kind: "package";
+        package: string;
+    };
+    service: typeof EventLog;
+    operations: (import("@house-rules/domain").Operation<"EventLog.claimDue", import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").optionalKey<import("effect/Schema").NonEmptyString>;
+        readonly limit: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+        readonly eventId: import("effect/Schema").String;
+        readonly attempt: import("effect/Schema").Int;
+        readonly replay: import("effect/Schema").Boolean;
+        readonly generation: import("effect/Schema").String;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"EventLog.due", import("effect/Schema").Struct<{}>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"EventLog.listDeadLetters", import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").optionalKey<import("effect/Schema").NonEmptyString>;
+        readonly after: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly eventId: import("effect/Schema").String;
+            readonly consumer: import("effect/Schema").NonEmptyString;
+        }>>;
+        readonly limit: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+        readonly eventId: import("effect/Schema").String;
+        readonly lastError: import("effect/Schema").String;
+        readonly attempts: import("effect/Schema").Int;
+        readonly failedAt: import("effect/Schema").Int;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"EventLog.read", import("effect/Schema").Struct<{
+        readonly after: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly kinds: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>>;
+        readonly subject: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>>;
+        readonly scopeId: import("effect/Schema").optionalKey<import("effect/Schema").NonEmptyString>;
+        readonly requestId: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly from: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+        readonly to: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+        readonly limit: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").NonEmptyString;
+        readonly subject: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly payload: import("effect/Schema").Unknown;
+        readonly scopeId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly id: import("effect/Schema").String;
+        readonly actorId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly occurredAt: import("effect/Schema").Int;
+        readonly requestId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"EventLog.record", import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").NonEmptyString;
+        readonly subject: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly payload: import("effect/Schema").Unknown;
+        readonly scopeId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").NonEmptyString;
+        readonly subject: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly payload: import("effect/Schema").Unknown;
+        readonly scopeId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly id: import("effect/Schema").String;
+        readonly actorId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly occurredAt: import("effect/Schema").Int;
+        readonly requestId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"EventLog.replay", import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+        readonly eventId: import("effect/Schema").String;
+    }>, import("effect/Schema").Literals<readonly ["enqueued", "busy", "already_queued"]>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable, typeof import("./contract.js").DeadLetterNotFound]>, NoInfer<readonly []>, false, false, true, true> | import("@house-rules/domain").Operation<"EventLog.settleFailure", import("effect/Schema").Struct<{
+        readonly token: import("effect/Schema").Struct<{
+            readonly consumer: import("effect/Schema").NonEmptyString;
+            readonly eventId: import("effect/Schema").String;
+            readonly attempt: import("effect/Schema").Int;
+            readonly replay: import("effect/Schema").Boolean;
+            readonly generation: import("effect/Schema").String;
+        }>;
+        readonly lastError: import("effect/Schema").String;
+    }>, import("effect/Schema").Boolean, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"EventLog.settleSuccess", import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+        readonly eventId: import("effect/Schema").String;
+        readonly attempt: import("effect/Schema").Int;
+        readonly replay: import("effect/Schema").Boolean;
+        readonly generation: import("effect/Schema").String;
+    }>, import("effect/Schema").Boolean, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"EventLog.takeNext", import("effect/Schema").Struct<{
+        readonly consumer: import("effect/Schema").NonEmptyString;
+        readonly eventId: import("effect/Schema").String;
+        readonly attempt: import("effect/Schema").Int;
+        readonly replay: import("effect/Schema").Boolean;
+        readonly generation: import("effect/Schema").String;
+    }>, import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly token: import("effect/Schema").Struct<{
+            readonly consumer: import("effect/Schema").NonEmptyString;
+            readonly eventId: import("effect/Schema").String;
+            readonly attempt: import("effect/Schema").Int;
+            readonly replay: import("effect/Schema").Boolean;
+            readonly generation: import("effect/Schema").String;
+        }>;
+        readonly event: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly subject: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly payload: import("effect/Schema").Unknown;
+            readonly scopeId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+            readonly id: import("effect/Schema").String;
+            readonly actorId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+            readonly occurredAt: import("effect/Schema").Int;
+            readonly requestId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        }>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").EventInputInvalid, typeof import("./contract.js").EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>)[];
+    bind: typeof bindEventLog;
+};
+export { EventLog } from "./facade.js";
+export { bindEventLog } from "./event/bind-event-log.js";
+export { EventStore } from "./storage.js";
+export { memoryEventStore } from "./adapters/memory/event.js";
+export { postgresEventStore } from "./adapters/postgres/event.js";
+export { EventId, EventFact, StoredEvent, EventQuery, EventInputInvalid, EventStoreUnavailable, DeadLetterNotFound, DeliveryToken, ReplayResult, Delivery, DeadLetter, DeadLetterQuery, DeadLetterCursor, ConsumerOptions, EventLogOperations, EventLogPermissions, type EventLogPermission, type EventLogOptions, } from "./contract.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+import { EventLog } from "./facade.js";
+import { EventLogOperations } from "./event/operations.js";
+import { bindEventLog } from "./event/bind-event-log.js";
+export const EventLogMount = {
+    map: { name: "event-log", kind: "package", package: "@house-rules/event-log" },
+    service: EventLog,
+    operations: Object.values(EventLogOperations),
+    bind: bindEventLog,
+};
+export { EventLog } from "./facade.js";
+export { bindEventLog } from "./event/bind-event-log.js";
+export { EventStore } from "./storage.js";
+export { memoryEventStore } from "./adapters/memory/event.js";
+export { postgresEventStore } from "./adapters/postgres/event.js";
+export { EventId, EventFact, StoredEvent, EventQuery, EventInputInvalid, EventStoreUnavailable, DeadLetterNotFound, DeliveryToken, ReplayResult, Delivery, DeadLetter, DeadLetterQuery, DeadLetterCursor, ConsumerOptions, EventLogOperations, EventLogPermissions, } from "./contract.js";

package/dist/storage.d.ts

@@ -0,0 +1,22 @@
+import type { NoOpenUnit } from "@house-rules/domain";
+import { Context, type Effect, type Stream } from "effect";
+import type { Candidate, DeadLetter, DeadLetterQuery } from "./event/delivery.js";
+import type { EventQuery, EventStoreUnavailable, StoredEvent } from "./event/event.js";
+type Write<A = void> = Effect.Effect<A, EventStoreUnavailable | NoOpenUnit>;
+declare const EventStore_base: Context.ServiceClass<EventStore, "@house-rules/event-log/EventStore", {
+    readonly append: (event: Omit<StoredEvent, "id">) => Write<StoredEvent>;
+    readonly read: (query: EventQuery) => Effect.Effect<ReadonlyArray<StoredEvent>, EventStoreUnavailable>;
+    readonly lock: (consumer: string) => Write<boolean>;
+    readonly candidate: (consumer: string, kinds: ReadonlyArray<string>) => Effect.Effect<Candidate | undefined, EventStoreUnavailable>;
+    readonly retry: (consumer: string, candidate: Candidate) => Write;
+    readonly enqueueReplay: (consumer: string, candidate: Candidate) => Write<boolean>;
+    readonly advance: (consumer: string, eventId: string, replay: boolean) => Write;
+    readonly deadLetter: (row: DeadLetter) => Write;
+    readonly listDeadLetters: (query: DeadLetterQuery) => Effect.Effect<ReadonlyArray<DeadLetter>, EventStoreUnavailable>;
+    readonly findDeadLetter: (consumer: string, eventId: string) => Effect.Effect<DeadLetter | undefined, EventStoreUnavailable>;
+    readonly clearDeadLetter: (consumer: string, eventId: string) => Write;
+    readonly wakeups: Stream.Stream<void, EventStoreUnavailable>;
+}>;
+export declare class EventStore extends EventStore_base {
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class EventStore extends Context.Service()("@house-rules/event-log/EventStore") {
+}

package/migrations/0001_event_log.sql

@@ -0,0 +1,49 @@
+CREATE TABLE event_log_sequence (
+  singleton boolean PRIMARY KEY DEFAULT true CHECK (singleton),
+  cursor bigint NOT NULL DEFAULT 0
+);
+--> statement-breakpoint
+INSERT INTO event_log_sequence (singleton) VALUES (true);
+--> statement-breakpoint
+CREATE TABLE event_log_events (
+  id bigint PRIMARY KEY,
+  kind text NOT NULL,
+  subject_kind text NOT NULL,
+  subject_id text NOT NULL,
+  payload jsonb NOT NULL,
+  scope_id text,
+  actor_id text,
+  occurred_at bigint NOT NULL,
+  request_id text
+);
+--> statement-breakpoint
+CREATE INDEX event_log_events_kind_cursor ON event_log_events (kind, id);
+--> statement-breakpoint
+CREATE TABLE event_log_consumers (
+  name text PRIMARY KEY,
+  cursor bigint NOT NULL DEFAULT 0
+);
+--> statement-breakpoint
+CREATE TABLE event_log_pending (
+  consumer text NOT NULL REFERENCES event_log_consumers (name),
+  event_id bigint NOT NULL REFERENCES event_log_events (id),
+  attempts integer NOT NULL CHECK (attempts >= 0),
+  next_due bigint NOT NULL,
+  replay boolean NOT NULL,
+  generation text NOT NULL,
+  last_error text NOT NULL,
+  PRIMARY KEY (consumer, event_id)
+);
+--> statement-breakpoint
+CREATE INDEX event_log_pending_replay_cursor ON event_log_pending (consumer, event_id) WHERE replay = true;
+--> statement-breakpoint
+CREATE TABLE event_log_dead_letters (
+  consumer text NOT NULL REFERENCES event_log_consumers (name),
+  event_id bigint NOT NULL REFERENCES event_log_events (id),
+  last_error text NOT NULL,
+  attempts integer NOT NULL CHECK (attempts > 0),
+  failed_at bigint NOT NULL,
+  PRIMARY KEY (consumer, event_id)
+);
+--> statement-breakpoint
+CREATE VIEW event_log_history AS SELECT id, kind, subject_kind, subject_id, payload, scope_id, actor_id, occurred_at, request_id FROM event_log_events;