@platformatic/sql-mapper 0.45.1 → 0.46.2

package/test/entity_transaction.test.js

@@ -1,132 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { clear, connInfo, isSQLite } = require('./helper')
-const { connect } = require('..')
-
-const fakeLogger = {
-  trace: () => {},
-  error: () => {}
-}
-
-test('entity transactions', async ({ equal, same, teardown, rejects }) => {
-  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,
-        title VARCHAR(42)
-      );`)
-    } else {
-      await db.query(sql`CREATE TABLE pages (
-        id SERIAL PRIMARY KEY,
-        title VARCHAR(255) NOT NULL
-      );`)
-    }
-    await db.query(sql`INSERT INTO pages (title) VALUES ('foo')`)
-    await db.query(sql`INSERT INTO pages (title) VALUES ('bar')`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {},
-    hooks: {}
-  })
-  const pageEntity = mapper.entities.page
-
-  // insert + rollback
-  {
-    const findResult = await pageEntity.find({ fields: ['title'] })
-    same(findResult, [{ title: 'foo' }, { title: 'bar' }])
-
-    try {
-      await mapper.db.tx(async tx => {
-        same(await pageEntity.save({
-          input: { title: 'new page' },
-          fields: ['title'],
-          tx
-        }), { title: 'new page' })
-        const findResult = await pageEntity.find({ fields: ['title'], tx })
-        same(findResult, [{ title: 'foo' }, { title: 'bar' }, { title: 'new page' }])
-        throw new Error('rollback')
-      })
-    } catch (e) {
-      // rollback
-    }
-
-    const afterRollback = await pageEntity.find({ fields: ['title'] })
-    same(afterRollback, [{ title: 'foo' }, { title: 'bar' }])
-  }
-
-  // update + rollback
-  {
-    const findResult = await pageEntity.find({ fields: ['id', 'title'], where: { id: { eq: 1 } } })
-    same(findResult, [{ id: 1, title: 'foo' }])
-
-    try {
-      await mapper.db.tx(async tx => {
-        same(await pageEntity.save({
-          input: { id: 1, title: 'changed' },
-          fields: ['id', 'title'],
-          tx
-        }), { id: 1, title: 'changed' })
-        const findResult = await pageEntity.find({ fields: ['id', 'title'], where: { id: { eq: 1 } }, tx })
-        same(findResult, [{ id: 1, title: 'changed' }])
-        throw new Error('rollback')
-      })
-    } catch (e) {
-      // rollback
-    }
-    const afterRollback = await pageEntity.find({ fields: ['id', 'title'], where: { id: { eq: 1 } } })
-    same(afterRollback, [{ id: 1, title: 'foo' }])
-  }
-
-  // delete
-  {
-    const findResult = await pageEntity.find({ fields: ['title'] })
-    same(findResult, [{ title: 'foo' }, { title: 'bar' }])
-
-    try {
-      await mapper.db.tx(async tx => {
-        same(await pageEntity.delete({
-          where: {
-            id: { eq: 1 }
-          },
-          tx
-        }), [{ id: 1, title: 'foo' }])
-        const findResult = await pageEntity.find({ fields: ['id', 'title'], where: { id: { eq: 1 } }, tx })
-        same(findResult, [])
-        throw new Error('rollback')
-      })
-    } catch (e) {
-      // rollback
-    }
-    const afterRollback = await pageEntity.find({ fields: ['title'] })
-    same(afterRollback, [{ title: 'foo' }, { title: 'bar' }])
-  }
-
-  // count
-  {
-    const countResult = await pageEntity.count()
-    same(countResult, 2)
-    try {
-      await mapper.db.tx(async tx => {
-        same(await pageEntity.save({
-          input: { title: 'new page' },
-          fields: ['title'],
-          tx
-        }), { title: 'new page' })
-        const countResult = await pageEntity.count({ tx })
-        same(countResult, 3)
-        throw new Error('rollback')
-      })
-    } catch (e) {
-      // rollback
-    }
-
-    const afterRollback = await pageEntity.count()
-    same(afterRollback, 2)
-  }
-})

package/test/helper.js

@@ -1,112 +0,0 @@
-'use strict'
-
-// Needed to work with dates & postgresql
-// See https://node-postgres.com/features/types/
-process.env.TZ = 'UTC'
-
-const connInfo = {
-  autoTimestamp: {
-    createdAt: 'inserted_at',
-    updatedAt: 'updated_at'
-  }
-}
-
-if (!process.env.DB || process.env.DB === 'postgresql') {
-  connInfo.connectionString = 'postgres://postgres:postgres@127.0.0.1/postgres'
-  module.exports.isPg = true
-} else if (process.env.DB === 'mariadb') {
-  connInfo.connectionString = 'mysql://root@127.0.0.1:3307/graph'
-  connInfo.poolSize = 10
-  module.exports.isMysql = true
-} else if (process.env.DB === 'mysql') {
-  connInfo.connectionString = 'mysql://root@127.0.0.1/graph'
-  connInfo.poolSize = 10
-  module.exports.isMysql = true
-} else if (process.env.DB === 'mysql8') {
-  connInfo.connectionString = 'mysql://root@127.0.0.1:3308/graph'
-  connInfo.poolSize = 10
-  module.exports.isMysql = true
-  module.exports.isMysql8 = true
-} else if (process.env.DB === 'sqlite') {
-  connInfo.connectionString = 'sqlite://:memory:'
-  module.exports.isSQLite = true
-}
-
-module.exports.connInfo = connInfo
-
-module.exports.clear = async function (db, sql) {
-  try {
-    await db.query(sql`DROP TABLE graphs`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE editors`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE pages`)
-  } catch (err) {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE comments`)
-  } catch (err) {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE categories`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE posts`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE simple_types`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE owners`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE users`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE versions`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TYPE pagetype`)
-  } catch {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE test1.pages`)
-  } catch (err) {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE test2.users`)
-  } catch (err) {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE test2.pages`)
-  } catch (err) {
-  }
-
-  try {
-    await db.query(sql`DROP TABLE generated_test`)
-  } catch (err) {
-  }
-}

package/test/hooks.test.js

@@ -1,325 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { connect } = require('..')
-const { clear, connInfo, isSQLite } = require('./helper')
-const fakeLogger = {
-  trace: () => {},
-  error: () => {}
-}
-
-test('basic hooks', async ({ pass, teardown, same, equal, plan, fail }) => {
-  plan(14)
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-
-      if (isSQLite) {
-        await db.query(sql`CREATE TABLE pages (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      } else {
-        await db.query(sql`CREATE TABLE pages (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      }
-    },
-    hooks: {
-      Page: {
-        noKey () {
-          fail('noKey should never be called')
-        },
-        async save (original, { input, ctx, fields }) {
-          pass('save  called')
-
-          if (!input.id) {
-            same(input, {
-              title: 'Hello'
-            })
-
-            return original({
-              input: {
-                title: 'Hello from hook'
-              },
-              fields
-            })
-          } else {
-            same(input, {
-              id: 1,
-              title: 'Hello World'
-            })
-
-            return original({
-              input: {
-                id: 1,
-                title: 'Hello from hook 2'
-              },
-              fields
-            })
-          }
-        },
-        async find (original, args) {
-          pass('find called')
-
-          same(args.where, {
-            id: {
-              eq: '1'
-            }
-          })
-          args.where = {
-            id: {
-              eq: '2'
-            }
-          }
-          same(args.fields, ['id', 'title'])
-          return original(args)
-        },
-        async insert (original, args) {
-          pass('insert called')
-
-          same(args.inputs, [{
-            title: 'hello'
-          }, {
-            title: 'world'
-          }])
-          same(args.fields, ['id', 'title'])
-          return original(args)
-        }
-      }
-    }
-  })
-
-  const entity = mapper.entities.page
-
-  same(await entity.save({ input: { title: 'Hello' } }), {
-    id: 1,
-    title: 'Hello from hook'
-  })
-
-  same(await entity.find({ where: { id: { eq: 1 } }, fields: ['id', 'title'] }), [])
-
-  same(await entity.save({ input: { id: 1, title: 'Hello World' } }), {
-    id: 1,
-    title: 'Hello from hook 2'
-  })
-
-  await entity.insert({ inputs: [{ title: 'hello' }, { title: 'world' }], fields: ['id', 'title'] })
-})
-
-test('addEntityHooks', async ({ pass, teardown, same, equal, plan, fail, throws }) => {
-  plan(15)
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-
-      if (isSQLite) {
-        await db.query(sql`CREATE TABLE pages (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      } else {
-        await db.query(sql`CREATE TABLE pages (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      }
-    }
-  })
-
-  throws(() => mapper.addEntityHooks('user', {}), 'Cannot find entity user')
-
-  mapper.addEntityHooks('page', {
-    noKey () {
-      fail('noKey should never be called')
-    },
-    async save (original, { input, ctx, fields }) {
-      pass('save  called')
-
-      if (!input.id) {
-        same(input, {
-          title: 'Hello'
-        })
-
-        return original({
-          input: {
-            title: 'Hello from hook'
-          },
-          fields
-        })
-      } else {
-        same(input, {
-          id: 1,
-          title: 'Hello World'
-        })
-
-        return original({
-          input: {
-            id: 1,
-            title: 'Hello from hook 2'
-          },
-          fields
-        })
-      }
-    },
-    async find (original, args) {
-      pass('find called')
-
-      same(args.where, {
-        id: {
-          eq: '1'
-        }
-      })
-      args.where = {
-        id: {
-          eq: '2'
-        }
-      }
-      same(args.fields, ['id', 'title'])
-      return original(args)
-    },
-    async insert (original, args) {
-      pass('insert called')
-
-      same(args.inputs, [{
-        title: 'hello'
-      }, {
-        title: 'world'
-      }])
-      same(args.fields, ['id', 'title'])
-      return original(args)
-    }
-  })
-
-  const entity = mapper.entities.page
-
-  same(await entity.save({ input: { title: 'Hello' } }), {
-    id: 1,
-    title: 'Hello from hook'
-  })
-
-  same(await entity.find({ where: { id: { eq: 1 } }, fields: ['id', 'title'] }), [])
-
-  same(await entity.save({ input: { id: 1, title: 'Hello World' } }), {
-    id: 1,
-    title: 'Hello from hook 2'
-  })
-
-  await entity.insert({ inputs: [{ title: 'hello' }, { title: 'world' }], fields: ['id', 'title'] })
-})
-
-test('basic hooks with smaller cap name', async ({ pass, teardown, same, equal, plan, fail }) => {
-  plan(14)
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-
-      if (isSQLite) {
-        await db.query(sql`CREATE TABLE pages (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      } else {
-        await db.query(sql`CREATE TABLE pages (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      }
-    },
-    hooks: {
-      page: {
-        noKey () {
-          fail('noKey should never be called')
-        },
-        async save (original, { input, ctx, fields }) {
-          pass('save  called')
-
-          if (!input.id) {
-            same(input, {
-              title: 'Hello'
-            })
-
-            return original({
-              input: {
-                title: 'Hello from hook'
-              },
-              fields
-            })
-          } else {
-            same(input, {
-              id: 1,
-              title: 'Hello World'
-            })
-
-            return original({
-              input: {
-                id: 1,
-                title: 'Hello from hook 2'
-              },
-              fields
-            })
-          }
-        },
-        async find (original, args) {
-          pass('find called')
-
-          same(args.where, {
-            id: {
-              eq: '1'
-            }
-          })
-          args.where = {
-            id: {
-              eq: '2'
-            }
-          }
-          same(args.fields, ['id', 'title'])
-          return original(args)
-        },
-        async insert (original, args) {
-          pass('insert called')
-
-          same(args.inputs, [{
-            title: 'hello'
-          }, {
-            title: 'world'
-          }])
-          same(args.fields, ['id', 'title'])
-          return original(args)
-        }
-      }
-    }
-  })
-
-  const entity = mapper.entities.page
-
-  same(await entity.save({ input: { title: 'Hello' } }), {
-    id: 1,
-    title: 'Hello from hook'
-  })
-
-  same(await entity.find({ where: { id: { eq: 1 } }, fields: ['id', 'title'] }), [])
-
-  same(await entity.save({ input: { id: 1, title: 'Hello World' } }), {
-    id: 1,
-    title: 'Hello from hook 2'
-  })
-
-  await entity.insert({ inputs: [{ title: 'hello' }, { title: 'world' }], fields: ['id', 'title'] })
-})

package/test/inserted_at_updated_at.test.js

@@ -1,132 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { clear, connInfo, isSQLite, isMysql } = require('./helper')
-const { setTimeout } = require('timers/promises')
-const { connect } = require('..')
-const fakeLogger = {
-  trace: () => {},
-  error: () => {}
-}
-
-async function createBasicPages (db, sql) {
-  if (isSQLite) {
-    await db.query(sql`CREATE TABLE pages (
-      id INTEGER PRIMARY KEY,
-      title VARCHAR(42),
-      inserted_at TIMESTAMP,
-      updated_at TIMESTAMP
-    );`)
-  } else if (isMysql) {
-    await db.query(sql`CREATE TABLE pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(42),
-      inserted_at TIMESTAMP NULL DEFAULT NULL,
-      updated_at TIMESTAMP NULL DEFAULT NULL
-    );`)
-  } else {
-    await db.query(sql`CREATE TABLE pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(42),
-      inserted_at TIMESTAMP,
-      updated_at TIMESTAMP
-    );`)
-  }
-}
-
-test('inserted_at updated_at happy path', async ({ pass, teardown, same, equal, not, comment, notSame }) => {
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-      await createBasicPages(db, sql)
-    }
-  })
-
-  const entity = mapper.entities.page
-
-  equal(entity.fields.inserted_at.autoTimestamp, true)
-  equal(entity.fields.updated_at.autoTimestamp, true)
-
-  const original = await entity.save({
-    input: { title: 'Hello' }
-  })
-  not(original.insertedAt, null, 'insertedAt')
-  not(original.updatedAt, null, 'updatedAt')
-  comment(`insertedAt: ${original.insertedAt}`)
-  comment(`updatedAt: ${original.updatedAt}`)
-
-  {
-    const [data] = await entity.find({ where: { id: { eq: original.id } } })
-    same(data.insertedAt, original.insertedAt, 'insertedAt')
-    same(data.updatedAt, original.updatedAt, 'updatedAt')
-    comment(`insertedAt: ${data.insertedAt}`)
-    comment(`updatedAt: ${data.updatedAt}`)
-  }
-
-  await setTimeout(1000) // await 1s
-
-  let updated
-  {
-    const data = await entity.save({
-      input: { id: original.id, title: 'Hello World' }
-    })
-    same(data.insertedAt, original.insertedAt, 'insertedAt')
-    notSame(data.updatedAt, original.updatedAt, 'updatedAt')
-    updated = data
-    comment(`insertedAt: ${data.insertedAt}`)
-    comment(`updatedAt: ${data.updatedAt}`)
-  }
-
-  {
-    const [data] = await entity.find({ where: { id: { eq: original.id } } })
-    same(data.insertedAt, updated.insertedAt, 'insertedAt')
-    same(data.updatedAt, updated.updatedAt, 'updatedAt')
-    comment(`insertedAt: ${data.insertedAt}`)
-    comment(`updatedAt: ${data.updatedAt}`)
-  }
-})
-
-test('bulk insert adds inserted_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-      await createBasicPages(db, sql)
-    }
-  })
-
-  const entity = mapper.entities.page
-
-  {
-    const pages = await entity.insert({
-      inputs: [
-        { title: 'Page 1' },
-        { title: 'Page 2' },
-        { title: 'Page 3' }
-      ]
-    })
-    for (const page of pages) {
-      not(page.insertedAt, null, 'insertedAt')
-      not(page.updatedAt, null, 'updatedAt')
-      same(page.insertedAt, page.updatedAt, 'insertedAt === updatedAt')
-    }
-  }
-
-  {
-    const pages = await entity.find()
-    for (const page of pages) {
-      not(page.insertedAt, null, 'insertedAt')
-      not(page.updatedAt, null, 'updatedAt')
-      same(page.insertedAt, page.updatedAt, 'insertedAt === updatedAt')
-    }
-  }
-})