@platformatic/sql-graphql 0.10.0 → 0.12.0

package/index.js

@@ -118,7 +118,21 @@ async function mapperToGraphql (app, opts) {
     }
   }
 
-  let sdl = graphql.printSchema(new graphql.GraphQLSchema({ query, mutation, subscription }))
+  let sdl = ''
+  try {
+    sdl = graphql.printSchema(new graphql.GraphQLSchema({ query, mutation, subscription }))
+  } catch (error) {
+    // The next lines are excluded from test coverage:
+    // it's quite hard to test the following lines for all of the DB types
+    /* istanbul ignore next */
+    app.log.debug({ query, mutation, subscription }, 'GraphQL input schema')
+    /* istanbul ignore next */
+    const newError = new Error('Error printing the GraphQL schema')
+    /* istanbul ignore next */
+    newError.cause = error
+    /* istanbul ignore next */
+    throw newError
+  }
 
   if (opts.federationMetadata) {
     for (const replacement of federationReplacements) {

package/lib/entity-to-type.js

@@ -50,10 +50,21 @@ function constructGraph (app, entity, opts, ignore) {
     /* istanbul ignore next */
     if (field.enum) {
       const enumValues = field.enum.reduce((acc, enumValue) => {
-        acc[enumValue] = { value: enumValue }
+        const valueStartsWithLetterOrUnderscore = !!enumValue.match(/^[_a-zA-Z]/g)
+        if (!valueStartsWithLetterOrUnderscore) {
+          enumValue = `_${enumValue}`
+        }
+
+        acc[enumValue.replace(/[^\w\s]/g, '_')] = { value: enumValue }
         return acc
       }, {})
-      meta.type = new graphql.GraphQLEnumType({ name: key, values: enumValues })
+      try {
+        const name = camelcase([entityName, key])
+        meta.type = new graphql.GraphQLEnumType({ name, values: enumValues })
+      } catch (error) {
+        app.log.error({ key, enumValues, entityName, table: entity.table, schema: entity.schema })
+        throw new Error('Unable to generate GraphQLEnumType')
+      }
     } else {
       meta.type = sqlTypeToGraphQL(field.sqlType)
     }
@@ -281,11 +292,14 @@ function constructGraph (app, entity, opts, ignore) {
   async function loadMany (keys, queries, ctx) {
     const fields = getFields(queries)
 
+    let limit = 0
+
     // TODO this is inefficient as it might load
     // more data than needed if there are more than
     // one primary key
     const where = keys.reduce((acc, pairs) => {
       pairs.reduce((acc, { key, value }) => {
+        limit++
         if (acc[key]) {
           acc[key].in.push(value)
         } else {
@@ -301,6 +315,7 @@ function constructGraph (app, entity, opts, ignore) {
     const res = await entity.find({
       where,
       fields,
+      limit,
       ctx
     })
 

package/lib/relationship.js

@@ -9,20 +9,20 @@ const {
 const assert = require('assert')
 
 module.exports = function establishRelations (app, relations, resolvers, loaders, queryTopFields, relationships, metaMap) {
-  const tablesTypeMap = {}
+  const entitiesTypeMap = {}
   const entities = app.platformatic.entities
   for (const key of Object.keys(entities)) {
-    const entity = entities[key]
-    tablesTypeMap[entity.table] = metaMap.get(entity)
+    entitiesTypeMap[key] = metaMap.get(entities[key])
   }
-  for (const { table_name, foreign_table_name, column_name, foreign_column_name } of relations) {
+  for (const relation of relations) {
+    const { table_name, foreign_table_name, column_name, foreign_column_name, entityName, foreignEntityName, loweredTableWithSchemaName } = relation
     const enhanceAssertLogMsg = `(table: "${table_name}", foreign table: "${foreign_table_name}", column: "${column_name}")`
 
     assert(table_name, `table_name is required ${enhanceAssertLogMsg}`)
     assert(foreign_table_name, `foreign_table_name is required ${enhanceAssertLogMsg}`)
 
-    const current = tablesTypeMap[table_name]
-    const foreign = tablesTypeMap[foreign_table_name]
+    const current = entitiesTypeMap[entityName]
+    const foreign = entitiesTypeMap[foreignEntityName]
     assert(foreign !== undefined, `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}`)
 
     // current to foreign, we skip this if the foreign table has a composite primary key
@@ -54,7 +54,7 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
     // foreign to current, we skip this if the current table has a composite primary key
     // TODO implement support for this case
     if (current.entity.primaryKeys.size === 1) {
-      const lowered = lowerCaseFirst(camelcase(current.entity.table))
+      const lowered = loweredTableWithSchemaName
       if (!relationships[foreign.type] || relationships[foreign.type][lowered] !== false) {
         foreign.fields[lowered] = queryTopFields[lowered]
         resolvers[foreign.type] = resolvers[foreign.type] || {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
   "repository": {
@@ -14,23 +14,23 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
-    "@platformatic/sql-events": "0.10.0",
-    "@platformatic/sql-mapper": "0.10.0",
-    "fastify": "^4.6.0",
+    "fastify": "^4.10.2",
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
-    "tap": "^16.0.0",
+    "tap": "^16.3.2",
     "tsd": "^0.25.0",
-    "ws": "^8.9.0"
+    "ws": "^8.11.0",
+    "@platformatic/sql-events": "0.12.0",
+    "@platformatic/sql-mapper": "0.12.0"
   },
   "dependencies": {
-    "camelcase": "^6.0.0",
-    "fastify-plugin": "^4.1.0",
+    "camelcase": "^6.3.0",
+    "fastify-plugin": "^4.4.0",
     "graphql": "^16.6.0",
-    "graphql-scalars": "^1.13.1",
+    "graphql-scalars": "^1.20.1",
     "graphql-type-json": "^0.3.2",
     "inflected": "^2.1.0",
-    "mercurius": "^11.2.0"
+    "mercurius": "^11.4.0"
   },
   "tsd": {
     "directory": "test/types"

package/test/created_updated_at.test.js

@@ -0,0 +1,517 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+const { setTimeout } = require('timers/promises')
+
+async function createBasicPages (db, sql) {
+  if (isSQLite) {
+    await db.query(sql`CREATE TABLE pages (
+      id INTEGER PRIMARY KEY,
+      title VARCHAR(42),
+      created_at TIMESTAMP,
+      updated_at TIMESTAMP
+    );`)
+  } else if (isMysql) {
+    await db.query(sql`CREATE TABLE pages (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(42),
+      created_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),
+      created_at TIMESTAMP,
+      updated_at TIMESTAMP
+    );`)
+  }
+}
+
+test('created_at updated_at happy path', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  let original
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const data = res.json().data
+    not(data.savePage.createdAt, null, 'createdAt')
+    not(data.savePage.updatedAt, null, 'updatedAt')
+    comment(`createdAt: ${data.savePage.createdAt}`)
+    comment(`updatedAt: ${data.savePage.updatedAt}`)
+    original = data.savePage
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    const data = res.json().data
+    equal(data.getPageById.createdAt, original.createdAt, 'createdAt')
+    equal(data.getPageById.updatedAt, original.updatedAt, 'updatedAt')
+    comment(`createdAt: ${data.getPageById.createdAt}`)
+    comment(`updatedAt: ${data.getPageById.updatedAt}`)
+  }
+
+  await setTimeout(1000) // await 1s
+
+  let updated
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { id: 1, title: "Hello World" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    const data = res.json().data
+    equal(data.savePage.createdAt, original.createdAt, 'createdAt')
+    not(data.savePage.updatedAt, original.updatedAt, 'updatedAt')
+    updated = data.savePage
+    comment(`createdAt: ${data.savePage.createdAt}`)
+    comment(`updatedAt: ${data.savePage.updatedAt}`)
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    const data = res.json().data
+    equal(data.getPageById.createdAt, updated.createdAt, 'createdAt')
+    equal(data.getPageById.updatedAt, updated.updatedAt, 'updatedAt')
+    comment(`createdAt: ${data.getPageById.createdAt}`)
+    comment(`updatedAt: ${data.getPageById.updatedAt}`)
+  }
+})
+
+test('cannot set created_at', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello", createdAt: "${new Date().toISOString()}" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 400, 'savePage status code')
+    const data = res.json()
+    equal(data.errors[0].message, 'Field "createdAt" is not defined by type "PageInput".')
+  }
+})
+
+test('cannot set updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const data = res.json().data
+    not(data.savePage.createdAt, null, 'createdAt')
+    not(data.savePage.updatedAt, null, 'updatedAt')
+    comment(`createdAt: ${data.savePage.createdAt}`)
+    comment(`updatedAt: ${data.savePage.updatedAt}`)
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { id: 1, title: "Hello World", updatedAt: "${new Date().toISOString()}" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 400, 'savePage status code')
+    const data = res.json()
+    equal(data.errors[0].message, 'Field "updatedAt" is not defined by type "PageInput".')
+  }
+})
+
+test('do not assign created_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    autoTimestamp: false,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const data = res.json().data
+    equal(data.savePage.createdAt, null, 'createdAt')
+    equal(data.savePage.updatedAt, null, 'updatedAt')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    const data = res.json().data
+    equal(data.getPageById.createdAt, null, 'createdAt')
+    equal(data.getPageById.updatedAt, null, 'updatedAt')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { id: 1, title: "Hello World" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    const data = res.json().data
+    equal(data.savePage.createdAt, null, 'createdAt')
+    equal(data.savePage.updatedAt, null, 'updatedAt')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    const data = res.json().data
+    equal(data.getPageById.createdAt, null, 'createdAt')
+    equal(data.getPageById.updatedAt, null, 'updatedAt')
+  }
+})
+
+test('bulk insert adds created_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello" }) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const data = res.json().data
+    not(data.savePage.createdAt, null, 'createdAt')
+    not(data.savePage.updatedAt, null, 'updatedAt')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation batch($inputs : [PageInput]!) {
+            insertPages (inputs: $inputs) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `,
+        variables: {
+          inputs: [
+            { title: 'Page 1' },
+            { title: 'Page 2' },
+            { title: 'Page 3' }
+          ]
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const pages = res.json().data.insertPages
+    for (const page of pages) {
+      not(page.createdAt, null, 'createdAt')
+      not(page.updatedAt, null, 'updatedAt')
+      equal(page.createdAt, page.updatedAt, 'createdAt === updatedAt')
+    }
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    const pages = res.json().data.pages
+    for (const page of pages) {
+      not(page.createdAt, null, 'createdAt')
+      not(page.updatedAt, null, 'updatedAt')
+      equal(page.createdAt, page.updatedAt, 'createdAt === updatedAt')
+    }
+  }
+})
+
+test('bulk insert with autoTimestamp=false do not had created_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    autoTimestamp: false,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation batch($inputs : [PageInput]!) {
+            insertPages (inputs: $inputs) {
+              id
+              title
+              createdAt
+              updatedAt
+            }
+          }
+        `,
+        variables: {
+          inputs: [
+            { title: 'Page 1' },
+            { title: 'Page 2' },
+            { title: 'Page 3' }
+          ]
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    const pages = res.json().data.insertPages
+    for (const page of pages) {
+      equal(page.createdAt, null, 'createdAt')
+      equal(page.updatedAt, null, 'updatedAt')
+    }
+  }
+})

package/test/enum.test.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite, isPg } = require('./helper')
+
+test('should properly setup the enum types', { skip: isSQLite }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isPg) {
+        await db.query(sql`
+        CREATE TYPE custom_enum AS ENUM('1', '2', '3');
+
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum custom_enum,
+          PRIMARY KEY (id)
+        );`)
+      } else {
+        await db.query(sql`
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum ENUM ('1', '2', '3') DEFAULT NULL,
+          PRIMARY KEY (id)
+        );`)
+      }
+    }
+  })
+
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+    same(true, true, 'Enum values are properly interpreted')
+  } catch (err) {
+    console.log(err)
+    same(true, false, 'Previous call should never fail')
+  }
+})
+
+test('should not fail if tables have duplicate enum names', { skip: isSQLite }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isPg) {
+        await db.query(sql`
+        CREATE TYPE custom_enum AS ENUM('1', '2', '3');
+        CREATE TYPE simple_enum AS ENUM('4', '5', '6');
+        
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum custom_enum,
+          PRIMARY KEY (id)
+        );
+        CREATE TABLE simple_types (
+          pk INTEGER NOT NULL,
+          test_enum simple_enum,
+          PRIMARY KEY (pk)
+        );`)
+      } else {
+        await db.query(sql`
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum ENUM ('1', '2', '3') DEFAULT NULL,
+          PRIMARY KEY (id)
+        );
+        CREATE TABLE simple_types (
+          pk INTEGER NOT NULL,
+          test_enum ENUM ('4', '5', '6') DEFAULT NULL,
+          PRIMARY KEY (pk)
+        );`)
+      }
+    }
+  })
+
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+    same(true, true, 'test_enum is used twice but app not throws')
+  } catch (err) {
+    console.log(err)
+    same(true, false, 'Previous call should never fail')
+  }
+})

package/test/helper.js

@@ -96,4 +96,54 @@ module.exports.clear = async function (db, sql) {
     await db.query(sql`DROP Type simple_enum`)
   } catch (err) {
   }
+
+  try {
+    await db.query(sql`DROP TABLE "myschema"."mytable"`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE "myschema"."template"`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP SCHEMA "myschema"`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE generated_test`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE enum_tests`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TYPE custom_enum`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE test2.books`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE test1.authors`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP SCHEMA test2`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP SCHEMA test1`)
+  } catch (err) {
+  }
 }

package/test/inserted_updated_at.test.js

@@ -36,6 +36,10 @@ test('inserted_at updated_at happy path', async ({ pass, teardown, same, equal,
   const app = fastify()
   app.register(sqlMapper, {
     ...connInfo,
+    autoTimestamp: {
+      createdAt: 'inserted_at',
+      updatedAt: 'updated_at'
+    },
     async onDatabaseLoad (db, sql) {
       pass('onDatabaseLoad called')
 
@@ -159,6 +163,10 @@ test('cannot set inserted_at', async ({ pass, teardown, same, equal, not, commen
   const app = fastify()
   app.register(sqlMapper, {
     ...connInfo,
+    autoTimestamp: {
+      createdAt: 'inserted_at',
+      updatedAt: 'updated_at'
+    },
     async onDatabaseLoad (db, sql) {
       pass('onDatabaseLoad called')
 
@@ -198,6 +206,10 @@ test('cannot set updated_at', async ({ pass, teardown, same, equal, not, comment
   const app = fastify()
   app.register(sqlMapper, {
     ...connInfo,
+    autoTimestamp: {
+      createdAt: 'inserted_at',
+      updatedAt: 'updated_at'
+    },
     async onDatabaseLoad (db, sql) {
       pass('onDatabaseLoad called')
 
@@ -371,6 +383,10 @@ test('bulk insert adds inserted_at updated_at', async ({ pass, teardown, same, e
   const app = fastify()
   app.register(sqlMapper, {
     ...connInfo,
+    autoTimestamp: {
+      createdAt: 'inserted_at',
+      updatedAt: 'updated_at'
+    },
     async onDatabaseLoad (db, sql) {
       pass('onDatabaseLoad called')
 
@@ -466,7 +482,7 @@ test('bulk insert adds inserted_at updated_at', async ({ pass, teardown, same, e
   }
 })
 
-test('bulk insert with autoTimestamp=false do not hadd inserted_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
+test('bulk insert with autoTimestamp=false do not had inserted_at updated_at', async ({ pass, teardown, same, equal, not, comment }) => {
   const app = fastify()
   app.register(sqlMapper, {
     ...connInfo,

package/test/nested.test.js

@@ -258,6 +258,161 @@ test('nested resolver', async ({ pass, teardown, same, equal }) => {
   }
 })
 
+test('nested resolver with more of 10 rows in nested entity', async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isMysql) {
+        await db.query(sql`
+          CREATE TABLE categories (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255)
+          );
+          CREATE TABLE pages (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            category_id BIGINT UNSIGNED,
+            FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE CASCADE
+          );
+        `)
+      } else if (isSQLite) {
+        await db.query(sql`
+          CREATE TABLE categories (
+            id INTEGER PRIMARY KEY,
+            name VARCHAR(42)
+          );
+        `)
+        await db.query(sql`
+          CREATE TABLE pages (
+            id INTEGER PRIMARY KEY,
+            title VARCHAR(42),
+            category_id INTEGER REFERENCES categories(id)
+          );
+        `)
+      } else {
+        await db.query(sql`
+          CREATE TABLE categories (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42)
+          );
+          CREATE TABLE pages (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            category_id INTEGER REFERENCES categories(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  const categories = [
+    { name: 'Category 01' },
+    { name: 'Category 02' },
+    { name: 'Category 03' },
+    { name: 'Category 04' },
+    { name: 'Category 05' },
+    { name: 'Category 06' },
+    { name: 'Category 07' },
+    { name: 'Category 08' },
+    { name: 'Category 09' },
+    { name: 'Category 10' },
+    { name: 'Category 11' }
+  ]
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+            mutation batch($inputs: [CategoryInput]!) {
+              insertCategories(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+      variables: {
+        inputs: categories
+      }
+    }
+  })
+
+  const pages = [
+    { title: 'Page 01', categoryId: 1 },
+    { title: 'Page 02', categoryId: 2 },
+    { title: 'Page 03', categoryId: 3 },
+    { title: 'Page 04', categoryId: 4 },
+    { title: 'Page 05', categoryId: 5 },
+    { title: 'Page 06', categoryId: 6 },
+    { title: 'Page 07', categoryId: 7 },
+    { title: 'Page 08', categoryId: 8 },
+    { title: 'Page 09', categoryId: 9 },
+    { title: 'Page 10', categoryId: 10 },
+    { title: 'Page 11', categoryId: 11 }
+  ]
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+            mutation batch($inputs: [PageInput]!) {
+              insertPages(inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+      variables: {
+        inputs: pages
+      }
+    }
+  })
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages(limit: 100) {
+              id
+              title
+              category {
+                id
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages.category status code')
+    same(res.json(), {
+      data: {
+        pages: [
+          { id: 1, title: 'Page 01', category: { id: 1 } },
+          { id: 2, title: 'Page 02', category: { id: 2 } },
+          { id: 3, title: 'Page 03', category: { id: 3 } },
+          { id: 4, title: 'Page 04', category: { id: 4 } },
+          { id: 5, title: 'Page 05', category: { id: 5 } },
+          { id: 6, title: 'Page 06', category: { id: 6 } },
+          { id: 7, title: 'Page 07', category: { id: 7 } },
+          { id: 8, title: 'Page 08', category: { id: 8 } },
+          { id: 9, title: 'Page 09', category: { id: 9 } },
+          { id: 10, title: 'Page 10', category: { id: 10 } },
+          { id: 11, title: 'Page 11', category: { id: 11 } }
+        ]
+      }
+    }, 'pages.category response')
+  }
+})
+
 test('disable one-too-many', async ({ pass, teardown, same, equal, match }) => {
   const app = fastify()
   app.register(sqlMapper, {

package/test/schema.test.js

@@ -0,0 +1,167 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { isSQLite, connInfo, isMysql, clear } = require('./helper')
+
+test('should handle relationships with different schemas', { skip: isSQLite }, async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    schema: ['test1', 'test2'],
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
+      if (isMysql) {
+        await db.query(sql`
+          CREATE TABLE test1.authors (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255)
+          );`)
+        await db.query(sql`
+          CREATE TABLE test2.books (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            author_id BIGINT UNSIGNED,
+            FOREIGN KEY(author_id) REFERENCES test1.authors(id) ON DELETE CASCADE
+          );
+        `)
+      } else {
+        await db.query(sql`
+          CREATE TABLE test1.authors (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42)
+          );
+          CREATE TABLE test2.books (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            author_id INTEGER REFERENCES test1.authors(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  const authors = [{
+    id: 1,
+    name: 'Mark'
+  }]
+
+  const books = [{
+    id: 1,
+    title: 'Harry',
+    authorId: 1
+  }]
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [Test1AuthorInput]!) {
+              insertTest1Authors(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+        variables: {
+          inputs: authors
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'authors status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [Test2BookInput]!) {
+              insertTest2Books(inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+        variables: {
+          inputs: books
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'books status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query {
+              test2Books {
+                id
+                author {
+                  id
+                } 
+              }
+            }
+          `
+      }
+    })
+    equal(res.statusCode, 200, 'query books')
+    same(res.json(), {
+      data: {
+        test2Books: [{
+          id: 1,
+          author: {
+            id: 1
+          }
+        }]
+      }
+    }, 'query book response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query {
+              test1Authors {
+                id
+                test2Books {
+                  id
+                }
+              }
+            }
+          `
+      }
+    })
+    equal(res.statusCode, 200, 'query authors')
+    same(res.json(), {
+      data: {
+        test1Authors: [{
+          id: 1,
+          test2Books: [{
+            id: 1
+          }]
+        }]
+      }
+    }, 'query authors response')
+  }
+})

package/test/special-chars.test.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite, isPg } = require('./helper')
+
+test('should correctly get the special characters', { skip: isSQLite }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isPg) {
+        await db.query(sql`
+        CREATE TYPE custom_enum AS ENUM ('application/pdf', 'image/jpeg', 'image/png');
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum custom_enum,
+          PRIMARY KEY (id)
+        );`)
+      } else {
+        await db.query(sql`
+        CREATE TABLE enum_tests (
+          id INTEGER NOT NULL,
+          test_enum ENUM ('application/pdf', 'image/jpeg', 'image/png'),
+          PRIMARY KEY (id)
+        );`)
+      }
+    }
+  })
+
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+    same(true, true, 'Special characters are properly configured')
+  } catch (err) {
+    console.log(err)
+    same(true, false, 'Previous call should never fail')
+  }
+})