@hasna/loops 0.4.27 → 0.4.29

package/dist/lib/storage/pg-executor.d.ts

@@ -8,12 +8,11 @@ export interface PgExecutorOptions {
     idleTimeoutMillis?: number;
 }
 /**
- * `PostgresQueryExecutor` backed by a live `pg.Pool` via the vendored kit.
+ * `PostgresQueryExecutor` backed by a live `pg.Pool` via the generated kit.
  *
- * Transaction support is intentionally omitted: `PostgresStorage.migrate`
- * treats DDL as idempotent (`CREATE ... IF NOT EXISTS` + a checksum ledger), so
- * a pooled sequential apply is correct and avoids binding every inner
- * `execute` to a single dedicated client.
+ * Transactions bind every statement to one dedicated pool client. This is
+ * required both for atomic migration+ledger writes and request-scoped RLS
+ * settings established with `SET LOCAL`.
  */
 export declare class PgPoolExecutor implements PostgresQueryExecutor {
     private readonly client;
@@ -23,5 +22,11 @@ export declare class PgPoolExecutor implements PostgresQueryExecutor {
     get queryClient(): PoolQueryClient;
     query<T extends Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<T[]>;
     execute(sql: string, params?: readonly unknown[]): Promise<void>;
+    transaction<T>(fn: (executor: PostgresQueryExecutor) => Promise<T>): Promise<T>;
+    withRequestContext<T>(context: {
+        tenantId: string;
+        principalId: string;
+        requestId: string;
+    }, fn: (client: PoolQueryClient) => Promise<T>): Promise<T>;
     close(): Promise<void>;
 }

package/dist/lib/storage/postgres-loop-storage.d.ts

@@ -1,23 +1,29 @@
-import type { RecoverExpiredRunLeasesResult } from "../store.js";
+import type { RecoverExpiredRunLeasesResult, RecoveredLeaseRunPage } from "../store.js";
 import { Store } from "../store.js";
 import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
 import type { LoopStorageContract, LoopStorageMethodName } from "./contract.js";
-/** Thrown by store methods that are not yet ported to the Postgres backend. */
-export declare class NotImplementedError extends Error {
-    readonly code = "not_implemented";
-    constructor(method: string);
-}
 type M<K extends LoopStorageMethodName> = Store[K] extends (...a: infer A) => infer R ? {
     args: A;
     result: R;
 } : never;
+export interface TenantStorageContext {
+    tenantId: string;
+    principalId: string;
+    requestId: string;
+}
 export declare class PostgresLoopStorage implements LoopStorageContract {
-    private readonly client;
     readonly backend = "postgres";
     readonly supportsRemoteRunners = true;
-    constructor(client: PoolQueryClient);
+    readonly tenantId: string;
+    readonly principalId: string;
+    readonly requestId: string;
+    private readonly client;
+    constructor(client: PoolQueryClient, context: TenantStorageContext, opts?: {
+        contextAlreadyBound?: boolean;
+    });
     close(): Promise<void>;
     private assertDaemonLeaseFence;
+    private lockWorkflowRun;
     private loadLoop;
     private loadRun;
     private loadRunBySlot;
@@ -25,18 +31,24 @@ export declare class PostgresLoopStorage implements LoopStorageContract {
     private setWorkItemsForLoop;
     private setWorkItemsForWorkflowRun;
     private cascadeWorkItemsForLoopRun;
+    private maybeArchiveGeneratedRouteWorkflow;
     createLoop(...args: M<"createLoop">["args"]): Promise<M<"createLoop">["result"]>;
     getLoop(...args: M<"getLoop">["args"]): Promise<M<"getLoop">["result"]>;
     findLoopByName(...args: M<"findLoopByName">["args"]): Promise<M<"findLoopByName">["result"]>;
     requireLoop(...args: M<"requireLoop">["args"]): Promise<M<"requireLoop">["result"]>;
+    requireUniqueLoop(...args: M<"requireUniqueLoop">["args"]): Promise<M<"requireUniqueLoop">["result"]>;
     listLoops(...args: M<"listLoops">["args"]): Promise<M<"listLoops">["result"]>;
     dueLoops(...args: M<"dueLoops">["args"]): Promise<M<"dueLoops">["result"]>;
     updateLoop(...args: M<"updateLoop">["args"]): Promise<M<"updateLoop">["result"]>;
+    advanceLoopIfCurrent(...args: M<"advanceLoopIfCurrent">["args"]): Promise<M<"advanceLoopIfCurrent">["result"]>;
+    tripCircuitBreakerIfCurrent(...args: M<"tripCircuitBreakerIfCurrent">["args"]): Promise<M<"tripCircuitBreakerIfCurrent">["result"]>;
     renameLoop(...args: M<"renameLoop">["args"]): Promise<M<"renameLoop">["result"]>;
     archiveLoop(...args: M<"archiveLoop">["args"]): Promise<M<"archiveLoop">["result"]>;
     unarchiveLoop(...args: M<"unarchiveLoop">["args"]): Promise<M<"unarchiveLoop">["result"]>;
     deleteLoop(...args: M<"deleteLoop">["args"]): Promise<M<"deleteLoop">["result"]>;
     private requireLoopIn;
+    private requireUniqueLoopIn;
+    private requireArchiveMutationLoopIn;
     countLoops(...args: M<"countLoops">["args"]): Promise<M<"countLoops">["result"]>;
     upsertMigrationWorkflow(...args: M<"upsertMigrationWorkflow">["args"]): Promise<M<"upsertMigrationWorkflow">["result"]>;
     upsertMigrationLoop(...args: M<"upsertMigrationLoop">["args"]): Promise<M<"upsertMigrationLoop">["result"]>;
@@ -44,6 +56,7 @@ export declare class PostgresLoopStorage implements LoopStorageContract {
     createSkippedRun(...args: M<"createSkippedRun">["args"]): Promise<M<"createSkippedRun">["result"]>;
     getRun(...args: M<"getRun">["args"]): Promise<M<"getRun">["result"]>;
     getRunBySlot(...args: M<"getRunBySlot">["args"]): Promise<M<"getRunBySlot">["result"]>;
+    nextRetryableRun(...args: M<"nextRetryableRun">["args"]): Promise<M<"nextRetryableRun">["result"]>;
     /**
      * Claim a specific loop slot for a runner.
      *
@@ -62,6 +75,7 @@ export declare class PostgresLoopStorage implements LoopStorageContract {
     heartbeatRunLease(...args: M<"heartbeatRunLease">["args"]): Promise<M<"heartbeatRunLease">["result"]>;
     recordRunProcess(...args: M<"recordRunProcess">["args"]): Promise<M<"recordRunProcess">["result"]>;
     listRuns(...args: M<"listRuns">["args"]): Promise<M<"listRuns">["result"]>;
+    listRecoveredLeaseRunsPage(...args: M<"listRecoveredLeaseRunsPage">["args"]): Promise<RecoveredLeaseRunPage>;
     writeRunReceipt(...args: M<"writeRunReceipt">["args"]): Promise<M<"writeRunReceipt">["result"]>;
     getRunReceipt(...args: M<"getRunReceipt">["args"]): Promise<M<"getRunReceipt">["result"]>;
     listRunReceipts(...args: M<"listRunReceipts">["args"]): Promise<M<"listRunReceipts">["result"]>;
@@ -71,9 +85,7 @@ export declare class PostgresLoopStorage implements LoopStorageContract {
      * Recover expired run leases. Divergence from sqlite (documented): the remote
      * backend cannot inspect local process liveness, so an expired lease is always
      * abandoned (never "deferred because the local process is still alive"). The
-     * `deferred` array is therefore always empty here. The generated-route
-     * workflow archival side effect is not ported (route automation is a TIER 2
-     * path); the core guarantee — no run stays `running` past its lease — holds.
+     * `deferred` array is therefore always empty here.
      */
     recoverExpiredRunLeasesDetailed(...args: M<"recoverExpiredRunLeasesDetailed">["args"]): Promise<RecoverExpiredRunLeasesResult>;
     pruneHistory(...args: M<"pruneHistory">["args"]): Promise<M<"pruneHistory">["result"]>;
@@ -101,20 +113,34 @@ export declare class PostgresLoopStorage implements LoopStorageContract {
     listGoalRuns(...args: M<"listGoalRuns">["args"]): Promise<M<"listGoalRuns">["result"]>;
     createWorkflow(...args: M<"createWorkflow">["args"]): Promise<M<"createWorkflow">["result"]>;
     archiveWorkflow(...args: M<"archiveWorkflow">["args"]): Promise<M<"archiveWorkflow">["result"]>;
-    createWorkflowInvocation(): never;
-    upsertWorkflowWorkItem(): never;
-    admitWorkflowWorkItem(): never;
-    createGoal(): never;
-    createGoalPlanNodes(): never;
-    updateGoalStatus(): never;
-    updateGoalPlanNode(): never;
-    recordGoalEvent(): never;
-    createWorkflowRun(): never;
-    startWorkflowStepRun(): never;
-    recoverWorkflowRun(): never;
-    finalizeWorkflowStepRun(): never;
-    finalizeWorkflowRun(): never;
-    appendWorkflowEvent(): never;
+    createWorkflowInvocation(...args: M<"createWorkflowInvocation">["args"]): Promise<M<"createWorkflowInvocation">["result"]>;
+    upsertWorkflowWorkItem(...args: M<"upsertWorkflowWorkItem">["args"]): Promise<M<"upsertWorkflowWorkItem">["result"]>;
+    admitWorkflowWorkItem(...args: M<"admitWorkflowWorkItem">["args"]): Promise<M<"admitWorkflowWorkItem">["result"]>;
+    createGoal(...args: M<"createGoal">["args"]): Promise<M<"createGoal">["result"]>;
+    requireGoal(...args: M<"requireGoal">["args"]): Promise<M<"requireGoal">["result"]>;
+    findGoalByContext(...args: M<"findGoalByContext">["args"]): Promise<M<"findGoalByContext">["result"]>;
+    private mapGoalPlanNode;
+    createGoalPlanNodes(...args: M<"createGoalPlanNodes">["args"]): Promise<M<"createGoalPlanNodes">["result"]>;
+    updateGoalStatus(...args: M<"updateGoalStatus">["args"]): Promise<M<"updateGoalStatus">["result"]>;
+    updateGoalPlanNode(...args: M<"updateGoalPlanNode">["args"]): Promise<M<"updateGoalPlanNode">["result"]>;
+    recordGoalEvent(...args: M<"recordGoalEvent">["args"]): Promise<M<"recordGoalEvent">["result"]>;
+    requireWorkflow(...args: M<"requireWorkflow">["args"]): Promise<M<"requireWorkflow">["result"]>;
+    createWorkflowRun(...args: M<"createWorkflowRun">["args"]): Promise<M<"createWorkflowRun">["result"]>;
+    requireWorkflowRun(...args: M<"requireWorkflowRun">["args"]): Promise<M<"requireWorkflowRun">["result"]>;
+    isWorkflowRunTerminal(...args: M<"isWorkflowRunTerminal">["args"]): Promise<M<"isWorkflowRunTerminal">["result"]>;
+    startWorkflowStepRun(...args: M<"startWorkflowStepRun">["args"]): Promise<M<"startWorkflowStepRun">["result"]>;
+    markWorkflowStepPid(...args: M<"markWorkflowStepPid">["args"]): Promise<M<"markWorkflowStepPid">["result"]>;
+    recordWorkflowStepProgress(...args: M<"recordWorkflowStepProgress">["args"]): Promise<M<"recordWorkflowStepProgress">["result"]>;
+    recoverWorkflowRun(...args: M<"recoverWorkflowRun">["args"]): Promise<M<"recoverWorkflowRun">["result"]>;
+    finalizeWorkflowStepRun(...args: M<"finalizeWorkflowStepRun">["args"]): Promise<M<"finalizeWorkflowStepRun">["result"]>;
+    skipWorkflowStepRun(...args: M<"skipWorkflowStepRun">["args"]): Promise<M<"skipWorkflowStepRun">["result"]>;
+    private setWorkflowWorkItemsForWorkflowRun;
+    private demoteNonProductiveWorkItems;
+    finalizeWorkflowRun(...args: M<"finalizeWorkflowRun">["args"]): Promise<M<"finalizeWorkflowRun">["result"]>;
+    private appendWorkflowEventWithClient;
+    appendWorkflowEvent(...args: M<"appendWorkflowEvent">["args"]): Promise<M<"appendWorkflowEvent">["result"]>;
 }
-export declare function createPostgresLoopStorage(client: PoolQueryClient): PostgresLoopStorage;
+export declare function createPostgresLoopStorage(client: PoolQueryClient, context: TenantStorageContext, opts?: {
+    contextAlreadyBound?: boolean;
+}): PostgresLoopStorage;
 export {};

package/dist/lib/storage/postgres-schema.d.ts

@@ -1,4 +1,12 @@
 import type { StorageMigration } from "./contract.js";
 export declare const POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
+export declare const POSTGRES_MIGRATION_ADVISORY_LOCK_SQL = "SELECT pg_advisory_xact_lock(1330466384, 1280262987)";
 export declare function checksumStorageSql(sql: string): string;
+export declare const POSTGRES_TENANT_BOOTSTRAP_ROLES_SQL: string;
+export declare const POSTGRES_TENANT_CLUSTER_ROLE_EXCLUSIVITY_SQL: string;
+export declare const POSTGRES_TENANT_BOOTSTRAP_MEMBERSHIPS_SQL: string;
+export declare const POSTGRES_TENANT_PRIVILEGED_MEMBERSHIPS_SQL: string;
+export declare const POSTGRES_TENANT_SERVICE_ROLE_MEMBERSHIPS_SQL: string;
+export declare const POSTGRES_TENANT_UNSAFE_SERVICE_MEMBERSHIPS_SQL: string;
+export declare const POSTGRES_TENANT_SERVICE_MEMBER_CLEANUP_SQL: string;
 export declare const POSTGRES_STORAGE_MIGRATIONS: readonly StorageMigration[];