@platformatic/sql-graphql 0.9.2 → 0.11.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

@@ -274,6 +274,7 @@ function constructGraph (app, entity, opts, ignore) {
     entity,
     loadMany,
     getFields,
+    relationalFields,
     fields
   }
 

package/lib/relationship.js

@@ -20,19 +20,20 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
 
     assert(table_name, `table_name is required ${enhanceAssertLogMsg}`)
     assert(foreign_table_name, `foreign_table_name is required ${enhanceAssertLogMsg}`)
-    assert(column_name.toLowerCase().endsWith('id'), `The column with id reference must be ended with "id" postfix ${enhanceAssertLogMsg}`)
 
     const current = tablesTypeMap[table_name]
     const foreign = tablesTypeMap[foreign_table_name]
     assert(foreign !== undefined, `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}`)
 
-    // current to foreign
-    {
-      const lowered = lowerCaseFirst(camelcase(cutOutIdEnding(column_name)))
+    // current to foreign, we skip this if the foreign table has a composite primary key
+    // TODO implement support for this case
+    /* istanbul ignore else */
+    if (foreign.entity.primaryKeys.size === 1) {
+      const lowered = generateRelationshipName(column_name, foreign)
       if (!relationships[current.type] || relationships[current.type][lowered] !== false) {
-        current.fields[lowered] = { type: foreign.type }
         const originalField = camelcase(column_name)
         delete current.fields[originalField]
+        current.fields[lowered] = { type: foreign.type }
         loaders[current.type] = loaders[current.type] || resolvers[current.type] || {}
         const key = camelcase(foreign_column_name)
         loaders[current.type][lowered] = {
@@ -59,7 +60,7 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
         resolvers[foreign.type] = resolvers[foreign.type] || {}
         const resolveRelation = async function (obj, args, ctx, info) {
           const fields = fromSelectionSet(info.fieldNodes[0].selectionSet, new Set())
-          const toSearch = { ...args, fields: [...fields, column_name], ctx }
+          const toSearch = { ...args, fields: [...fields, column_name, ...current.relationalFields], ctx }
           toSearch.where = toSearch.where || {}
           toSearch.where[camelcase(column_name)] = { eq: obj.id }
           return current.entity.find(toSearch)
@@ -84,9 +85,13 @@ function lowerCaseFirst (str) {
   return str.charAt(0).toLowerCase() + str.slice(1)
 }
 
-function cutOutIdEnding (str) {
+function generateRelationshipName (str, foreign) {
+  const primaryKey = foreign.entity.primaryKeys.values().next().value
   str = str.toString()
-  return str.slice(0, str.toLowerCase().lastIndexOf('id'))
+  if (str.endsWith('_' + primaryKey)) {
+    str = str.slice(0, -2)
+  }
+  return lowerCaseFirst(camelcase(str))
 }
 
 function findPrimaryColumnName (camelCasedFields) {

package/lib/utils.js

@@ -21,11 +21,13 @@ function sqlTypeToGraphQL (sqlType) {
     case 'decimal':
       return graphql.GraphQLInt
     case 'bigint':
-      return graphql.GraphQLInt
+      return graphql.GraphQLString
     case 'int2':
       return graphql.GraphQLInt
     case 'int4':
       return graphql.GraphQLInt
+    case 'int8':
+      return graphql.GraphQLString
     case 'varchar':
       return graphql.GraphQLString
     case 'text':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
   "repository": {
@@ -14,14 +14,14 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
-    "@platformatic/sql-events": "0.9.2",
-    "@platformatic/sql-mapper": "0.9.2",
     "fastify": "^4.6.0",
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
     "tsd": "^0.25.0",
-    "ws": "^8.9.0"
+    "ws": "^8.9.0",
+    "@platformatic/sql-events": "0.11.0",
+    "@platformatic/sql-mapper": "0.11.0"
   },
   "dependencies": {
     "camelcase": "^6.0.0",

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/datatypes.test.js

@@ -722,3 +722,82 @@ test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equa
     }, 'savePage response')
   }
 })
+
+test('BIGINT!', { skip: isSQLite, only: true }, async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`
+      CREATE TABLE simple_types (
+        id SERIAL PRIMARY KEY,
+        counter BIGINT
+      );`)
+    }
+  })
+  teardown(app.close.bind(app))
+
+  app.register(sqlGraphQL)
+
+  await app.ready()
+
+  const counter = BigInt(Number.MAX_SAFE_INTEGER) + 1000n
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveSimpleType(input: {
+                             counter: "${counter}"
+                           }) {
+              id
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveSimpleType status code')
+    same(res.json(), {
+      data: {
+        saveSimpleType: {
+          id: '1',
+          counter
+        }
+      }
+    }, 'saveSimpleType response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getSimpleTypeById(id: 1) {
+              id
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'getSimpleTypeById status code')
+    same(res.json(), {
+      data: {
+        getSimpleTypeById: {
+          id: 1,
+          counter
+        }
+      }
+    }, 'getSimpleTypeById response')
+  }
+})

package/test/fix-428.test.js

@@ -0,0 +1,172 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { connInfo, isPg } = require('./helper')
+
+async function runMigrations (db, sql) {
+  await db.query(sql`
+create table company (
+  id SERIAL primary key,
+  name varchar(60)
+);
+
+create table social_medias (
+  id SERIAL primary key,
+  name varchar(60)
+);
+
+create table company_social_medias (
+  id SERIAL primary key,
+  username varchar not null,
+  social_medias_id integer not null,
+  company_id integer not null,
+  constraint "fk_company_id" foreign key ("company_id") references company,
+  constraint "fk_social_medias_id" foreign key ("social_medias_id") references social_medias
+);
+  `)
+}
+
+async function clean (db, sql) {
+  await db.query(sql`
+drop table if exists company_social_medias;
+drop table if exists company;
+drop table if exists social_medias;
+  `)
+}
+
+test('do not crash', { skip: !isPg }, async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+      await clean(db, sql)
+
+      await runMigrations(db, sql)
+      teardown(async () => {
+        await clean(db, sql)
+      })
+    }
+  })
+  await app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveCompany(input: { name: "Platformatic" }) {
+              id
+              name
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveCompany status code')
+    same(res.json(), {
+      data: {
+        saveCompany: {
+          id: 1,
+          name: 'Platformatic'
+        }
+      }
+    }, 'saveCompany response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveSocialMedia(input: { name: "Twitter" }) {
+              id
+              name
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveSocialMedia status code')
+    same(res.json(), {
+      data: {
+        saveSocialMedia: {
+          id: 1,
+          name: 'Twitter'
+        }
+      }
+    }, 'saveSocialMedia response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveCompanySocialMedia(input: { companyId: 1, socialMediasId: 1, username: "platformatic" }) {
+              id
+              username
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveCompanySocialMedia status code')
+    same(res.json(), {
+      data: {
+        saveCompanySocialMedia: {
+          id: 1,
+          username: 'platformatic'
+        }
+      }
+    }, 'saveCompanySocialMedia response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            company {
+              name
+              companySocialMedias {
+                username
+                socialMedias {
+                  name
+                }
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'complex status code')
+    same(res.json(), {
+      data: {
+        company: [{
+          name: 'Platformatic',
+          companySocialMedias: [{
+            username: 'platformatic',
+            socialMedias: {
+              name: 'Twitter'
+            }
+          }]
+        }]
+      }
+    }, 'complex response')
+  }
+})

package/test/helper.js

@@ -96,4 +96,19 @@ 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) {
+  }
 }

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

@@ -860,3 +860,255 @@ test('nested update', async ({ pass, teardown, same, equal }) => {
     }, 'savePage response')
   }
 })
+
+test('nested resolver without `id` suffix', 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 BIGINT UNSIGNED,
+            FOREIGN KEY (category) 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 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 INTEGER REFERENCES categories(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  const categories = [{
+    name: 'Pets'
+  }, {
+    name: 'Food'
+  }]
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+            mutation batch($inputs: [CategoryInput]!) {
+              insertCategories(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+      variables: {
+        inputs: categories
+      }
+    }
+  })
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello", category: 1 }) {
+              id
+              title
+              category {
+                id
+                name
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    same(res.json(), {
+      data: {
+        savePage: {
+          id: 1,
+          title: 'Hello',
+          category: {
+            id: 1,
+            name: 'Pets'
+          }
+        }
+      }
+    }, 'savePage response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              id
+              title
+              category {
+                id
+                name
+                pages {
+                  id
+                  title
+                  category {
+                    id
+                    name
+                  }
+                }
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        getPageById: {
+          id: 1,
+          title: 'Hello',
+          category: {
+            id: 1,
+            name: 'Pets',
+            pages: [{
+              id: 1,
+              title: 'Hello',
+              category: {
+                id: 1,
+                name: 'Pets'
+              }
+            }]
+          }
+        }
+      }
+    }, 'pages response')
+  }
+
+  // Without ids
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageById(id: 1) {
+              title
+              category {
+                name
+                pages {
+                  title
+                  category {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        getPageById: {
+          title: 'Hello',
+          category: {
+            name: 'Pets',
+            pages: [{
+              title: 'Hello',
+              category: {
+                name: 'Pets'
+              }
+            }]
+          }
+        }
+      }
+    }, 'pages response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            categories {
+              id
+              name
+              pages {
+                id
+                title
+                category {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'categories.posts status code')
+    same(res.json(), {
+      data: {
+        categories: [{
+          id: 1,
+          name: 'Pets',
+          pages: [{
+            id: 1,
+            title: 'Hello',
+            category: {
+              id: 1,
+              name: 'Pets'
+            }
+          }]
+        }, {
+          id: 2,
+          name: 'Food',
+          pages: []
+        }]
+      }
+    }, 'categories.posts response')
+  }
+})

package/test/schema-error.test.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isPg } = require('./helper')
+
+const connInfoWithSchema = {
+  ...connInfo,
+  schema: ['public', 'myschema']
+}
+
+test('should catch GraphQL print schema errors', { skip: !isPg }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfoWithSchema,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`
+      CREATE SCHEMA IF NOT EXISTS "myschema";
+
+      CREATE TABLE IF NOT EXISTS "myschema"."template" (
+          "id" uuid NOT NULL,
+          PRIMARY KEY ("id")
+      );
+      
+      CREATE TABLE IF NOT EXISTS "myschema"."mytable" (
+          "id" int4 NOT NULL,
+          "template_id" uuid,
+          CONSTRAINT "mytable_template" FOREIGN KEY ("template_id") REFERENCES "myschema"."template"("id"),
+          PRIMARY KEY ("id")
+      );`)
+    }
+  })
+
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+    same(true, false, 'We check that this line never runs, since we should catch the previous error')
+  } catch (error) {
+    same(error.name, 'Error')
+    same(error.message, 'Error printing the GraphQL schema')
+    same(error.cause, new Error('MyschemaTemplate.mytable field config must be an object.'))
+  }
+})