@dbsp/adapter-pgsql 3.2.2 → 3.3.0

package/dist/index.js

@@ -27306,7 +27306,69 @@ async function readTransitionJournal(executor, runId) {
   };
 }
 
+// src/transition/lessor.ts
+import { createTransitionLessor } from "@dbsp/core";
+function createPgTransitionLessor(pool) {
+  if (pool != null && (typeof pool === "object" || typeof pool === "function") && typeof pool.release === "function") {
+    throw new Error(
+      "createPgTransitionLessor received a checked-out pg PoolClient. A transition owns its lease from acquisition to release, so it needs a pool to lease from; there is no borrowed-client mode here. Pass the pg Pool the client was checked out of."
+    );
+  }
+  return createTransitionLessor(async () => {
+    const client = await pool.connect();
+    const end = readMember(client, "end");
+    const release = readMember(client, "release");
+    const query = readMember(client, "query");
+    if (typeof release !== "function" || typeof query !== "function") {
+      if (typeof release === "function") {
+        const rejection = new Error(
+          "createPgTransitionLessor acquired a malformed pg lease without query(); it was returned through its captured release()."
+        );
+        try {
+          void Promise.resolve(release.call(client, rejection)).catch(
+            () => void 0
+          );
+        } catch {
+        }
+        throw rejection;
+      }
+      endLeakedConnection(client, end);
+      throw new Error(
+        "createPgTransitionLessor was given a pg Client rather than a pg Pool: connect() returned the connection itself without release(), so no acquired lease could be returned. Pass a pg Pool."
+      );
+    }
+    return Object.freeze({
+      query: (sql, params) => query.call(client, sql, params),
+      release: (error) => release.call(client, error)
+    });
+  });
+}
+function endLeakedConnection(client, end) {
+  if (typeof end !== "function") {
+    return;
+  }
+  try {
+    void Promise.resolve(end.call(client)).catch(() => void 0);
+  } catch {
+  }
+}
+function readMember(value, member) {
+  if (value == null || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  try {
+    return value[member];
+  } catch {
+    return void 0;
+  }
+}
+
 // src/transition/observation-issuer.ts
+import {
+  acquireTransitionLease,
+  isTransitionLessor,
+  TRANSITION_LESSOR_REJECTION
+} from "@dbsp/core";
 init_validate();
 
 // src/transition/claim-stamping.ts
@@ -27429,9 +27491,6 @@ function queryable(target) {
     "PostgreSQL observation target must expose query(sql, params)"
   );
 }
-function poolLike(target) {
-  return isRecord4(target) && typeof target.connect === "function" && typeof target.release !== "function" ? target : void 0;
-}
 function nextEvidenceId(kind) {
   observationSequence += 1;
   return evidenceId(
@@ -28874,75 +28933,78 @@ async function observeEngineVersion(executor, request, context) {
     value
   });
 }
-function createPgObservationIssuer() {
-  return {
-    artifact: PG_INTROSPECTION_ARTIFACT,
-    mergeObservationPrivileges: mergePgObservationPrivileges,
-    async readContext(target, context, requests) {
-      return readPgObservationContext(
-        target,
-        explicitSchemaFromContext(context),
-        targetFromRequests(requests, context)
-      );
-    },
-    async execute(request, target, context) {
-      const executor = queryable(target);
-      switch (request.kind) {
-        case COLUMN_EXISTS_OBSERVATION:
-          return observeColumn(executor, request, context);
-        case TABLE_CHECK_CONSTRAINTS_OBSERVATION:
-          return observeTableChecks(executor, request, context);
-        case TABLE_INDEXES_OBSERVATION:
-          return observeTableIndexes(executor, request, context);
-        case LOGICAL_IDENTITY_CARRIER_OBSERVATION:
-          return observeLogicalIdentityCarrier(executor, request, context);
-        case ENUM_TYPE_EXISTS_OBSERVATION:
-        case ENUM_LABEL_VISIBLE_OBSERVATION:
-          return observeEnumLabels(executor, request, context);
-        case ALTER_AUTHORITY_OBSERVATION:
-        case ALTER_TYPE_AUTHORITY_OBSERVATION:
-          return observeAlterAuthority(executor, request, context);
-        case ENGINE_VERSION_OBSERVATION:
-          return observeEngineVersion(executor, request, context);
-        case EXPRESSION_DEPARSE_OBSERVATION: {
-          const deparsePool = poolLike(target);
-          if (deparsePool) {
-            const client = await deparsePool.connect();
-            try {
-              return await observeExpressionDeparse(client, request, context);
-            } finally {
-              client.release();
-            }
-          }
-          return observeExpressionDeparse(executor, request, context);
-        }
-        default:
-          throw new Error(`unsupported PostgreSQL observation ${request.kind}`);
-      }
-    }
-  };
+async function executePgObservationFromClient(request, target, context) {
+  const executor = queryable(target);
+  switch (request.kind) {
+    case COLUMN_EXISTS_OBSERVATION:
+      return observeColumn(executor, request, context);
+    case TABLE_CHECK_CONSTRAINTS_OBSERVATION:
+      return observeTableChecks(executor, request, context);
+    case TABLE_INDEXES_OBSERVATION:
+      return observeTableIndexes(executor, request, context);
+    case LOGICAL_IDENTITY_CARRIER_OBSERVATION:
+      return observeLogicalIdentityCarrier(executor, request, context);
+    case ENUM_TYPE_EXISTS_OBSERVATION:
+    case ENUM_LABEL_VISIBLE_OBSERVATION:
+      return observeEnumLabels(executor, request, context);
+    case ALTER_AUTHORITY_OBSERVATION:
+    case ALTER_TYPE_AUTHORITY_OBSERVATION:
+      return observeAlterAuthority(executor, request, context);
+    case ENGINE_VERSION_OBSERVATION:
+      return observeEngineVersion(executor, request, context);
+    case EXPRESSION_DEPARSE_OBSERVATION:
+      return observeExpressionDeparse(executor, request, context);
+    default:
+      throw new Error(`unsupported PostgreSQL observation ${request.kind}`);
+  }
 }
-async function readPgObservationContext(target, schema, observationTarget) {
-  const pool = poolLike(target);
-  if (pool) {
-    const client = await pool.connect();
-    try {
-      return await readPgObservationContextFromClient(
-        client,
-        schema,
-        observationTarget
-      );
-    } finally {
-      client.release();
-    }
+function assertTransitionLessor(value) {
+  if (!isTransitionLessor(value)) {
+    throw new Error(TRANSITION_LESSOR_REJECTION);
   }
-  return readPgObservationContextFromClient(
+}
+async function executePgObservationFromLessor(lessor, request, context) {
+  assertTransitionLessor(lessor);
+  const lease = await acquireTransitionLease(lessor);
+  let releaseFailure;
+  try {
+    return await executePgObservationFromClient(
+      request,
+      lease.session,
+      context
+    );
+  } catch (error) {
+    releaseFailure = { error };
+    throw error;
+  } finally {
+    await lease.release(releaseFailure);
+  }
+}
+async function readPgObservationContextFromClient(target, schema, observationTarget) {
+  return readPgObservationContextFromQueryable(
     queryable(target),
     schema,
     observationTarget
   );
 }
-async function readPgObservationContextFromClient(executor, schema, observationTarget) {
+async function readPgObservationContextFromLessor(lessor, schema, observationTarget) {
+  assertTransitionLessor(lessor);
+  const lease = await acquireTransitionLease(lessor);
+  let releaseFailure;
+  try {
+    return await readPgObservationContextFromClient(
+      lease.session,
+      schema,
+      observationTarget
+    );
+  } catch (error) {
+    releaseFailure = { error };
+    throw error;
+  } finally {
+    await lease.release(releaseFailure);
+  }
+}
+async function readPgObservationContextFromQueryable(executor, schema, observationTarget) {
   const version = await executor.query("SHOW server_version_num");
   const database = await executor.query(
     "SELECT current_database() AS database_id"
@@ -29010,6 +29072,20 @@ async function readPgObservationContextFromClient(executor, schema, observationT
     ...collationVersion ? { collationVersion } : {}
   };
 }
+function createPgObservationIssuer() {
+  return {
+    artifact: PG_INTROSPECTION_ARTIFACT,
+    mergeObservationPrivileges: mergePgObservationPrivileges,
+    async readContext(target, context, requests) {
+      return readPgObservationContextFromClient(
+        target,
+        explicitSchemaFromContext(context),
+        targetFromRequests(requests, context)
+      );
+    },
+    execute: executePgObservationFromClient
+  };
+}
 
 // src/transition/operations/alter-column-set-not-null.ts
 import { createHash } from "crypto";
@@ -31136,12 +31212,6 @@ function queryable2(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable(target) {
-  return isRecord8(target) && typeof target.release === "function";
-}
-function poolLike2(target) {
-  return isRecord8(target) && typeof target.connect === "function" && !releasable(target) ? target : void 0;
-}
 function clientQuery(client) {
   return queryable2(client.opaqueClient);
 }
@@ -31241,20 +31311,6 @@ function createAlterColumnSetNotNullOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints,
-    async checkout(target) {
-      const pool = poolLike2(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery(client), record);
     },
@@ -31276,7 +31332,7 @@ function createAlterColumnSetNotNullOperationRuntime() {
     },
     async observeContext(client, operation, _proofContext) {
       const payload = payloadOf(operation);
-      return readPgObservationContext(
+      return readPgObservationContextFromClient(
         client.opaqueClient,
         explicitSchema(payload),
         payload
@@ -31834,12 +31890,6 @@ function queryable3(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable2(target) {
-  return isRecord9(target) && typeof target.release === "function";
-}
-function poolLike3(target) {
-  return isRecord9(target) && typeof target.connect === "function" && !releasable2(target) ? target : void 0;
-}
 function clientQuery2(client) {
   return queryable3(client.opaqueClient);
 }
@@ -31949,20 +31999,6 @@ function createAlterTableAddCheckOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints2,
-    async checkout(target) {
-      const pool = poolLike3(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable2(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery2(client), record);
     },
@@ -31984,11 +32020,15 @@ function createAlterTableAddCheckOperationRuntime() {
     },
     async observeContext(client, operation, _proofContext) {
       const payload = payloadOf2(operation);
-      return readPgObservationContext(client.opaqueClient, payload.schema, {
-        schema: payload.schema,
-        table: payload.table,
-        constraint: payload.constraint
-      });
+      return readPgObservationContextFromClient(
+        client.opaqueClient,
+        payload.schema,
+        {
+          schema: payload.schema,
+          table: payload.table,
+          constraint: payload.constraint
+        }
+      );
     },
     async observeOperation(client, operation, context, phase, issuer) {
       const payload = payloadOf2(operation);
@@ -32480,12 +32520,6 @@ function queryable4(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable3(target) {
-  return isRecord10(target) && typeof target.release === "function";
-}
-function poolLike4(target) {
-  return isRecord10(target) && typeof target.connect === "function" && !releasable3(target) ? target : void 0;
-}
 function clientQuery3(client) {
   return queryable4(client.opaqueClient);
 }
@@ -32546,20 +32580,6 @@ function createAlterTypeAddValueOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints3,
-    async checkout(target) {
-      const pool = poolLike4(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable3(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery3(client), record);
     },
@@ -32582,10 +32602,14 @@ function createAlterTypeAddValueOperationRuntime() {
     },
     async observeContext(client, operation, _proofContext) {
       const payload = payloadOf3(operation);
-      return readPgObservationContext(client.opaqueClient, payload.schema, {
-        schema: payload.schema,
-        type: payload.type
-      });
+      return readPgObservationContextFromClient(
+        client.opaqueClient,
+        payload.schema,
+        {
+          schema: payload.schema,
+          type: payload.type
+        }
+      );
     },
     async observeOperation(client, operation, context, _phase, issuer) {
       const payload = payloadOf3(operation);
@@ -32990,12 +33014,6 @@ function queryable5(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable4(target) {
-  return isRecord11(target) && typeof target.release === "function";
-}
-function poolLike5(target) {
-  return isRecord11(target) && typeof target.connect === "function" && !releasable4(target) ? target : void 0;
-}
 function clientQuery4(client) {
   return queryable5(client.opaqueClient);
 }
@@ -33089,20 +33107,6 @@ function createAttachLogicalIdentityOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints4,
-    async checkout(target) {
-      const pool = poolLike5(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable4(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery4(client), record);
     },
@@ -33124,11 +33128,15 @@ function createAttachLogicalIdentityOperationRuntime() {
     },
     async observeContext(client, operation, _proofContext) {
       const payload = payloadOf4(operation);
-      return readPgObservationContext(client.opaqueClient, payload.schema, {
-        table: payload.table,
-        ...payload.column ? { column: payload.column } : {},
-        schema: payload.schema
-      });
+      return readPgObservationContextFromClient(
+        client.opaqueClient,
+        payload.schema,
+        {
+          table: payload.table,
+          ...payload.column ? { column: payload.column } : {},
+          schema: payload.schema
+        }
+      );
     },
     async observeOperation(client, operation, context, phase, issuer) {
       const payload = payloadOf4(operation);
@@ -33594,12 +33602,6 @@ function queryable6(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable5(target) {
-  return isRecord12(target) && typeof target.release === "function";
-}
-function poolLike6(target) {
-  return isRecord12(target) && typeof target.connect === "function" && !releasable5(target) ? target : void 0;
-}
 function clientQuery5(client) {
   return queryable6(client.opaqueClient);
 }
@@ -33865,20 +33867,6 @@ function createCreateUniqueIndexConcurrentlyOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints5,
-    async checkout(target) {
-      const pool = poolLike6(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable5(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery5(client), record);
     },
@@ -33893,11 +33881,15 @@ function createCreateUniqueIndexConcurrentlyOperationRuntime() {
     },
     async observeContext(client, operation, _proofContext) {
       const payload = payloadOf5(operation);
-      return readPgObservationContext(client.opaqueClient, payload.schema, {
-        schema: payload.schema,
-        table: payload.table,
-        index: payload.index
-      });
+      return readPgObservationContextFromClient(
+        client.opaqueClient,
+        payload.schema,
+        {
+          schema: payload.schema,
+          table: payload.table,
+          index: payload.index
+        }
+      );
     },
     async observeOperation(client, operation, context, phase, issuer) {
       const payload = payloadOf5(operation);
@@ -34013,12 +34005,6 @@ function queryable7(target) {
     "PostgreSQL transition target must expose query(sql, params)"
   );
 }
-function releasable6(target) {
-  return isRecord13(target) && typeof target.release === "function";
-}
-function poolLike7(target) {
-  return isRecord13(target) && typeof target.connect === "function" && !releasable6(target) ? target : void 0;
-}
 function clientQuery6(client) {
   return queryable7(client.opaqueClient);
 }
@@ -34600,20 +34586,6 @@ function createManualSqlOperationRuntime() {
       };
     },
     buildFingerprints: beforeAfterFingerprints6,
-    async checkout(target) {
-      const pool = poolLike7(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable6(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async writeIntentJournal(client, record) {
       await appendIntentJournal(clientQuery6(client), record);
     },
@@ -34625,7 +34597,7 @@ function createManualSqlOperationRuntime() {
     async acquireLocks() {
     },
     async observeContext(client, _operation, proofContext) {
-      return readPgObservationContext(
+      return readPgObservationContextFromClient(
         client.opaqueClient,
         proofContext.targetSchema ?? proofContext.searchPath?.[0] ?? "public"
       );
@@ -36909,15 +36881,6 @@ var PG_TRANSACTION_DOMAIN = "postgresql.transition.connection";
 function isRecord19(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
-function poolLike8(value) {
-  if (isRecord19(value) && typeof value.connect === "function") {
-    return value;
-  }
-  return void 0;
-}
-function releasable7(value) {
-  return isRecord19(value) && typeof value.query === "function" && typeof value.release === "function";
-}
 function clientQuery7(client) {
   if (isRecord19(client.opaqueClient) && typeof client.opaqueClient.query === "function") {
     return client.opaqueClient;
@@ -36933,20 +36896,6 @@ function boundedLockTimeout(maxWaitMs) {
 function createPgExecutionCoordinator() {
   return {
     transactionDomain: PG_TRANSACTION_DOMAIN,
-    async checkout(target) {
-      const pool = poolLike8(target);
-      if (!pool) {
-        throw new Error(
-          "PostgreSQL transition target must be a Pool-like object with connect(); checked-out clients are not accepted"
-        );
-      }
-      return { opaqueClient: await pool.connect() };
-    },
-    release(client, error) {
-      if (releasable7(client.opaqueClient)) {
-        client.opaqueClient.release(error);
-      }
-    },
     async begin(client) {
       await clientQuery7(client).query("BEGIN");
     },
@@ -37122,6 +37071,7 @@ export {
   createManualSqlOperationRuntime,
   createParamRef,
   createPgObservationIssuer,
+  createPgTransitionLessor,
   createPgTransitionPack,
   createPgsqlAdapter,
   createPgsqlCompileOnlyAdapter,
@@ -37132,6 +37082,7 @@ export {
   ensureMigrationsTable,
   ensureTransitionJournal,
   excludedRef,
+  executePgObservationFromLessor,
   generateCreateIndex,
   generateCursorName,
   generateDDL,
@@ -37163,7 +37114,7 @@ export {
   parseExplainJson,
   parseMigrationFile,
   rawDistance,
-  readPgObservationContext,
+  readPgObservationContextFromLessor,
   readTransitionJournal,
   recordMigration,
   redactParams,