@platformatic/sql-mapper 0.45.1 → 0.46.2

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, {})
-})

package/test/or.test.js

@@ -1,193 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { connect } = require('..')
-const { clear, connInfo, isSQLite, isMysql } = require('./helper')
-const fakeLogger = {
-  trace: () => { },
-  error: () => { }
-}
-
-test('where clause with or operation', async ({ pass, teardown, same }) => {
-  const mapper = await connect({
-    ...connInfo,
-    autoTimestamp: true,
-    log: fakeLogger,
-    async onDatabaseLoad (db, sql) {
-      teardown(() => db.dispose())
-      pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-
-      if (isSQLite) {
-        await db.query(sql`CREATE TABLE posts (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42),
-          long_text TEXT,
-          counter INTEGER
-        );`)
-      } else if (isMysql) {
-        await db.query(sql`CREATE TABLE posts (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42),
-          long_text TEXT,
-          counter INTEGER
-        );`)
-      } else {
-        await db.query(sql`CREATE TABLE posts (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42),
-          long_text TEXT,
-          counter INTEGER
-        );`)
-      }
-    }
-  })
-
-  const entity = mapper.entities.post
-
-  const posts = [{
-    title: 'Dog',
-    longText: 'Foo',
-    counter: 10
-  }, {
-    title: 'Cat',
-    longText: 'Bar',
-    counter: 20
-  }, {
-    title: 'Mouse',
-    longText: 'Baz',
-    counter: 30
-  }, {
-    title: 'Duck',
-    longText: 'A duck tale',
-    counter: 40
-  }]
-
-  await entity.insert({
-    inputs: posts
-  })
-
-  {
-    const data = await entity.find({
-      where: {
-        or: [
-          {
-            counter: {
-              eq: 10
-            }
-          },
-          {
-            counter: {
-              eq: 20
-            }
-          }
-        ]
-      }
-    })
-
-    same(data, [
-      { id: '1', title: 'Dog', longText: 'Foo', counter: 10 },
-      { id: '2', title: 'Cat', longText: 'Bar', counter: 20 }
-    ])
-  }
-
-  {
-    const data = await entity.find({
-      where: {
-        or: [
-          {
-            counter: {
-              eq: 20
-            }
-          },
-          {
-            counter: {
-              gte: 30
-            }
-          }
-        ]
-      }
-    })
-
-    same(data, [
-      { id: '2', title: 'Cat', longText: 'Bar', counter: 20 },
-      { id: '3', title: 'Mouse', longText: 'Baz', counter: 30 },
-      { id: '4', title: 'Duck', longText: 'A duck tale', counter: 40 }
-    ])
-  }
-
-  {
-    const data = await entity.find({
-      where: {
-        or: [
-          {
-            title: {
-              eq: 'Dog'
-            }
-          },
-          {
-            title: {
-              eq: 'Duck'
-            }
-          }
-        ]
-      }
-    })
-
-    same(data, [
-      { id: '1', title: 'Dog', longText: 'Foo', counter: 10 },
-      { id: '4', title: 'Duck', longText: 'A duck tale', counter: 40 }
-    ])
-  }
-
-  {
-    const data = await entity.find({
-      where: {
-        or: [
-          {
-            title: {
-              eq: 'Dog'
-            }
-          },
-          {
-            longText: {
-              eq: 'Baz'
-            }
-          }
-        ]
-      }
-    })
-
-    same(data, [
-      { id: '1', title: 'Dog', longText: 'Foo', counter: 10 },
-      { id: '3', title: 'Mouse', longText: 'Baz', counter: 30 }
-    ])
-  }
-
-  {
-    const data = await entity.find({
-      where: {
-        counter: {
-          in: [10, 20]
-        },
-        or: [
-          {
-            title: {
-              eq: 'Dog'
-            }
-          },
-          {
-            longText: {
-              eq: 'Baz'
-            }
-          }
-        ]
-      }
-    })
-
-    same(data, [
-      { id: '1', title: 'Dog', longText: 'Foo', counter: 10 }
-    ])
-  }
-})