effect-actors 0.0.1

package/dist/store/memory/model.js

@@ -0,0 +1,149 @@
+import { Clock, Duration, Effect, Result } from "effect";
+import { InvalidInput, UnsupportedVersion } from "../../errors/index.js";
+import { addressId, canonicalJson, makeCursor, validateId } from "../../protocol/index.js";
+import { nonNegativeInteger, protocolBoundary } from "../sql/model.js";
+export const cloneJson = (value) => JSON.parse(canonicalJson(value));
+export const durationMillis = (input, name) => protocolBoundary(() => {
+    const value = Math.ceil(Duration.toMillis(input));
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new InvalidInput({ message: `${name} must be a finite positive duration` });
+    }
+    return value;
+});
+export const snapshot = (head) => {
+    if (head.schemaVersion === undefined || head.state === undefined) {
+        throw new UnsupportedVersion({ actorType: head.address.actorType, version: 0 });
+    }
+    return {
+        schemaVersion: head.schemaVersion,
+        state: cloneJson(head.state),
+        revision: head.revision.toString(),
+        cursor: makeCursor(head.address, head.eventSequence.toString()),
+    };
+};
+export const receiptValue = (address, commandId, revision, sequence, committedAtMillis, outcome) => ({
+    commandId,
+    revision: revision.toString(),
+    cursor: makeCursor(address, sequence.toString()),
+    committedAtMillis,
+    value: cloneJson(outcome),
+});
+export const cloneReceipt = (receipt) => ({
+    ...receipt,
+    value: cloneJson(receipt.value),
+});
+export const receiptMap = (context, actorId) => {
+    let receipts = context.receipts.get(actorId);
+    if (receipts === undefined) {
+        receipts = new Map();
+        context.receipts.set(actorId, receipts);
+    }
+    return receipts;
+};
+const prepare = (source, transition) => protocolBoundary(() => {
+    const encoded = cloneJson(transition);
+    if (!Array.isArray(encoded.events) ||
+        !Array.isArray(encoded.timers) ||
+        !Array.isArray(encoded.outbox)) {
+        throw new InvalidInput({ message: "Invalid encoded transition" });
+    }
+    for (const timer of encoded.timers) {
+        validateId(timer.timerId);
+        if (timer._tag === "Set") {
+            nonNegativeInteger(timer.dueAtMillis, "timer dueAtMillis");
+            if (typeof timer.command !== "string" || timer.command.length === 0) {
+                throw new InvalidInput({ message: "Invalid timer command" });
+            }
+        }
+        else if (timer._tag !== "Cancel") {
+            throw new InvalidInput({ message: "Invalid timer change" });
+        }
+    }
+    for (const command of encoded.outbox) {
+        addressId(command.target);
+        if (command.target.namespace !== source.namespace ||
+            command.target.tenant !== source.tenant ||
+            (command.kind !== "command" && command.kind !== "hosted") ||
+            typeof command.commandId !== "string" ||
+            typeof command.operation !== "string" ||
+            command.operation.length === 0 ||
+            !Number.isSafeInteger(command.protocolVersion) ||
+            command.protocolVersion < 0) {
+            throw new InvalidInput({ message: "Invalid outgoing command" });
+        }
+        validateId(command.commandId);
+    }
+    return encoded;
+});
+const applyTimers = (context, actorId, address, changes) => {
+    for (const change of changes) {
+        const id = canonicalJson([actorId, change.timerId]);
+        let timer = context.timers.get(id);
+        if (timer === undefined) {
+            timer = { address, timerId: change.timerId, generation: 0n, status: "cancelled" };
+            context.timers.set(id, timer);
+        }
+        timer.generation += 1n;
+        if (change._tag === "Cancel") {
+            timer.status = "cancelled";
+            timer.dueAtMillis = undefined;
+            timer.command = undefined;
+            timer.payload = undefined;
+        }
+        else {
+            timer.status = "scheduled";
+            timer.dueAtMillis = change.dueAtMillis;
+            timer.command = change.command;
+            timer.payload = cloneJson(change.payload);
+        }
+    }
+};
+const applyOutbox = (context, actorId, namespace, commandId, calls, nowMillis) => {
+    calls.forEach((command, index) => {
+        const id = canonicalJson(["effect-actors/outbox", actorId, commandId, index]);
+        context.outbox.set(id, {
+            id,
+            namespace,
+            command: cloneJson(command),
+            createdAtMillis: nowMillis,
+            status: "pending",
+            attempt: 0,
+            retryAtMillis: 0,
+        });
+    });
+};
+export const applyEvaluation = (context, head, input) => Effect.gen(function* () {
+    const actorId = addressId(head.address);
+    const receipts = receiptMap(context, actorId);
+    if (Result.isFailure(input.evaluation)) {
+        const failure = input.evaluation.failure;
+        const error = yield* protocolBoundary(() => cloneJson(failure));
+        const nowMillis = yield* Clock.currentTimeMillis;
+        input.consume?.();
+        const receipt = receiptValue(head.address, input.commandId, head.revision, head.eventSequence, nowMillis, { _tag: "Failure", error });
+        receipts.set(input.commandId, { fingerprint: input.fingerprint, receipt });
+        return cloneReceipt(receipt);
+    }
+    const transition = yield* prepare(head.address, input.evaluation.success);
+    const nowMillis = yield* Clock.currentTimeMillis;
+    input.consume?.();
+    head.revision += 1n;
+    head.state = transition.state;
+    const actorEvents = context.events.get(actorId) ?? [];
+    for (const value of transition.events) {
+        head.eventSequence += 1n;
+        actorEvents.push({
+            sequence: head.eventSequence,
+            cursor: makeCursor(head.address, head.eventSequence.toString()),
+            commandId: input.commandId,
+            committedAtMillis: nowMillis,
+            value,
+        });
+    }
+    context.events.set(actorId, actorEvents);
+    applyTimers(context, actorId, head.address, transition.timers);
+    applyOutbox(context, actorId, head.address.namespace, input.commandId, transition.outbox, nowMillis);
+    const receipt = receiptValue(head.address, input.commandId, head.revision, head.eventSequence, nowMillis, { _tag: "Success", value: transition.value });
+    receipts.set(input.commandId, { fingerprint: input.fingerprint, receipt });
+    return cloneReceipt(receipt);
+});

package/dist/store/memory/ownership.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import type { Duration } from "effect";
+import { OwnershipLost, type StoreError } from "../../errors/index.js";
+import type { Address } from "../../protocol/index.js";
+import type { Ownership } from "../service.js";
+import { type MemoryContext, type MemoryHead, type MemoryOwner } from "./model.js";
+export declare const withOwner: <A, E, R>(context: MemoryContext, ownership: Ownership, use: (owner: MemoryOwner, head: MemoryHead, nowMillis: number) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | OwnershipLost, R>;
+export declare const acquire: (context: MemoryContext, address: Address, options: {
+    readonly leaseDuration: Duration.Input;
+    readonly renewEvery: Duration.Input;
+}) => Effect.Effect<Ownership, StoreError, import("effect").Scope.Scope>;

package/dist/store/memory/ownership.js

@@ -0,0 +1,82 @@
+import { Clock, Deferred, Effect } from "effect";
+import { InvalidInput, OwnershipLost, StorageUnavailable, } from "../../errors/index.js";
+import { addressId } from "../../protocol/index.js";
+import { protocolBoundary } from "../sql/model.js";
+import { durationMillis } from "./model.js";
+const lost = (address) => new OwnershipLost({ actorType: address.actorType });
+const expireOwner = (owner, error) => Effect.gen(function* () {
+    owner.active = false;
+    yield* Deferred.fail(owner.lost, error);
+});
+const ownerFor = (context, ownership) => {
+    const owner = context.owners.get(ownership);
+    return owner === undefined ||
+        ownership.address !== owner.address ||
+        ownership.fence !== owner.fence
+        ? Effect.fail(lost(ownership.address))
+        : Effect.succeed(owner);
+};
+export const withOwner = (context, ownership, use) => Effect.flatMap(ownerFor(context, ownership), (owner) => context.gate.withPermit(Effect.gen(function* () {
+    const nowMillis = yield* Clock.currentTimeMillis;
+    const head = context.heads.get(owner.addressId);
+    if (!owner.active ||
+        head === undefined ||
+        head.fence.toString() !== owner.fence ||
+        head.leaseUntil <= nowMillis) {
+        const error = lost(owner.address);
+        yield* expireOwner(owner, error);
+        return yield* Effect.fail(error);
+    }
+    return yield* use(owner, head, nowMillis);
+})));
+export const acquire = (context, address, options) => Effect.gen(function* () {
+    const leaseMillis = yield* durationMillis(options.leaseDuration, "leaseDuration");
+    const renewMillis = yield* durationMillis(options.renewEvery, "renewEvery");
+    if (renewMillis >= leaseMillis) {
+        return yield* Effect.fail(new InvalidInput({ message: "renewEvery must be shorter than leaseDuration" }));
+    }
+    const actorId = yield* protocolBoundary(() => addressId(address));
+    const fence = yield* context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        let head = context.heads.get(actorId);
+        if (head === undefined) {
+            head = {
+                address,
+                fence: 0n,
+                leaseUntil: 0,
+                revision: 0n,
+                eventSequence: 0n,
+                eventFloor: 0n,
+            };
+            context.heads.set(actorId, head);
+        }
+        if (head.leaseUntil > nowMillis)
+            return yield* Effect.fail(lost(address));
+        head.fence += 1n;
+        head.leaseUntil = nowMillis + leaseMillis;
+        return head.fence.toString();
+    }));
+    const deferred = yield* Deferred.make();
+    const state = { addressId: actorId, address, fence, lost: deferred, active: true };
+    const ownership = Object.freeze({ address, fence, lost: Deferred.await(deferred) });
+    context.owners.set(ownership, state);
+    yield* Effect.addFinalizer(() => context.gate.withPermit(Effect.gen(function* () {
+        if (!state.active)
+            return;
+        yield* expireOwner(state, lost(state.address));
+        const head = context.heads.get(state.addressId);
+        if (head !== undefined && head.fence.toString() === state.fence)
+            head.leaseUntil = 0;
+    })));
+    yield* Effect.forever(Effect.sleep(renewMillis).pipe(Effect.andThen(context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        const head = context.heads.get(state.addressId);
+        if (!state.active ||
+            head === undefined ||
+            head.fence.toString() !== state.fence ||
+            head.leaseUntil <= nowMillis)
+            return yield* Effect.fail(lost(state.address));
+        head.leaseUntil = nowMillis + leaseMillis;
+    }))))).pipe(Effect.catch((error) => expireOwner(state, error)), Effect.catchDefect(() => expireOwner(state, new StorageUnavailable({ retryable: false }))), Effect.forkScoped);
+    return ownership;
+});

package/dist/store/memory/service.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import type { Service } from "../service.js";
+export declare const makeMemory: Effect.Effect<Service>;

package/dist/store/memory/service.js

@@ -0,0 +1,32 @@
+import { Effect, Semaphore } from "effect";
+import { claimOutbox, collectEvents, dueTimers, events, fireTimer, receipt, retryOutbox, settleOutbox, } from "./background.js";
+import { acquire } from "./ownership.js";
+import { initialize, query, transact } from "./state.js";
+export const makeMemory = Effect.gen(function* () {
+    const gate = yield* Semaphore.make(1);
+    const context = {
+        gate,
+        heads: new Map(),
+        receipts: new Map(),
+        events: new Map(),
+        timers: new Map(),
+        outbox: new Map(),
+        owners: new WeakMap(),
+        token: 0n,
+    };
+    const service = {
+        acquire: (address, options) => acquire(context, address, options),
+        initialize: (owner, options) => initialize(context, owner, options),
+        transact: (owner, input, evaluate) => transact(context, owner, input, evaluate),
+        query: (owner, evaluate) => query(context, owner, evaluate),
+        receipt: (address, commandId) => receipt(context, address, commandId),
+        events: (address, options) => events(context, address, options),
+        claimOutbox: (options) => claimOutbox(context, options),
+        settleOutbox: (claim, outcome) => settleOutbox(context, claim, outcome),
+        retryOutbox: (claim, options) => retryOutbox(context, claim, options),
+        dueTimers: (options) => dueTimers(context, options),
+        fireTimer: (owner, candidate, evaluate) => fireTimer(context, owner, candidate, evaluate),
+        collectEvents: (options) => collectEvents(context, options),
+    };
+    return service;
+});

package/dist/store/memory/state.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Result } from "effect";
+import { CommandConflict, type StoreError } from "../../errors/index.js";
+import type { Invocation, Json, WireReceipt } from "../../protocol/index.js";
+import type { Migration } from "../../actor/definition.js";
+import type { EncodedTransition, Ownership, Snapshot, Turn } from "../service.js";
+import { type MemoryContext } from "./model.js";
+export declare const initialize: (context: MemoryContext, ownership: Ownership, options: {
+    readonly currentVersion: number;
+    readonly initial: Json;
+    readonly migrations: ReadonlyArray<Migration>;
+}) => Effect.Effect<Snapshot, StoreError>;
+export declare const transact: (context: MemoryContext, ownership: Ownership, input: Invocation, evaluate: (turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<WireReceipt, StoreError | CommandConflict>;
+export declare const query: <A>(context: MemoryContext, ownership: Ownership, evaluate: (snapshot: Snapshot) => A) => Effect.Effect<A, StoreError>;

package/dist/store/memory/state.js

@@ -0,0 +1,109 @@
+import { Effect, Result } from "effect";
+import { CommandConflict, InvalidInput, MigrationRejected, UnsupportedVersion, } from "../../errors/index.js";
+import { addressId, validateId } from "../../protocol/index.js";
+import { decimalInput, normalizeCallbackError, positiveInteger, protocolBoundary, } from "../sql/model.js";
+import { applyEvaluation, cloneJson, cloneReceipt, receiptMap, receiptValue, snapshot, } from "./model.js";
+import { withOwner } from "./ownership.js";
+const safeSnapshot = (head) => Effect.try({
+    try: () => snapshot(head),
+    catch: normalizeCallbackError,
+});
+export const initialize = (context, ownership, options) => withOwner(context, ownership, (_owner, head) => Effect.gen(function* () {
+    const currentVersion = yield* protocolBoundary(() => positiveInteger(options.currentVersion, "currentVersion"));
+    const initial = yield* protocolBoundary(() => cloneJson(options.initial));
+    if (head.schemaVersion === undefined) {
+        head.schemaVersion = currentVersion;
+        head.state = initial;
+        return yield* safeSnapshot(head);
+    }
+    if (head.schemaVersion > currentVersion) {
+        return yield* Effect.fail(new UnsupportedVersion({
+            actorType: head.address.actorType,
+            version: head.schemaVersion,
+        }));
+    }
+    if (head.schemaVersion === currentVersion)
+        return yield* safeSnapshot(head);
+    let version = head.schemaVersion;
+    let encoded = cloneJson(head.state);
+    while (version < currentVersion) {
+        const candidates = options.migrations.filter((migration) => migration.fromVersion === version);
+        if (candidates.length !== 1) {
+            return yield* Effect.fail(new MigrationRejected({
+                fromVersion: version,
+                toVersion: currentVersion,
+                message: "Migration chain is incomplete or ambiguous",
+            }));
+        }
+        const migration = candidates[0];
+        if (!Number.isSafeInteger(migration.toVersion) ||
+            migration.toVersion <= version ||
+            migration.toVersion > currentVersion) {
+            return yield* Effect.fail(new MigrationRejected({
+                fromVersion: migration.fromVersion,
+                toVersion: migration.toVersion,
+                message: "Migration chain does not advance toward the current version",
+            }));
+        }
+        const result = yield* Effect.try({
+            try: () => migration.migrate(encoded),
+            catch: normalizeCallbackError,
+        });
+        if (Result.isFailure(result))
+            return yield* Effect.fail(result.failure);
+        encoded = yield* protocolBoundary(() => cloneJson(result.success));
+        version = migration.toVersion;
+    }
+    head.schemaVersion = currentVersion;
+    head.state = encoded;
+    return yield* safeSnapshot(head);
+}));
+export const transact = (context, ownership, input, evaluate) => withOwner(context, ownership, (owner, head, nowMillis) => Effect.gen(function* () {
+    const inputAddress = yield* protocolBoundary(() => addressId(input.address));
+    if (inputAddress !== owner.addressId) {
+        return yield* Effect.fail(new InvalidInput({ message: "Invocation does not match its owner" }));
+    }
+    yield* protocolBoundary(() => validateId(input.commandId));
+    if (typeof input.fingerprint !== "string")
+        return yield* Effect.fail(new InvalidInput({ message: "Invalid command identity" }));
+    const receipts = receiptMap(context, owner.addressId);
+    const duplicate = receipts.get(input.commandId);
+    if (duplicate !== undefined) {
+        if (duplicate.fingerprint !== input.fingerprint) {
+            return yield* Effect.fail(new CommandConflict({ commandId: input.commandId }));
+        }
+        return cloneReceipt(duplicate.receipt);
+    }
+    const current = yield* safeSnapshot(head);
+    if (input.expectedRevision !== undefined) {
+        yield* protocolBoundary(() => decimalInput(input.expectedRevision, "expectedRevision"));
+        if (input.expectedRevision !== current.revision) {
+            const receipt = receiptValue(head.address, input.commandId, head.revision, head.eventSequence, nowMillis, {
+                _tag: "Failure",
+                error: {
+                    _tag: "effect-actors/RevisionConflict",
+                    expected: input.expectedRevision,
+                    actual: current.revision,
+                },
+            });
+            receipts.set(input.commandId, { fingerprint: input.fingerprint, receipt });
+            return cloneReceipt(receipt);
+        }
+    }
+    const evaluation = yield* Effect.try({
+        try: () => evaluate({ snapshot: current, nowMillis }),
+        catch: normalizeCallbackError,
+    });
+    return yield* applyEvaluation(context, head, {
+        commandId: input.commandId,
+        fingerprint: input.fingerprint,
+        evaluation,
+    });
+}));
+export const query = (context, ownership, evaluate) => withOwner(context, ownership, (_owner, head) => Effect.gen(function* () {
+    const current = yield* safeSnapshot(head);
+    return yield* Effect.try({
+        try: () => evaluate(current),
+        catch: normalizeCallbackError,
+    });
+}));

package/dist/store/service.d.ts

@@ -0,0 +1,89 @@
+import { Context, Layer } from "effect";
+import type { Crypto, Duration, Effect, Option, Result, Scope } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import type { Migration } from "../actor/definition.js";
+import type { CommandConflict, CursorExpired, StoreError } from "../errors/index.js";
+import type { Address, EventPage, Invocation, Json, OutgoingCommand, Outcome, TimerChange, WireReceipt } from "../protocol/index.js";
+import { migrate as migrateSql } from "./sql/schema.js";
+export interface Ownership {
+    readonly address: Address;
+    readonly fence: string;
+    readonly lost: Effect.Effect<never, StoreError>;
+}
+export interface Snapshot {
+    readonly schemaVersion: number;
+    readonly state: Json;
+    readonly revision: string;
+    readonly cursor: string;
+}
+export interface EncodedTransition {
+    readonly state: Json;
+    readonly value: Json;
+    readonly events: ReadonlyArray<Json>;
+    readonly timers: ReadonlyArray<TimerChange>;
+    readonly outbox: ReadonlyArray<OutgoingCommand>;
+}
+export interface Turn {
+    readonly snapshot: Snapshot;
+    readonly nowMillis: number;
+}
+export interface OutboxClaim {
+    readonly id: string;
+    readonly claimToken: string;
+    readonly attempt: number;
+    readonly command: OutgoingCommand;
+}
+export interface TimerCandidate {
+    readonly address: Address;
+    readonly timerId: string;
+    readonly generation: string;
+    readonly dueAtMillis: number;
+}
+export interface Service {
+    readonly acquire: (address: Address, options: {
+        readonly leaseDuration: Duration.Input;
+        readonly renewEvery: Duration.Input;
+    }) => Effect.Effect<Ownership, StoreError, Scope.Scope>;
+    readonly initialize: (owner: Ownership, options: {
+        readonly currentVersion: number;
+        readonly initial: Json;
+        readonly migrations: ReadonlyArray<Migration>;
+    }) => Effect.Effect<Snapshot, StoreError>;
+    readonly transact: (owner: Ownership, input: Invocation, evaluate: (turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<WireReceipt, StoreError | CommandConflict>;
+    readonly query: <A>(owner: Ownership, evaluate: (snapshot: Snapshot) => A) => Effect.Effect<A, StoreError>;
+    readonly receipt: (address: Address, commandId: string) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;
+    readonly events: (address: Address, options: {
+        readonly after: string;
+        readonly limit: number;
+    }) => Effect.Effect<EventPage, StoreError | CursorExpired>;
+    readonly claimOutbox: (options: {
+        readonly namespace: string;
+        readonly limit: number;
+        readonly claimDuration: Duration.Input;
+    }) => Effect.Effect<ReadonlyArray<OutboxClaim>, StoreError>;
+    readonly settleOutbox: (claim: OutboxClaim, outcome: Outcome) => Effect.Effect<void, StoreError>;
+    readonly retryOutbox: (claim: OutboxClaim, options: {
+        readonly retryAtMillis: number;
+        readonly reasonCode: string;
+    }) => Effect.Effect<void, StoreError>;
+    readonly dueTimers: (options: {
+        readonly namespace: string;
+        readonly limit: number;
+    }) => Effect.Effect<ReadonlyArray<TimerCandidate>, StoreError>;
+    readonly fireTimer: (owner: Ownership, candidate: TimerCandidate, evaluate: (command: string, payload: Json, turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;
+    readonly collectEvents: (options: {
+        readonly namespace: string;
+        readonly beforeMillis: number;
+        readonly limit: number;
+    }) => Effect.Effect<number, StoreError>;
+}
+declare const Store_base: Context.ServiceClass<Store, "effect-actors/Store", Service>;
+export declare class Store extends Store_base {
+}
+export interface SqlOptions {
+    readonly tablePrefix: string;
+}
+export declare const layerSql: (options: SqlOptions) => Layer.Layer<Store, StoreError, SqlClient.SqlClient | Crypto.Crypto>;
+export declare const migrate: typeof migrateSql;
+export declare const layerMemory: Layer.Layer<Store>;
+export {};

package/dist/store/service.js

@@ -0,0 +1,9 @@
+import { Context, Layer } from "effect";
+import { makeMemory } from "./memory/service.js";
+import { migrate as migrateSql } from "./sql/schema.js";
+import { make as makeSql } from "./sql/service.js";
+export class Store extends Context.Service()("effect-actors/Store") {
+}
+export const layerSql = (options) => Layer.effect(Store, makeSql(options));
+export const migrate = migrateSql;
+export const layerMemory = Layer.effect(Store, makeMemory);

package/dist/store/sql/events.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { CursorExpired, type StoreError } from "../../errors/index.js";
+import type { Address, EventPage } from "../../protocol/index.js";
+import type { SqlStoreContext } from "./ownership.js";
+export declare const events: (context: SqlStoreContext, address: Address, options: {
+    readonly after: string;
+    readonly limit: number;
+}) => Effect.Effect<EventPage, StoreError | CursorExpired>;
+export declare const collectEvents: (context: SqlStoreContext, options: {
+    readonly namespace: string;
+    readonly beforeMillis: number;
+    readonly limit: number;
+}) => Effect.Effect<number, StoreError>;

package/dist/store/sql/events.js

@@ -0,0 +1,89 @@
+import { Effect } from "effect";
+import { CursorExpired, InvalidInput, StorageUnavailable, } from "../../errors/index.js";
+import { addressId, makeCursor, readCursor } from "../../protocol/index.js";
+import { decimal, decodeJson, forUpdate, integer, nonNegativeInteger, normalizeSqlError, positiveInteger, protocolBoundary, } from "./model.js";
+export const events = (context, address, options) => Effect.gen(function* () {
+    const actorId = yield* protocolBoundary(() => addressId(address));
+    const after = yield* protocolBoundary(() => readCursor(address, options.after));
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "event page limit"));
+    const program = Effect.gen(function* () {
+        const heads = yield* context.sql `
+      SELECT event_sequence, event_floor
+      FROM ${context.sql(context.tables.heads)}
+      WHERE address = ${actorId}
+      ${forUpdate(context.sql, context.dialect)}
+    `;
+        const highwater = heads[0] === undefined ? "0" : decimal(heads[0].event_sequence);
+        const floor = heads[0] === undefined ? "0" : decimal(heads[0].event_floor);
+        if (BigInt(after) < BigInt(floor)) {
+            return yield* Effect.fail(new CursorExpired({ message: "Event cursor precedes retained history" }));
+        }
+        if (BigInt(after) > BigInt(highwater)) {
+            return yield* Effect.fail(new InvalidInput({ message: "Event cursor is ahead of the actor" }));
+        }
+        const rows = yield* context.sql `
+      SELECT sequence, command_id, payload, committed_at_ms
+      FROM ${context.sql(context.tables.events)}
+      WHERE address = ${actorId} AND sequence > ${after}
+      ORDER BY sequence
+      LIMIT ${limit + 1}
+    `;
+        const selected = rows.slice(0, limit);
+        const decoded = yield* protocolBoundary(() => selected.map((row) => {
+            if (typeof row.command_id !== "string")
+                throw new Error("Invalid event row");
+            const sequence = decimal(row.sequence);
+            return {
+                cursor: makeCursor(address, sequence),
+                commandId: row.command_id,
+                committedAtMillis: integer(row.committed_at_ms),
+                value: decodeJson(row.payload),
+            };
+        })).pipe(Effect.mapError(() => new StorageUnavailable({ retryable: false })));
+        const nextSequence = selected.length === 0 ? after : decimal(selected[selected.length - 1].sequence);
+        return {
+            events: decoded,
+            nextCursor: yield* protocolBoundary(() => makeCursor(address, nextSequence)),
+            hasMore: rows.length > limit,
+        };
+    });
+    return yield* context.sql.withTransaction(program);
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+export const collectEvents = (context, options) => Effect.gen(function* () {
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "event retention limit"));
+    yield* protocolBoundary(() => nonNegativeInteger(options.beforeMillis, "event retention cutoff"));
+    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
+        return yield* Effect.fail(new InvalidInput({ message: "Invalid event retention namespace" }));
+    }
+    const program = Effect.gen(function* () {
+        const rows = yield* context.sql `
+      SELECT address, sequence
+      FROM ${context.sql(context.tables.events)}
+      WHERE namespace = ${options.namespace} AND committed_at_ms < ${options.beforeMillis}
+      ORDER BY committed_at_ms, address, sequence
+      LIMIT ${limit}
+      ${forUpdate(context.sql, context.dialect)}
+    `;
+        let deleted = 0;
+        for (const row of rows) {
+            if (typeof row.address !== "string")
+                throw new Error("Invalid event row");
+            const sequence = decimal(row.sequence);
+            const removed = yield* context.sql `
+        DELETE FROM ${context.sql(context.tables.events)}
+        WHERE address = ${row.address} AND sequence = ${sequence}
+        RETURNING sequence
+      `;
+            if (removed.length === 0)
+                continue;
+            yield* context.sql `
+        UPDATE ${context.sql(context.tables.heads)}
+        SET event_floor = CASE WHEN event_floor < ${sequence} THEN ${sequence} ELSE event_floor END
+        WHERE address = ${row.address}
+      `;
+            deleted += 1;
+        }
+        return deleted;
+    });
+    return yield* context.sql.withTransaction(program);
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));

package/dist/store/sql/model.d.ts

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import { CommandConflict, CursorExpired, InvalidInput, MigrationRejected, OwnershipLost, StorageUnavailable, UnsupportedVersion } from "../../errors/index.js";
+import type { Address, Json } from "../../protocol/index.js";
+export type Dialect = "sqlite" | "pg";
+export interface Tables {
+    readonly schema: string;
+    readonly heads: string;
+    readonly receipts: string;
+    readonly events: string;
+    readonly timers: string;
+    readonly outbox: string;
+}
+export declare const tablesFor: (tablePrefix: string) => Tables;
+export declare const validateTablePrefix: (tablePrefix: string) => Tables;
+export declare const dialectOf: (sql: SqlClient.SqlClient) => Dialect;
+export declare const databaseNow: (sql: SqlClient.SqlClient, dialect: Dialect) => import("effect/unstable/sql/Statement").Fragment;
+export declare const forUpdate: (sql: SqlClient.SqlClient, dialect: Dialect) => import("effect/unstable/sql/Statement").Fragment;
+export declare const forUpdateSkipLocked: (sql: SqlClient.SqlClient, dialect: Dialect) => import("effect/unstable/sql/Statement").Fragment;
+export declare const storageUnavailable: (retryable: boolean) => StorageUnavailable;
+export declare const isFrameworkError: (error: unknown) => error is InvalidInput | CommandConflict | CursorExpired | MigrationRejected | OwnershipLost | StorageUnavailable | UnsupportedVersion;
+type FrameworkError = InvalidInput | CommandConflict | CursorExpired | MigrationRejected | OwnershipLost | StorageUnavailable | UnsupportedVersion;
+export declare const normalizeSqlError: <E>(error: E) => Extract<E, FrameworkError> | StorageUnavailable;
+export declare const normalizeCallbackError: (error: unknown) => InvalidInput | MigrationRejected | OwnershipLost | StorageUnavailable | UnsupportedVersion;
+export declare const protectSql: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, StorageUnavailable | Extract<E, FrameworkError>, R>;
+export declare const protocolBoundary: <A>(evaluate: () => A) => Effect.Effect<A, InvalidInput>;
+export declare const encodeJson: (value: Json) => string;
+export declare const decodeJson: (value: unknown) => Json;
+export declare const encodeAddress: (address: Address) => {
+    readonly id: string;
+    readonly json: string;
+};
+export declare const decodeAddress: (json: unknown, expectedId: string) => Address;
+export declare const decimal: (value: unknown) => string;
+export declare const integer: (value: unknown) => number;
+export declare const positiveInteger: (value: number, name: string) => number;
+export declare const nonNegativeInteger: (value: number, name: string) => number;
+export declare const decimalInput: (value: string, name: string) => string;
+export {};