effect-actors 0.0.1

package/dist/store/sql/model.js

@@ -0,0 +1,126 @@
+import { Effect } from "effect";
+import { CommandConflict, CursorExpired, InvalidInput, MigrationRejected, OwnershipLost, StorageUnavailable, UnsupportedVersion, } from "../../errors/index.js";
+import { addressId, canonicalJson } from "../../protocol/index.js";
+export const tablesFor = (tablePrefix) => ({
+    schema: `${tablePrefix}_store_schema`,
+    heads: `${tablePrefix}_actor_heads`,
+    receipts: `${tablePrefix}_receipts`,
+    events: `${tablePrefix}_events`,
+    timers: `${tablePrefix}_timers`,
+    outbox: `${tablePrefix}_outbox`,
+});
+export const validateTablePrefix = (tablePrefix) => {
+    if (!/^[a-z_][a-z0-9_]{0,31}$/.test(tablePrefix)) {
+        throw new InvalidInput({ message: "Invalid actor store table prefix" });
+    }
+    return tablesFor(tablePrefix);
+};
+export const dialectOf = (sql) => {
+    const dialect = sql.onDialectOrElse({
+        sqlite: () => "sqlite",
+        pg: () => "pg",
+        orElse: () => undefined,
+    });
+    if (dialect === undefined) {
+        throw new InvalidInput({ message: "Actor store supports only SQLite and PostgreSQL" });
+    }
+    return dialect;
+};
+export const databaseNow = (sql, dialect) => dialect === "pg"
+    ? sql.literal("CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)")
+    : sql.literal("CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)");
+export const forUpdate = (sql, dialect) => sql.literal(dialect === "pg" ? " FOR UPDATE" : "");
+export const forUpdateSkipLocked = (sql, dialect) => sql.literal(dialect === "pg" ? " FOR UPDATE SKIP LOCKED" : "");
+export const storageUnavailable = (retryable) => new StorageUnavailable({ retryable });
+const frameworkTags = new Set([
+    "effect-actors/InvalidInput",
+    "effect-actors/CommandConflict",
+    "effect-actors/CursorExpired",
+    "effect-actors/MigrationRejected",
+    "effect-actors/OwnershipLost",
+    "effect-actors/StorageUnavailable",
+    "effect-actors/UnsupportedVersion",
+]);
+export const isFrameworkError = (error) => typeof error === "object" &&
+    error !== null &&
+    "_tag" in error &&
+    typeof error._tag === "string" &&
+    frameworkTags.has(error._tag);
+export const normalizeSqlError = (error) => isFrameworkError(error) ? error : storageUnavailable(true);
+export const normalizeCallbackError = (error) => {
+    if (error instanceof InvalidInput ||
+        error instanceof MigrationRejected ||
+        error instanceof OwnershipLost ||
+        error instanceof StorageUnavailable ||
+        error instanceof UnsupportedVersion)
+        return error;
+    return storageUnavailable(false);
+};
+export const protectSql = (effect) => effect.pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(storageUnavailable(true))));
+export const protocolBoundary = (evaluate) => Effect.try({
+    try: evaluate,
+    catch: (error) => error instanceof InvalidInput
+        ? error
+        : new InvalidInput({ message: "Invalid actor store value" }),
+});
+export const encodeJson = (value) => canonicalJson(value);
+export const decodeJson = (value) => {
+    if (typeof value !== "string")
+        throw new Error("Invalid stored JSON");
+    const parsed = JSON.parse(value);
+    canonicalJson(parsed);
+    return parsed;
+};
+export const encodeAddress = (address) => ({
+    id: addressId(address),
+    json: canonicalJson(address),
+});
+export const decodeAddress = (json, expectedId) => {
+    const value = decodeJson(json);
+    const address = value;
+    if (addressId(address) !== expectedId)
+        throw new Error("Stored actor address does not match its key");
+    return address;
+};
+export const decimal = (value) => {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+        return String(value);
+    if (typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value))
+        return value;
+    throw new Error("Invalid stored decimal");
+};
+export const integer = (value) => {
+    if (typeof value === "number" && Number.isSafeInteger(value))
+        return value;
+    if (typeof value === "bigint" &&
+        value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+        value >= BigInt(Number.MIN_SAFE_INTEGER)) {
+        return Number(value);
+    }
+    if (typeof value === "string" && /^-?(0|[1-9][0-9]*)$/.test(value)) {
+        const number = Number(value);
+        if (Number.isSafeInteger(number))
+            return number;
+    }
+    throw new Error("Invalid stored integer");
+};
+export const positiveInteger = (value, name) => {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new InvalidInput({ message: `${name} must be a positive integer` });
+    }
+    return value;
+};
+export const nonNegativeInteger = (value, name) => {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new InvalidInput({ message: `${name} must be a non-negative integer` });
+    }
+    return value;
+};
+export const decimalInput = (value, name) => {
+    if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+        throw new InvalidInput({ message: `${name} must be a canonical decimal string` });
+    }
+    return value;
+};

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

@@ -0,0 +1,15 @@
+import { Duration, Effect } from "effect";
+import { type StoreError } from "../../errors/index.js";
+import type { Outcome } from "../../protocol/index.js";
+import type { OutboxClaim } from "../service.js";
+import type { SqlStoreContext } from "./ownership.js";
+export declare const claimOutbox: (context: SqlStoreContext, options: {
+    readonly namespace: string;
+    readonly limit: number;
+    readonly claimDuration: Duration.Input;
+}) => Effect.Effect<ReadonlyArray<OutboxClaim>, StoreError>;
+export declare const settleOutbox: (context: SqlStoreContext, claim: OutboxClaim, outcome: Outcome) => Effect.Effect<void, StoreError>;
+export declare const retryOutbox: (context: SqlStoreContext, claim: OutboxClaim, options: {
+    readonly retryAtMillis: number;
+    readonly reasonCode: string;
+}) => Effect.Effect<void, StoreError>;

package/dist/store/sql/outbox.js

@@ -0,0 +1,130 @@
+import { Duration, Effect } from "effect";
+import { InvalidInput, StorageUnavailable } from "../../errors/index.js";
+import { addressId, validateId } from "../../protocol/index.js";
+import { databaseNow, decodeJson, encodeJson, forUpdateSkipLocked, integer, nonNegativeInteger, normalizeSqlError, positiveInteger, protocolBoundary, } from "./model.js";
+const claimDurationMillis = (input) => protocolBoundary(() => {
+    const value = Math.ceil(Duration.toMillis(input));
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new InvalidInput({ message: "claimDuration must be a finite positive duration" });
+    }
+    return value;
+});
+const decodeCommand = (value) => {
+    const command = decodeJson(value);
+    if (typeof command !== "object" ||
+        command === null ||
+        (command.kind !== "command" && command.kind !== "hosted") ||
+        typeof command.operation !== "string" ||
+        command.operation.length === 0 ||
+        !Number.isSafeInteger(command.protocolVersion) ||
+        command.protocolVersion < 0 ||
+        typeof command.commandId !== "string") {
+        throw new Error("Invalid stored outgoing command");
+    }
+    validateId(command.commandId);
+    addressId(command.target);
+    encodeJson(command.payload);
+    return command;
+};
+export const claimOutbox = (context, options) => Effect.gen(function* () {
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "outbox claim limit"));
+    const duration = yield* claimDurationMillis(options.claimDuration);
+    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
+        return yield* Effect.fail(new InvalidInput({ message: "Invalid outbox namespace" }));
+    }
+    const { crypto, dialect, sql, tables } = context;
+    const program = Effect.gen(function* () {
+        const candidates = yield* sql `
+      SELECT delivery_id
+      FROM ${sql(tables.outbox)}
+      WHERE namespace = ${options.namespace}
+        AND (
+          (status = 'pending' AND retry_at_ms <= ${databaseNow(sql, dialect)})
+          OR (status = 'claimed' AND claim_until_ms <= ${databaseNow(sql, dialect)})
+        )
+      ORDER BY created_at_ms, delivery_id
+      LIMIT ${limit}
+      ${forUpdateSkipLocked(sql, dialect)}
+    `;
+        const claims = [];
+        for (const candidate of candidates) {
+            if (typeof candidate.delivery_id !== "string")
+                throw new Error("Invalid outbox row");
+            const claimToken = yield* crypto.randomUUIDv4.pipe(Effect.mapError(() => new StorageUnavailable({ retryable: true })));
+            const rows = yield* sql `
+        UPDATE ${sql(tables.outbox)}
+        SET status = 'claimed',
+            attempt = attempt + 1,
+            claim_token = ${claimToken},
+            claim_until_ms = ${databaseNow(sql, dialect)} + ${duration}
+        WHERE delivery_id = ${candidate.delivery_id}
+          AND namespace = ${options.namespace}
+          AND (
+            (status = 'pending' AND retry_at_ms <= ${databaseNow(sql, dialect)})
+            OR (status = 'claimed' AND claim_until_ms <= ${databaseNow(sql, dialect)})
+          )
+        RETURNING attempt, target_call
+      `;
+            const row = rows[0];
+            if (row === undefined)
+                continue;
+            claims.push({
+                id: candidate.delivery_id,
+                claimToken,
+                attempt: integer(row.attempt),
+                command: decodeCommand(row.target_call),
+            });
+        }
+        return claims;
+    });
+    return yield* sql.withTransaction(program);
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+const validClaim = (claim) => protocolBoundary(() => {
+    if (typeof claim.id !== "string" ||
+        claim.id.length === 0 ||
+        typeof claim.claimToken !== "string" ||
+        claim.claimToken.length === 0) {
+        throw new InvalidInput({ message: "Invalid outbox claim" });
+    }
+});
+export const settleOutbox = (context, claim, outcome) => Effect.gen(function* () {
+    yield* validClaim(claim);
+    const encoded = yield* protocolBoundary(() => encodeJson(outcome));
+    const { dialect, sql, tables } = context;
+    yield* sql `
+    UPDATE ${sql(tables.outbox)}
+    SET status = 'settled',
+        outcome = ${encoded},
+        claim_token = NULL,
+        claim_until_ms = NULL,
+        reason_code = NULL
+    WHERE delivery_id = ${claim.id}
+      AND status = 'claimed'
+      AND claim_token = ${claim.claimToken}
+      AND claim_until_ms > ${databaseNow(sql, dialect)}
+  `;
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+export const retryOutbox = (context, claim, options) => Effect.gen(function* () {
+    yield* validClaim(claim);
+    yield* protocolBoundary(() => {
+        nonNegativeInteger(options.retryAtMillis, "retryAtMillis");
+        if (typeof options.reasonCode !== "string" ||
+            options.reasonCode.length === 0 ||
+            options.reasonCode.length > 256) {
+            throw new InvalidInput({ message: "Invalid outbox retry reason" });
+        }
+    });
+    const { dialect, sql, tables } = context;
+    yield* sql `
+    UPDATE ${sql(tables.outbox)}
+    SET status = 'pending',
+        retry_at_ms = ${options.retryAtMillis},
+        reason_code = ${options.reasonCode},
+        claim_token = NULL,
+        claim_until_ms = NULL
+    WHERE delivery_id = ${claim.id}
+      AND status = 'claimed'
+      AND claim_token = ${claim.claimToken}
+      AND claim_until_ms > ${databaseNow(sql, dialect)}
+  `;
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));

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

@@ -0,0 +1,44 @@
+import { Deferred, Duration, Effect, Semaphore } from "effect";
+import type { Crypto } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import { OwnershipLost, type StoreError } from "../../errors/index.js";
+import type { Address } from "../../protocol/index.js";
+import type { Ownership } from "../service.js";
+import { type Dialect, type Tables } from "./model.js";
+export interface SqlStoreContext {
+    readonly sql: SqlClient.SqlClient;
+    readonly crypto: Crypto.Crypto;
+    readonly dialect: Dialect;
+    readonly tables: Tables;
+    readonly owners: WeakMap<Ownership, OwnerState>;
+}
+export interface HeadRow {
+    readonly address: unknown;
+    readonly address_json: unknown;
+    readonly namespace: unknown;
+    readonly fence: unknown;
+    readonly lease_until_ms: unknown;
+    readonly schema_version: unknown;
+    readonly state: unknown;
+    readonly revision: unknown;
+    readonly event_sequence: unknown;
+    readonly event_floor: unknown;
+    readonly now_ms: unknown;
+}
+export interface OwnerState {
+    readonly address: Address;
+    readonly addressId: string;
+    readonly fence: string;
+    readonly gate: Semaphore.Semaphore;
+    readonly lost: Deferred.Deferred<never, StoreError>;
+    active: boolean;
+}
+export declare const loseOwner: (state: OwnerState, error: StoreError) => Effect.Effect<void>;
+export declare const ownerState: (context: SqlStoreContext, owner: Ownership) => Effect.Effect<OwnerState, OwnershipLost>;
+export declare const withOwner: <A, E, R>(context: SqlStoreContext, owner: Ownership, use: (state: OwnerState) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | OwnershipLost, R>;
+export declare const ownedHead: (context: SqlStoreContext, state: OwnerState, lock: boolean) => Effect.Effect<HeadRow, StoreError>;
+export declare const finalFence: (context: SqlStoreContext, state: OwnerState) => Effect.Effect<void, StoreError>;
+export declare const acquire: (context: SqlStoreContext, address: Address, options: {
+    readonly leaseDuration: Duration.Input;
+    readonly renewEvery: Duration.Input;
+}) => Effect.Effect<Ownership, StoreError, import("effect").Scope.Scope>;

package/dist/store/sql/ownership.js

@@ -0,0 +1,130 @@
+import { Deferred, Duration, Effect, Semaphore } from "effect";
+import { InvalidInput, OwnershipLost } from "../../errors/index.js";
+import { databaseNow, decimal, encodeAddress, forUpdate, normalizeSqlError, protocolBoundary, } from "./model.js";
+const ownershipLost = (address) => new OwnershipLost({ actorType: address.actorType });
+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 loseOwner = (state, error) => Effect.gen(function* () {
+    state.active = false;
+    yield* Deferred.fail(state.lost, error);
+});
+export const ownerState = (context, owner) => {
+    const state = context.owners.get(owner);
+    if (state === undefined || owner.fence !== state.fence || owner.address !== state.address) {
+        return Effect.fail(ownershipLost(owner.address));
+    }
+    return Effect.succeed(state);
+};
+export const withOwner = (context, owner, use) => Effect.flatMap(ownerState(context, owner), (state) => state.gate.withPermit(Effect.flatMap(Effect.sync(() => state.active), (active) => active ? use(state) : Effect.fail(ownershipLost(state.address)))));
+export const ownedHead = (context, state, lock) => {
+    const { dialect, sql, tables } = context;
+    const query = sql `
+    SELECT address, address_json, namespace, fence, lease_until_ms, schema_version, state,
+      revision, event_sequence, event_floor, ${databaseNow(sql, dialect)} AS now_ms
+    FROM ${sql(tables.heads)}
+    WHERE address = ${state.addressId}
+      AND fence = ${state.fence}
+      AND lease_until_ms > ${databaseNow(sql, dialect)}
+    ${lock ? forUpdate(sql, dialect) : sql.literal("")}
+  `;
+    return query.pipe(Effect.mapError(normalizeSqlError), Effect.flatMap((rows) => {
+        const row = rows[0];
+        if (row !== undefined)
+            return Effect.succeed(row);
+        const error = ownershipLost(state.address);
+        return loseOwner(state, error).pipe(Effect.andThen(Effect.fail(error)));
+    }));
+};
+export const finalFence = (context, state) => {
+    if (!state.active)
+        return Effect.fail(ownershipLost(state.address));
+    const { dialect, sql, tables } = context;
+    return sql `
+    UPDATE ${sql(tables.heads)}
+    SET lease_until_ms = lease_until_ms
+    WHERE address = ${state.addressId}
+      AND fence = ${state.fence}
+      AND lease_until_ms > ${databaseNow(sql, dialect)}
+    RETURNING fence
+  `.pipe(Effect.mapError(normalizeSqlError), Effect.flatMap((rows) => {
+        if (rows.length === 1 && decimal(rows[0].fence) === state.fence)
+            return Effect.void;
+        const error = ownershipLost(state.address);
+        return loseOwner(state, error).pipe(Effect.andThen(Effect.fail(error)));
+    }));
+};
+const renew = (context, state, leaseMillis) => state.gate.withPermit(Effect.suspend(() => {
+    if (!state.active)
+        return Effect.fail(ownershipLost(state.address));
+    const { dialect, sql, tables } = context;
+    return sql `
+      UPDATE ${sql(tables.heads)}
+      SET lease_until_ms = ${databaseNow(sql, dialect)} + ${leaseMillis}
+      WHERE address = ${state.addressId}
+        AND fence = ${state.fence}
+        AND lease_until_ms > ${databaseNow(sql, dialect)}
+      RETURNING fence
+    `.pipe(Effect.mapError(normalizeSqlError), Effect.flatMap((rows) => rows.length === 1 ? Effect.void : Effect.fail(ownershipLost(state.address))));
+}));
+const closeOwner = (context, state) => state.gate.withPermit(Effect.gen(function* () {
+    if (!state.active)
+        return;
+    const error = ownershipLost(state.address);
+    yield* loseOwner(state, error);
+    const { sql, tables } = context;
+    yield* sql `
+      UPDATE ${sql(tables.heads)}
+      SET lease_until_ms = 0
+      WHERE address = ${state.addressId} AND fence = ${state.fence}
+    `.pipe(Effect.catch(() => Effect.void), Effect.catchDefect(() => Effect.void));
+}));
+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 encoded = yield* protocolBoundary(() => encodeAddress(address));
+    const { dialect, sql, tables } = context;
+    const fence = yield* sql
+        .withTransaction(Effect.gen(function* () {
+        yield* sql `
+      INSERT INTO ${sql(tables.heads)}
+        (address, address_json, namespace, fence, lease_until_ms, revision, event_sequence, event_floor)
+      VALUES (${encoded.id}, ${encoded.json}, ${address.namespace}, 0, 0, 0, 0, 0)
+      ON CONFLICT (address) DO NOTHING
+    `;
+        const rows = yield* sql `
+      UPDATE ${sql(tables.heads)}
+      SET fence = fence + 1,
+          lease_until_ms = ${databaseNow(sql, dialect)} + ${leaseMillis}
+      WHERE address = ${encoded.id}
+        AND lease_until_ms <= ${databaseNow(sql, dialect)}
+      RETURNING fence
+    `;
+        if (rows.length !== 1)
+            return yield* Effect.fail(ownershipLost(address));
+        return decimal(rows[0].fence);
+    }))
+        .pipe(Effect.mapError(normalizeSqlError));
+    const deferred = yield* Deferred.make();
+    const gate = yield* Semaphore.make(1);
+    const state = {
+        address,
+        addressId: encoded.id,
+        fence,
+        gate,
+        lost: deferred,
+        active: true,
+    };
+    const owner = Object.freeze({ address, fence, lost: Deferred.await(deferred) });
+    context.owners.set(owner, state);
+    yield* Effect.addFinalizer(() => closeOwner(context, state));
+    yield* Effect.forever(Effect.sleep(renewMillis).pipe(Effect.andThen(renew(context, state, leaseMillis)))).pipe(Effect.catch((error) => loseOwner(state, error)), Effect.catchDefect(() => loseOwner(state, normalizeSqlError(undefined))), Effect.forkScoped);
+    return owner;
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(normalizeSqlError(undefined))));

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

@@ -0,0 +1,25 @@
+import { Effect, Option } from "effect";
+import { type StoreError } from "../../errors/index.js";
+import type { Address, Json, Outcome, WireReceipt } from "../../protocol/index.js";
+import type { OwnerState, SqlStoreContext } from "./ownership.js";
+export declare const storedReceipt: (context: SqlStoreContext, state: OwnerState, commandId: string) => Effect.Effect<Readonly<{
+    receipt: WireReceipt;
+    fingerprint: string;
+}> | undefined, StoreError>;
+export declare const committedAt: (context: SqlStoreContext) => Effect.Effect<number, StoreError>;
+export declare const insertReceipt: (context: SqlStoreContext, state: OwnerState, input: {
+    readonly commandId: string;
+    readonly fingerprint: string;
+    readonly outcome: Outcome;
+    readonly revision: string;
+    readonly eventSequence: string;
+    readonly committedAtMillis: number;
+}) => Effect.Effect<WireReceipt, StoreError>;
+export declare const recordFailure: (context: SqlStoreContext, state: OwnerState, input: {
+    readonly commandId: string;
+    readonly fingerprint: string;
+    readonly error: Json;
+    readonly revision: string;
+    readonly eventSequence: string;
+}) => Effect.Effect<WireReceipt, StoreError>;
+export declare const receipt: (context: SqlStoreContext, address: Address, commandId: string) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;

package/dist/store/sql/receipts.js

@@ -0,0 +1,93 @@
+import { Effect, Option } from "effect";
+import { StorageUnavailable } from "../../errors/index.js";
+import { addressId, makeCursor, validateId } from "../../protocol/index.js";
+import { databaseNow, decimal, decodeJson, encodeJson, integer, normalizeSqlError, protocolBoundary, } from "./model.js";
+import { finalFence } from "./ownership.js";
+const invalidStoredData = () => new StorageUnavailable({ retryable: false });
+const readReceipt = (address, row) => {
+    if (typeof row.command_id !== "string" || typeof row.fingerprint !== "string")
+        throw new Error("Invalid receipt");
+    const outcome = decodeJson(row.outcome);
+    if (typeof outcome !== "object" ||
+        outcome === null ||
+        Array.isArray(outcome) ||
+        !("_tag" in outcome)) {
+        throw new Error("Invalid receipt outcome");
+    }
+    if (outcome._tag === "Success") {
+        if (!Object.hasOwn(outcome, "value"))
+            throw new Error("Invalid success receipt");
+    }
+    else if (outcome._tag === "Failure") {
+        if (!Object.hasOwn(outcome, "error"))
+            throw new Error("Invalid failure receipt");
+    }
+    else {
+        throw new Error("Invalid receipt outcome");
+    }
+    const sequence = decimal(row.event_sequence);
+    return {
+        commandId: row.command_id,
+        revision: decimal(row.revision),
+        cursor: makeCursor(address, sequence),
+        committedAtMillis: integer(row.committed_at_ms),
+        value: outcome,
+    };
+};
+export const storedReceipt = (context, state, commandId) => {
+    const { sql, tables } = context;
+    return sql `
+    SELECT command_id, fingerprint, outcome, revision, event_sequence, committed_at_ms
+    FROM ${sql(tables.receipts)}
+    WHERE address = ${state.addressId} AND command_id = ${commandId}
+  `.pipe(Effect.mapError(normalizeSqlError), Effect.flatMap((rows) => protocolBoundary(() => {
+        const row = rows[0];
+        return row === undefined
+            ? undefined
+            : { receipt: readReceipt(state.address, row), fingerprint: String(row.fingerprint) };
+    }).pipe(Effect.mapError(() => invalidStoredData()))));
+};
+export const committedAt = (context) => {
+    const { dialect, sql } = context;
+    return sql `SELECT ${databaseNow(sql, dialect)} AS now_ms`.pipe(Effect.mapError(normalizeSqlError), Effect.flatMap((rows) => protocolBoundary(() => integer(rows[0]?.now_ms)).pipe(Effect.mapError(() => invalidStoredData()))));
+};
+export const insertReceipt = (context, state, input) => Effect.gen(function* () {
+    const { sql, tables } = context;
+    const encoded = yield* protocolBoundary(() => encodeJson(input.outcome));
+    yield* sql `
+    INSERT INTO ${sql(tables.receipts)}
+      (address, command_id, fingerprint, outcome, revision, event_sequence, committed_at_ms)
+    VALUES (${state.addressId}, ${input.commandId}, ${input.fingerprint}, ${encoded}, ${input.revision},
+      ${input.eventSequence}, ${input.committedAtMillis})
+  `;
+    return {
+        commandId: input.commandId,
+        revision: input.revision,
+        cursor: yield* protocolBoundary(() => makeCursor(state.address, input.eventSequence)),
+        committedAtMillis: input.committedAtMillis,
+        value: input.outcome,
+    };
+}).pipe(Effect.mapError(normalizeSqlError));
+export const recordFailure = (context, state, input) => Effect.gen(function* () {
+    yield* protocolBoundary(() => encodeJson(input.error));
+    const nowMillis = yield* committedAt(context);
+    const receipt = yield* insertReceipt(context, state, {
+        ...input,
+        outcome: { _tag: "Failure", error: input.error },
+        committedAtMillis: nowMillis,
+    });
+    yield* finalFence(context, state);
+    return receipt;
+});
+export const receipt = (context, address, commandId) => Effect.gen(function* () {
+    const actorId = yield* protocolBoundary(() => addressId(address));
+    yield* protocolBoundary(() => validateId(commandId, 1024));
+    const rows = yield* context.sql `
+    SELECT command_id, fingerprint, outcome, revision, event_sequence, committed_at_ms
+    FROM ${context.sql(context.tables.receipts)}
+    WHERE address = ${actorId} AND command_id = ${commandId}
+  `;
+    if (rows.length === 0)
+        return Option.none();
+    return Option.some(yield* protocolBoundary(() => readReceipt(address, rows[0])).pipe(Effect.mapError(() => invalidStoredData())));
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));

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

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { InvalidInput, UnsupportedVersion } from "../../errors/index.js";
+import { type Tables } from "./model.js";
+export declare const schemaVersion = 1;
+export declare const validateSchema: (sql: SqlClient.SqlClient, tables: Tables) => Effect.Effect<undefined, import("../../errors/index.js").StorageUnavailable | UnsupportedVersion, never>;
+export declare const migrate: (options: {
+    readonly tablePrefix: string;
+}) => Effect.Effect<void, InvalidInput | import("../../errors/index.js").StorageUnavailable | UnsupportedVersion, SqlClient.SqlClient>;