@platformatic/sql-mapper 0.6.1 → 0.8.0

package/lib/queries/shared.js

@@ -1,12 +1,14 @@
 'use strict'
 
+const { tableName } = require('../utils')
+
 /* istanbul ignore file */
 
-async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRetrieve) {
+async function insertOne (db, sql, table, schema, input, primaryKeysTypes, fieldsToRetrieve) {
   const inputKeys = Object.keys(input)
   if (inputKeys.length === 0) {
     const insert = sql`
-      INSERT INTO ${sql.ident(table)}
+      INSERT INTO ${tableName(sql, table, schema)}
       ()
       VALUES ()
       RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
@@ -24,7 +26,7 @@ async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRet
     sql`, `
   )
   const insert = sql`
-    INSERT INTO ${sql.ident(table)} (${keys})
+    INSERT INTO ${tableName(sql, table, schema)} (${keys})
     VALUES (${values})
     RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
   `
@@ -32,9 +34,9 @@ async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRet
   return res[0]
 }
 
-async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
+async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   let query = sql`
-      DELETE FROM ${sql.ident(table)}
+      DELETE FROM ${tableName(sql, table, schema)}
     `
 
   if (criteria.length > 0) {
@@ -46,10 +48,10 @@ async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
   return res
 }
 
-async function insertMany (db, sql, table, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields) {
+async function insertMany (db, sql, table, schema, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields) {
   const { keys, values } = insertPrep(inputs, inputToFieldMap, fields, sql)
   const insert = sql`
-    insert into ${sql.ident(table)} (${keys})
+    insert into ${tableName(sql, table, schema)} (${keys})
     values ${sql.join(values, sql`, `)}
     returning ${sql.join(fieldsToRetrieve, sql`, `)}
   `
@@ -75,7 +77,13 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
 
       inputSet.add(newKey)
 
-      const value = input[key] || input[newKey]
+      let value = input[key] || input[newKey]
+
+      if (value && typeof value === 'object' && !(value instanceof Date)) {
+        // This is a JSON field
+        value = JSON.stringify(value)
+      }
+
       inputValues.push(sql.value(value))
     }
 
@@ -92,9 +100,25 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
   return { keys, values }
 }
 
+async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map((key) => {
+    const value = input[key]
+    return sql`${sql.ident(key)} = ${value}`
+  })
+  const update = sql`
+    UPDATE ${sql.ident(table)}
+    SET ${sql.join(pairs, sql`, `)}
+    WHERE ${sql.join(criteria, sql` AND `)}
+    RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+    `
+  const res = await db.query(update)
+  return res
+}
+
 module.exports = {
   insertOne,
   insertPrep,
   deleteAll,
-  insertMany
+  insertMany,
+  updateMany
 }

package/lib/queries/sqlite.js

@@ -1,13 +1,15 @@
 'use strict'
 
 const { randomUUID } = require('crypto')
+const shared = require('./shared')
 
 async function listTables (db, sql) {
-  const tables = await db.query(sql`
+  const res = await db.query(sql`
     SELECT name FROM sqlite_master
     WHERE type='table'
   `)
-  return tables.map(t => t.name)
+  // sqlite has no schemas
+  return res.map(r => ({ schema: null, table: r.name }))
 }
 
 module.exports.listTables = listTables
@@ -36,13 +38,9 @@ async function listConstraints (db, sql, table) {
     WHERE pk > 0
   `)
 
-  if (pks.length > 1) {
-    throw new Error(`Table ${table} has ${pks.length} primary keys`)
-  }
-
-  if (pks.length === 1) {
+  for (const pk of pks) {
     constraints.push({
-      column_name: pks[0].name,
+      column_name: pk.name,
       constraint_type: 'PRIMARY KEY'
     })
   }
@@ -66,25 +64,38 @@ async function listConstraints (db, sql, table) {
 
 module.exports.listConstraints = listConstraints
 
-async function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRetrieve) {
-  const keysToSql = Object.keys(input).map((key) => sql.ident(key))
-  keysToSql.push(sql.ident(primaryKey))
+async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
+  const fieldNames = Object.keys(input)
+  const keysToSql = fieldNames.map((key) => sql.ident(key))
+  const valuesToSql = fieldNames.map((key) => sql.value(input[key]))
+
+  const primaryKeyValues = {}
+  let useUUID = false
+  const where = []
+  let autoIncrement = 0
+  for (const { key, sqlType } of primaryKeys) {
+    keysToSql.push(sql.ident(key))
+    // TODO figure out while this is not covered by tests
+    /* istanbul ignore next */
+    if (sqlType === 'uuid') {
+      useUUID = true
+      primaryKeyValues[key] = randomUUID()
+    } else if (autoIncrement > 1) {
+      throw new Error('SQLite only supports autoIncrement on one column')
+    } else if (input[key]) {
+      primaryKeyValues[key] = input[key]
+    } else {
+      autoIncrement++
+      primaryKeyValues[key] = null
+    }
+    valuesToSql.push(sql.value(primaryKeyValues[key]))
+  }
+
   const keys = sql.join(
     keysToSql,
     sql`, `
   )
 
-  const valuesToSql = Object.keys(input).map((key) => {
-    return sql.value(input[key])
-  })
-  let primaryKeyValue
-  // TODO add test for this
-  if (useUUID) {
-    primaryKeyValue = randomUUID()
-    valuesToSql.push(sql.value(primaryKeyValue))
-  } else {
-    valuesToSql.push(sql.value(null))
-  }
   const values = sql.join(
     valuesToSql,
     sql`, `
@@ -96,18 +107,22 @@ async function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRe
   `
   await db.query(insert)
 
-  if (!useUUID) {
+  if (!useUUID && primaryKeys.length === 1) {
     const res2 = await db.query(sql`
       SELECT last_insert_rowid()
     `)
 
-    primaryKeyValue = res2[0]['last_insert_rowid()']
+    primaryKeyValues[primaryKeys[0].key] = res2[0]['last_insert_rowid()']
+  }
+
+  for (const { key } of primaryKeys) {
+    where.push(sql`${sql.ident(key)} = ${sql.value(primaryKeyValues[key])}`)
   }
 
   const res = await db.query(sql`
     SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
     FROM ${sql.ident(table)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(primaryKeyValue)}
+    WHERE ${sql.join(where, sql` AND `)}
   `)
 
   return res[0]
@@ -115,23 +130,28 @@ async function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRe
 
 module.exports.insertOne = insertOne
 
-async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
+async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const pairs = Object.keys(input).map((key) => {
     const value = input[key]
     return sql`${sql.ident(key)} = ${value}`
   })
 
+  const where = []
+  for (const key of primaryKeys) {
+    where.push(sql`${sql.ident(key)} = ${input[key]}`)
+  }
+
   const update = sql`
     UPDATE ${sql.ident(table)}
     SET ${sql.join(pairs, sql`, `)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    WHERE ${sql.join(where, sql` AND `)}
   `
   await db.query(update)
 
   const select = sql`
     SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
     FROM ${sql.ident(table)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    WHERE ${sql.join(where, sql` AND `)}
   `
   const res = await db.query(select)
   return res[0]
@@ -139,7 +159,7 @@ async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
 
 module.exports.updateOne = updateOne
 
-async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
+async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   let query = sql`
     SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
     FROM ${sql.ident(table)}
@@ -167,3 +187,5 @@ async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
 }
 
 module.exports.deleteAll = deleteAll
+
+module.exports.updateMany = shared.updateMany

package/lib/utils.js

@@ -9,6 +9,12 @@ function toSingular (str) {
   return str
 }
 
+function tableName (sql, table, schema) {
+  /* istanbul ignore next */
+  return schema ? sql.ident(schema, table) : sql.ident(table)
+}
+
 module.exports = {
-  toSingular
+  toSingular,
+  tableName
 }

package/mapper.d.ts

@@ -94,6 +94,10 @@ export interface WhereCondition {
      * Not in values.
      */
     nin?: any[]
+    /**
+     * Like value.
+     */
+    like?: string
   }
 }
 

package/mapper.js

@@ -6,7 +6,7 @@ const fp = require('fastify-plugin')
 
 // Ignore the function as it is only used only for MySQL and PostgreSQL
 /* istanbul ignore next */
-async function buildConnection (log, createConnectionPool, connectionString, poolSize) {
+async function buildConnection (log, createConnectionPool, connectionString, poolSize, schema) {
   const db = await createConnectionPool({
     connectionString,
     bigIntMode: 'string',
@@ -34,12 +34,13 @@ async function buildConnection (log, createConnectionPool, connectionString, poo
           error: err.message
         }
       }, 'query error')
-    }
+    },
+    schema
   })
   return db
 }
 
-async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {} }) {
+async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema }) {
   // TODO validate config using the schema
   if (!connectionString) {
     throw new Error('connectionString is required')
@@ -49,10 +50,15 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
   let sql
   let db
 
+  // Specify an empty array must be the same of specifying no schema
+  const schemaList = schema?.length > 0 ? schema : null
+
   /* istanbul ignore next */
   if (connectionString.indexOf('postgres') === 0) {
     const createConnectionPoolPg = require('@databases/pg')
-    db = await buildConnection(log, createConnectionPoolPg, connectionString, poolSize)
+    // We pass schema here so @databases/pg set the schema in the search path. This is not stritly necessary, though,
+    // because now we use fully qualified names in all queries.
+    db = await buildConnection(log, createConnectionPoolPg, connectionString, poolSize, schemaList)
     sql = createConnectionPoolPg.sql
     queries = queriesFactory.pg
     db.isPg = true
@@ -95,9 +101,17 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       await onDatabaseLoad(db, sql)
     }
 
-    const tables = await queries.listTables(db, sql)
+    const tablesWithSchema = await queries.listTables(db, sql, schemaList)
+    const tables = tablesWithSchema.map(({ table }) => table)
+    const duplicates = tables.filter((table, index) => tables.indexOf(table) !== index)
 
-    for (const table of tables) {
+    // Ignored because this never happens in sqlite
+    /* istanbul ignore next */
+    if (duplicates.length > 0) {
+      throw new Error(`Conflicting table names: ${duplicates.join(', ')}`)
+    }
+
+    for (const { table, schema } of tablesWithSchema) {
       // The following line is a safety net when developing this module,
       // it should never happen.
       /* istanbul ignore next */
@@ -107,11 +121,10 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       if (ignore[table] === true) {
         continue
       }
-
-      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, ignore[table] || {})
+      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, schema, ignore[table] || {})
       // Check for primary key of all entities
-      if (!entity.primaryKey) {
-        throw new Error(`Cannot find primary key for ${entity.name} entity`)
+      if (entity.primaryKeys.size === 0) {
+        throw new Error(`Cannot find any primary keys for ${entity.name} entity`)
       }
       entities[entity.singularName] = entity
       if (hooks[entity.name]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "repository": {

package/test/composite.test.js

@@ -0,0 +1,162 @@
+'use strict'
+
+const { clear, connInfo, isSQLite, isMysql, isPg } = require('./helper')
+const { test } = require('tap')
+const { connect } = require('..')
+const fakeLogger = {
+  trace: () => {},
+  // trace: console.log,
+  error: () => {}
+}
+
+test('composite primary keys', async ({ equal, same, teardown, rejects }) => {
+  /* https://github.com/platformatic/platformatic/issues/299 */
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    if (isSQLite) {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        the_title VARCHAR(42)
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id INTEGER PRIMARY KEY,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT fk_editor_pages FOREIGN KEY (page_id) REFERENCES pages(id),
+        CONSTRAINT fk_editor_users FOREIGN KEY (user_id) REFERENCES users(id),
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    } else if (isPg) {
+      await db.query(sql`CREATE TABLE pages (
+        id SERIAL PRIMARY KEY,
+        the_title VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id SERIAL PRIMARY KEY,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT fk_editor_pages FOREIGN KEY (page_id) REFERENCES pages(id),
+        CONSTRAINT fk_editor_users FOREIGN KEY (user_id) REFERENCES users(id),
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    } else if (isMysql) {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY AUTO_INCREMENT,
+        the_title VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTO_INCREMENT,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT \`fk_editor_pages\` FOREIGN KEY (page_id) REFERENCES pages (id) ON DELETE CASCADE ON UPDATE RESTRICT,
+        CONSTRAINT \`fk_editor_users\` FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE ON UPDATE RESTRICT,
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const pageEntity = mapper.entities.page
+  const userEntity = mapper.entities.user
+  const editorEntity = mapper.entities.editor
+
+  const page = await pageEntity.save({
+    input: { theTitle: 'foobar' }
+  })
+  same(page, { id: '1', theTitle: 'foobar' })
+
+  const user = await userEntity.save({
+    input: { username: 'mcollina' }
+  })
+  same(user, { id: '1', username: 'mcollina' })
+
+  const user2 = await userEntity.save({
+    input: { username: 'lucamaraschi' }
+  })
+  same(user2, { id: '2', username: 'lucamaraschi' })
+
+  const editor1 = await editorEntity.save({
+    input: {
+      pageId: '1',
+      userId: '1',
+      role: 'admin'
+    }
+  })
+  same(editor1, { pageId: '1', userId: '1', role: 'admin' })
+
+  const editor2 = await editorEntity.save({
+    input: {
+      pageId: '1',
+      userId: '2',
+      role: 'author'
+    }
+  })
+  same(editor2, { pageId: '1', userId: '2', role: 'author' })
+
+  await editorEntity.save({
+    input: {
+      pageId: '1',
+      userId: '1',
+      role: 'captain'
+    }
+  })
+
+  const editors = await editorEntity.find({ orderBy: [{ field: 'userId', direction: 'ASC' }] })
+  same(editors, [{
+    pageId: '1',
+    userId: '1',
+    role: 'captain'
+  }, {
+    pageId: '1',
+    userId: '2',
+    role: 'author'
+  }])
+
+  await editorEntity.delete({})
+
+  const editorsInserted = await editorEntity.insert({
+    inputs: [{
+      pageId: '1',
+      userId: '1',
+      role: 'admin'
+    }, {
+      pageId: '1',
+      userId: '2',
+      role: 'author'
+    }]
+  })
+  same(editorsInserted, [{
+    pageId: '1',
+    userId: '1',
+    role: 'admin'
+  }, {
+    pageId: '1',
+    userId: '2',
+    role: 'author'
+  }])
+})

package/test/entity.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('tap')
 
-const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+const { clear, connInfo, isSQLite, isMysql, isPg, isMysql8 } = require('./helper')
 const { connect } = require('..')
 const fakeLogger = {
   trace: () => {},
@@ -38,12 +38,12 @@ test('entity fields', async ({ equal, not, same, teardown }) => {
   equal(pageEntity.name, 'Page')
   equal(pageEntity.singularName, 'page')
   equal(pageEntity.pluralName, 'pages')
-  equal(pageEntity.primaryKey, 'id')
+  same(pageEntity.primaryKeys, new Set(['id']))
   equal(pageEntity.table, 'pages')
   equal(pageEntity.camelCasedFields.id.primaryKey, true)
 })
 
-test('entity API', async ({ equal, same, teardown, rejects }) => {
+test('entity API', { only: true }, async ({ equal, same, teardown, rejects }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
     teardown(() => db.dispose())
@@ -168,6 +168,33 @@ test('empty save', async ({ equal, same, teardown, rejects }) => {
   same(insertResult, { id: '1', theTitle: null })
 })
 
+test('insert with explicit PK value', async ({ same, teardown }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+    await db.query(sql`CREATE TABLE pages (
+      id INTEGER PRIMARY KEY,
+      title varchar(255) NOT NULL
+    );`)
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const pageEntity = mapper.entities.page
+  const [newPage] = await pageEntity.insert({
+    fields: ['id', 'title'],
+    inputs: [{ id: 13, title: '13th page with explicit id equal to 13' }]
+  })
+  same(newPage, {
+    id: '13',
+    title: '13th page with explicit id equal to 13'
+  })
+})
+
 test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equal }) => {
   const mapper = await connect({
     connectionString: connInfo.connectionString,
@@ -186,6 +213,7 @@ test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equa
       );`)
     }
   })
+  teardown(() => mapper.db.dispose())
 
   const pageEntity = mapper.entities.page
 
@@ -216,7 +244,7 @@ test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equa
   }
 })
 
-test('[sqlite] throws if PK is not INTEGER', { skip: !isSQLite }, async ({ fail, equal, teardown, rejects }) => {
+test('[SQLite] throws if PK is not INTEGER', { skip: !isSQLite }, async ({ fail, equal, teardown, rejects }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
     await db.query(sql`CREATE TABLE pages (
@@ -604,3 +632,88 @@ test('include all fields', async ({ pass, teardown, same, equal }) => {
     }])
   }
 })
+
+test('include possible values of enum columns', { skip: isSQLite }, async ({ same, teardown }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    if (isPg) {
+      await db.query(sql`
+      CREATE TYPE pagetype as enum ('blank', 'non-blank');
+      CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        title VARCHAR(42),
+        type pagetype
+      );`)
+    } else {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        title VARCHAR(42),
+        type ENUM ('blank', 'non-blank')
+      );
+      `)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const pageEntity = mapper.entities.page
+  const typeField = pageEntity.fields.type
+  same(typeField.enum, ['blank', 'non-blank'])
+})
+
+test('JSON type', { skip: !(isPg || isMysql8) }, async ({ teardown, same, equal, pass }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE TABLE simple_types (
+        id SERIAL PRIMARY KEY,
+        config json NOT NULL
+      );`)
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+
+  const simpleType = mapper.entities.simpleType
+
+  // save - new record
+  same(await simpleType.save({
+    input: { config: { foo: 'bar' } }
+  }), { id: 1, config: { foo: 'bar' } })
+
+  // save - update
+  same(await simpleType.save({
+    input: { id: 1, config: { foo: 'bar', bar: 'foo' } }
+  }), { id: 1, config: { foo: 'bar', bar: 'foo' } })
+
+  // insert
+  same(await simpleType.insert({
+    inputs: [{ config: { foo: 'bar' } }]
+  }), [{ id: 2, config: { foo: 'bar' } }])
+
+  // updateMany
+  same(await simpleType.updateMany({
+    where: {
+      id: {
+        eq: 2
+      }
+    },
+    input: {
+      config: {
+        foo: 'bar',
+        bar: 'foo'
+      }
+    }
+  }), [{ id: 2, config: { foo: 'bar', bar: 'foo' } }])
+})

package/test/entity_transaction.test.js

@@ -42,7 +42,6 @@ test('entity transactions', async ({ equal, same, teardown, rejects }) => {
     same(findResult, [{ title: 'foo' }, { title: 'bar' }])
 
     try {
-      console.log('isSQLite', mapper.db.isSQLite)
       await mapper.db.tx(async tx => {
         same(await pageEntity.save({
           input: { title: 'new page' },