murmuration 1.1.9 → 2.0.1

package/README.md

@@ -1,19 +1,17 @@
 # Murmuration
 
-Database connections, transactions and migrations.
+Database statements, transactions and migrations.
 
 There are two specific packages that you should make use of instead this one:
 
 * [Murmuration-MariaDB](https://github.com/djalbat/murmuration-mariadb)
 * [Murmuration-PostGreSQL](https://github.com/djalbat/murmuration-postgresql)
 
-This readme file largely pertains to both, although there are also specific instructions given in readme file for each.
+This readme file pertains to both, although there are specific instructions for each of the above in their respective readme files.
 
-Murmuration is meant to be used as alternative to a database [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping). Aside from migrations, it is deliberately simple and low level, in the sense that it provides no more than the bare minimum functionality needed to connect to a database and run commands, optionally in the context of transactions.
+Murmuration can be used as alternative to a database [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping). It is deliberately simple and low level in the sense that it provides no more than the bare minimum functionality needed to connect to a database and generate statements to be executed ideally in the context of transactions. 
 
-The migration functionality, if used correctly, will guarantee that a Node application's codebase remains in line with the database it relies on, updating the latter each time the former is deployed.
-
-The prescriptions given below are an essential part of the package. They show how to write database utility functions at scale; how to employ them in the context of transactions; and they outline what needs to be done in order to guarantee the success of migrations.
+There is also some adjunct migration functionality that may or may not suit your use case. If used as prescribed then it guarantees that an application remains in line with its database, as the latter will be migrated if needed each time the former is deployed.
 
 ## Installation
 
@@ -33,134 +31,257 @@ Remember that it is the aforementioned specific packages that you should install
 
 ## Usage
 
-Functionality across the specific packages is identical, aside from small differences in configuration and error handling, and is therefore covered here.
+Aside from small differences in configuration and error handling the Functionality across the aforementioned specific packages is identical, and is therefore covered here.
 
-### Getting and releasing connections
+Statements are covered first up, but ideally they should be executed in the context of transactions and therefore the remainder of this section cannot be overlooked. In particular, the example statements that follow are executed within operations, which are covered in the later subsection on transactions.
 
-The static `fromConfiguration()` method of the `Connection` class takes a configuration and a callback argument:
+### Generating statements
 
-```
-Connection.fromConfiguration(configuration, (error, connection) => {
+Statements are generated dynamically with a simple, promise-like syntax. 
 
-  ...
+In the first example a row is selected should its email address and password match the given values:
 
-  connection.release();
-};
+```
+const using = require("../using");
+
+function checkAccountOperation(connection, abort, proceed, complete, context) {
+  const { emailAddress, password } = context;
+  
+  using(connection)
+    .selectFromAccont()
+    .where({ emailAddress, password })
+    .one(({ id }) => {
+      Object.assign(context, {
+        id
+      });
+    
+      proceed();
+    })
+    .else(() => {
+      ...
+    
+      complete()
+    })
+    .catch(abort)
+    .execute();
+}
 ```
 
-If successful, the `error` argument of the callback will be null and a `connection` object will be returned, otherwise the `error` argument will be truthy. Details of the format of the `configuration` object can be found in the configuration subsections of the specific package readme files.
+There are several points worth noting:
 
-### Logging
+* A local `using()` function has been employed rather the function supplied by the package, because the `Statement` class it utilities has been extended for convenience. For example, `selectFromAccount()` is defined in the application's own `Statement` class.
+* Each operation provides a connection and a context as well as three callbacks. These allow the result of the execution to determine whether the application should proceed to the next operation or if the transaction should be aborted or completed.
+* The `where()` method takes a plain old JavaScript object.
+* The `one()` method takes a handler that is called if one row is returned.
+* The `else()` method takes a handler that is called in all other cases.
+* The `catch()` method takes a handler that is called should execution fail.
 
-Ideally you should add a `log` property to the `configuration` object that references an object of the following form:
+In the following example rows in a table holding temporary reset codes are deleted once they expire.
 
 ```
-const log = {
-  trace: () => { ... },
-  debug: () => { ... },
-  info: () => { ... },
-  warning: () => { ... },
-  error: () => { ... },
-  fatal: () => { ... },
-});
+const using = require("../using");
+
+const { unauthorized } = require("../utilities/states");
+ 
+function deleteExpiredResetCodesOperation(connection, abort, proceed, complete, context) {
+  const { emailAddress, password } = context;
+    
+  using(connection)
+    .deleteFromResetCode()
+    .where`
+    
+      expires < NOW()
+    
+    `
+    .success(proceed)
+    .catch(abort)
+    .execute();
+}
 ```
-Currently only the `error()`, `info()` and `debug()` functions are made use of, but in future others may be utilised.
 
-If you do not provide a `log` object, all logging is suppressed.
+The following points are worth noting:
 
-### Error handling
+* The `where()` method takes a template literal this time.
+* The `success()` method takes a callback that is called should hte execution succeed.
 
-In the event of an error, if a `log` property has been added to the `configuration` object then the `log.error()` function will be called with a message containing a reasonable stab at the cause of the error. Details can be found in the subsections of the same name in the specific package readme files.
+In this example a row is inserted into a table for software packages:
 
-These messages are meant to help with debugging simple mistakes such as providing incorrect configuration. If you do not find them helpful, do not provide a `log` object and be assured that the errors are always returned by way of callback function arguments for you to deal with as you see fit.
+```
+const using = require("../using");
 
-### Running queries
+function createReleaseOperation(connection, abort, proceed, complete, context) {
+  const { name, entriesBlob, versionNumber } = context;
 
-Two functions are provided, namely `query()` and `execute()`. The former returns an error and an array of rows returned by the query by way of a callback, the latter only an error by way of a callback. Otherwise their signatures are the same:
+  using(connection)
+    .insertIntoRelease()
+    .values({ name, entriesBlob, versionNumber })
+    .success(proceed)
+    .catch(abort)
+    .execute();
+}
+```
+
+Note the following:
+
+* The `values()` method takes a plain old JavaScript object with the values to be inserted.
 
+Finally, the following operation updates a user profile:
+
+```
+const using = require("../using");
+
+function editProfileOperation(connection, abort, proceed, complete, context) {
+  const { name, notes, userIdentifier } = context,
+        identifier = userIdentifier;	///
+
+  using(connection)
+    .updateUser()
+    .set({ name, notes })
+    .where({ identifier })
+    .success(proceed)
+    .execute();
+}
 ```
-const sql = ... ;
 
-query(connection, sql, ...parameters, (error, rows) => {
+Note:
 
-  ...
+* The `set()` method takes a plain old JavaScript object.
 
-});
+In general, the assumption with passing plain old JavaScript objects is that clauses and so forth can easily be constructed from them. The `set()`, `where()` and `values()` methods can also take appended template literals, however, so that you can define parts of the SQL with more freedom. More detail is given towards the end of the next subsection.
 
-execute(connection, sql, ...parameters, status, (error) => {
+### Statement class specification
 
-  ...
+The following specification gives a complete and more detailed list of the methods available.
 
-});
-```
-In both cases, a variable length list of parameters can be passed between the `sql` and `callback` arguments. These replace the placeholders in the SQL you provide. For more information, see the specific packages.
+* One of the `selectFrom()`, `insertInto()`, `deleteFrom()` or `delete()` methods must be called. Each takes a string for the name of a table or view. 
+
+It is recommended that these methods are not called directly, by the way, rather methods that call them indirectly are created on a subclass of the `Statement` class, in order to avoid repetition. This is covered in the later subsection on extending the `Statement` class.
+
+* The `success()` method must accompany the `insertInto()`, `deleteFrom()` or `delete()` methods.
+* If the `selectFrom()` method is called, then one of the following of the following methods must also be called. Each takes a callback. In all but the last case, you must also call the `else()` method with a callback:
+    * The `none()` method for when no rows are returned.
+    * The `one()` method for when exactly one row is returned.
+    * The `first()` method for when one or more rows are returned.
+    * The `many()` method for when any number of rows are returned, including none.
 
-To make use of these functions, it is recommended that you create a file corresponding to each table or view, naming the functions therein to reflect the SQL statements and parameters. The SQL they employ can be read from files, the names of which exactly match the function names. For example:
+* The `catch()` method must always be called with a callback for when an exception occurs.
+* The `set()` method must be called along with the `update()` method.
+* The `where()` method can be called with all but the `insertInto()` method.
+* The `values()` method must be called along with the `insertInto()` method.
+* Either the `getSQL()` or `execute()` methods must be called, usually the latter.
+
+Each of the `set()`, `where()` and `values()` methods can take a plain old JavaScript object or an appended template literal. You cannot pass a string as an argument because there is a danger that it might contain an un-escaped value. By forcing you to pass an appended template literal, the method in question is able to pass the array of arguments it receives directly on to the underlying database package, thereby guaranteeing that they will be correctly cast and escaped.
+
+### Extending the Statement class
+
+This is recommended for no other reason than to avoid repetitively passing table or view names to `selectFrom()` methods and the like. A simple exapmle will amply demonstrate:
 
 ```
-const SELECT_USERNAME_FILE_NAME = "table/user/selectUsername.sql",
-      SELECT_IDENTIFIER_FILE_NAME = "table/user/selectIdentifier.sql",
-      SELECT_EMAIL_ADDRESS_FILE_NAME = "table/user/selectEmailAddress.sql",
-      UPDATE_NAME_IDENTIFIER_FILE_NAME = "table/user/updateNameIdentifier.sql",
-      ...
-      ;
+"use strict";
+
+const { Statement: BaseStatement } = require("./murmuration-...");
+
+const USER_TABLE = "user",
+      RELEASE_TABLE = "release",
+      DISTRIBUTION_TABLE = "attribution",
+      LATEST_RELEASE_VIEW = "latest_release";
 
-function selectUsername(connection, username, callback) { ... }
+class Statement extends BaseStatement {
+  updateUser() { return this.update(USER_TABLE); }
+  updateRelease() { return this.update(RELEASE_TABLE); }
+  updateDistribution() { return this.update(DISTRIBUTION_TABLE); }
 
-function selectIdentifier(connection, identifier, callback) { ... }
+  insertIntoUser() { return this.insertInto(USER_TABLE); }
+  insertIntoRelease() { return this.insertInto(RELEASE_TABLE); }
+  insertIntoDistribution() { return this.insertInto(DISTRIBUTION_TABLE); }
 
-function selectEmailAddress(connection, emailAddress, callback) { ... }
+  deleteFromUser() { return this.deleteFrom(USER_TABLE); }
+  deleteFromRelease() { return this.deleteFrom(RELEASE_TABLE); }
+  deleteFromDistribution() { return this.deleteFrom(DISTRIBUTION_TABLE); }
 
-function updateNameIdentifier(connection, name, identifier, callback) { ... }
+  selectFromUser() { return this.selectFrom(USER_TABLE); }
+  selectFromRelease() { return this.selectFrom(RELEASE_TABLE); }
+  selectFromDistribution() { return this.selectFrom(DISTRIBUTION_TABLE); }
 
-...
+  selectFromLatestRelease() { return this.selectFrom(LATEST_RELEASE_VIEW); }
+
+  static fromConnection(connection) { return BaseStatement.fromConnection(Statement, connection); }
+}
+
+module.exports = Statement;
 ```
-The body of each of the function should be identical bar the parameters and the use of the `query()` versus the `execute()` function:
+
+Here the ellipsis in the `require()` statement should be replaced as needed.
+
+Now make use of this subclass in your own `using()` function...
 
 ```
-function selectEmailAddress(connection, emailAddress, callback) {
-  const filePath = `${SQL_DIRECTORY_PATH}/${SELECT_EMAIL_ADDRESS_FILE_NAME}`,
-        sql = sqlFromFilePath(filePath);
+"use strict";
+
+const Statement = require("./statement");
 
-  query(connection, sql, emailAddress, (error, rows) => {
-    if (error) {
-      log.error("selectEmailAddress() failed.");
-    }
+function using(connection) {
+  const statement = Statement.fromConnection(connection);
 
-    callback(error, rows);
-  });
+  return statement;
 }
 
-function updateNameIdentifier(connection, name, identifier, callback) {
-  const filePath = `${SQL_DIRECTORY_PATH}/${UPDATE_NAME_IDENTIFIER_FILE_NAME}`,
-        sql = sqlFromFilePath(filePath);
+module.exports = using;
+```
+
+...or require and instantiate it directly. The `using()` function is purely for convenience.
 
-  execute(connection, sql, name, identifier, (error) => {
-    if (error) {
-      log.error("updateNameIdentifier() failed.");
-    }
+### Getting and releasing connections
 
-    callback(error);
-  });
-}
+The static `fromConfiguration()` method of the `Connection` class takes a configuration and a callback argument:
+
+```
+Connection.fromConfiguration(configuration, (error, connection) => {
+
+  ...
+
+  connection.release();
+};
+```
+
+If successful, the `error` argument of the callback will be null and a `connection` object will be returned, otherwise the `error` argument will be truthy. Details of the format of the `configuration` object can be found in the configuration subsections of the specific package readme files.
+
+### Logging
+
+Ideally you should add a `log` property to the `configuration` object that references an object of the following form:
+
+```
+const log = {
+  trace: () => { ... },
+  debug: () => { ... },
+  info: () => { ... },
+  warning: () => { ... },
+  error: () => { ... },
+  fatal: () => { ... },
+});
 ```
-Note that the parameters, as well as matching the function names precisely, are passed directly to the `query()` or `execute()` functions. Essentially the only purpose of these functions is to retrieve the SQL, pass it to the requisite murmuration function and log an error if it occurs.
+Currently only the `error()`, `info()` and `debug()` functions are made use of, but in future others may be utilised.
 
-Lastly, it is recommended that you avoid complex queries that span more than one table and always employ views instead. For information on views, see the MariaDB documentation [here](https://mariadb.com/kb/en/views/).
+If you do not provide a `log` object, all logging is suppressed.
+
+### Error handling
+
+In the event of an error, if a `log` property has been added to the `configuration` object then the `log.error()` function will be called with a message containing a reasonable stab at the cause of the error. Details can be found in the subsections of the same name in the specific package readme files.
+
+These messages are meant to help with debugging simple mistakes such as providing incorrect configuration. If you do not find them helpful, do not provide a `log` object and be assured that the errors are always returned by way of callback function arguments for you to deal with as you see fit.
 
 ### Using transactions
 
 Ideally, all database operations should be run in the context of transactions. There is a single `transaction()` function that allows you to do this. It takes `configuration`, `operations`, `callback` and `context` arguments. The callback provided will have a `completed` argument while the context is mandatory and must be a plain old JavaScript object. The `transaction()` function makes use of the `context` object itself, in fact, with the object's `connection`, `operations` and `completed` properties being reserved.
 
-In the example below, four operations has been provided and the context has properties that they will make use of:
+In the example below, three operations has been provided and the context has properties that they will make use of:
 
 ```
 const configuration = ... ,
       operations = [
-        checkUsernameAvailable,
-        checkEmailAddressAvailable,
-        addEmailAddressUsernamePasswordAndStatus,
-        retrieveUserIdentifier,
+        checkUsernameOperation,
+        checkEmailAddressOperation,
+        addEmailOperation
       ],
       context = {
         emailAddress,
@@ -174,32 +295,10 @@ transaction(configuration, operations, (completed) => {
 
 }, context);
 ```
-The signature of the operations must be identical to the following example:
-
-```
-function checkUsernameAvailable(connection, abort, proceed, complete, context) {
-  const { username } = context;
-
-  selectUsername(connection, username, (error, rows) => {
-    if (error) {
-      abort();
 
-      return;
-    }
+The signatures of the operations are given in the usage section. The bodies of the operations are immaterial, again see the usage section for idees. What follows are general prescriptions for how to make use of transactions. 
 
-    const rowsLength = rows.length;
-
-    (rowsLength === 0) ?
-      proceed() :
-        complete();
-  });
-}
-```
-Note the provision of the `abort()`, `proceed()` and `complete()` callbacks, each of which is utilised. Their utility should be self evident. One important point to note is that there is an explicit `return` statement after the call to the `abort()` callback. It is easy to forget that invoking a callback does not prevent execution continuing in the current context.
-
-It is entirely possible to conflate the first three of these operations into a single SQL statement and then to combine that with the last SQL statement that recovers an auto-incremented identifier. Both of these statements can then be placed in a single SQL file and run with a call to the `query()` function. There is nothing to be gained from such a approach, however, and there are good reasons not to take it:
-
-* You can try to insert values into a table and test whether they are unique by whether or not the insert fails. However, the database will throw an error that is indistinguishable from errors that occur because of, say, syntax errors in the SQL. It could be considered bad practice to knowingly run a query that may result in an error and use the presence of such as an indication of whether or not an otherwise correct query has been successful.
+* You can try to insert values into a table and test whether they are unique by whether or not the insert fails. However, the database will throw an error that is indistinguishable from errors that occur because of, say, syntax errors in the SQL. It could be argued that it is bad practice to knowingly run a query that may result in an error and use the presence of such as an indication of whether or not an otherwise correct query has been successful.
 
 * Often conflating operations means that application logic that is far more suited to, in this case, JavaScript must be added to the SQL itself. Or worse, the application logic is simply assumed to be implicit in the SQL. It is far better to implement this kind of logic explicitly in JavaScript than complicate SQL statements with it.
 
@@ -207,13 +306,11 @@ It is entirely possible to conflate the first three of these operations into a s
 
 The example above demonstrates the crux of the approach taken here, therefore. The application logic is to be found in easily readable, atomic form within the body of each operation. On the other hand the SQL statements are considered to be dumb in the sense that they do nothing but slavishly place or retrieve information into or from the database.
 
-This approach leads to less SQL and more JavaScript, however, as already mentioned but well worth repeating, that JavaScript is easily readable and atomic. The downside is a small amount of boilerplate JavaScript wrapping each operation, but this is a small price to pay.
-
 ### Making use of migrations
 
 The migration functionality will definitely not suit every use case, however it can provide surety for small applications running on multiple Node instances connecting to a single MariaDB instance. It is essential that the prescriptions below are followed pretty much to the letter. Failing to do so will doubtless result in failure.
 
-The `migrate()` function takes the usual `configuration` argument followed by `migrationsDirectoryPath` argument and a `callback` argument.  The callback is invoked with the usual `error` argument, which is truthy if the migrations have succeeded and falsey otherwise.
+The `migrate()` function takes the usual `configuration` argument followed by `migrationsDirectoryPath` argument and a `callback` argument.  The callback is called with the usual `error` argument, which is truthy if the migrations have succeeded and falsey otherwise.
 
 ```
 const configuration = ... ,

package/bin/statement.js

@@ -76,6 +76,10 @@ class Statement {
     this.query = query;
   }
 
+  setParameters(parameters) {
+    this.parameters = parameters;
+  }
+
   one(oneHandler) {
     this.oneHandler = oneHandler;
 
@@ -118,8 +122,21 @@ class Statement {
     return this;
   }
 
-  set(object) {
-    const assignments = this.assignmentsFromObject(object); ///
+  set(objectOrArray, ...parameters) {
+    let assignments;
+
+    const objectOrArrayIsArray = Array.isArray(objectOrArray);
+
+    if (objectOrArrayIsArray) {
+      const array = objectOrArray,  ///
+            strings = array;  ///
+
+      assignments = this.assignmentsFromStringsAndParameters(strings, parameters);
+    } else {
+      const object = objectOrArray;  ///
+
+      assignments = this.assignmentsFromObject(object); ///
+    }
 
     this.sql = ` ${this.sql} SET ${assignments}`;
 
@@ -132,7 +149,7 @@ class Statement {
     const objectOrArrayIsArray = Array.isArray(objectOrArray);
 
     if (objectOrArrayIsArray) {
-      const array = objectOrArray,
+      const array = objectOrArray,  ///
             strings = array;  ///
 
       clause = this.clauseFromStringsAndParameters(strings, parameters);
@@ -150,20 +167,21 @@ class Statement {
   values(objectOrArray, ...parameters) {
     const objectOrArrayIsArray = Array.isArray(objectOrArray);
 
+    let columnsAndValues;
+
     if (objectOrArrayIsArray) {
-      const array = objectOrArray,
-            strings = array,  ///
-            columnsAndValues = this.columnsAndValuesFromStringsAndParameters(strings, parameters);
+      const array = objectOrArray,  ///
+            strings = array;  ///
 
-      this.sql = `${this.sql} ${columnsAndValues}`;
+      columnsAndValues = this.columnsAndValuesFromStringsAndParameters(strings, parameters);
     } else {
-      const object = objectOrArray,  ///
-            values = this.valuesFromObject(object),
-            columns = this.columnsFromObject(object)
+      const object = objectOrArray;  ///
 
-      this.sql = `${this.sql} (${columns}) VALUES (${values})`;
+      columnsAndValues = this.columnsAndValuesFromObject(object);
     }
 
+    this.sql = `${this.sql} ${columnsAndValues}`;
+
     return this;
   }
 
@@ -182,18 +200,19 @@ class Statement {
     return object;
   }
 
-  valuesFromObject(object) {
-    const columns = this.columnsFromObject(object),
+  clauseFromObject(object) {
+    const keys = Object.keys(object),
+          columns = keys.map((key) => this.columnFromKey(key)),
           parameters = Object.values(object), ///
           firstIndex = 0,
-          values = columns.reduce((values, column, index) => {
+          clause = columns.reduce((clause, column, index) => {
             const placeholder = this.placeholder();
 
-            values = (index === firstIndex) ?
-                      `${placeholder}` :
-                        ` ${values}, ${placeholder}`;
+            clause = (index === firstIndex) ?
+                `${column}=${placeholder}` :
+                ` ${clause} AND ${column}=${placeholder}`;
 
-            return values;
+            return clause;
           }, EMPTY_STRING);
 
     this.parameters = [
@@ -201,21 +220,22 @@ class Statement {
       ...parameters
     ];
 
-    return values;
+    return clause;
   }
 
-  clauseFromObject(object) {
-    const columns = this.columnsFromObject(object),
+  assignmentsFromObject(object) {
+    const keys = Object.keys(object),
+          columns = keys.map((key) => this.columnFromKey(key)),
           parameters = Object.values(object), ///
           firstIndex = 0,
-          clause = columns.reduce((clause, column, index) => {
+          assignments = columns.reduce((assignments, column, index) => {
             const placeholder = this.placeholder();
 
-            clause = (index === firstIndex) ?
-                       `${column}=${placeholder}` :
-                         ` ${clause} AND ${column}=${placeholder}`;
+            assignments = (index === firstIndex) ?
+                `${column}=${placeholder}` :
+                ` ${assignments}, ${column}=${placeholder}`;
 
-            return clause;
+            return assignments;
           }, EMPTY_STRING);
 
     this.parameters = [
@@ -223,36 +243,31 @@ class Statement {
       ...parameters
     ];
 
-    return clause;
+    return assignments;
   }
 
-  columnsFromObject(object) {
+  columnsAndValuesFromObject(object) {
     const keys = Object.keys(object),
-          columns = keys.map((key) => this.columnFromKey(key));
-
-    return columns;
-  }
-
-  assignmentsFromObject(object) {
-    const columns = this.columnsFromObject(object),
+          columns = keys.map((key) => this.columnFromKey(key)),
           parameters = Object.values(object), ///
           firstIndex = 0,
-          assignments = columns.reduce((assignments, column, index) => {
+          values = columns.reduce((values, column, index) => {
             const placeholder = this.placeholder();
 
-            assignments = (index === firstIndex) ?
-                           `${column}=${placeholder}` :
-                             ` ${assignments}, ${column}=${placeholder}`;
+            values = (index === firstIndex) ?
+                        `${placeholder}` :
+                        ` ${values}, ${placeholder}`;
 
-            return assignments;
-          }, EMPTY_STRING);
+            return values;
+          }, EMPTY_STRING),
+          columnsAndValues = `(${columns}) VALUES (${values})`;
 
     this.parameters = [
       ...this.parameters,
       ...parameters
     ];
 
-    return assignments;
+    return columnsAndValues;
   }
 
   clauseFromStringsAndParameters(strings, parameters) {
@@ -272,12 +287,35 @@ class Statement {
 
     this.parameters = [
       ...this.parameters,
-        ...parameters
+      ...parameters
     ];
 
     return clause;
   }
 
+  assignmentsFromStringsAndParameters(strings, parameters) {
+    const stringsLength = strings.length,
+          lastIndex = stringsLength - 1,
+          assignments = strings.reduce((assignments, string, index) => {
+            if (index < lastIndex) {
+              const placeholder = this.placeholder();
+
+              assignments = `${assignments}${string}${placeholder}`
+            } else {
+              assignments = `${assignments}${string}`;
+            }
+
+            return assignments;
+          }, EMPTY_STRING);
+
+    this.parameters = [
+      ...this.parameters,
+      ...parameters
+    ];
+
+    return assignments;
+  }
+
   columnsAndValuesFromStringsAndParameters(strings, parameters) {
     const stringsLength = strings.length,
           lastIndex = stringsLength - 1,

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "murmuration",
   "author": "James Smith",
-  "version": "1.1.9",
+  "version": "2.0.1",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/murmuration",
-  "description": "Database connections, transactions and migrations.",
+  "description": "Database statements, transactions and migrations.",
   "repository": {
     "type": "git",
     "url": "https://github.com/djalbat/murmuration"