knex 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Master (Unreleased)
 
+# 2.1.0 - 26 May, 2022
+
+### New features:
+
+- Improve bundling experience to safely import dialects while using static paths #5142
+- Implement extendable builders #5041
+- PostgreSQL: Refresh materialized view concurrently #5166
+
+### Bug fixes:
+
+- Use correct paths in package.json browser field #5174
+- MariaDB: Fix 'NULL' returned instead of NULL on MariaDB 10.2.6+ #5181
+- MySQL: fix hasColumn Error (hasColumn ('a_id') is true, but hasColumn('a_Id') is false) #5148
+- MSSQL: Fix .hasTable result when using .withSchema #5176
+- Oracle: correctly INSERTS Buffer #4869
+
+### Typings:
+
+- Update type definitions for pg connection #5139
+
 # 2.0.0 - 21 April, 2022
 
 ### Breaking changes

package/CONTRIBUTING.md

@@ -169,6 +169,16 @@ Once this is done, check it works by attempting to login:
 psql -h localhost -U postgres -d knex_test
 ```
 
+## Typescript source files
+
+> TL;DR: Starting with release 2.0.0 Knex is adding support for Typescript source files. Thus to develop in this repo you will need to run `npm run build` each time you edit `.ts` files to generate the resulting `.js` files. This is automatically run whenever you run `npm install` or checkout a new Git branch so when developing in Javascript you don't have to worry about it. It is encouraged that new functionality and sources be written in Typescript but this is not required.
+
+Starting with release 2.0.0, Knex is support source additions in Typescript! This allows for better safety in the code added. However, pre-2.0.0 Knex was always written in pure Javascript and thus a "hybrid" approach is being used for 2.0.0 to allow for the new `.ts` files to exist along `.js` files that make up the majority of this repository.
+
+To develop in this repository use the `npm run build` and `npm run clean` commands to compile and delete the `.js` and related files from `.ts` files. If you wish to have the `tsc` compiled watch and recompile on changes then run `npm run build:ts -- --watch`. Note that for easy integration with Javascript the outputted files are done in a "side-by-side" manner meaning that `lib/foo/bar.ts` will result in `lib/foo/bar.js`. This is done automatically via the npm script command `"prepare"` whenever you run `npm install` and Git hook for `post-checkout` (added by Husky) which executes when you run commands like `git checkout` , thus making it easier to not have to worry about this if you're working in pure Javascript.
+
+The script file `./scripts/update_gitignore_for_tsc_output.js` file is called as part of the `npm run build` command which will update the `lib/.gitignore` file which is used to ensure generated `.js` and related files from `tsc` compilation are not checked into the git repo.
+
 ## Want to be Collaborator?
 
 There is always room for more collaborators. Be active on resolving github issues / sending pull requests / reviewing code and we will ask you to join.

package/lib/dialects/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDialectByNameOrAlias = void 0;
+const { resolveClientNameWithAliases } = require('../util/helpers');
+const dbNameToDialectLoader = Object.freeze({
+    'better-sqlite3': () => require('./better-sqlite3'),
+    cockroachdb: () => require('./cockroachdb'),
+    mssql: () => require('./mssql'),
+    mysql: () => require('./mysql'),
+    mysql2: () => require('./mysql2'),
+    oracle: () => require('./oracle'),
+    oracledb: () => require('./oracledb'),
+    pgnative: () => require('./pgnative'),
+    postgres: () => require('./postgres'),
+    redshift: () => require('./redshift'),
+    sqlite3: () => require('./sqlite3'),
+});
+/**
+ * Gets the Dialect object with the given client name or throw an
+ * error if not found.
+ *
+ * NOTE: This is a replacement for prior practice of doing dynamic
+ * string construction for imports of Dialect objects.
+ */
+function getDialectByNameOrAlias(clientName) {
+    const resolvedClientName = resolveClientNameWithAliases(clientName);
+    const dialectLoader = dbNameToDialectLoader[resolvedClientName];
+    if (!dialectLoader) {
+        throw new Error(`Invalid clientName given: ${clientName}`);
+    }
+    return dialectLoader();
+}
+exports.getDialectByNameOrAlias = getDialectByNameOrAlias;
+//# sourceMappingURL=index.js.map

package/lib/dialects/mssql/schema/mssql-compiler.js

@@ -49,10 +49,17 @@ class SchemaCompiler_MSSQL extends SchemaCompiler {
       this.builder,
       this.bindingsHolder
     );
-    const sql =
+    const bindings = [tableName];
+    let sql =
       `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES ` +
       `WHERE TABLE_NAME = ${formattedTable}`;
-    this.pushQuery({ sql, output: (resp) => resp.length > 0 });
+
+    if (this.schema) {
+      sql += ' AND TABLE_SCHEMA = ?';
+      bindings.push(this.schema);
+    }
+
+    this.pushQuery({ sql, bindings, output: (resp) => resp.length > 0 });
   }
 
   // Check whether a column exists on the schema.

package/lib/dialects/mysql/query/mysql-querycompiler.js

@@ -131,7 +131,7 @@ class QueryCompiler_MySQL extends QueryCompiler {
       output(resp) {
         const out = resp.reduce(function (columns, val) {
           columns[val.COLUMN_NAME] = {
-            defaultValue: val.COLUMN_DEFAULT,
+            defaultValue: val.COLUMN_DEFAULT === 'NULL' ? null : val.COLUMN_DEFAULT,
             type: val.DATA_TYPE,
             maxLength: val.CHARACTER_MAXIMUM_LENGTH,
             nullable: val.IS_NULLABLE === 'YES',

package/lib/dialects/mysql/schema/mysql-compiler.js

@@ -48,8 +48,8 @@ class SchemaCompiler_MySQL extends SchemaCompiler {
       output(resp) {
         return resp.some((row) => {
           return (
-            this.client.wrapIdentifier(row.Field) ===
-            this.client.wrapIdentifier(column)
+            this.client.wrapIdentifier(row.Field.toLowerCase()) ===
+            this.client.wrapIdentifier(column.toLowerCase())
           );
         });
       },

package/lib/dialects/oracledb/index.js

@@ -111,7 +111,8 @@ class Client_Oracledb extends Client_Oracle {
         this
       );
     } else if (value instanceof BlobHelper) {
-      return 'EMPTY_BLOB()';
+      formatter.bindings.push(value.value);
+      return '?';
     }
     return unwrapRaw(value, true, builder, this, formatter) || '?';
   }

package/lib/dialects/postgres/schema/pg-compiler.js

@@ -118,9 +118,9 @@ class SchemaCompiler_PG extends SchemaCompiler {
     );
   }
 
-  refreshMaterializedView(viewName) {
+  refreshMaterializedView(viewName, concurrently = false) {
     this.pushQuery({
-      sql: `refresh materialized view ${this.formatter.wrap(viewName)}`,
+      sql: `refresh materialized view${concurrently ? " concurrently" : ""} ${this.formatter.wrap(viewName)}`,
     });
   }
 

package/lib/knex-builder/Knex.js

@@ -5,6 +5,10 @@ const QueryInterface = require('../query/method-constants');
 const makeKnex = require('./make-knex');
 const { KnexTimeoutError } = require('../util/timeout');
 const { resolveConfig } = require('./internal/config-resolver');
+const SchemaBuilder = require('../schema/builder');
+const ViewBuilder = require('../schema/viewbuilder');
+const ColumnBuilder = require('../schema/columnbuilder');
+const TableBuilder = require('../schema/tablebuilder');
 
 function knex(config) {
   const { resolvedConfig, Dialect } = resolveConfig(...arguments);
@@ -28,4 +32,28 @@ knex.QueryBuilder = {
   },
 };
 
+knex.SchemaBuilder = {
+  extend: function (methodName, fn) {
+    SchemaBuilder.extend(methodName, fn);
+  },
+};
+
+knex.ViewBuilder = {
+  extend: function (methodName, fn) {
+    ViewBuilder.extend(methodName, fn);
+  },
+};
+
+knex.ColumnBuilder = {
+  extend: function (methodName, fn) {
+    ColumnBuilder.extend(methodName, fn);
+  },
+};
+
+knex.TableBuilder  = {
+  extend: function (methodName, fn) {
+    TableBuilder.extend(methodName, fn);
+  },
+};
+
 module.exports = knex;

package/lib/knex-builder/internal/config-resolver.js

@@ -2,7 +2,7 @@ const Client = require('../../client');
 const { SUPPORTED_CLIENTS } = require('../../constants');
 
 const parseConnection = require('./parse-connection');
-const { resolveClientNameWithAliases } = require('../../util/helpers');
+const { getDialectByNameOrAlias } = require('../../dialects');
 
 function resolveConfig(config) {
   let Dialect;
@@ -34,8 +34,7 @@ function resolveConfig(config) {
       );
     }
 
-    const resolvedClientName = resolveClientNameWithAliases(clientName);
-    Dialect = require(`../../dialects/${resolvedClientName}/index.js`);
+    Dialect = getDialectByNameOrAlias(clientName);
   }
 
   // If config connection parameter is passed as string, try to parse it

package/lib/migrations/migrate/MigrationGenerator.js

@@ -41,7 +41,7 @@ class MigrationGenerator {
 
   _getNewMigrationName(name) {
     if (name[0] === '-') name = name.slice(1);
-    return yyyymmddhhmmss() + '_' + name + '.' + this.config.extension;
+    return yyyymmddhhmmss() + '_' + name + '.' + this.config.extension.split('-')[0];
   }
 
   _getNewMigrationPath(name) {

package/lib/migrations/migrate/stub/js-schema.stub

@@ -0,0 +1,22 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.up = function({schema}) {
+  <% if (d.tableName) { %>
+  return schema.createTable("<%= d.tableName %>", function(t) {
+    t.increments();
+    t.timestamp();
+  });
+  <% } %>
+};
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+exports.down = function({schema}) {
+  <% if (d.tableName) { %>
+  return schema.dropTable("<%= d.tableName %>");
+  <% } %>
+};

package/lib/migrations/migrate/stub/ts-schema.stub

@@ -0,0 +1,21 @@
+import { Knex } from "knex";
+
+<% if (d.tableName) { %>
+export async function up({schema}: Knex): Promise<Knex.SchemaBuilder> {
+    return schema.createTable("<%= d.tableName %>", (t) => {
+        t.increments();
+        t.timestamps();
+    });
+}
+<% } else { %>
+export async function up({schema}: Knex): Promise<void> {
+}
+<% } %>
+<% if (d.tableName) { %>
+export async function down({schema}: Knex): Promise<Knex.SchemaBuilder> {
+    return schema.dropTable("<%= d.tableName %>");
+}
+<% } else { %>
+export async function down({schema}: Knex): Promise<void> {
+}
+<% } %>

package/lib/schema/builder.js

@@ -1,5 +1,6 @@
 const { EventEmitter } = require('events');
 const toArray = require('lodash/toArray');
+const assign = require('lodash/assign');
 const { addQueryContext } = require('../util/helpers');
 const saveAsyncStack = require('../util/save-async-stack');
 const {
@@ -96,6 +97,17 @@ class SchemaBuilder extends EventEmitter {
   };
 });
 
+
+SchemaBuilder.extend = (methodName, fn) => {
+  if (Object.prototype.hasOwnProperty.call(SchemaBuilder.prototype, methodName)) {
+    throw new Error(
+      `Can't extend SchemaBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(SchemaBuilder.prototype, { [methodName]: fn });
+};
+
 augmentWithBuilderInterface(SchemaBuilder);
 addQueryContext(SchemaBuilder);
 

package/lib/schema/columnbuilder.js

@@ -1,4 +1,5 @@
 const extend = require('lodash/extend');
+const assign = require('lodash/assign');
 const toArray = require('lodash/toArray');
 const { addQueryContext } = require('../util/helpers');
 
@@ -87,6 +88,17 @@ ColumnBuilder.prototype.notNull = ColumnBuilder.prototype.notNullable =
   };
 });
 
+
+ColumnBuilder.extend = (methodName, fn) => {
+  if (Object.prototype.hasOwnProperty.call(ColumnBuilder.prototype, methodName)) {
+    throw new Error(
+      `Can't extend ColumnBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(ColumnBuilder.prototype, { [methodName]: fn });
+};
+
 const AlterMethods = {};
 
 // Specify that the column is to be dropped. This takes precedence

package/lib/schema/tablebuilder.js

@@ -8,6 +8,7 @@
 // ------
 const each = require('lodash/each');
 const extend = require('lodash/extend');
+const assign = require('lodash/assign');
 const toArray = require('lodash/toArray');
 const helpers = require('../util/helpers');
 const { isString, isFunction, isObject } = require('../util/is');
@@ -360,4 +361,15 @@ AlterMethods.dropColumn = AlterMethods.dropColumns = function () {
   return this;
 };
 
+
+TableBuilder.extend = (methodName, fn) => {
+  if (Object.prototype.hasOwnProperty.call(TableBuilder.prototype, methodName)) {
+    throw new Error(
+      `Can't extend TableBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(TableBuilder.prototype, { [methodName]: fn });
+};
+
 module.exports = TableBuilder;

package/lib/schema/viewbuilder.js

@@ -1,5 +1,6 @@
 const helpers = require('../util/helpers');
 const extend = require('lodash/extend');
+const assign = require('lodash/assign');
 
 class ViewBuilder {
   constructor(client, method, viewName, fn) {
@@ -78,4 +79,15 @@ const AlterMethods = {
 
 helpers.addQueryContext(ViewBuilder);
 
+
+ViewBuilder.extend = (methodName, fn) => {
+  if (Object.prototype.hasOwnProperty.call(ViewBuilder.prototype, methodName)) {
+    throw new Error(
+      `Can't extend ViewBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(ViewBuilder.prototype, { [methodName]: fn });
+};
+
 module.exports = ViewBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3",
   "main": "knex",
   "types": "types/index.d.ts",
@@ -8,6 +8,10 @@
     "node": ">=12"
   },
   "scripts": {
+    "build": "npm run build:gitignore && npm run build:ts",
+    "clean": "node scripts/clean.js",
+    "build:ts": "tsc",
+    "build:gitignore": "node scripts/update_gitignore_for_tsc_output.js run",
     "format": "prettier --write \"{lib,bin,scripts,test}/**/*.js\"",
     "debug:test": "mocha --inspect-brk --exit -t 0 test/all-tests-suite.js",
     "debug:tape": "node --inspect-brk test/tape/index.js",
@@ -52,7 +56,8 @@
     "stress:init": "docker-compose -f scripts/stress-test/docker-compose.yml up --no-start && docker-compose -f scripts/stress-test/docker-compose.yml start",
     "stress:test": "node scripts/stress-test/knex-stress-test.js | grep -A 5 -B 60 -- '- STATS '",
     "stress:destroy": "docker-compose -f scripts/stress-test/docker-compose.yml stop",
-    "prepare": "husky install"
+    "prepare": "husky install && npm run clean && npm run build",
+    "prepublishOnly": "npm run clean && npm run build"
   },
   "dependencies": {
     "colorette": "2.0.16",
@@ -95,11 +100,11 @@
   },
   "lint-staged": {
     "*.{js,json}": [
-      "prettier --write",
-      "git add"
+      "prettier --write"
     ]
   },
   "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
     "@types/node": "^17.0.25",
     "better-sqlite3": "^7.5.1",
     "chai": "^4.3.6",
@@ -113,11 +118,11 @@
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-mocha-no-only": "^1.1.1",
-    "husky": "^7.0.4",
+    "husky": "^8.0.1",
     "jake": "^10.8.5",
     "JSONStream": "^1.3.5",
     "lint-staged": "^12.3.7",
-    "mocha": "^9.2.2",
+    "mocha": "^10.0.0",
     "mock-fs": "^5.1.2",
     "mysql": "^2.18.1",
     "mysql2": "^2.3.3",
@@ -127,7 +132,7 @@
     "pg-query-stream": "^4.2.1",
     "prettier": "2.6.2",
     "rimraf": "^3.0.2",
-    "sinon": "^13.0.1",
+    "sinon": "^14.0.0",
     "sinon-chai": "^3.7.0",
     "source-map-support": "^0.5.21",
     "sqlite3": "^5.0.4",
@@ -137,7 +142,7 @@
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^10.7.0",
     "tsd": "^0.20.0",
-    "typescript": "4.6.3"
+    "typescript": "4.7.2"
   },
   "buildDependencies": [
     "rimraf"
@@ -194,9 +199,9 @@
     }
   ],
   "browser": {
-    "./lib/migrate/Migrator.js": "./lib/util/noop.js",
+    "./lib/migrations/migrate/Migrator.js": "./lib/util/noop.js",
     "./lib/bin/cli.js": "./lib/util/noop.js",
-    "./lib/seed/Seeder.js": "./lib/util/noop.js",
+    "./lib/migrations/seed/Seeder.js": "./lib/util/noop.js",
     "tedious": false,
     "mysql": false,
     "mysql2": false,
@@ -214,7 +219,12 @@
   },
   "files": [
     "bin/*",
-    "lib/*",
+    "lib/",
+    "lib/**/*.js",
+    "!lib/**/*.ts",
+    "!lib/**/*.d.ts",
+    "!lib/**/*.js.map",
+    "!lib/.gitignore",
     "scripts/*",
     "types/index.d.ts",
     "types/result.d.ts",

package/scripts/clean.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require("child_process");
+
+function main() {
+  const repoDir = path.dirname(__dirname)
+  const gitDir = path.join(repoDir, '.git')
+  const gitDirExists = doesDirectoryExist(gitDir)
+  if (!gitDirExists) {
+    console.log("No .git directory detected so can not clean 'lib/'. Exiting.")
+    process.exit(0)
+  }
+  console.log("Cleaning 'lib/' of outputted files from Typescript compilation ...")
+  const cmd = 'git clean -f -X lib/'
+  const output = execSync(cmd, { cwd: repoDir })
+  console.log(output.toString('utf8'))
+  console.log('Done')
+}
+
+function doesDirectoryExist(p) {
+  if (fs.existsSync(p)) {
+    return fs.lstatSync(p).isDirectory()
+  }
+  return false
+}
+
+main()

package/scripts/update_gitignore_for_tsc_output.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+const path = require('path')
+const fs = require('fs')
+
+// Directory constants
+const scriptDirectory = __dirname
+const repoDirectory = path.join(scriptDirectory, '..')
+const libDirectory = path.join(repoDirectory, 'lib')
+
+const helpText = `
+Helper script to update lib/.gitignore for all .js files from .ts files.
+
+    update_gitignore_for_tsc_output.js COMMAND
+
+    COMMAND:
+        run:  Update lib/.gitignore file.
+        help: Print this menu.
+
+    NOTES FOR USAGE:
+    1. This script is tested to work on Ubuntu 18.04 LTS.
+`
+
+const gitignoreHeader = `# DO NOT EDIT, GENERATED BY: scripts/update_gitignore_for_tsc_output.js
+
+# Do not include tsc generated type definitions
+**/*.d.ts
+
+# Do not include tsc source maps
+**/*.js.map
+
+# Do not include .js files from .ts files
+`
+
+function main(cliCommand) {
+  if (cliCommand === 'run') {
+    console.log('Generating lib/.gitignore ...')
+
+    // Find all .ts files in lib/
+    const directoriesToProcess = [libDirectory]
+    const tsFiles = []
+    while (directoriesToProcess.length > 0) {
+      const directory = directoriesToProcess.pop()
+      if (!fs.existsSync(directory)) {
+        throw new Error("Directory doesn't exist:", directory)
+      }
+
+      const files = fs.readdirSync(directory)
+      files.forEach((file) => {
+        const filename = path.join(directory, file)
+        const stat = fs.lstatSync(filename)
+        if (stat.isDirectory()) {
+          directoriesToProcess.push(filename)
+        } else if (filename.endsWith('.ts') && !filename.endsWith('.d.ts')) {
+          tsFiles.push(filename)
+          console.log('Found .ts file:', filename)
+        }
+      })
+    }
+
+    // Get paths of .js files to ignore
+    const jsFilesToIgnore = tsFiles.map((filepath) => {
+      // Cuts off `${libDirectory}/`
+      const relativeTsPath = filepath.slice(libDirectory.length + 1)
+      // Swaps .ts for .js file ending
+      const relativeJsPath = relativeTsPath.slice(0, relativeTsPath.length - 3) + '.js'
+      return relativeJsPath
+    })
+    const jsFilesToIgnoreString = jsFilesToIgnore.join('\n')
+    const libGitignorePath = path.join(libDirectory, '.gitignore')
+    fs.writeFileSync(libGitignorePath, gitignoreHeader + jsFilesToIgnoreString + '\n')
+    console.log('DONE')
+  } else if (['help', '--help', '-h', undefined].includes(cliCommand)) {
+    console.log(helpText)
+  } else {
+    console.log(`Unsupported command: ${cliCommand}`)
+    console.log("Try running with 'help' to see supported commands.")
+    process.exit(1)
+  }
+}
+
+// Main script logic
+const cliCommand = process.argv[2]
+// Start the bash app's main function
+main(cliCommand)

package/types/index.d.ts

@@ -384,6 +384,43 @@ export declare namespace knex {
     ): void;
   }
 
+  class TableBuilder {
+    static extend(
+      methodName: string,
+      fn: (
+        this: Knex.TableBuilder,
+        ...args: any[]
+      ) => Knex.TableBuilder
+    ): void;
+  }
+  class ViewBuilder {
+    static extend(
+      methodName: string,
+      fn: (
+        this: Knex.ViewBuilder,
+        ...args: any[]
+      ) => Knex.ViewBuilder
+    ): void;
+  }
+  class SchemaBuilder {
+    static extend(
+      methodName: string,
+      fn: (
+        this: Knex.SchemaBuilder,
+        ...args: any[]
+      ) => Knex.SchemaBuilder
+    ): void;
+  }
+  class ColumnBuilder {
+    static extend(
+      methodName: string,
+      fn: (
+        this: Knex.ColumnBuilder,
+        ...args: any[]
+      ) => Knex.ColumnBuilder
+    ): void;
+  }
+
   export class KnexTimeoutError extends Error {}
 
   export const Client: typeof Knex.Client;
@@ -1983,7 +2020,7 @@ export declare namespace Knex {
       viewName: string,
       callback: (viewBuilder: ViewBuilder) => any
     ): SchemaBuilder;
-    refreshMaterializedView(viewName: string): SchemaBuilder;
+    refreshMaterializedView(viewName: string, concurrently?: boolean): SchemaBuilder;
     dropView(viewName: string): SchemaBuilder;
     dropViewIfExists(viewName: string): SchemaBuilder;
     dropMaterializedView(viewName: string): SchemaBuilder;
@@ -2570,17 +2607,28 @@ export declare namespace Knex {
   interface PgConnectionConfig {
     user?: string;
     database?: string;
-    password?: string;
+    password?: string | (() => string | Promise<string>);
     port?: number;
     host?: string;
     connectionString?: string;
     keepAlive?: boolean;
     stream?: stream.Duplex;
     statement_timeout?: false | number;
-    connectionTimeoutMillis?: number;
-    keepAliveInitialDelayMillis?: number;
+    parseInputDatesAsUTC?: boolean;
     ssl?: boolean | ConnectionOptions;
+    query_timeout?: number;
+    keepAliveInitialDelayMillis?: number;
+    idle_in_transaction_session_timeout?: number;
     application_name?: string;
+    connectionTimeoutMillis?: number;
+    types?: PgCustomTypesConfig;
+    options?: string;
+  }
+
+  type PgGetTypeParser = (oid: number, format: string) => any;
+
+  interface PgCustomTypesConfig {
+      getTypeParser: PgGetTypeParser;
   }
 
   type RedshiftConnectionConfig = PgConnectionConfig;