@platformatic/sql-mapper 0.7.0 → 0.9.0

package/test/helper.js

@@ -21,6 +21,7 @@ if (!process.env.DB || process.env.DB === 'postgresql') {
   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
@@ -29,6 +30,11 @@ if (!process.env.DB || process.env.DB === 'postgresql') {
 module.exports.connInfo = connInfo
 
 module.exports.clear = async function (db, sql) {
+  try {
+    await db.query(sql`DROP TABLE editors`)
+  } catch {
+  }
+
   try {
     await db.query(sql`DROP TABLE pages`)
   } catch (err) {
@@ -68,4 +74,19 @@ module.exports.clear = async function (db, sql) {
     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) {
+  }
 }

package/test/mapper.test.js

@@ -6,7 +6,8 @@ const fastify = require('fastify')
 
 const fakeLogger = {
   trace: () => {},
-  error: () => {}
+  error: () => {},
+  warn: () => {}
 }
 
 test('should throw if no connection string is provided', async ({ equal }) => {
@@ -193,96 +194,19 @@ test('missing connectionString', async ({ rejects }) => {
   await rejects(app.ready(), /connectionString/)
 })
 
-test('[pg] throws if no primary key', { skip: !isPg }, async ({ pass, teardown, equal }) => {
+test('throw if no primary keys', async ({ rejects, teardown }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL,
-      title VARCHAR(255) NOT NULL
-    );`)
-  }
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {}
-    })
-  } catch (err) {
-    equal(err.message, 'Cannot find primary key for Page entity')
-  }
-})
-
-test('[mysql] throws if no primary key', { 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,
       title VARCHAR(255) NOT NULL
     );`)
   }
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {}
-    })
-  } catch (err) {
-    equal(err.message, 'Cannot find primary key for Page entity')
-  }
-})
-
-test('[sqlite] throws if primary key is not defined', { skip: !isSQLite }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-
-    await db.query(sql`CREATE TABLE pages(
-      id INTEGER NOT NULL,
-      title TEXT NOT NULL
-   );
-   `)
-  }
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {}
-    })
-  } catch (err) {
-    equal(err.message, 'Cannot find primary key for Page entity')
-  }
-})
-
-test('[sqlite] throws with multiple primary keys', { skip: !isSQLite }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-
-    await db.query(sql`CREATE TABLE pages(
-      id INTEGER NOT NULL,
-      author_id INTEGER NOT NULL,
-      title TEXT NOT NULL,
-      PRIMARY KEY (id, author_id)
-   );
-   `)
-  }
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {}
-    })
-  } catch (err) {
-    equal(err.message, 'Table pages has 2 primary keys')
-  }
+  await rejects(connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  }))
 })

package/test/schema.test.js

@@ -0,0 +1,320 @@
+const { test } = require('tap')
+const { connect } = require('..')
+
+const { connInfo, isSQLite, isMysql, isMysql8, isPg, clear } = require('./helper')
+
+const fakeLogger = {
+  trace: () => {},
+  error: () => {}
+}
+
+test('uses tables from different schemas', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    }
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
+
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test2\`.\`users\` (
+      id SERIAL PRIMARY KEY,
+      username VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test2"."users" (
+      id SERIAL PRIMARY KEY,
+      username VARCHAR(255) NOT NULL
+    );`)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {},
+    schema: ['test1', 'test2']
+  })
+  const pageEntity = mapper.entities.test1Page
+  equal(pageEntity.name, 'Test1Page')
+  equal(pageEntity.singularName, 'test1Page')
+  equal(pageEntity.pluralName, 'test1Pages')
+  equal(pageEntity.schema, 'test1')
+  const userEntity = mapper.entities.test2User
+  equal(userEntity.name, 'Test2User')
+  equal(userEntity.singularName, 'test2User')
+  equal(userEntity.pluralName, 'test2Users')
+  equal(userEntity.schema, 'test2')
+  pass()
+})
+
+test('find enums correctly using schemas', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+    if (isMysql || isMysql8) {
+      await db.query(sql`
+      CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(255) NOT NULL,
+        type ENUM ('blank', 'non-blank')
+    );`)
+    } else if (isPg) {
+      await db.query(sql`
+      CREATE TYPE pagetype as enum ('blank', 'non-blank');
+      CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL,
+      type pagetype
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL,
+      type ENUM ('blank', 'non-blank')
+    );`)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {},
+    schema: ['test1']
+  })
+  const pageEntity = mapper.entities.test1Page
+  equal(pageEntity.name, 'Test1Page')
+  equal(pageEntity.singularName, 'test1Page')
+  equal(pageEntity.pluralName, 'test1Pages')
+  pass()
+})
+
+test('if schema is empty array, should not load entities from tables in explicit schema', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    }
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
+
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test2\`.\`users\` (
+      id SERIAL PRIMARY KEY,
+      username VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test2"."users" (
+      id SERIAL PRIMARY KEY,
+      username VARCHAR(255) NOT NULL
+    );`)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {},
+    schema: []
+  })
+
+  equal(Object.keys(mapper.entities).length, 0)
+  pass()
+})
+
+test('[pg] if schema is empty array, should find entities only in default \'public\' schema', { skip: !isPg }, async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    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 SCHEMA IF NOT EXISTS test2;`)
+    await db.query(sql`CREATE TABLE IF NOT EXISTS "test2"."users" (
+      id SERIAL PRIMARY KEY,
+      username VARCHAR(255) NOT NULL
+    );`)
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {},
+    schema: []
+  })
+
+  equal(Object.keys(mapper.entities).length, 1)
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+  equal(pageEntity.singularName, 'page')
+  equal(pageEntity.pluralName, 'pages')
+  equal(pageEntity.schema, 'public')
+  pass()
+})
+
+test('[sqlite] if sqllite, ignores schema information', { skip: !isSQLite }, async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+    await db.query(sql`CREATE TABLE "pages" (
+      "id" INTEGER PRIMARY KEY,
+      "title" TEXT NOT NULL
+    );`)
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {},
+    schema: ['ignored', 'also_ignored']
+  })
+
+  equal(Object.keys(mapper.entities).length, 1)
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+  equal(pageEntity.singularName, 'page')
+  equal(pageEntity.pluralName, 'pages')
+  equal(pageEntity.schema, null)
+  pass()
+})
+
+test('addEntityHooks in entities with schema', { skip: isSQLite }, async ({ pass, teardown, same, equal, plan, fail, throws, end }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    }
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    onDatabaseLoad,
+    schema: ['test1']
+  })
+
+  throws(() => mapper.addEntityHooks('user', {}), 'Cannot find entity user')
+
+  mapper.addEntityHooks('test1Page', {
+    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.test1Page
+
+  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'] })
+  end()
+})