feat: add sql.with(sequelize).escape/values/literal/query

Author: jedwards1211

README.md

@@ -102,6 +102,9 @@ Good for conditionally including a SQL clause (see examples above)
 #### `Sequelize.literal(...)`
 Text will be included as-is
 
+#### Arrays of `values` tagged template literals
+Will be included as-is joined by commas.
+
 #### All other values
 Will be added to bind parameters.
 
@@ -127,11 +130,68 @@ Good for conditionally including a SQL clause (see examples above)
 #### `Sequelize.literal(...)`
 Text will be included as-is
 
+#### Arrays of `values` tagged template literals
+Will be included as-is joined by commas.
+
 #### All other values
 Will be escaped with `QueryGenerator.escape(...)`.  If none of the expressions
-is a Sequelize `Model` class or attribute (or nested `` sql`query` `` containing
-such) then an error will be thrown.
+is a Sequelize `Model` class, attribute, `Sequelize` instance, or nested `` sql`query` `` containing
+such, then an error will be thrown.
 
 ### Returns (`string`)
 
 The raw SQL.
+
+## `sql.with(sequelize)`
+
+Returns an interface using the `QueryGenerator` from the given `Sequelize` instance.
+The returned interface has the following tagged template literals:
+
+#### `` escape`query` ``
+
+Just like `sql.escape`, but doesn't require any of the expressions to be a Sequelize `Model` class
+or attribute.
+
+#### `` values`sql` ``
+
+Used for building `VALUES` lists.  Only works inside an array expression.
+The items will be included as-is joined by commas.  For example:
+
+```js
+const users = [
+  {name: 'Jim', birthday: 'Jan 1 2020'},
+  {name: 'Bob', birthday: 'Jan 2 1986'},
+]
+const {escape, values} = sql.with(sequelize)
+escape`
+INSERT INTO ${User}
+  ${User.attributes.name}, ${User.attributes.birthday}
+  VALUES ${users.map(({name, birthday}) => values`(${name}, ${birthday})`)}
+`
+// returns `INSERT INTO "Users" "name", "birthday" VALUES ('Jim', 'Jan 1 2020'), ('Bob', 'Jan 2 1986')`
+```
+
+#### `` literal`sql` ``
+
+Like `sql.escape`, but wraps the escaped SQL in `Sequelize.literal`.
+
+#### `` query`sql` ``
+
+Returns a function that executes the query.  Example:
+
+```js
+const Sequelize = require('sequelize')
+const sql = require('@jcoreio/sequelize-sql-tag')
+const sequelize = new Sequelize('test', 'test', 'test', { dialect: 'postgres', logging: false })
+
+const User = sequelize.define('User', {
+  name: {type: Sequelize.STRING},
+})
+
+async function insertUser(user) {
+  const {query} = sql.with(sequelize)
+  await query`
+    INSERT INTO ${User} ${User.attributes.name} VALUES (${user.name});
+  `({transaction})
+}
+```

src/index.js

@@ -8,6 +8,21 @@ const Literal = Object.getPrototypeOf(Sequelize.literal('foo')).constructor
 const sqlOutput = Symbol('sqlOutput')
 const queryGeneratorSymbol = Symbol('queryGenerator')
 
+class ValuesRow {
+  value: string
+  constructor(value: string) {
+    this.value = value
+  }
+}
+
+function isValuesArray(expression: any): boolean {
+  if (!Array.isArray(expression)) return false
+  for (let i = 0; i < expression.length; i++) {
+    if (!(expression[i] instanceof ValuesRow)) return false
+  }
+  return true
+}
+
 function sql(
   strings: $ReadOnlyArray<string>,
   ...expressions: $ReadOnlyArray<mixed>
@@ -20,6 +35,8 @@ function sql(
     const expression = expressions[i]
     if (expression instanceof Literal) {
       parts.push(expression.val)
+    } else if (isValuesArray(expression)) {
+      parts.push((expression: any).map(row => row.value).join(', '))
     } else if (expression instanceof Object && expression[sqlOutput]) {
       const [query, options] = expression
       parts.push(query.replace(/(\$+)(\d+)/g, (match: string, dollars: string, index: string) =>
@@ -57,45 +74,93 @@ function findQueryGenerator(expressions: $ReadOnlyArray<mixed>): QueryGenerator
       return (expression: any).QueryGenerator
     } else if (expression && expression.type instanceof Sequelize.ABSTRACT) {
       return (expression: any).Model.QueryGenerator
+    } else if (expression instanceof Sequelize) {
+      return expression.getQueryInterface().QueryGenerator
     }
   }
-  throw new Error(`at least one of the expressions must be a sequelize Model or attribute`)
+  throw new Error(`at least one of the expressions must be a sequelize Model, attribute, or Sequelize instance`)
+}
+
+const once = <F: Function>(fn: F): F => {
+  let called = false
+  let result: any
+  return ((): any => {
+    if (called) return result
+    called = true
+    return result = fn()
+  }: any)
 }
 
-sql.escape = function escapeSql(
+const escapeSql = (
+  queryGenerator: () => QueryGenerator,
+) => (
   strings: $ReadOnlyArray<string>,
   ...expressions: $ReadOnlyArray<mixed>
-): string {
+): string => {
   const parts: Array<string> = []
-  let queryGenerator: ?QueryGenerator
-  function getQueryGenerator(): QueryGenerator {
-    return queryGenerator || (queryGenerator = findQueryGenerator(expressions))
-  }
-
   for (let i = 0, {length} = expressions; i < length; i++) {
     parts.push(strings[i])
     const expression = expressions[i]
     if (expression instanceof Literal) {
       parts.push(expression.val)
+    } else if (isValuesArray(expression)) {
+      parts.push((expression: any).map(row => row.value).join(', '))
     } else if (expression instanceof Object && expression[sqlOutput]) {
       const [query, options] = expression
       parts.push(query.replace(/(\$+)(\d+)/g, (match: string, dollars: string, index: string) =>
         dollars.length % 2 === 0
           ? match
-          : getQueryGenerator().escape(options.bind[parseInt(index) - 1])
+          : queryGenerator().escape(options.bind[parseInt(index) - 1])
       ))
     } else if (expression && expression.prototype instanceof Model) {
       const {tableName} = (expression: any)
-      parts.push(getQueryGenerator().quoteTable(tableName))
+      parts.push(queryGenerator().quoteTable(tableName))
     } else if (expression && expression.type instanceof Sequelize.ABSTRACT) {
       const {field} = (expression: any)
-      parts.push(getQueryGenerator().quoteIdentifier(field))
+      parts.push(queryGenerator().quoteIdentifier(field))
     } else {
-      parts.push(getQueryGenerator().escape(expression))
+      parts.push(queryGenerator().escape(expression))
     }
   }
   parts.push(strings[expressions.length])
-  return parts.join('').trim().replace(/\s+/g, ' ')
+  return parts.join('').trim()
 }
 
+sql.escape = (
+  strings: $ReadOnlyArray<string>,
+  ...expressions: $ReadOnlyArray<mixed>
+): string => escapeSql(once(() => findQueryGenerator(expressions)))(strings, ...expressions)
+
+sql.literal = (
+  strings: $ReadOnlyArray<string>,
+  ...expressions: $ReadOnlyArray<mixed>
+): Literal => Sequelize.literal(escapeSql(once(() => findQueryGenerator(expressions)))(strings, ...expressions))
+
+sql.with = (
+  sequelize: Sequelize
+) => ({
+  escape: (
+    strings: $ReadOnlyArray<string>,
+    ...expressions: $ReadOnlyArray<mixed>
+  ): string => escapeSql(() => sequelize.getQueryInterface().QueryGenerator)(strings, ...expressions),
+  values: (
+    strings: $ReadOnlyArray<string>,
+    ...expressions: $ReadOnlyArray<mixed>
+  ): ValuesRow => new ValuesRow(escapeSql(() => sequelize.getQueryInterface().QueryGenerator)(strings, ...expressions)),
+  literal: (
+    strings: $ReadOnlyArray<string>,
+    ...expressions: $ReadOnlyArray<mixed>
+  ): Literal => Sequelize.literal(escapeSql(() => sequelize.getQueryInterface().QueryGenerator)(strings, ...expressions)),
+  query: (
+    strings: $ReadOnlyArray<string>,
+    ...expressions: $ReadOnlyArray<mixed>
+  ) => (options: QueryOptions = {}): Promise<any> => {
+    const [query, baseOptions] = sql(strings, ...expressions)
+    return sequelize.query(
+      query,
+      {...baseOptions, ...options}
+    )
+  }
+})
+
 module.exports = sql

test/index.js

@@ -7,14 +7,14 @@ import {expect} from 'chai'
 import sql from '../src'
 
 describe(`sql`, function () {
-  it(`works`, function () {
-    const sequelize = new Sequelize('test', 'test', 'test', {dialect: 'postgres'})
+  const sequelize = new Sequelize('test', 'test', 'test', {dialect: 'postgres'})
 
-    const User = sequelize.define('User', {
-      name: {type: Sequelize.STRING},
-      birthday: {type: Sequelize.DATE},
-    })
+  const User = sequelize.define('User', {
+    name: {type: Sequelize.STRING},
+    birthday: {type: Sequelize.DATE},
+  })
 
+  it(`works`, function () {
     expect(sql`
 SELECT ${User.attributes.name} ${Sequelize.literal('FROM')} ${User}
 WHERE ${User.attributes.birthday} = ${new Date('2346-7-11')} AND
@@ -27,6 +27,22 @@ WHERE ${User.attributes.birthday} = ${new Date('2346-7-11')} AND
   it(`handles escaped $ in nested templates properly`, function () {
     expect(sql`SELECT ${sql`'$$1'`}`).to.deep.equal([`SELECT '$$1'`, {bind: []}])
   })
+  it(`works with nested sql.literal`, function () {
+    expect(sql`SELECT ${sql.with(sequelize).literal`${'foo'}`} FROM ${User}`).to.deep.equal([`SELECT 'foo' FROM "Users"`, {bind: []}])
+  })
+  it(`works with nested .values`, function () {
+    const {values} = sql.with(sequelize)
+    const users = [
+      {name: 'Jim', birthday: 'Jan 1 2020'},
+      {name: 'Bob', birthday: 'Jan 2 1986'},
+    ]
+    expect(sql`
+    INSERT INTO ${User}
+      ${User.attributes.name}, ${User.attributes.birthday}
+      VALUES ${users.map(({name, birthday}) => values`(${name}, ${birthday})`)}
+    `).to.deep.equal([
+      `INSERT INTO "Users" "name", "birthday" VALUES ('Jim', 'Jan 1 2020'), ('Bob', 'Jan 2 1986')`, {bind: []}])
+  })
 })
 
 describe(`sql.escape`, function () {
@@ -43,10 +59,13 @@ SELECT ${User.attributes.id} ${Sequelize.literal('FROM')} ${User}
 WHERE ${User.attributes.name} LIKE ${'and%'} AND
   ${sql`${User.attributes.name} LIKE ${'a%'} AND`}${sql``}
   ${User.attributes.id} = ${1}
-    `).to.deep.equal(`SELECT "id" FROM "Users" WHERE "name" LIKE 'and%' AND "name" LIKE 'a%' AND "id" = 1`)
+    `).to.deep.equal(`SELECT "id" FROM "Users"
+WHERE "name" LIKE 'and%' AND
+  "name" LIKE 'a%' AND
+  "id" = 1`)
   })
   it(`throws if it can't get a QueryGenerator`, function () {
-    expect(() => sql.escape`SELECT ${1} + ${2};`).to.throw(Error, 'at least one of the expressions must be a sequelize Model or attribute')
+    expect(() => sql.escape`SELECT ${1} + ${2};`).to.throw(Error, 'at least one of the expressions must be a sequelize Model, attribute, or Sequelize instance')
   })
   it(`can get QueryGenerator from Sequelize Model class`, function () {
     const sequelize = new Sequelize('test', 'test', 'test', {dialect: 'postgres'})
@@ -71,4 +90,35 @@ WHERE ${User.attributes.name} LIKE ${'and%'} AND
 
     expect(sql.escape`SELECT ${'foo'} FROM ${sql`${User}`}`).to.deep.equal(`SELECT 'foo' FROM "Users"`)
   })
+  describe(`.with`, function () {
+    const sequelize = new Sequelize('test', 'test', 'test', {dialect: 'postgres'})
+
+    describe(`.escape`, function () {
+      it(`works`, function () {
+        expect(sql.with(sequelize).escape`SELECT LOWER(${'foo'});`).to.deep.equal(`SELECT LOWER('foo');`)
+      })
+      it(`works in conjunction with .values`, function () {
+        const items = [
+          {foo: 1, bar: {hello: 'world'}},
+          {foo: 3, bar: 'baz'},
+        ]
+        const {escape, values} = sql.with(sequelize)
+        expect(escape`SELECT VALUES ${items.map(({foo, bar}) => values`(${foo}, ${JSON.stringify(bar)}::jsonb)`)}`)
+          .to.equal(`SELECT VALUES (1, '{"hello":"world"}'::jsonb), (3, '"baz"'::jsonb)`)
+      })
+    })
+    describe(`.query`, function () {
+      it(`works`, function () {
+        const calls = []
+        const _sequelize: any = {query: (...args: any) => {
+          calls.push(args)
+          return Promise.resolve()
+        }, getQueryInterface(): any {return sequelize.getQueryInterface()}}
+        expect(sql.with(_sequelize).query`SELECT LOWER(${'foo'});`({test: 'bar'})).to.be.an.instanceOf(Promise)
+        expect(calls).to.deep.equal([
+          ['SELECT LOWER($1);', {bind: ['foo'], test: 'bar'}]
+        ])
+      })
+    })
+  })
 })