feat: remove overloaded pool#connect(); too many edge cases to cover

gajus · Nov 15, 2018 · fb595bf · fb595bf
1 parent f00b9de
commit fb595bf
Show file tree

Hide file tree

Showing 5 changed files with 20 additions and 84 deletions.
diff --git a/src/binders/bindIsolatedPoolConnection.js b/src/binders/bindIsolatedPoolConnection.js
diff --git a/src/binders/bindPool.js b/src/binders/bindPool.js
@@ -22,7 +22,6 @@ import {
   query
 } from '../connectionMethods';
 import createPoolTransaction from '../factories/createPoolTransaction';
-import bindIsolatedPoolConnection from './bindIsolatedPoolConnection';
 import bindPoolConnection from './bindPoolConnection';
 
 export default (
@@ -33,25 +32,10 @@ export default (
   return {
     any: mapTaggedTemplateLiteralInvocation(any.bind(null, parentLog, pool, clientConfiguration)),
     anyFirst: mapTaggedTemplateLiteralInvocation(anyFirst.bind(null, parentLog, pool, clientConfiguration)),
+    connect: async () => {
+      const connection: InternalDatabaseConnectionType = await pool.connect();
 
-    // @see https://stackoverflow.com/questions/42539202/flowtype-how-can-i-overload-function-return-types-by-argument-count-types
-    // eslint-disable-next-line consistent-return, flowtype/no-weak-types
-    connect: async (handler): any => {
-      if (handler) {
-        const connection: InternalDatabaseConnectionType = await pool.connect();
-
-        try {
-          await handler(bindIsolatedPoolConnection(parentLog, pool, connection, clientConfiguration));
-        } catch (error) {
-          connection.release();
-
-          throw error;
-        }
-      } else {
-        const connection: InternalDatabaseConnectionType = await pool.connect();
-
-        return bindPoolConnection(parentLog, pool, connection, clientConfiguration);
-      }
+      return bindPoolConnection(parentLog, pool, connection, clientConfiguration);
     },
     many: mapTaggedTemplateLiteralInvocation(many.bind(null, parentLog, pool, clientConfiguration)),
     manyFirst: mapTaggedTemplateLiteralInvocation(manyFirst.bind(null, parentLog, pool, clientConfiguration)),

diff --git a/src/binders/index.js b/src/binders/index.js
@@ -1,6 +1,5 @@
 // @flow
 
-export {default as bindIsolatedPoolConnection} from './bindIsolatedPoolConnection';
 export {default as bindPool} from './bindPool';
 export {default as bindPoolConnection} from './bindPoolConnection';
 export {default as bindSingleConnection} from './bindSingleConnection';

diff --git a/src/index.js b/src/index.js
@@ -23,7 +23,6 @@ types.setTypeParser(TIMESTAMP_OID, (value) => {
 
 export type {
   DatabaseConnectionType,
-  DatabaseIsolatedPoolConnectionType,
   DatabasePoolConnectionType,
   DatabasePoolType,
   DatabaseSingleConnectionType,

diff --git a/src/types.js b/src/types.js
@@ -55,7 +55,7 @@ export type DatabaseConfigurationType =
     +user?: string
   |};
 
-export type DatabaseConnectionType = {|
+type CommonQueryMethodsType = {|
   +any: QueryAnyFunctionType<*>,
   +anyFirst: QueryAnyFirstFunctionType<*>,
   +many: QueryManyFunctionType<*>,
@@ -68,39 +68,40 @@ export type DatabaseConnectionType = {|
 |};
 
 export type DatabaseTransactionConnectionType = {|
-  ...DatabaseConnectionType
+  ...CommonQueryMethodsType
 |};
 
 export type TransactionFunctionType = (connection: DatabaseTransactionConnectionType) => Promise<*>;
 
 export type DatabaseSingleConnectionType = {|
-  ...DatabaseConnectionType,
+  ...CommonQueryMethodsType,
   +end: () => Promise<void>,
   +transaction: (handler: TransactionFunctionType) => Promise<*>
 |};
 
 export type DatabasePoolConnectionType = {|
-  ...DatabaseConnectionType,
+  ...CommonQueryMethodsType,
   +release: () => Promise<void>,
   +transaction: (handler: TransactionFunctionType) => Promise<*>
 |};
 
-export type DatabaseIsolatedPoolConnectionType = {|
-  ...DatabaseConnectionType,
-  +transaction: (handler: TransactionFunctionType) => Promise<*>
-|};
-
-// @todo Document `((connection: DatabaseIsolatedPoolConnectionType) => Promise<void>) => Promise<void>` API.
-type DataPoolConnectMethodType =
-  () => Promise<DatabasePoolConnectionType> &
-  ((connection: DatabaseIsolatedPoolConnectionType) => Promise<void>) => Promise<void>;
-
 export type DatabasePoolType = {|
-  ...DatabaseConnectionType,
-  +connect: DataPoolConnectMethodType,
+  ...CommonQueryMethodsType,
+  +connect: () => Promise<DatabasePoolConnectionType>,
   +transaction: (handler: TransactionFunctionType) => Promise<*>
 |};
 
+/**
+ * This appears to be the only sane way to have a generic database connection type
+ * that can be refined, i.e. DatabaseConnectionType => DatabasePoolType.
+ */
+export type DatabaseConnectionType =
+  $Shape<{
+    ...DatabasePoolConnectionType,
+    ...DatabasePoolType,
+    ...DatabaseSingleConnectionType
+  }>;
+
 type QueryResultRowColumnType = string | number;
 
 export type QueryResultRowType = {