Add support of sql-template-strings, v3.0.0 (#66)

Author: samogot

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+### [v3.0.0]
+> 2018-08-22
+
+- Add support for ES6 tagged template strings ([#66](https://github.com/kriasoft/node-sqlite/pull/66))
+
 ### [v2.9.3]
 > 2018-08-22
 

README.md

@@ -57,6 +57,22 @@ app.get('/post/:id', async (req, res, next) => {
 app.listen(port);
 ```
 
+### ES6 tagged template strings
+
+This module is compatible with [sql-template-strings](https://www.npmjs.com/package/sql-template-strings).
+
+```js
+import SQL from 'sql-template-strings';
+import sqlite from 'sqlite';
+
+const db = await sqlite.open('./database.sqlite');
+
+const book = 'harry potter';
+const author = 'J. K. Rowling';
+
+const data = await db.all(SQL`SELECT author FROM books WHERE name = ${book} AND author = ${author}`);
+```
+
 ### Cached DB Driver
 
 If you want to enable the [database object cache](https://github.com/mapbox/node-sqlite3/wiki/Caching)
@@ -156,6 +172,7 @@ main();
 
 * [Using SQLite with Node.js for Rapid Prototyping](https://medium.com/@tarkus/node-js-and-sqlite-for-rapid-prototyping-bc9cf1f26f10) on Medium.com
 * [SQLite Documentation](https://www.sqlite.org/docs.html), e.g. [SQL Syntax](https://www.sqlite.org/lang.html), [Data Types](https://www.sqlite.org/datatype3.html) etc. on SQLite.org
+* ES6 tagged [sql-template-strings](https://www.npmjs.com/package/sql-template-strings).
 
 
 ### Related Projects

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "sqlite",
-  "version": "2.9.3",
+  "version": "3.0.0",
   "description": "SQLite client for Node.js applications with SQL-based migrations API",
   "repository": "kriasoft/node-sqlite",
   "author": "Kriasoft <hello@kriasoft.com> (https://www.kriasoft.com)",
@@ -68,6 +68,9 @@
     "rollup": "^0.41.4",
     "rollup-plugin-babel": "^2.7.1"
   },
+  "optionalDependencies": {
+    "sql-template-strings": "^2.2.2"
+  },
   "scripts": {
     "lint": "eslint src test tools",
     "test": "node tools/build && mocha",

src/Database.js

@@ -12,7 +12,7 @@ import path from 'path';
 // eslint-disable-next-line no-unused-vars,import/no-unresolved,import/extensions
 import sqlite3 from 'sqlite3'; // import sqlite3 for jsdoc type information only
 import Statement from './Statement';
-import prepareParams from './utils';
+import { resolveTemplateStringObject } from './utils';
 
 class Database {
   /**
@@ -50,8 +50,8 @@ class Database {
     this.driver.on(eventName, listener);
   }
 
-  run(sql) {
-    const params = prepareParams(arguments, { offset: 1 });
+  run() {
+    const { sql, params } = resolveTemplateStringObject(arguments);
     const Promise = this.Promise;
     return new Promise((resolve, reject) => {
       this.driver.run(sql, params, function runExecResult(err) {
@@ -67,8 +67,8 @@ class Database {
     });
   }
 
-  get(sql) {
-    const params = prepareParams(arguments, { offset: 1 });
+  get() {
+    const { sql, params } = resolveTemplateStringObject(arguments);
     return new this.Promise((resolve, reject) => {
       this.driver.get(sql, params, (err, row) => {
         if (err) {
@@ -80,8 +80,8 @@ class Database {
     });
   }
 
-  all(sql) {
-    const params = prepareParams(arguments, { offset: 1 });
+  all() {
+    const { sql, params } = resolveTemplateStringObject(arguments);
     return new this.Promise((resolve, reject) => {
       this.driver.all(sql, params, (err, rows) => {
         if (err) {
@@ -108,8 +108,8 @@ class Database {
     });
   }
 
-  each(sql) {
-    const params = prepareParams(arguments, { offset: 1, excludeLastArg: true });
+  each() {
+    const { sql, params } = resolveTemplateStringObject(arguments, { excludeLastArg: true });
     const callback = arguments[arguments.length - 1];
     return new this.Promise((resolve, reject) => {
       this.driver.each(sql, params, callback, (err, rowsCount = 0) => {
@@ -122,8 +122,8 @@ class Database {
     });
   }
 
-  prepare(sql) {
-    const params = prepareParams(arguments, { offset: 1 });
+  prepare() {
+    const { sql, params } = resolveTemplateStringObject(arguments);
     return new this.Promise((resolve, reject) => {
       const stmt = this.driver.prepare(sql, params, (err) => {
         if (err) {

src/Statement.js

@@ -7,7 +7,7 @@
  * LICENSE.txt file in the root directory of this source tree.
  */
 
-import prepareParams from './utils';
+import { prepareParams } from './utils';
 
 class Statement {
 

src/main.d.ts

@@ -1,3 +1,5 @@
+import { SQLStatement } from "sql-template-strings";
+
 declare module 'sqlite' {
   export interface Statement {
     readonly sql: string;
@@ -35,26 +37,33 @@ declare module 'sqlite' {
 
     run(sql: string): Promise<Statement>;
     run(sql: string, ...params: any[]): Promise<Statement>;
+    run(sql: SQLStatement): Promise<Statement>;
 
     get(sql: string): Promise<any>;
     get(sql: string, ...params: any[]): Promise<any>;
+    get(sql: SQLStatement): Promise<any>;
 
     get<T>(sql: string): Promise<T>;
     get<T>(sql: string, ...params: any[]): Promise<T>;
+    get<T>(sql: SQLStatement): Promise<T>;
 
     all(sql: string): Promise<any[]>;
     all(sql: string, ...params: any[]): Promise<any[]>;
+    all(sql: SQLStatement): Promise<any[]>;
 
     all<T>(sql: string): Promise<T[]>;
     all<T>(sql: string, ...params: any[]): Promise<T[]>;
+    all<T>(sql: SQLStatement): Promise<T[]>;
 
     exec(sql: string): Promise<Database>;
 
     each(sql: string, callback?: (err: Error, row: any) => void): Promise<number>;
     each(sql: string, ...params: any[]): Promise<number>;
+    each(sql: SQLStatement, callback?: (err: Error, row: any) => void): Promise<number>;
 
     prepare(sql: string): Promise<Statement>;
     prepare(sql: string, ...params: any[]): Promise<Statement>;
+    prepare(sql: SQLStatement): Promise<Statement>;
 
     configure(option: "busyTimeout", value: number): void;
     configure(option: string, value: any): void;

src/utils.js

@@ -5,12 +5,24 @@
  * LICENSE.txt file in the root directory of this source tree.
  */
 
-function prepareParams(args, { offset = 0, excludeLastArg = false } = {}) {
+export function prepareParams(args, { offset = 0, excludeLastArg = false } = {}) {
   const hasOneParam = (args.length === (offset + 1 + (excludeLastArg ? 1 : 0)));
   if (hasOneParam) {
     return args[offset];
   }
   return Array.prototype.slice.call(args, offset, args.length - (excludeLastArg ? 1 : 0));
 }
 
-export default prepareParams;
+export function resolveTemplateStringObject(args, { offset = 0, excludeLastArg = false } = {}) {
+  const hasOneParam = (args.length === (offset + 1 + (excludeLastArg ? 1 : 0)));
+  if (hasOneParam && typeof args[offset] === 'object') {
+    return {
+      sql: args[offset].sql,
+      params: args[offset].values,
+    };
+  }
+  return {
+    sql: args[offset],
+    params: prepareParams(args, { offset: offset + 1, excludeLastArg }),
+  };
+}

test/spec.js

@@ -9,6 +9,7 @@
 
 const db = require('../build/main');
 const expect = require('chai').expect;
+const SQL = require('sql-template-strings');
 
 // enable the sqlite cached database or not
 const cache = [false, true];
@@ -150,6 +151,37 @@ it('Should handle BLOBs', (done) => {
   p.then(done, done);
 });
 
+it('Should work with sql-template-strings', (done) => {
+  let p = db.open(':memory:');
+  const value1 = 'test';
+  const value2 = 'foo';
+  p = p.then(() => db.exec('CREATE TABLE tbl (col TEXT)'));
+  p = p.then(() => db.run(SQL`INSERT INTO tbl VALUES (${value1})`));
+  p = p.then(() => db.get(SQL`SELECT col FROM tbl`).then((result) => {
+    expect(result).to.be.deep.equal({ col: value1 });
+  }));
+  p = p.then(() => db.all(SQL`SELECT col FROM tbl`).then((result) => {
+    expect(result).to.be.deep.equal([{ col: value1 }]);
+  }));
+  p = p.then(() => db.all(SQL`SELECT * FROM tbl WHERE col = ${value1}`).then((result) => {
+    expect(result).to.have.length(1);
+  }));
+  p = p.then(() => db.prepare(SQL`UPDATE tbl SET col = ${value2} WHERE col = ${value1}`)).then(s => s.run().then((stmt) => {
+    // Cannot use deep equals because stmt is a Statement instance
+    expect(stmt.lastID).to.equal(1);
+    expect(stmt.changes).to.equal(1);
+    expect(stmt.sql).to.equal('UPDATE tbl SET col = ? WHERE col = ?');
+    return stmt.finalize();
+  }));
+  p = p.then(() => db.each(SQL`SELECT col FROM tbl`, (err, result) => {
+    expect(result).to.be.deep.equal({ col: value2 });
+  }).then((rowsCount) => {
+    expect(rowsCount).to.equal(1);
+  }));
+  p = p.then(() => db.close());
+  p.then(done, done);
+});
+
 it('Should migrate the database', (done) => {
   let p = db.open(':memory:');
   p = p.then(() => db.migrate());