@voyant-travel/action-ledger 0.104.10

package/dist/service/predicates.js

@@ -0,0 +1,368 @@
+import { and, eq, gt, gte, inArray, lt, lte, or, sql } from "drizzle-orm";
+import { actionApprovals, actionDelegations, actionLedgerEntries, actionLedgerRelayOutbox, actionMutationDetails, actionSensitiveReadDetails, } from "../schema.js";
+import { parseCursorDate } from "./cursors.js";
+function riskCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionLedgerEntries.evaluatedRisk, value);
+    }
+    return eq(actionLedgerEntries.evaluatedRisk, value);
+}
+function statusCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionLedgerEntries.status, value);
+    }
+    return eq(actionLedgerEntries.status, value);
+}
+function approvalStatusCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionApprovals.status, value);
+    }
+    return eq(actionApprovals.status, value);
+}
+function approvalRiskCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionApprovals.riskSnapshot, value);
+    }
+    return eq(actionApprovals.riskSnapshot, value);
+}
+function reversalKindCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionMutationDetails.reversalKind, value);
+    }
+    return eq(actionMutationDetails.reversalKind, value);
+}
+function reversalStateCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionMutationDetails.reversalStateProjection, value);
+    }
+    return eq(actionMutationDetails.reversalStateProjection, value);
+}
+function reversalOutcomeCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionMutationDetails.reversalOutcomeProjection, value);
+    }
+    return eq(actionMutationDetails.reversalOutcomeProjection, value);
+}
+function relayStatusCondition(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return inArray(actionLedgerRelayOutbox.relayStatus, value);
+    }
+    return eq(actionLedgerRelayOutbox.relayStatus, value);
+}
+function mutationDetailExists(condition) {
+    return sql `EXISTS (
+    SELECT 1
+    FROM ${actionMutationDetails}
+    WHERE ${actionMutationDetails.actionId} = ${actionLedgerEntries.id}
+      AND ${condition}
+  )`;
+}
+function sensitiveReadDetailExists(condition) {
+    return sql `EXISTS (
+    SELECT 1
+    FROM ${actionSensitiveReadDetails}
+    WHERE ${actionSensitiveReadDetails.actionId} = ${actionLedgerEntries.id}
+      AND ${condition}
+  )`;
+}
+function buildCursorCondition(cursor, sortDir = "desc") {
+    const occurredAt = parseCursorDate(cursor.occurredAt);
+    const compare = sortDir === "asc" ? gt : lt;
+    const tieBreaker = and(eq(actionLedgerEntries.occurredAt, occurredAt), compare(actionLedgerEntries.id, cursor.id));
+    return or(compare(actionLedgerEntries.occurredAt, occurredAt), tieBreaker);
+}
+function buildRelayOutboxCursorCondition(cursor) {
+    const createdAt = parseCursorDate(cursor.createdAt);
+    const tieBreaker = and(eq(actionLedgerRelayOutbox.createdAt, createdAt), lt(actionLedgerRelayOutbox.id, cursor.id));
+    return or(lt(actionLedgerRelayOutbox.createdAt, createdAt), tieBreaker);
+}
+function buildApprovalCursorCondition(cursor) {
+    const createdAt = parseCursorDate(cursor.createdAt);
+    const tieBreaker = and(eq(actionApprovals.createdAt, createdAt), lt(actionApprovals.id, cursor.id));
+    return or(lt(actionApprovals.createdAt, createdAt), tieBreaker);
+}
+function buildDelegationCursorCondition(cursor) {
+    const createdAt = parseCursorDate(cursor.createdAt);
+    const tieBreaker = and(eq(actionDelegations.createdAt, createdAt), lt(actionDelegations.id, cursor.id));
+    return or(lt(actionDelegations.createdAt, createdAt), tieBreaker);
+}
+function buildActionDelegationsPredicate(input) {
+    const conditions = [];
+    if (input.rootPrincipalType) {
+        conditions.push(eq(actionDelegations.rootPrincipalType, input.rootPrincipalType));
+    }
+    if (input.rootPrincipalId) {
+        conditions.push(eq(actionDelegations.rootPrincipalId, input.rootPrincipalId));
+    }
+    if (input.parentPrincipalType) {
+        conditions.push(eq(actionDelegations.parentPrincipalType, input.parentPrincipalType));
+    }
+    if (input.parentPrincipalId) {
+        conditions.push(eq(actionDelegations.parentPrincipalId, input.parentPrincipalId));
+    }
+    if (input.childPrincipalType) {
+        conditions.push(eq(actionDelegations.childPrincipalType, input.childPrincipalType));
+    }
+    if (input.childPrincipalId) {
+        conditions.push(eq(actionDelegations.childPrincipalId, input.childPrincipalId));
+    }
+    if (input.grantSource)
+        conditions.push(eq(actionDelegations.grantSource, input.grantSource));
+    if (input.capabilityScopeRef) {
+        conditions.push(eq(actionDelegations.capabilityScopeRef, input.capabilityScopeRef));
+    }
+    if (input.budgetScopeRef) {
+        conditions.push(eq(actionDelegations.budgetScopeRef, input.budgetScopeRef));
+    }
+    if (input.expiresAtFrom) {
+        conditions.push(gte(actionDelegations.expiresAt, parseCursorDate(input.expiresAtFrom)));
+    }
+    if (input.expiresAtTo) {
+        conditions.push(lte(actionDelegations.expiresAt, parseCursorDate(input.expiresAtTo)));
+    }
+    if (input.createdAtFrom) {
+        conditions.push(gte(actionDelegations.createdAt, parseCursorDate(input.createdAtFrom)));
+    }
+    if (input.createdAtTo) {
+        conditions.push(lte(actionDelegations.createdAt, parseCursorDate(input.createdAtTo)));
+    }
+    if (input.cursor) {
+        conditions.push(buildDelegationCursorCondition(input.cursor));
+    }
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return and(...conditions);
+}
+function buildActionApprovalsPredicate(input) {
+    const conditions = [];
+    if (input.requestedActionId) {
+        conditions.push(eq(actionApprovals.requestedActionId, input.requestedActionId));
+    }
+    const entryStatusCondition = approvalStatusCondition(input.status);
+    if (entryStatusCondition)
+        conditions.push(entryStatusCondition);
+    if (input.requestedByPrincipalId) {
+        conditions.push(eq(actionApprovals.requestedByPrincipalId, input.requestedByPrincipalId));
+    }
+    if (input.assignedToPrincipalId) {
+        conditions.push(eq(actionApprovals.assignedToPrincipalId, input.assignedToPrincipalId));
+    }
+    if (input.decidedByPrincipalId) {
+        conditions.push(eq(actionApprovals.decidedByPrincipalId, input.decidedByPrincipalId));
+    }
+    if (input.delegatedFromPrincipalId) {
+        conditions.push(eq(actionApprovals.delegatedFromPrincipalId, input.delegatedFromPrincipalId));
+    }
+    if (input.policyName)
+        conditions.push(eq(actionApprovals.policyName, input.policyName));
+    if (input.policyVersion)
+        conditions.push(eq(actionApprovals.policyVersion, input.policyVersion));
+    const riskSnapshotCondition = approvalRiskCondition(input.riskSnapshot);
+    if (riskSnapshotCondition)
+        conditions.push(riskSnapshotCondition);
+    if (input.reasonCode)
+        conditions.push(eq(actionApprovals.reasonCode, input.reasonCode));
+    if (input.expiresAtFrom) {
+        conditions.push(gte(actionApprovals.expiresAt, parseCursorDate(input.expiresAtFrom)));
+    }
+    if (input.expiresAtTo) {
+        conditions.push(lte(actionApprovals.expiresAt, parseCursorDate(input.expiresAtTo)));
+    }
+    if (input.decidedAtFrom) {
+        conditions.push(gte(actionApprovals.decidedAt, parseCursorDate(input.decidedAtFrom)));
+    }
+    if (input.decidedAtTo) {
+        conditions.push(lte(actionApprovals.decidedAt, parseCursorDate(input.decidedAtTo)));
+    }
+    if (input.createdAtFrom) {
+        conditions.push(gte(actionApprovals.createdAt, parseCursorDate(input.createdAtFrom)));
+    }
+    if (input.createdAtTo) {
+        conditions.push(lte(actionApprovals.createdAt, parseCursorDate(input.createdAtTo)));
+    }
+    if (input.cursor) {
+        conditions.push(buildApprovalCursorCondition(input.cursor));
+    }
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return and(...conditions);
+}
+function buildActionLedgerRelayOutboxPredicate(input) {
+    const conditions = [];
+    if (input.actionId)
+        conditions.push(eq(actionLedgerRelayOutbox.actionId, input.actionId));
+    if (input.organizationId) {
+        conditions.push(eq(actionLedgerRelayOutbox.organizationId, input.organizationId));
+    }
+    const entryRelayStatusCondition = relayStatusCondition(input.relayStatus);
+    if (entryRelayStatusCondition)
+        conditions.push(entryRelayStatusCondition);
+    if (input.dueBefore) {
+        conditions.push(lte(actionLedgerRelayOutbox.nextRetryAt, parseCursorDate(input.dueBefore)));
+    }
+    if (input.createdAtFrom) {
+        conditions.push(gte(actionLedgerRelayOutbox.createdAt, parseCursorDate(input.createdAtFrom)));
+    }
+    if (input.createdAtTo) {
+        conditions.push(lte(actionLedgerRelayOutbox.createdAt, parseCursorDate(input.createdAtTo)));
+    }
+    if (input.processedAtFrom) {
+        conditions.push(gte(actionLedgerRelayOutbox.processedAt, parseCursorDate(input.processedAtFrom)));
+    }
+    if (input.processedAtTo) {
+        conditions.push(lte(actionLedgerRelayOutbox.processedAt, parseCursorDate(input.processedAtTo)));
+    }
+    if (input.cursor) {
+        conditions.push(buildRelayOutboxCursorCondition(input.cursor));
+    }
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return and(...conditions);
+}
+function buildActionLedgerEntriesPredicate(input) {
+    const conditions = [];
+    if (input.actionName)
+        conditions.push(eq(actionLedgerEntries.actionName, input.actionName));
+    if (input.actionKind)
+        conditions.push(eq(actionLedgerEntries.actionKind, input.actionKind));
+    if (input.actorType)
+        conditions.push(eq(actionLedgerEntries.actorType, input.actorType));
+    if (input.principalType) {
+        conditions.push(eq(actionLedgerEntries.principalType, input.principalType));
+    }
+    if (input.principalId)
+        conditions.push(eq(actionLedgerEntries.principalId, input.principalId));
+    if (input.apiTokenId)
+        conditions.push(eq(actionLedgerEntries.apiTokenId, input.apiTokenId));
+    if (input.sessionId)
+        conditions.push(eq(actionLedgerEntries.sessionId, input.sessionId));
+    if (input.callerType)
+        conditions.push(eq(actionLedgerEntries.callerType, input.callerType));
+    if (input.organizationId) {
+        conditions.push(eq(actionLedgerEntries.organizationId, input.organizationId));
+    }
+    if (input.targetType)
+        conditions.push(eq(actionLedgerEntries.targetType, input.targetType));
+    if (input.targetId)
+        conditions.push(eq(actionLedgerEntries.targetId, input.targetId));
+    if (input.targetIds && input.targetIds.length > 0) {
+        conditions.push(inArray(actionLedgerEntries.targetId, input.targetIds));
+    }
+    if (input.routeOrToolName) {
+        conditions.push(eq(actionLedgerEntries.routeOrToolName, input.routeOrToolName));
+    }
+    if (input.workflowRunId) {
+        conditions.push(eq(actionLedgerEntries.workflowRunId, input.workflowRunId));
+    }
+    if (input.workflowStepId) {
+        conditions.push(eq(actionLedgerEntries.workflowStepId, input.workflowStepId));
+    }
+    if (input.correlationId) {
+        conditions.push(eq(actionLedgerEntries.correlationId, input.correlationId));
+    }
+    if (input.causationActionId) {
+        conditions.push(eq(actionLedgerEntries.causationActionId, input.causationActionId));
+    }
+    if (input.capabilityId)
+        conditions.push(eq(actionLedgerEntries.capabilityId, input.capabilityId));
+    if (input.capabilityVersion) {
+        conditions.push(eq(actionLedgerEntries.capabilityVersion, input.capabilityVersion));
+    }
+    if (input.authorizationSource) {
+        conditions.push(eq(actionLedgerEntries.authorizationSource, input.authorizationSource));
+    }
+    if (input.approvalId)
+        conditions.push(eq(actionLedgerEntries.approvalId, input.approvalId));
+    if (input.amendsActionId) {
+        conditions.push(eq(actionLedgerEntries.amendsActionId, input.amendsActionId));
+    }
+    if (input.idempotencyScope) {
+        conditions.push(eq(actionLedgerEntries.idempotencyScope, input.idempotencyScope));
+    }
+    if (input.idempotencyKey) {
+        conditions.push(eq(actionLedgerEntries.idempotencyKey, input.idempotencyKey));
+    }
+    const evaluatedRiskCondition = riskCondition(input.evaluatedRisk);
+    if (evaluatedRiskCondition)
+        conditions.push(evaluatedRiskCondition);
+    const entryStatusCondition = statusCondition(input.status);
+    if (entryStatusCondition)
+        conditions.push(entryStatusCondition);
+    const entryReversalKindCondition = reversalKindCondition(input.reversalKind);
+    if (entryReversalKindCondition) {
+        conditions.push(mutationDetailExists(entryReversalKindCondition));
+    }
+    const entryReversalStateCondition = reversalStateCondition(input.reversalState);
+    if (entryReversalStateCondition) {
+        conditions.push(mutationDetailExists(entryReversalStateCondition));
+    }
+    const entryReversalOutcomeCondition = reversalOutcomeCondition(input.reversalOutcome);
+    if (entryReversalOutcomeCondition) {
+        conditions.push(mutationDetailExists(entryReversalOutcomeCondition));
+    }
+    if (input.reversesActionId) {
+        conditions.push(mutationDetailExists(eq(actionMutationDetails.reversesActionId, input.reversesActionId)));
+    }
+    if (input.reversedByActionId) {
+        conditions.push(mutationDetailExists(eq(actionMutationDetails.reversedByActionIdProjection, input.reversedByActionId)));
+    }
+    if (input.sensitiveReasonCode) {
+        conditions.push(sensitiveReadDetailExists(eq(actionSensitiveReadDetails.reasonCode, input.sensitiveReasonCode)));
+    }
+    if (input.decisionPolicy) {
+        conditions.push(sensitiveReadDetailExists(eq(actionSensitiveReadDetails.decisionPolicy, input.decisionPolicy)));
+    }
+    if (input.occurredAtFrom) {
+        conditions.push(gte(actionLedgerEntries.occurredAt, parseCursorDate(input.occurredAtFrom)));
+    }
+    if (input.occurredAtTo) {
+        conditions.push(lte(actionLedgerEntries.occurredAt, parseCursorDate(input.occurredAtTo)));
+    }
+    if (input.cursor) {
+        conditions.push(buildCursorCondition(input.cursor, input.sortDir));
+    }
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return and(...conditions);
+}
+export { buildActionApprovalsPredicate, buildActionDelegationsPredicate, buildActionLedgerEntriesPredicate, buildActionLedgerRelayOutboxPredicate, };

package/dist/service/records.d.ts

@@ -0,0 +1,6 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { GetActionApprovalResult, GetActionDelegationResult, GetActionLedgerEntryResult } from "./types.js";
+export declare function getEntry(db: AnyDrizzleDb, id: string): Promise<GetActionLedgerEntryResult | null>;
+export declare function getApproval(db: AnyDrizzleDb, id: string): Promise<GetActionApprovalResult | null>;
+export declare function getDelegation(db: AnyDrizzleDb, id: string): Promise<GetActionDelegationResult | null>;
+//# sourceMappingURL=records.d.ts.map

package/dist/service/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../src/service/records.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAYrD,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,YAAY,CAAA;AAEnB,wBAAsB,QAAQ,CAC5B,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CA2B5C;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAazC;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC,CAS3C"}

package/dist/service/records.js

@@ -0,0 +1,51 @@
+import { eq } from "drizzle-orm";
+import { actionApprovals, actionDelegations, actionLedgerEntries, actionLedgerPayloads, actionLedgerRelayOutbox, actionMutationDetails, actionSensitiveReadDetails, } from "../schema.js";
+export async function getEntry(db, id) {
+    const [entry] = await db
+        .select()
+        .from(actionLedgerEntries)
+        .where(eq(actionLedgerEntries.id, id))
+        .limit(1);
+    if (!entry)
+        return null;
+    const [[mutationDetail], [sensitiveReadDetail], payloads, relayOutbox] = await Promise.all([
+        db.select().from(actionMutationDetails).where(eq(actionMutationDetails.actionId, id)).limit(1),
+        db
+            .select()
+            .from(actionSensitiveReadDetails)
+            .where(eq(actionSensitiveReadDetails.actionId, id))
+            .limit(1),
+        db.select().from(actionLedgerPayloads).where(eq(actionLedgerPayloads.actionId, id)),
+        db.select().from(actionLedgerRelayOutbox).where(eq(actionLedgerRelayOutbox.actionId, id)),
+    ]);
+    return {
+        entry,
+        mutationDetail: mutationDetail ?? null,
+        sensitiveReadDetail: sensitiveReadDetail ?? null,
+        payloads,
+        relayOutbox,
+    };
+}
+export async function getApproval(db, id) {
+    const [approval] = await db
+        .select()
+        .from(actionApprovals)
+        .where(eq(actionApprovals.id, id))
+        .limit(1);
+    if (!approval)
+        return null;
+    return {
+        approval,
+        requestedAction: await getEntry(db, approval.requestedActionId),
+    };
+}
+export async function getDelegation(db, id) {
+    const [delegation] = await db
+        .select()
+        .from(actionDelegations)
+        .where(eq(actionDelegations.id, id))
+        .limit(1);
+    if (!delegation)
+        return null;
+    return { delegation };
+}

package/dist/service/relay-lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type ActionLedgerRelayOutbox } from "../schema.js";
+import type { ClaimActionLedgerRelayOutboxInput, ClaimActionLedgerRelayOutboxResult, MarkActionLedgerRelayOutboxFailedInput, MarkActionLedgerRelayOutboxSucceededInput } from "./types.js";
+export declare function claimRelayOutbox(db: AnyDrizzleDb, input?: ClaimActionLedgerRelayOutboxInput): Promise<ClaimActionLedgerRelayOutboxResult>;
+export declare function markRelayOutboxSucceeded(db: AnyDrizzleDb, input: MarkActionLedgerRelayOutboxSucceededInput): Promise<ActionLedgerRelayOutbox | null>;
+export declare function markRelayOutboxFailed(db: AnyDrizzleDb, input: MarkActionLedgerRelayOutboxFailedInput): Promise<ActionLedgerRelayOutbox | null>;
+//# sourceMappingURL=relay-lifecycle.d.ts.map

package/dist/service/relay-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-lifecycle.d.ts","sourceRoot":"","sources":["../../src/service/relay-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,OAAO,EAAE,KAAK,uBAAuB,EAA2B,MAAM,cAAc,CAAA;AAMpF,OAAO,KAAK,EACV,iCAAiC,EACjC,kCAAkC,EAClC,sCAAsC,EACtC,yCAAyC,EAC1C,MAAM,YAAY,CAAA;AAEnB,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,iCAAsC,GAC5C,OAAO,CAAC,kCAAkC,CAAC,CAuC7C;AAED,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,yCAAyC,GAC/C,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAkBzC;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,sCAAsC,GAC5C,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CA2BzC"}

package/dist/service/relay-lifecycle.js

@@ -0,0 +1,78 @@
+import { and, eq, sql } from "drizzle-orm";
+import { actionLedgerRelayOutbox } from "../schema.js";
+import { normalizeListLimit, parseCursorDate } from "./cursors.js";
+import { actionLedgerRelayOutboxFromSqlRow, } from "./relay-outbox.js";
+export async function claimRelayOutbox(db, input = {}) {
+    const limit = normalizeListLimit(input.limit);
+    const dueAt = input.dueAt ? parseCursorDate(input.dueAt) : new Date();
+    const organizationId = input.organizationId ?? null;
+    const result = await db.execute(sql `
+      WITH due AS (
+        SELECT id
+        FROM action_ledger_outbox
+        WHERE relay_status IN ('pending', 'failed')
+          AND (${organizationId}::text IS NULL OR organization_id = ${organizationId})
+          AND (next_retry_at IS NULL OR next_retry_at <= ${dueAt})
+        ORDER BY created_at ASC, id ASC
+        LIMIT ${limit}
+        FOR UPDATE SKIP LOCKED
+      )
+      UPDATE action_ledger_outbox AS outbox
+      SET relay_status = 'processing',
+          attempt_count = outbox.attempt_count + 1,
+          last_error = NULL,
+          processed_at = NULL
+      FROM due
+      WHERE outbox.id = due.id
+      RETURNING
+        outbox.id,
+        outbox.action_id,
+        outbox.organization_id,
+        outbox.relay_status,
+        outbox.payload_ref,
+        outbox.attempt_count,
+        outbox.next_retry_at,
+        outbox.last_error,
+        outbox.created_at,
+        outbox.processed_at
+    `);
+    const rows = ("rows" in result ? result.rows : result);
+    return {
+        rows: rows.map(actionLedgerRelayOutboxFromSqlRow),
+    };
+}
+export async function markRelayOutboxSucceeded(db, input) {
+    const [row] = await db
+        .update(actionLedgerRelayOutbox)
+        .set({
+        relayStatus: "succeeded",
+        nextRetryAt: null,
+        lastError: null,
+        processedAt: input.processedAt ? parseCursorDate(input.processedAt) : new Date(),
+    })
+        .where(and(eq(actionLedgerRelayOutbox.id, input.id), eq(actionLedgerRelayOutbox.relayStatus, "processing")))
+        .returning();
+    return row ?? null;
+}
+export async function markRelayOutboxFailed(db, input) {
+    const deadLetter = input.deadLetter ?? false;
+    const [row] = await db
+        .update(actionLedgerRelayOutbox)
+        .set({
+        relayStatus: deadLetter ? "dead_letter" : "failed",
+        nextRetryAt: deadLetter
+            ? null
+            : input.nextRetryAt
+                ? parseCursorDate(input.nextRetryAt)
+                : null,
+        lastError: input.lastError,
+        processedAt: deadLetter
+            ? input.processedAt
+                ? parseCursorDate(input.processedAt)
+                : new Date()
+            : null,
+    })
+        .where(and(eq(actionLedgerRelayOutbox.id, input.id), eq(actionLedgerRelayOutbox.relayStatus, "processing")))
+        .returning();
+    return row ?? null;
+}

package/dist/service/relay-outbox.d.ts

@@ -0,0 +1,15 @@
+import type { ActionLedgerRelayOutbox } from "../schema.js";
+export type ActionLedgerRelayOutboxSqlRow = {
+    id: string;
+    action_id: string;
+    organization_id: string | null;
+    relay_status: ActionLedgerRelayOutbox["relayStatus"];
+    payload_ref: string | null;
+    attempt_count: number | string;
+    next_retry_at: Date | string | null;
+    last_error: string | null;
+    created_at: Date | string;
+    processed_at: Date | string | null;
+};
+export declare function actionLedgerRelayOutboxFromSqlRow(row: ActionLedgerRelayOutboxSqlRow): ActionLedgerRelayOutbox;
+//# sourceMappingURL=relay-outbox.d.ts.map

package/dist/service/relay-outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-outbox.d.ts","sourceRoot":"","sources":["../../src/service/relay-outbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAG3D,MAAM,MAAM,6BAA6B,GAAG;IAC1C,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,YAAY,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAA;IACpD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,aAAa,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,aAAa,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAA;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,UAAU,EAAE,IAAI,GAAG,MAAM,CAAA;IACzB,YAAY,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAA;CACnC,CAAA;AAED,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,6BAA6B,GACjC,uBAAuB,CAazB"}

package/dist/service/relay-outbox.js

@@ -0,0 +1,15 @@
+import { parseCursorDate } from "./cursors.js";
+export function actionLedgerRelayOutboxFromSqlRow(row) {
+    return {
+        id: row.id,
+        actionId: row.action_id,
+        organizationId: row.organization_id,
+        relayStatus: row.relay_status,
+        payloadRef: row.payload_ref,
+        attemptCount: Number(row.attempt_count),
+        nextRetryAt: row.next_retry_at ? parseCursorDate(row.next_retry_at) : null,
+        lastError: row.last_error,
+        createdAt: parseCursorDate(row.created_at),
+        processedAt: row.processed_at ? parseCursorDate(row.processed_at) : null,
+    };
+}