knex 1.0.7 → 2.2.0

package/CHANGELOG.md

@@ -1,19 +1,67 @@
 # Master (Unreleased)
 
-# 1.0.7 - 13 March, 2022
+# 2.2.0 - 19 July, 2022
+
+### New features:
+
+- Inline primary key creation for postgres flavours #5233
+- SQLite: Add warning for undefined connection file #5223
+- MSSQL: Add JSON parameter support for connection #5200
+
+### Bug fixes:
+
+- PostgreSQL: add primaryKey option for uuid #5212
+
+### Typings:
+
+- Add promisable and better types #5222
+- Update raw query bind parameter type #5208
+
+# 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
+
+- Restore sqlite3 package #5136
+
+### Test / internal changes:
+
+- Migrate Husky from 4 to 7 #5137
+- Migrate Jake to 10.8.5 #5138
+
+# 1.0.7 - 13 April, 2022
 
 ### Bug fixes:
 
 - CLI: Fix cli migrate:make SQLite dependency #5106
 
-# 1.0.6 - 12 March, 2022
+# 1.0.6 - 12 April, 2022
 
 ### Bug fixes:
 
 - PostgreSQL: Wait for search path to be set before returning connection #5107
 - CLI: No client override during migrate:make #5109
 
-# 1.0.5 - 05 March, 2022
+# 1.0.5 - 05 April, 2022
 
 ### New features:
 

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/UPGRADING.md

@@ -1,5 +1,9 @@
 ## Upgrading to new knex.js versions
 
+### Upgrading to version 2.0.0+
+
+* Since `sqlite3` is maintained again, we switched back to it. If you are using `@vscode/sqlite3` driver dependency, please replace it with `sqlite3` in your `package.json`;
+
 ### Upgrading to version 1.0.0+
 
 * Node.js older than 12 is no longer supported, make sure to update your environment;

package/lib/client.js

@@ -189,10 +189,7 @@ class Client extends EventEmitter {
     try {
       this.driver = this._driver();
     } catch (e) {
-      const driverName = this.aliasDriverName
-        ? this.aliasDriverName
-        : this.driverName;
-      const message = `Knex: run\n$ npm install ${driverName} --save`;
+      const message = `Knex: run\n$ npm install ${this.driverName} --save`;
       this.logger.error(`${message}\n${e.message}\n${e.stack}`);
       throw new Error(`${message}\n${e.message}`);
     }

package/lib/dialects/cockroachdb/crdb-columncompiler.js

@@ -0,0 +1,14 @@
+const ColumnCompiler_PG = require('../postgres/schema/pg-columncompiler.js');
+
+class ColumnCompiler_CRDB extends ColumnCompiler_PG {
+  uuid(options = { primaryKey: false }) {
+    return (
+      'uuid' +
+      (this.tableCompiler._canBeAddPrimaryKey(options)
+        ? ' primary key default gen_random_uuid()'
+        : '')
+    );
+  }
+}
+
+module.exports = ColumnCompiler_CRDB;

package/lib/dialects/cockroachdb/index.js

@@ -3,6 +3,7 @@
 const Client_PostgreSQL = require('../postgres');
 const Transaction = require('../postgres/execution/pg-transaction');
 const QueryCompiler = require('./crdb-querycompiler');
+const ColumnCompiler = require('./crdb-columncompiler');
 const TableCompiler = require('./crdb-tablecompiler');
 const ViewCompiler = require('./crdb-viewcompiler');
 const QueryBuilder = require('./crdb-querybuilder');
@@ -19,6 +20,10 @@ class Client_CockroachDB extends Client_PostgreSQL {
     return new QueryCompiler(this, builder, formatter);
   }
 
+  columnCompiler() {
+    return new ColumnCompiler(this, ...arguments);
+  }
+
   tableCompiler() {
     return new TableCompiler(this, ...arguments);
   }

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-columncompiler.js

@@ -124,6 +124,13 @@ class ColumnCompiler_PG extends ColumnCompiler {
       (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
     );
   }
+
+  uuid(options = { primaryKey: false }) {
+    return (
+      'uuid' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
+  }
 }
 
 ColumnCompiler_PG.prototype.bigint = 'bigint';
@@ -133,7 +140,6 @@ ColumnCompiler_PG.prototype.double = 'double precision';
 ColumnCompiler_PG.prototype.floating = 'real';
 ColumnCompiler_PG.prototype.smallint = 'smallint';
 ColumnCompiler_PG.prototype.tinyint = 'smallint';
-ColumnCompiler_PG.prototype.uuid = 'uuid';
 
 function jsonColumn(client, jsonb) {
   if (

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/dialects/postgres/schema/pg-tablecompiler.js

@@ -44,7 +44,10 @@ class TableCompiler_PG extends TableCompiler {
     const createStatement = ifNot
       ? 'create table if not exists '
       : 'create table ';
-    const columnsSql = ' (' + columns.sql.join(', ') + this._addChecks() + ')';
+    const columnsSql = ` (${columns.sql.join(', ')}${
+      this.primaryKeys() || ''
+    }${this._addChecks()})`;
+
     let sql =
       createStatement +
       this.tableName() +
@@ -65,6 +68,28 @@ class TableCompiler_PG extends TableCompiler {
     if (hasComment) this.comment(this.single.comment);
   }
 
+  primaryKeys() {
+    const pks = (this.grouped.alterTable || []).filter(
+      (k) => k.method === 'primary'
+    );
+    if (pks.length > 0 && pks[0].args.length > 0) {
+      const columns = pks[0].args[0];
+      let constraintName = pks[0].args[1] || '';
+      let deferrable;
+      if (isObject(constraintName)) {
+        ({ constraintName, deferrable } = constraintName);
+      }
+      deferrable = deferrable ? ` deferrable initially ${deferrable}` : '';
+      constraintName = constraintName
+        ? this.formatter.wrap(constraintName)
+        : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+
+      return `, constraint ${constraintName} primary key (${this.formatter.columnize(
+        columns
+      )})${deferrable}`;
+    }
+  }
+
   addColumns(columns, prefix, colCompilers) {
     if (prefix === this.alterColumnsPrefix) {
       // alter columns
@@ -153,11 +178,13 @@ class TableCompiler_PG extends TableCompiler {
     constraintName = constraintName
       ? this.formatter.wrap(constraintName)
       : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
-    this.pushQuery(
-      `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
-        columns
-      )})${deferrable}`
-    );
+    if (this.method !== 'create' && this.method !== 'createIfNot') {
+      this.pushQuery(
+        `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
+          columns
+        )})${deferrable}`
+      );
+    }
   }
 
   unique(columns, indexName) {

package/lib/dialects/sqlite3/index.js

@@ -20,17 +20,26 @@ const QueryBuilder = require('./query/sqlite-querybuilder');
 class Client_SQLite3 extends Client {
   constructor(config) {
     super(config);
+
+    if (config.connection && config.connection.filename === undefined) {
+      this.logger.warn(
+        'Could not find `connection.filename` in config. Please specify ' +
+          'the database path and name to avoid errors. ' +
+          '(see docs https://knexjs.org/guide/#configuration-options)'
+      );
+    }
+
     if (config.useNullAsDefault === undefined) {
       this.logger.warn(
         'sqlite does not support inserting default values. Set the ' +
           '`useNullAsDefault` flag to hide this warning. ' +
-          '(see docs http://knexjs.org/#Builder-insert).'
+          '(see docs https://knexjs.org/guide/query-builder.html#insert).'
       );
     }
   }
 
   _driver() {
-    return require('@vscode/sqlite3');
+    return require('sqlite3');
   }
 
   schemaCompiler() {
@@ -232,8 +241,6 @@ Object.assign(Client_SQLite3.prototype, {
   dialect: 'sqlite3',
 
   driverName: 'sqlite3',
-  // SqlLite3 driver package name is different from driver name.
-  aliasDriverName: '@vscode/sqlite3',
 });
 
 module.exports = Client_SQLite3;

package/lib/dialects/sqlite3/query/sqlite-querycompiler.js

@@ -76,7 +76,7 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
             throw new TypeError(
               '`sqlite` does not support inserting default values. Specify ' +
                 'values explicitly or use the `useNullAsDefault` config flag. ' +
-                '(see docs http://knexjs.org/#Builder-insert).'
+                '(see docs https://knexjs.org/guide/query-builder.html#insert).'
             );
         });
       });

package/lib/execution/runner.js

@@ -61,22 +61,15 @@ class Runner {
     Transform = Transform || require('stream').Transform;
 
     const queryContext = this.builder.queryContext();
-    let queryStream;
 
     const stream = new Transform({
       objectMode: true,
       transform: (chunk, _, callback) => {
         callback(null, this.client.postProcessResponse(chunk, queryContext));
       },
-      destroy() {
-        // For some reason destroy is not available for mssql on Node 14. Might be a problem with tedious: https://github.com/tediousjs/tedious/issues/1139
-        if (queryStream && queryStream.destroy) {
-          queryStream.destroy(new Error('stream destroyed'));
-        }
-      },
     });
-    stream.on('pipe', (qs) => {
-      queryStream = qs;
+    stream.on('close', () => {
+      this.client.releaseConnection(this.connection);
     });
 
     const connectionAcquirePromise = this.ensureConnection(

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/knex-builder/internal/parse-connection.js

@@ -69,8 +69,10 @@ function connectionObject(parsed) {
   }
   if (parsed.searchParams) {
     for (const [key, value] of parsed.searchParams.entries()) {
-      const isMySQLLike = ['mysql:', 'mariadb:'].includes(parsed.protocol);
-      if (isMySQLLike) {
+      const isNestedConfigSupported = ['mysql:', 'mariadb:', 'mssql:'].includes(
+        parsed.protocol
+      );
+      if (isNestedConfigSupported) {
         try {
           connection[key] = JSON.parse(value);
         } catch (err) {

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/columncompiler.js

@@ -277,8 +277,10 @@ ColumnCompiler.prototype.geography = 'geography';
 ColumnCompiler.prototype.point = 'point';
 ColumnCompiler.prototype.enu = 'varchar';
 ColumnCompiler.prototype.bit = ColumnCompiler.prototype.json = 'text';
-ColumnCompiler.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
-  useBinaryUuid ? 'binary(16)' : 'char(36)';
+ColumnCompiler.prototype.uuid = ({
+  useBinaryUuid = false,
+  primaryKey = false,
+} = {}) => (useBinaryUuid ? 'binary(16)' : 'char(36)');
 ColumnCompiler.prototype.integer =
   ColumnCompiler.prototype.smallint =
   ColumnCompiler.prototype.mediumint =

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;