Support for Postgres Pooling

deno.json

@@ -0,0 +1,3 @@
+{
+    "importMap": "./import_map.json"
+}

deps.ts

@@ -13,7 +13,8 @@ export {
 } from "https://deno.land/x/mysql@v2.10.1/mod.ts";
 export type { LoggerConfig } from "https://deno.land/x/mysql@v2.10.1/mod.ts";
 
-export { Client as PostgresClient } from "https://deno.land/x/postgres@v0.14.2/mod.ts";
+export { Client as PostgresClient,Pool as PostgresPool } from "https://deno.land/x/postgres@v0.16.1/mod.ts";
+export type { ClientOptions as PostgresClientOptions, ConnectionString as PostgresConnectionString } from "https://deno.land/x/postgres@v0.16.1/mod.ts";
 
 export { DB as SQLiteClient } from "https://deno.land/x/sqlite@v3.1.3/mod.ts";
 

import_map.json

@@ -0,0 +1,7 @@
+{
+  "imports": {
+    "https://dev.jspm.io/npm:@jspm/core@1/nodelibs/timers.js": "https://deno.land/std@0.159.0/node/timers.ts",
+    "https://dev.jspm.io/npm:@jspm/core@1/nodelibs/url.js": "https://deno.land/std@0.159.0/node/url.ts",
+    "https://dev.jspm.io/npm:@jspm/core@1/nodelibs/events.js": "https://deno.land/std@0.159.0/node/events.ts"
+  }
+}

lib/connectors/connector.ts

@@ -1,11 +1,18 @@
+import { PostgresPool } from "../../deps.ts";
 import type { QueryDescription } from "../query-builder.ts";
 import { Translator } from "../translators/translator.ts";
 
 /** Default connector options. */
-export interface ConnectorOptions {}
+export interface ConnectorOptions { }
+
+/** Default pool options. */
+export interface ConnectorPoolOptions { }
 
 /** Default connector client. */
-export interface ConnectorClient {}
+export interface ConnectorClient { }
+
+/** Default connector pool. */
+export interface ConnectionPool extends PostgresPool{ }
 
 /** Connector interface for a database provider connection. */
 export interface Connector {
@@ -16,19 +23,22 @@ export interface Connector {
   _translator: Translator;
 
   /** Client that maintains an external database connection. */
-  _client: ConnectorClient;
+  _client?: ConnectorClient | undefined;
 
   /** Options to connect to an external instance. */
   _options: ConnectorOptions;
 
   /** Is the client connected to an external instance. */
-  _connected: boolean;
+  _connected?: boolean | undefined;
+
+  /** Is the optional pool for making connections to an external instance. */
+  _pool?: ConnectionPool | undefined;
 
   /** Test connection. */
   ping(): Promise<boolean>;
 
   /** Connect to an external database instance. */
-  _makeConnection(): void;
+  _makeConnection(): void | ConnectorClient | Promise<void> | Promise<ConnectorClient>;
 
   /** Execute a query on the external database instance. */
   query(queryDescription: QueryDescription): Promise<any | any[]>;

lib/connectors/postgres-connector.ts

@@ -1,5 +1,5 @@
-import { PostgresClient } from "../../deps.ts";
-import type { Connector, ConnectorOptions } from "./connector.ts";
+import { PostgresClient, PostgresPool } from "../../deps.ts";
+import type { Connector, ConnectorOptions, ConnectorPoolOptions } from "./connector.ts";
 import { SQLTranslator } from "../translators/sql-translator.ts";
 import type { SupportedSQLDatabaseDialect } from "../translators/sql-translator.ts";
 import type { QueryDescription } from "../query-builder.ts";
@@ -17,24 +17,53 @@ interface PostgresOptionsWithURI extends ConnectorOptions {
   uri: string;
 }
 
+interface PostgresPoolOptions extends ConnectorPoolOptions {
+  connection_params: PostgresOptionsWithConfig | PostgresOptionsWithURI,
+  size: number,
+  lazy: boolean,
+}
+
 export type PostgresOptions =
+  PostgresPoolOptions
   | PostgresOptionsWithConfig
   | PostgresOptionsWithURI;
 
+
+
 export class PostgresConnector implements Connector {
   _dialect: SupportedSQLDatabaseDialect = "postgres";
-
-  _client: PostgresClient;
+  _pool: PostgresPool | undefined;
+  _client: PostgresClient | undefined;
   _options: PostgresOptions;
   _translator: SQLTranslator;
-  _connected = false;
-
-  /** Create a PostgreSQL connection. */
+  _connected: boolean | undefined;
+
+  /** Create a PostgreSQL connection
+   *  @example 
+   * //Direct connection usage:
+   * const connection = new PostgresConnector({
+   *    host: '...',
+   *    username: 'user',
+   *    password: 'password',
+   *    database: 'airlines',
+   * });
+   * //Pool connection usage:
+   * const connection = new PostgresConnector({
+   *    connection_params: {
+   *      host: '...',
+   *      username: 'user',
+   *      password: 'password',
+   *      database: 'airlines',
+   *    },
+   *    size: 5,
+   *    lazy: false
+   * });
+   */
   constructor(options: PostgresOptions) {
     this._options = options;
     if ("uri" in options) {
       this._client = new PostgresClient(options.uri);
-    } else {
+    } else if ("database" in options) {
       this._client = new PostgresClient({
         hostname: options.host,
         user: options.username,
@@ -43,25 +72,43 @@ export class PostgresConnector implements Connector {
         port: options.port ?? 5432,
       });
     }
+    else {
+      this._pool = new PostgresPool("uri" in options.connection_params ? options.connection_params.uri : {
+        hostname: options.connection_params.host,
+        user: options.connection_params.username,
+        ...options.connection_params,
+      },
+        options.size,
+        options.lazy
+      );
+    }
     this._translator = new SQLTranslator(this._dialect);
   }
 
   async _makeConnection() {
-    if (this._connected) {
-      return;
+    if (this._client) {
+      if (this._connected) {
+        return;
+      }
+
+      await this._client.connect();
+      this._connected = true;
+      return this._client;
+    } else {
+      return await this._pool!.connect();
     }
 
-    await this._client.connect();
-    this._connected = true;
   }
 
   async ping() {
-    await this._makeConnection();
+    return await this.tryConnection(await this._makeConnection());
+  }
 
+  async tryConnection(client?: PostgresClient) {
     try {
       const [result] = (
-        await this._client.queryObject("SELECT 1 + 1 as result")
-      ).rows;
+        await client!.queryArray("SELECT 1 + 1 as result")
+      ).rows[0];
       return result === 2;
     } catch {
       return false;
@@ -70,32 +117,35 @@ export class PostgresConnector implements Connector {
 
   // deno-lint-ignore no-explicit-any
   async query(queryDescription: QueryDescription): Promise<any | any[]> {
-    await this._makeConnection();
-
+    const client = await this._makeConnection()
     const query = this._translator.translateToQuery(queryDescription);
-    const response = await this._client.queryObject(query);
+    const response = await client!.queryObject(query);
     const results = response.rows as Values[];
 
     if (queryDescription.type === "insert") {
       return results.length === 1 ? results[0] : results;
     }
-
     return results;
   }
 
   async transaction(queries: () => Promise<void>) {
-    const transaction = this._client.createTransaction("transaction");
+    const client = await this._makeConnection()
+    const transaction = client!.createTransaction("transaction");
     await transaction.begin();
     await queries();
     return transaction.commit();
   }
 
   async close() {
-    if (!this._connected) {
-      return;
+    if (this._client) {
+      if (!this._connected) {
+        return;
+      }
+      await this._client.end();
+    } else {
+      await this._pool?.end()!
     }
-
-    await this._client.end();
     this._connected = false;
   }
+
 }

lib/database.ts

@@ -189,6 +189,11 @@ export class Database {
     return this.getConnector()._client;
   }
 
+  /* Get the database pool if existent. */
+  getPool?() {
+    return this.getConnector()._pool;
+  }
+
   /** Create the given models in the current database.
    *
    *     await db.sync({ drop: true });

tests/connection.ts

@@ -15,6 +15,18 @@ const defaultSQLiteOptions = {
   filepath: "test.sqlite",
 };
 
+const defaultPostgreSQLPoolOptions = {
+  connection_params: {
+    uri: "postgres://postgres:user@localhost:5432/test"
+  },
+  size: 2,
+  lazy: false
+};
+
+const defaultPostgreSQLOptions = {
+  uri: "postgres://postgres:user@localhost:5432/test"
+};
+
 const getMySQLConnection = (options = {}, debug = true): Database => {
   const connection: Database = new Database(
     { dialect: "mysql", debug },
@@ -39,4 +51,28 @@ const getSQLiteConnection = (options = {}, debug = true): Database => {
   return connection;
 };
 
-export { getMySQLConnection, getSQLiteConnection };
+const getPostgreSQLPoolConnection = (options = {}, debug = true): Database => {
+  const connection: Database = new Database(
+    { dialect: "postgres", debug },
+    {
+      ...defaultPostgreSQLPoolOptions,
+      ...options,
+    },
+  );
+
+  return connection;
+};
+
+const getPostgreSQLConnection = (options = {}, debug = true): Database => {
+  const connection: Database = new Database(
+    { dialect: "postgres", debug },
+    {
+      ...defaultPostgreSQLOptions,
+      ...options,
+    },
+  );
+
+  return connection;
+};
+
+export { getMySQLConnection, getSQLiteConnection, getPostgreSQLPoolConnection, getPostgreSQLConnection };

tests/units/connectors/postgres/connection.test.ts

@@ -0,0 +1,18 @@
+import { getPostgreSQLPoolConnection, getPostgreSQLConnection } from "../../../connection.ts";
+import { assertEquals } from "../../../deps.ts";
+
+Deno.test({ name: "PostgreSQL: Connection", sanitizeResources: false}, async function () {
+  const connection = getPostgreSQLPoolConnection();
+  const ping = await connection.ping();
+  await connection.close();
+
+  assertEquals(ping, true);
+});
+
+Deno.test({ name: "PostgreSQL: Pool Connection", sanitizeResources: false}, async function () {
+  const connection = getPostgreSQLConnection();
+  const ping = await connection.ping();
+  await connection.close();
+
+  assertEquals(ping, true);
+});