@platformatic/sql-mapper 0.46.1 → 0.47.0

package/test/ignore.test.js

@@ -1,187 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { connect } = require('..')
-const { clear, connInfo, isSQLite } = require('./helper')
-
-const fakeLogger = {
-  trace: () => {},
-  error: () => {},
-  warn: () => {}
-}
-
-async function createBasicPages (db, sql) {
-  if (isSQLite) {
-    await db.query(sql`CREATE TABLE pages (
-      id INTEGER PRIMARY KEY,
-      title VARCHAR(42)
-    );`)
-    await db.query(sql`CREATE TABLE categories (
-      id INTEGER PRIMARY KEY,
-      name VARCHAR(42)
-    );`)
-  } else {
-    await db.query(sql`CREATE TABLE pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(42)
-    );`)
-    await db.query(sql`CREATE TABLE categories (
-      id SERIAL PRIMARY KEY,
-      name VARCHAR(42)
-    );`)
-  }
-}
-
-test('ignore a table', async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    pass('onDatabaseLoad called')
-    teardown(() => db.dispose())
-
-    await clear(db, sql)
-    await createBasicPages(db, sql)
-  }
-
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {
-      categories: true
-    }
-  })
-
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-
-  const categoryEntity = mapper.entities.category
-  equal(categoryEntity, undefined, 'category entity is ignored')
-})
-
-test('show a warning if there is no ignored table', async ({ plan, pass, teardown, equal }) => {
-  plan(4)
-
-  async function onDatabaseLoad (db, sql) {
-    pass('onDatabaseLoad called')
-    teardown(() => db.dispose())
-
-    await clear(db, sql)
-    await createBasicPages(db, sql)
-  }
-
-  const logger = {
-    trace: () => {},
-    error: () => {},
-    warn: (msg) => {
-      equal(msg, 'Ignored table "missing_table_pages" not found. Did you mean "pages"?')
-    }
-  }
-
-  const mapper = await connect({
-    ...connInfo,
-    log: logger,
-    onDatabaseLoad,
-    ignore: {
-      missing_table_pages: true
-    }
-  })
-
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-
-  const categoryEntity = mapper.entities.category
-  equal(categoryEntity.name, 'Category')
-})
-
-test('show a warning if the database is empty', async ({ plan, pass, teardown, equal }) => {
-  // plan(4)
-
-  async function onDatabaseLoad (db, sql) {
-    pass('onDatabaseLoad called')
-    teardown(() => db.dispose())
-
-    await clear(db, sql)
-  }
-
-  const logger = {
-    trace: () => {},
-    error: () => {},
-    warn: (msg) => {
-      equal(msg, 'Ignored table "missing_table_pages" not found.')
-    }
-  }
-
-  await connect({
-    ...connInfo,
-    log: logger,
-    onDatabaseLoad,
-    ignore: {
-      missing_table_pages: true
-    }
-  })
-})
-
-test('ignore a column', async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    pass('onDatabaseLoad called')
-    teardown(() => db.dispose())
-
-    await clear(db, sql)
-    await createBasicPages(db, sql)
-  }
-
-  const mapper = await connect({
-    ...connInfo,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {
-      categories: {
-        name: true
-      }
-    }
-  })
-
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-
-  const categoryEntity = mapper.entities.category
-  equal(categoryEntity.name, 'Category')
-  equal(categoryEntity.fields.id.camelcase, 'id')
-  equal(categoryEntity.fields.name, undefined, 'name column is ignored')
-})
-
-test('shows a warning if there is no ignored column', async ({ plan, pass, teardown, equal }) => {
-  plan(4)
-
-  async function onDatabaseLoad (db, sql) {
-    pass('onDatabaseLoad called')
-    teardown(() => db.dispose())
-
-    await clear(db, sql)
-    await createBasicPages(db, sql)
-  }
-
-  const logger = {
-    trace: () => {},
-    error: () => {},
-    warn: (msg) => {
-      equal(msg, 'Ignored column "missing_column_name" not found. Did you mean "name"?')
-    }
-  }
-
-  const mapper = await connect({
-    ...connInfo,
-    log: logger,
-    onDatabaseLoad,
-    ignore: {
-      categories: {
-        missing_column_name: true
-      }
-    }
-  })
-
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-
-  const categoryEntity = mapper.entities.category
-  equal(categoryEntity.name, 'Category')
-})

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')
-    }
-  }
-})

package/test/mapper.test.js

@@ -1,325 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { connect, plugin } = require('..')
-const { clear, connInfo, isPg, isMysql, isSQLite } = require('./helper')
-const fastify = require('fastify')
-
-const fakeLogger = {
-  trace: () => {},
-  error: () => {},
-  warn: () => {}
-}
-
-test('should throw if no connection string is provided', async ({ equal }) => {
-  try {
-    await connect({
-      connectionString: false
-    })
-  } catch (err) {
-    equal(err.message, 'connectionString is required')
-  }
-})
-
-test('[PG] return entities', { skip: !isPg }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {},
-    hooks: {}
-  })
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('[mysql] return entities', { skip: !isMysql }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {},
-    hooks: {}
-  })
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('[sqlite] return entities', { skip: !isSQLite }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {},
-    hooks: {}
-  })
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('ignore tables', async ({ teardown, has }) => {
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS users (
-      id SERIAL PRIMARY KEY,
-      username VARCHAR(255) NOT NULL
-    );`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: { users: true },
-    hooks: {}
-  })
-  has(mapper.entities.users, undefined)
-})
-
-test('[PG] return entities with Fastify', { skip: !isPg }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const app = fastify()
-  teardown(() => app.close())
-  app.register(plugin, {
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad
-  })
-  await app.ready()
-  const pageEntity = app.platformatic.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('[mysql] return entities', { skip: !isMysql }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const app = fastify()
-  teardown(() => app.close())
-  app.register(plugin, {
-    connectionString: connInfo.connectionString,
-    onDatabaseLoad
-  })
-  await app.ready()
-  const pageEntity = app.platformatic.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('[sqlite] return entities', { skip: !isSQLite }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const app = fastify()
-  teardown(() => app.close())
-  app.register(plugin, {
-    connectionString: connInfo.connectionString,
-    onDatabaseLoad
-  })
-  await app.ready()
-  const pageEntity = app.platformatic.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})
-
-test('missing connectionString', async ({ rejects }) => {
-  const app = fastify()
-  app.register(plugin)
-
-  await rejects(app.ready(), /connectionString/)
-})
-
-test('platformaticContext', async ({ plan, equal, teardown }) => {
-  plan(3)
-  async function onDatabaseLoad (db, sql) {
-    teardown(async () => await clear(db, sql))
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const app = fastify()
-  teardown(() => app.close())
-  app.register(plugin, {
-    connectionString: connInfo.connectionString,
-    onDatabaseLoad
-  })
-
-  app.get('/', function (req, reply) {
-    const ctx = req.platformaticContext
-    equal(app, ctx.app)
-    equal(reply, ctx.reply)
-    return 'hello world'
-  })
-
-  const res = await app.inject('/')
-  equal(res.statusCode, 200)
-})
-
-test('platformatic decorator already present', async ({ teardown }) => {
-  async function onDatabaseLoad (db, sql) {
-  }
-  const app = fastify()
-  app.decorate('platformatic', {})
-  teardown(() => app.close())
-  app.register(plugin, {
-    connectionString: connInfo.connectionString,
-    onDatabaseLoad
-  })
-  await app.ready()
-})
-
-test('clean up all tables', async ({ teardown, has, equal, same }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(async () => await clear(db, sql))
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad
-  })
-
-  const res = await mapper.entities.page.save({ input: { title: 'hello' } })
-
-  same(await mapper.entities.page.find(), [res])
-
-  await mapper.cleanUpAllEntities()
-
-  const pages = await mapper.entities.page.find()
-  equal(pages.length, 0)
-})
-
-test('clean up all tables with foreign keys', async ({ teardown, has, equal, same }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(async () => await clear(db, sql))
-    teardown(() => db.dispose())
-
-    if (db.isSQLite) {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-        id INTEGER PRIMARY KEY,
-        title VARCHAR(255) NOT NULL
-      );`)
-      await db.query(sql`CREATE TABLE IF NOT EXISTS comments (
-        id INTEGER PRIMARY KEY,
-        text VARCHAR(255) NOT NULL,
-        page_id INTEGER NOT NULL REFERENCES pages(id)
-      );`)
-    } else if (db.isPg) {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-        id SERIAL PRIMARY KEY,
-        title VARCHAR(255) NOT NULL
-      );`)
-      await db.query(sql`CREATE TABLE IF NOT EXISTS comments (
-        id SERIAL PRIMARY KEY,
-        text VARCHAR(255) NOT NULL,
-        page_id INTEGER NOT NULL REFERENCES pages(id)
-      );`)
-    } else {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-        id INTEGER PRIMARY KEY AUTO_INCREMENT,
-        title VARCHAR(255) NOT NULL
-      );`)
-      await db.query(sql`CREATE TABLE IF NOT EXISTS comments (
-        id INTEGER PRIMARY KEY AUTO_INCREMENT,
-        text VARCHAR(255) NOT NULL,
-        page_id INTEGER NOT NULL REFERENCES pages(id)
-      );`)
-    }
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad
-  })
-
-  {
-    const p1 = await mapper.entities.page.save({ input: { title: 'hello' } })
-    same(await mapper.entities.page.find(), [p1])
-
-    const c1 = await mapper.entities.comment.save({ input: { text: 'foo', pageId: p1.id } })
-    same(await mapper.entities.comment.find(), [c1])
-  }
-
-  await mapper.cleanUpAllEntities()
-
-  const pages = await mapper.entities.page.find()
-  equal(pages.length, 0)
-
-  const comments = await mapper.entities.comment.find()
-  equal(comments.length, 0)
-})

package/test/no-primary-key.test.js

@@ -1,79 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-
-const { clear, connInfo, isMysql8, isSQLite } = require('./helper')
-const { connect } = require('..')
-const fakeLogger = {
-  trace: () => {},
-  warn: () => {},
-  error: () => {}
-}
-
-test('unique key', async ({ equal, not, same, teardown }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    const table = sql`
-      CREATE TABLE pages (
-        xx INTEGER DEFAULT NULL UNIQUE,
-        name varchar(75) DEFAULT NULL UNIQUE
-      );
-    `
-
-    await db.query(table)
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log: fakeLogger,
-    onDatabaseLoad,
-    ignore: {},
-    hooks: {}
-  })
-  const pageEntity = mapper.entities.page
-  not(pageEntity, undefined)
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  if (isMysql8 || isSQLite) {
-    same(pageEntity.primaryKeys, new Set(['name']))
-    equal(pageEntity.camelCasedFields.name.primaryKey, true)
-  } else {
-    same(pageEntity.primaryKeys, new Set(['xx']))
-    equal(pageEntity.camelCasedFields.xx.primaryKey, true)
-  }
-  equal(pageEntity.camelCasedFields.xx.unique, true)
-  equal(pageEntity.camelCasedFields.name.unique, true)
-})
-
-test('no key', async ({ same, teardown, pass, equal, plan }) => {
-  plan(3)
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    const table = sql`
-      CREATE TABLE pages (
-        xx INTEGER DEFAULT NULL,
-        name varchar(75) DEFAULT NULL
-      );
-    `
-
-    await db.query(table)
-  }
-  const log = {
-    trace: () => {},
-    warn: (obj, str) => {
-      same(obj, { table: 'pages' })
-      equal(str, 'Cannot find any primary keys for table')
-    },
-    error: () => {}
-  }
-  const mapper = await connect({
-    connectionString: connInfo.connectionString,
-    log,
-    onDatabaseLoad
-  })
-  same(mapper.entities, {})
-})