@platformatic/sql-mapper 0.45.1 → 0.46.2

package/test/schema.test.js

@@ -1,474 +0,0 @@
-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, match }) => {
-  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')
-  match(mapper.dbschema, [
-    {
-      schema: 'test1',
-      table: 'pages',
-      constraints: [
-        {
-          constraint_type: isMysql8 ? 'UNIQUE' : 'PRIMARY KEY'
-        }
-      ],
-      columns: [
-        {
-          column_name: 'id',
-          is_nullable: 'NO'
-        },
-        {
-          column_name: 'title',
-          is_nullable: 'NO'
-        },
-        {
-          column_name: 'type',
-          is_nullable: 'YES'
-        }
-      ]
-    }
-  ])
-  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()
-})
-
-test('uses tables from different schemas with FK', { 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,
-      page_id BIGINT UNSIGNED,
-      FOREIGN KEY(page_id) REFERENCES test1.pages(id) ON DELETE CASCADE
-    );`)
-    } else {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS "test2"."users" (
-      id SERIAL PRIMARY KEY,
-      username VARCHAR(255) NOT NULL,
-      page_id integer REFERENCES test1.pages(id)
-    );`)
-    }
-  }
-  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')
-  equal(pageEntity.relations.length, 0)
-
-  const userEntity = mapper.entities.test2User
-  equal(userEntity.name, 'Test2User')
-  equal(userEntity.singularName, 'test2User')
-  equal(userEntity.pluralName, 'test2Users')
-  equal(userEntity.schema, 'test2')
-  equal(userEntity.relations.length, 1)
-  const userRelation = userEntity.relations[0]
-  equal(userRelation.foreignEntityName, 'test1Page')
-  equal(userRelation.entityName, 'test2User')
-  pass()
-})
-
-test('recreate mapper from schema', async ({ pass, teardown, equal, match, fail }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    if (isMysql || isMysql8) {
-      await db.query(sql`
-      CREATE TABLE IF NOT EXISTS \`pages\` (
-        id SERIAL PRIMARY KEY,
-        title VARCHAR(255) NOT NULL
-    );`)
-    } else if (isPg) {
-      await db.query(sql`
-      CREATE TABLE IF NOT EXISTS "pages" (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-    } else if (isSQLite) {
-      await db.query(sql`
-      CREATE TABLE IF NOT EXISTS "pages" (
-      id INTEGER PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-    } else {
-      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 dbschema = mapper.dbschema
-  const knownQueries = [
-    'SELECT VERSION()'
-  ]
-  const mapper2 = await connect({
-    connectionString: connInfo.connectionString,
-    log: {
-      trace (msg) {
-        if (knownQueries.indexOf(msg.query?.text) < 0) {
-          console.log(msg)
-          fail('no trace')
-        }
-      },
-      error (...msg) {
-        console.log(...msg)
-        fail('no error')
-      }
-    },
-    dbschema,
-    ignore: {},
-    hooks: {}
-  })
-  teardown(() => mapper2.db.dispose())
-
-  const pageEntity = mapper2.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
-  pass()
-})

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

@@ -1,139 +0,0 @@
-import { expectType } from 'tsd'
-import { SQL, SQLQuery } from '@databases/sql'
-import { fastify, FastifyInstance, FastifyReply } from 'fastify'
-import { FastifyError } from '@fastify/error'
-import {
-  connect,
-  plugin,
-  utils,
-  Entity,
-  DBEntityField,
-  Database,
-  SQLMapperPluginInterface,
-  EntityHooks,
-  createConnectionPool,
-  Entities,
-  errors
-} from '../../mapper'
-
-const log = {
-  trace() { },
-  error() { },
-  warn() { }
-}
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: SQLMapperPluginInterface<Entities>
-  }
-}
-
-const pluginOptions: SQLMapperPluginInterface<Entities> = await connect<Entities>({ connectionString: '', log })
-expectType<Database>(pluginOptions.db)
-expectType<SQL>(pluginOptions.sql)
-expectType<{ [entityName: string]: Entity }>(pluginOptions.entities)
-
-expectType<Promise<void>>(pluginOptions.cleanUpAllEntities())
-
-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<number>(await entity.count())
-
-const entityHooks: EntityHooks = {
-  async find(originalFind: typeof entity.find, ...options: Parameters<typeof entity.find>): ReturnType<typeof entity.find> { return [] },
-  async insert(originalInsert: typeof entity.insert, ...options: Parameters<typeof entity.insert>): ReturnType<typeof entity.insert> { return [] },
-  async save(originalSave: typeof entity.save, ...options: Parameters<typeof entity.save>): ReturnType<typeof entity.save> { return {} },
-  async delete(originalDelete: typeof entity.delete, ...options: Parameters<typeof entity.delete>): ReturnType<typeof entity.delete> { return [] },
-  async count(originalCount: typeof entity.count, ...options: Parameters<typeof entity.count>): ReturnType<typeof entity.count> { return 0 },
-}
-expectType<EntityHooks>(entityHooks)
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', log }))
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', autoTimestamp: true, log }))
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', hooks: {}, log }))
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({
-  connectionString: '', hooks: {
-    Page: entityHooks
-  },
-  log
-}))
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', ignore: {}, log }))
-expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({
-  connectionString: '', log, onDatabaseLoad(db: Database, sql: SQL) {
-    expectType<(query: SQLQuery) => Promise<any[]>>(db.query)
-    expectType<() => Promise<void>>(db.dispose)
-    expectType<boolean | undefined>(pluginOptions.db.isMySql)
-    expectType<boolean | undefined>(pluginOptions.db.isMariaDB)
-    expectType<boolean | undefined>(pluginOptions.db.isSQLite)
-    expectType<boolean | undefined>(pluginOptions.db.isPg)
-
-  }
-}))
-
-const instance: FastifyInstance = fastify()
-instance.register(plugin, { connectionString: '', autoTimestamp: true })
-instance.register((instance) => {
-  expectType<SQLMapperPluginInterface<Entities>>(instance.platformatic)
-
-  instance.platformatic.addEntityHooks<EntityFields>('something', {
-    async find(originalFind, options) {
-      expectType<Partial<EntityFields>[]>(await originalFind())
-      expectType<Parameters<typeof entity.find>[0]>(options)
-
-      return [{
-        id: 42
-      }]
-    }
-  })
-
-  instance.get('/', async (request, reply) => {
-    const ctx = request.platformaticContext
-    expectType<FastifyInstance>(ctx.app)
-    expectType<FastifyReply>(ctx.reply)
-    await instance.platformatic.cleanUpAllEntities()
-  })
-})
-
-expectType<(str: string) => string>(utils.toSingular)
-
-expectType<Promise<{ db: Database, sql: SQL }>>(createConnectionPool({ connectionString: '', log }))
-
-// Errors
-type ErrorWithNoParams = () => FastifyError
-type ErrorWithOneParam = (param: string) => FastifyError
-type ErrorWithOneAnyParam = (param: any) => FastifyError
-type ErrorWithTwoParams = (param1: string, param2: string) => FastifyError
-
-expectType<ErrorWithOneParam>(errors.CannotFindEntityError)
-expectType<ErrorWithNoParams>(errors.SpecifyProtocolError)
-expectType<ErrorWithNoParams>(errors.ConnectionStringRequiredError)
-expectType<ErrorWithOneAnyParam>(errors.TableMustBeAStringError)
-expectType<ErrorWithOneParam>(errors.UnknownFieldError)
-expectType<ErrorWithNoParams>(errors.InputNotProvidedError)
-expectType<ErrorWithOneParam>(errors.UnsupportedWhereClauseError)
-expectType<ErrorWithNoParams>(errors.UnsupportedOperatorForArrayFieldError)
-expectType<ErrorWithNoParams>(errors.UnsupportedOperatorForNonArrayFieldError)
-expectType<ErrorWithOneParam>(errors.ParamNotAllowedError)
-expectType<ErrorWithTwoParams>(errors.InvalidPrimaryKeyTypeError)
-expectType<ErrorWithTwoParams>(errors.ParamLimitNotAllowedError)
-expectType<ErrorWithOneParam>(errors.ParamLimitMustBeNotNegativeError)
-expectType<ErrorWithOneParam>(errors.MissingValueForPrimaryKeyError)
-expectType<ErrorWithNoParams>(errors.SQLiteOnlySupportsAutoIncrementOnOneColumnError)
-