@platformatic/sql-mapper 0.7.0 → 0.9.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,7 +100,7 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
   return { keys, values }
 }
 
-async function updateMany (db, sql, table, criteria, input, fieldsToRetrieve) {
+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}`

package/lib/queries/sqlite.js

@@ -4,11 +4,12 @@ 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
@@ -37,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'
     })
   }
@@ -67,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`, `
@@ -97,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]
@@ -116,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]
@@ -140,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)}

package/lib/utils.js

@@ -3,12 +3,49 @@
 const { singularize } = require('inflected')
 const camelcase = require('camelcase')
 
+function toUpperFirst (str) {
+  return str[0].toUpperCase() + str.slice(1)
+}
+
 function toSingular (str) {
   str = camelcase(singularize(str))
-  str = str[0].toUpperCase() + str.slice(1)
+  str = toUpperFirst(str)
   return str
 }
 
+/**
+ * If limit is not defined or invalid
+ * let's set a safe default value preventing to load huge amount of data in memory
+ */
+function sanitizeLimit (unsafeLimit, conf) {
+  const defaultLimit = conf?.default ?? 10
+  const limit = (unsafeLimit !== undefined) ? unsafeLimit : defaultLimit
+  const max = conf?.max ?? 100
+
+  if (limit > max) {
+    throw new Error(`Param limit=${limit} not allowed. Max accepted value ${max}.`)
+  }
+
+  if (limit < 0) {
+    throw new Error(`Param limit=${limit} not allowed. It must be not negative value.`)
+  }
+
+  return limit
+}
+
+function tableName (sql, table, schema) {
+  /* istanbul ignore next */
+  return schema ? sql.ident(schema, table) : sql.ident(table)
+}
+
+function areSchemasSupported (sql) {
+  return !sql.isSQLite
+}
+
 module.exports = {
-  toSingular
+  toSingular,
+  toUpperFirst,
+  sanitizeLimit,
+  tableName,
+  areSchemasSupported
 }

package/mapper.d.ts

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

package/mapper.js

@@ -1,12 +1,11 @@
-'use strict'
-
 const buildEntity = require('./lib/entity')
 const queriesFactory = require('./lib/queries')
 const fp = require('fastify-plugin')
+const { areSchemasSupported } = require('./lib/utils')
 
 // 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 +33,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, limit = {} }) {
   // TODO validate config using the schema
   if (!connectionString) {
     throw new Error('connectionString is required')
@@ -87,6 +87,11 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
     throw new Error('You must specify either postgres, mysql or sqlite as protocols')
   }
 
+  // Specify an empty array must be the same of specifying no schema
+  /* istanbul ignore next */ // Ignoring because this won't be fully covered by DB not supporting schemas (SQLite)
+  const schemaList = areSchemasSupported(db) && schema?.length > 0 ? schema : null
+  const useSchema = !!schemaList
+
   const entities = {}
 
   try {
@@ -95,9 +100,9 @@ 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)
 
-    for (const table of tables) {
+    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,13 +112,14 @@ 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, useSchema, ignore[table] || {}, limit)
       // 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 Error(`Cannot find any primary keys for ${entity.name} entity`)
       }
+
       entities[entity.singularName] = entity
+
       if (hooks[entity.name]) {
         addEntityHooks(entity.singularName, hooks[entity.name])
       } else if (hooks[entity.singularName]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "repository": {
@@ -18,7 +18,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.24.0"
+    "tsd": "^0.25.0"
   },
   "dependencies": {
     "@databases/mysql": "^5.2.0",

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, isPg } = 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 (
@@ -638,3 +666,54 @@ test('include possible values of enum columns', { skip: isSQLite }, async ({ sam
   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' },