fix: correctly catch errors bubbling up to withConnection

musicglue · Jun 14, 2018 · 21f7ae4 · 21f7ae4
1 parent eab4998
commit 21f7ae4
Show file tree

Hide file tree

Showing 3 changed files with 25 additions and 3 deletions.
diff --git a/src/errors.ts b/src/errors.ts
@@ -97,6 +97,21 @@ export const catchAsTransactionRollbackError = (e: mixed) => new PgTransactionRo
 export const isPgTransactionRollbackError = (e: Error): e is PgTransactionRollbackError =>
   e instanceof PgTransactionRollbackError;
 
+export class PgUnhandledConnectionUsageError extends Error {
+  constructor(public readonly error: mixed) {
+    super("An unhandled error occurred while a connection was in use.");
+
+    Error.captureStackTrace(this, PgUnhandledConnectionUsageError);
+    this.name = this.constructor.name;
+  }
+}
+
+export const catchAsUnhandledConnectionUsageError = (e: mixed) =>
+  new PgUnhandledConnectionUsageError(e);
+export const ensureAsUnhandledConnectionUsageError = ensureError(
+  catchAsUnhandledConnectionUsageError,
+);
+
 export class PgUnhandledTransactionError extends Error {
   constructor(public readonly error: mixed) {
     super("An unhandled error occurred during a transaction.");

diff --git a/src/parser.ts b/src/parser.ts
@@ -1,7 +1,7 @@
 import { constant } from "fp-ts/lib/function";
-import { tryCatch } from "fp-ts/lib/TaskEither";
+import { TaskEither, tryCatch } from "fp-ts/lib/TaskEither";
 import * as pg from "pg";
-import { catchAsTypeParserSetupError } from "./errors";
+import { catchAsTypeParserSetupError, PgTypeParserSetupError } from "./errors";
 import { parseInterval } from "./pgTypes/interval";
 import { TypeParser, TypeParsers } from "./types";
 import { SQL } from "./utils/sql";

diff --git a/src/pool.ts b/src/pool.ts
@@ -11,6 +11,7 @@ import {
   fromIOEither,
   TaskEither,
   taskEither,
+  tryCatch,
   tryCatch as taskEitherTryCatch,
 } from "fp-ts/lib/TaskEither";
 import { Pool } from "pg";
@@ -20,10 +21,13 @@ import {
   catchAsPoolCheckoutError,
   catchAsPoolCreationError,
   catchAsPoolShutdownError,
+  ensureAsUnhandledConnectionUsageError,
+  ensureAsUnhandledTransactionError,
   isPgTransactionRollbackError,
 } from "./errors";
 import { setupParsers } from "./parser";
 import { ConnectionE, ConnectionPool, ConnectionPoolConfig } from "./types";
+import { eitherToPromise } from "./utils/eitherToPromise";
 
 export const makeConnectionPool = (
   poolConfig: ConnectionPoolConfig,
@@ -59,7 +63,10 @@ export const wrapConnectionPool = (pool: pg.Pool): ConnectionPool => ({
       readerTryCatch<E, Error, pg.PoolClient>(() => pool.connect(), catchAsPoolCheckoutError)
         .map(wrapPoolClient)
         .map(connection =>
-          withConnection.value({ connection, environment }).fold<Either<Error, A>>(
+          tryCatch(
+            () => withConnection.run({ connection, environment }).then(eitherToPromise),
+            ensureAsUnhandledConnectionUsageError,
+          ).fold<Either<Error, A>>(
             err => {
               connection.release(isPgTransactionRollbackError(err) ? err : undefined);
               return left(err);