@platformatic/sql-mapper 0.0.23

package/test/mapper.test.js

@@ -0,0 +1,288 @@
+
+const { test } = require('tap')
+const { connect, plugin } = require('..')
+const { clear, connInfo, isPg, isMysql, isSQLite } = require('./helper')
+const fastify = require('fastify')
+
+const fakeLogger = {
+  trace: () => {},
+  error: () => {}
+}
+
+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('[pg] throws if no primary key', { 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,
+      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')
+  }
+})

package/test/types/mapper.test-d.ts

@@ -0,0 +1,64 @@
+import { expectType } from 'tsd'
+import { SQL, SQLQuery } from '@databases/sql'
+import { fastify, FastifyInstance } from 'fastify'
+import {
+  connect,
+  plugin,
+  utils,
+  Entity,
+  DBEntityField,
+  Database,
+  WhereCondition,
+  SQLMapperPluginInterface,
+  EntityHooks,
+} from '../../mapper'
+
+const pluginOptions: SQLMapperPluginInterface = await connect({ connectionString: '' })
+expectType<Database>(pluginOptions.db)
+expectType<SQL>(pluginOptions.sql)
+expectType<(entityName: string, hooks: EntityHooks) => any>(pluginOptions.addEntityHooks)
+expectType<{ [entityName: string]: Entity }>(pluginOptions.entities)
+
+interface EntityFields {
+  id: number,
+  name: string,
+}
+
+const entity: Entity<EntityFields> = pluginOptions.entities.entityName
+expectType<string>(entity.name)
+expectType<string>(entity.singularName)
+expectType<string>(entity.pluralName)
+expectType<string>(entity.primaryKey)
+expectType<string>(entity.table)
+expectType<any[]>(entity.relations)
+expectType<{ [columnName: string]: DBEntityField }>(entity.fields)
+expectType<{ [columnName: string]: DBEntityField }>(entity.camelCasedFields)
+expectType<(input: { [columnName: string]: any }) => { [columnName: string]: any }>(entity.fixInput)
+expectType<(input: { [columnName: string]: any }) => { [columnName: string]: any }>(entity.fixOutput)
+expectType<Partial<EntityFields>[]>(await entity.find())
+expectType<Partial<EntityFields>[]>(await entity.insert({ inputs: [{ id: 1, name: 'test' }] }))
+expectType<Partial<EntityFields>>(await entity.save({ input: { id: 1, name: 'test' } }))
+expectType<Partial<EntityFields>[]>(await entity.delete())
+
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '' }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', autoTimestamp: true }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', hooks: {} }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', hooks: {
+  Page: {
+    async find(options: any): Promise<any[]> { return [] },
+    async insert(options: { inputs: any[], fields?: string[] }): Promise<any[]> { return [] },
+    async save(options: { input: any, fields?: string[] }): Promise<any> { return {} },
+    async delete(options?: { where: WhereCondition, fields: string[] }): Promise<any[]> { return [] },
+  }
+}}))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', ignore: {} }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', onDatabaseLoad(db: Database, sql: SQL) {
+  expectType<(query: SQLQuery) => Promise<any[]>>(db.query)
+  expectType<() => Promise<void>>(db.dispose)
+}}))
+
+const instance: FastifyInstance = fastify()
+instance.register(plugin, { connectionString: '', autoTimestamp: true })
+instance.register((instance) => { expectType<SQLMapperPluginInterface>(instance.platformatic) })
+
+expectType<(str: string) => string>(utils.toSingular)

package/test/where.test.js

@@ -0,0 +1,316 @@
+'use strict'
+
+const { test } = require('tap')
+const { connect } = require('..')
+const { clear, connInfo, isMysql, isSQLite } = require('./helper')
+const fakeLogger = {
+  trace: () => {},
+  error: () => {}
+}
+
+test('list', async ({ pass, teardown, same, equal }) => {
+  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 posts (
+          id INTEGER 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
+  })
+
+  same(await entity.find({ where: { title: { eq: 'Dog' } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '1',
+    title: 'Dog',
+    longText: 'Foo'
+  }])
+
+  same(await entity.find({ limit: 1, offset: 0, fields: ['id', 'title', 'longText'] }), [{
+    id: '1',
+    title: 'Dog',
+    longText: 'Foo'
+  }])
+
+  same(await entity.find({ limit: 1, offset: 0, orderBy: [{ field: 'id', direction: 'desc' }], fields: ['id', 'title'] }), [{
+    id: '4',
+    title: 'Duck'
+  }])
+
+  same(await entity.find({ where: { title: { neq: 'Dog' } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }, {
+    id: '4',
+    title: 'Duck',
+    longText: 'A duck tale'
+  }])
+
+  same(await entity.find({ where: { counter: { gt: 10 } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }, {
+    id: '4',
+    title: 'Duck',
+    longText: 'A duck tale'
+  }])
+
+  same(await entity.find({ where: { counter: { lt: 40 } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '1',
+    title: 'Dog',
+    longText: 'Foo'
+  }, {
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }])
+
+  same(await entity.find({ where: { counter: { lte: 30 } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '1',
+    title: 'Dog',
+    longText: 'Foo'
+  }, {
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }])
+
+  same(await entity.find({ where: { counter: { gte: 20 } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }, {
+    id: '4',
+    title: 'Duck',
+    longText: 'A duck tale'
+  }])
+
+  same(await entity.find({ where: { counter: { in: [20, 30] } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }])
+
+  same(await entity.find({ where: { counter: { nin: [10, 40] } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }])
+
+  same(await entity.find({ where: { counter: { gt: 10, lt: 40 } }, fields: ['id', 'title', 'longText'] }), [{
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar'
+  }, {
+    id: '3',
+    title: 'Mouse',
+    longText: 'Baz'
+  }])
+})
+
+test('foreign keys', async ({ pass, teardown, same, equal }) => {
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    async onDatabaseLoad (db, sql) {
+      teardown(() => db.dispose())
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isMysql) {
+        await db.query(sql`
+          CREATE TABLE owners (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255)
+          );
+          CREATE TABLE posts (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            long_text TEXT,
+            counter INTEGER,
+            owner_id BIGINT UNSIGNED,
+            FOREIGN KEY (owner_id) REFERENCES owners(id) ON DELETE CASCADE
+          );
+        `)
+      } else if (isSQLite) {
+        await db.query(sql`
+          CREATE TABLE owners (
+            id INTEGER PRIMARY KEY,
+            name VARCHAR(255)
+          );
+        `)
+
+        await db.query(sql`
+          CREATE TABLE posts (
+            id INTEGER PRIMARY KEY,
+            title VARCHAR(42),
+            long_text TEXT,
+            counter INTEGER,
+            owner_id BIGINT UNSIGNED,
+            FOREIGN KEY (owner_id) REFERENCES owners(id) ON DELETE CASCADE
+          );
+        `)
+      } else {
+        await db.query(sql`
+        CREATE TABLE owners (
+          id SERIAL PRIMARY KEY,
+          name VARCHAR(255)
+        );
+        CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER,
+          owner_id INTEGER REFERENCES owners(id)
+        );`)
+      }
+    }
+  })
+
+  const owners = [{
+    name: 'Matteo'
+  }, {
+    name: 'Luca'
+  }]
+
+  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
+  }]
+
+  {
+    const res = await mapper.entities.owner.insert({
+      inputs: owners
+    })
+    const toAssign = [...posts]
+    for (const owner of res) {
+      toAssign.shift().ownerId = owner.id
+      toAssign.shift().ownerId = owner.id
+    }
+    await mapper.entities.post.insert({
+      inputs: posts
+    })
+  }
+
+  {
+    const owners = await mapper.entities.owner.find()
+    equal(owners.length, 2)
+
+    for (const owner of owners) {
+      owner.posts = await mapper.entities.post.find({ where: { ownerId: { eq: owner.id } }, fields: ['id', 'title', 'longText'] })
+    }
+    same(owners, [{
+      id: '1',
+      name: 'Matteo',
+      posts: [{
+        id: '1',
+        title: 'Dog',
+        longText: 'Foo',
+        ownerId: '1'
+      }, {
+        id: '2',
+        title: 'Cat',
+        longText: 'Bar',
+        ownerId: '1'
+      }]
+    }, {
+      id: '2',
+      name: 'Luca',
+      posts: [{
+        id: '3',
+        title: 'Mouse',
+        longText: 'Baz',
+        ownerId: '2'
+      }, {
+        id: '4',
+        title: 'Duck',
+        longText: 'A duck tale',
+        ownerId: '2'
+      }]
+    }])
+  }
+})