@platformatic/sql-graphql 0.7.0 → 0.9.0

package/index.js

@@ -16,6 +16,7 @@ async function mapperToGraphql (app, opts) {
   const loaders = {}
   const federationReplacements = []
   const relations = []
+  const ignore = opts.ignore || {}
 
   const graphOpts = {
     queryTopFields,
@@ -35,8 +36,11 @@ async function mapperToGraphql (app, opts) {
     }
   } else {
     for (const entity of Object.values(mapper.entities)) {
+      if (ignore[entity.pluralName] === true) {
+        continue
+      }
       relations.push(...entity.relations)
-      const meta = constructGraph(app, entity, graphOpts)
+      const meta = constructGraph(app, entity, graphOpts, ignore[entity.pluralName] || {})
       metaMap.set(entity, meta)
     }
 
@@ -89,10 +93,23 @@ async function mapperToGraphql (app, opts) {
 
   let subscription
   if (app.platformatic.mq) {
-    const entitiesList = Object.keys(app.platformatic.entities)
-    const ignoreList = opts.subscriptionIgnore || []
+    // Create a copy because we will alter it
+    const ignoreList = Array.from(opts.subscriptionIgnore || [])
+
+    const entitiesList = []
+
+    for (const entity of Object.values(app.platformatic.entities)) {
+      if (ignoreList.includes(entity.singularName)) {
+        continue
+      }
+      // We currently do not support subscriptions for join tables
+      if (entity.primaryKeys.size > 1) {
+        continue
+      }
+      entitiesList.push(entity)
+    }
 
-    if (entitiesList.length - ignoreList.length > 0) {
+    if (entitiesList.length > 0) {
       opts.subscription = {
         emitter: app.platformatic.mq
       }

package/lib/entity-to-type.js

@@ -15,8 +15,13 @@ const ascDesc = new graphql.GraphQLEnumType({
   }
 })
 
-function constructGraph (app, entity, opts) {
-  const primaryKey = camelcase(entity.primaryKey)
+const limitType = new graphql.GraphQLScalarType({
+  name: 'LimitInt',
+  description: 'Limit will be applied by default if not passed. If the provided value exceeds the maximum allowed value a validation error will be thrown'
+})
+
+function constructGraph (app, entity, opts, ignore) {
+  const primaryKeys = Array.from(entity.primaryKeys).map((key) => camelcase(key))
   const relationalFields = entity.relations
     .map((relation) => relation.column_name)
   const entityName = entity.name
@@ -35,6 +40,10 @@ function constructGraph (app, entity, opts) {
 
   for (const key of Object.keys(entity.fields)) {
     const field = entity.fields[key]
+    if (ignore[field.camelcase]) {
+      continue
+    }
+
     const meta = { field }
 
     // sqlite doesn't support enums
@@ -66,7 +75,12 @@ function constructGraph (app, entity, opts) {
   resolvers.Mutation = resolvers.Mutation || {}
   loaders.Query = loaders.Query || {}
 
-  const getBy = camelcase(['get', singular, 'by', primaryKey])
+  const getBy = camelcase(['get', singular, ...(primaryKeys.map((key, i) => {
+    if (i === 0) {
+      return ['by', key]
+    }
+    return ['and', key]
+  }).flat())].join('_'))
 
   const whereArgType = new graphql.GraphQLInputObjectType({
     name: `${entityName}WhereArguments`,
@@ -81,6 +95,7 @@ function constructGraph (app, entity, opts) {
             gte: { type: fields[field].type },
             lt: { type: fields[field].type },
             lte: { type: fields[field].type },
+            like: { type: fields[field].type },
             in: { type: new graphql.GraphQLList(fields[field].type) },
             nin: { type: new graphql.GraphQLList(fields[field].type) }
           }
@@ -93,14 +108,21 @@ function constructGraph (app, entity, opts) {
   queryTopFields[getBy] = {
     type,
     args: {
-      [primaryKey]: { type: new graphql.GraphQLNonNull(fields[primaryKey].type) }
+      ...(primaryKeys.reduce((acc, primaryKey) => {
+        acc[primaryKey] = { type: new graphql.GraphQLNonNull(fields[primaryKey].type) }
+        return acc
+      }, {}))
     }
   }
   loaders.Query[getBy] = {
     loader (queries, ctx) {
       const keys = []
       for (const query of queries) {
-        keys.push(query.params[primaryKey])
+        const pairs = []
+        for (const key of primaryKeys) {
+          pairs.push({ key, value: query.params[key] })
+        }
+        keys.push(pairs)
       }
       return loadMany(keys, queries, ctx)
     },
@@ -121,7 +143,7 @@ function constructGraph (app, entity, opts) {
   queryTopFields[plural] = {
     type: new graphql.GraphQLList(type),
     args: {
-      limit: { type: graphql.GraphQLInt },
+      limit: { type: limitType },
       offset: { type: graphql.GraphQLInt },
       orderBy: {
         type: new graphql.GraphQLList(new graphql.GraphQLInputObjectType({
@@ -138,7 +160,9 @@ function constructGraph (app, entity, opts) {
 
   resolvers.Query[plural] = (_, query, ctx, info) => {
     const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
-    requestedFields.push(primaryKey)
+    for (const primaryKey of primaryKeys) {
+      requestedFields.push(primaryKey)
+    }
     return entity.find({ ...query, fields: [...requestedFields, ...relationalFields], ctx })
   }
 
@@ -172,7 +196,9 @@ function constructGraph (app, entity, opts) {
 
   resolvers.Query[count] = async (_, query, ctx, info) => {
     const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
-    requestedFields.push(primaryKey)
+    for (const primaryKey of primaryKeys) {
+      requestedFields.push(primaryKey)
+    }
     const total = await entity.count({ ...query, fields: [...requestedFields, ...relationalFields], ctx })
     return { total }
   }
@@ -220,14 +246,21 @@ function constructGraph (app, entity, opts) {
 
   federationReplacements.push({
     find: new RegExp(`type ${entityName}`),
-    replace: `type ${entityName} @key(fields: "${primaryKey}")`
+    replace: `type ${entityName} @key(fields: "${primaryKeys}")`
   })
 
   if (federationMetadata) {
     loaders[entityName] = loaders[entityName] || {}
     loaders[entityName].__resolveReference = {
       loader (queries, ctx) {
-        const keys = queries.map(({ obj }) => obj[primaryKey])
+        const keys = []
+        for (const { obj } of queries) {
+          const pairs = []
+          for (const key of primaryKeys) {
+            pairs.push({ key, value: obj[key] })
+          }
+          keys.push(pairs)
+        }
         return loadMany(keys, queries, ctx)
       },
       opts: {
@@ -246,25 +279,47 @@ function constructGraph (app, entity, opts) {
 
   async function loadMany (keys, queries, ctx) {
     const fields = getFields(queries)
-    const res = await entity.find({
-      where: {
-        [primaryKey]: {
-          in: keys
+
+    // 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 }) => {
+        if (acc[key]) {
+          acc[key].in.push(value)
+        } else {
+          acc[key] = {
+            in: [value]
+          }
         }
-      },
+        return acc
+      }, acc)
+      return acc
+    }, {})
+
+    const res = await entity.find({
+      where,
       fields,
       ctx
     })
 
-    const map = {}
-
-    for (const row of res) {
-      map[row[primaryKey]] = row
-    }
-
     const output = []
-    for (const key of keys) {
-      output.push(map[key])
+    // TODO this is extremely inefficient
+    // we need a better data structure
+    for (const pair of keys) {
+      for (const row of res) {
+        let target = row
+        for (const { key, value } of pair) {
+          if (row[key] !== value) {
+            target = null
+            break
+          }
+        }
+
+        if (target) {
+          output.push(target)
+        }
+      }
     }
 
     return output
@@ -272,7 +327,9 @@ function constructGraph (app, entity, opts) {
 
   function getFields (queries) {
     const fields = new Set([...relationalFields])
-    fields.add(primaryKey)
+    for (const primaryKey of primaryKeys) {
+      fields.add(primaryKey)
+    }
     for (const query of queries) {
       fromSelectionSet(query.info.fieldNodes[0].selectionSet, fields)
     }

package/lib/relationship.js

@@ -15,7 +15,7 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
     const entity = entities[key]
     tablesTypeMap[entity.table] = metaMap.get(entity)
   }
-  for (const { table_name, foreign_table_name, column_name } of relations) {
+  for (const { table_name, foreign_table_name, column_name, foreign_column_name } of relations) {
     const enhanceAssertLogMsg = `(table: "${table_name}", foreign table: "${foreign_table_name}", column: "${column_name}")`
 
     assert(table_name, `table_name is required ${enhanceAssertLogMsg}`)
@@ -34,11 +34,13 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
         const originalField = camelcase(column_name)
         delete current.fields[originalField]
         loaders[current.type] = loaders[current.type] || resolvers[current.type] || {}
+        const key = camelcase(foreign_column_name)
         loaders[current.type][lowered] = {
           loader (queries, ctx) {
-            const keys = queries.map(({ obj }) => {
-              return obj[originalField]
-            })
+            const keys = []
+            for (const { obj } of queries) {
+              keys.push([{ key, value: obj[originalField].toString() }])
+            }
             return foreign.loadMany(keys, queries, ctx)
           },
           opts: {
@@ -48,8 +50,9 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
       }
     }
 
-    // foreign to current
-    {
+    // 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))
       if (!relationships[foreign.type] || relationships[foreign.type][lowered] !== false) {
         foreign.fields[lowered] = queryTopFields[lowered]

package/lib/subscriptions.js

@@ -9,6 +9,14 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
     if (ignores.indexOf(field.singularName) >= 0) {
       continue
     }
+    // TODO currently we are not supporting subscriptions for
+    // entities that have a composite primary key
+    /* istanbul ignore next */
+    if (field.primaryKeys.size !== 1) {
+      continue
+    }
+    const entity = app.platformatic.entities[field.singularName]
+    const primaryKey = entity.primaryKeys.values().next().value
     const { type } = meta
     const saved = `${field.singularName}Saved`
     fields[saved] = {
@@ -18,11 +26,9 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
       subscribe: async function * (_, query, ctx, info) {
         const log = ctx.reply.request.log
         const { pubsub } = ctx
-        const entity = app.platformatic.entities[field.singularName]
         const topic = await entity.getSubscriptionTopic({ action: 'save', ctx })
         log.trace({ topic }, 'subscribed')
         const res = await pubsub.subscribe(topic)
-        const primaryKey = entity.primaryKey
         const fields = meta.getFields([{ info }])
 
         for await (const msg of res) {
@@ -55,8 +61,8 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
       type: new graphql.GraphQLObjectType({
         name: `${field.name}Deleted`,
         fields: {
-          [field.primaryKey]: {
-            type: meta.fields[field.primaryKey].type
+          [primaryKey]: {
+            type: meta.fields[primaryKey].type
           }
         }
       })
@@ -64,7 +70,6 @@ function setupSubscriptions (app, metaMap, resolvers, ignores) {
     resolvers.Subscription[deleted] = {
       subscribe: async (_, query, ctx, info) => {
         const { pubsub } = ctx
-        const entity = app.platformatic.entities[field.singularName]
         const topic = await entity.getSubscriptionTopic({ action: 'delete', ctx })
         const res = await pubsub.subscribe(topic)
         ctx.reply.request.log.trace({ topic }, 'subscribed')

package/lib/utils.js

@@ -54,6 +54,8 @@ function sqlTypeToGraphQL (sqlType) {
       return graphql.GraphQLString
     case 'json':
       return GraphQLJSONObject
+    case 'jsonb':
+      return GraphQLJSONObject
     default:
       return graphql.GraphQLString
   }

package/package.json

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

package/test/composite.test.js

@@ -0,0 +1,474 @@
+'use strict'
+
+const { clear, connInfo, isSQLite, isMysql, isPg } = require('./helper')
+const { test } = require('tap')
+const fastify = require('fastify')
+const sqlMapper = require('@platformatic/sql-mapper')
+const sqlEvents = require('@platformatic/sql-events')
+const sqlGraphQL = require('..')
+
+test('composite primary keys', async ({ equal, same, teardown, rejects }) => {
+  /* https://github.com/platformatic/platformatic/issues/299 */
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+
+    if (isSQLite) {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        the_title VARCHAR(42)
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id INTEGER PRIMARY KEY,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT fk_editor_pages FOREIGN KEY (page_id) REFERENCES pages(id),
+        CONSTRAINT fk_editor_users FOREIGN KEY (user_id) REFERENCES users(id),
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    } else if (isPg) {
+      await db.query(sql`CREATE TABLE pages (
+        id SERIAL PRIMARY KEY,
+        the_title VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id SERIAL PRIMARY KEY,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT fk_editor_pages FOREIGN KEY (page_id) REFERENCES pages(id),
+        CONSTRAINT fk_editor_users FOREIGN KEY (user_id) REFERENCES users(id),
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    } else if (isMysql) {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY AUTO_INCREMENT,
+        the_title VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTO_INCREMENT,
+        username VARCHAR(255) NOT NULL
+      );`)
+
+      await db.query(sql`CREATE TABLE editors (
+        page_id INTEGER NOT NULL,
+        user_id INTEGER NOT NULL,
+        role VARCHAR(255) NOT NULL,
+        CONSTRAINT \`fk_editor_pages\` FOREIGN KEY (page_id) REFERENCES pages (id) ON DELETE CASCADE ON UPDATE RESTRICT,
+        CONSTRAINT \`fk_editor_users\` FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE ON UPDATE RESTRICT,
+        PRIMARY KEY (page_id, user_id)
+      );`)
+    }
+  }
+
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    onDatabaseLoad
+  })
+  app.register(sqlEvents) // needed as if it's present it might throw
+  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: { theTitle: "foobar" }) {
+              id
+              theTitle
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    same(res.json(), {
+      data: {
+        savePage: {
+          id: 1,
+          theTitle: 'foobar'
+        }
+      }
+    }, 'savePage response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveUser(input: { username: "mcollina" }) {
+              id
+              username
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveUser status code')
+    same(res.json(), {
+      data: {
+        saveUser: {
+          id: 1,
+          username: 'mcollina'
+        }
+      }
+    }, 'saveUser response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveUser(input: { username: "lucamaraschi" }) {
+              id
+              username
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveUser status code')
+    same(res.json(), {
+      data: {
+        saveUser: {
+          id: 2,
+          username: 'lucamaraschi'
+        }
+      }
+    }, 'saveUser response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "1", pageId: "1", role: "admin" }) {
+              user {
+                id
+                username
+              }
+              page {
+                id
+                theTitle
+              }
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          user: {
+            id: 1,
+            username: 'mcollina'
+          },
+          page: {
+            id: 1,
+            theTitle: 'foobar'
+          },
+          role: 'admin'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "2", pageId: "1", role: "author" }) {
+              user {
+                id
+                username
+              }
+              page {
+                id
+                theTitle
+              }
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          user: {
+            id: 2,
+            username: 'lucamaraschi'
+          },
+          page: {
+            id: 1,
+            theTitle: 'foobar'
+          },
+          role: 'author'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "1", pageId: "1", role: "captain" }) {
+              user {
+                id
+                username
+              }
+              page {
+                id
+                theTitle
+              }
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          user: {
+            id: 1,
+            username: 'mcollina'
+          },
+          page: {
+            id: 1,
+            theTitle: 'foobar'
+          },
+          role: 'captain'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'post',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            editors(orderBy: { field: role, direction: DESC }) {
+              user {
+                id
+                username
+              }
+              page {
+                id
+                theTitle
+              }
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'editors status code')
+    same(res.json(), {
+      data: {
+        editors: [{
+          user: {
+            id: '1',
+            username: 'mcollina'
+          },
+          page: {
+            id: '1',
+            theTitle: 'foobar'
+          },
+          role: 'captain'
+        }, {
+          user: {
+            id: '2',
+            username: 'lucamaraschi'
+          },
+          page: {
+            id: '1',
+            theTitle: 'foobar'
+          },
+          role: 'author'
+        }]
+      }
+    }, 'editor response')
+  }
+})
+
+test('composite primary keys with no foreign keys', async ({ equal, same, teardown, rejects }) => {
+  /* https://github.com/platformatic/platformatic/issues/299 */
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+
+    await db.query(sql`CREATE TABLE editors (
+      page_id INTEGER NOT NULL,
+      user_id INTEGER NOT NULL,
+      role VARCHAR(255) NOT NULL,
+      PRIMARY KEY (page_id, user_id)
+    );`)
+  }
+
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    onDatabaseLoad
+  })
+  app.register(sqlEvents) // needed as if it's present it will throw
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "1", pageId: "1", role: "admin" }) {
+              userId
+              pageId
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          userId: '1',
+          pageId: '1',
+          role: 'admin'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "2", pageId: "1", role: "author" }) {
+              userId
+              pageId
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          userId: '2',
+          pageId: '1',
+          role: 'author'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            saveEditor(input: { userId: "1", pageId: "1", role: "captain" }) {
+              userId
+              pageId
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'saveEditor status code')
+    same(res.json(), {
+      data: {
+        saveEditor: {
+          userId: 1,
+          pageId: 1,
+          role: 'captain'
+        }
+      }
+    }, 'saveEditor response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'post',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            editors(orderBy: { field: role, direction: DESC }) {
+              userId
+              pageId
+              role
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'editors status code')
+    same(res.json(), {
+      data: {
+        editors: [{
+          userId: '1',
+          pageId: '1',
+          role: 'captain'
+        }, {
+          userId: '2',
+          pageId: '1',
+          role: 'author'
+        }]
+      }
+    }, 'editor response')
+  }
+})

package/test/helper.js

@@ -30,6 +30,11 @@ if (!process.env.DB || process.env.DB === 'postgresql') {
 module.exports.connInfo = connInfo
 
 module.exports.clear = async function (db, sql) {
+  try {
+    await db.query(sql`DROP TABLE editors`)
+  } catch (err) {
+  }
+
   try {
     await db.query(sql`DROP TABLE pages`)
   } catch (err) {

package/test/ignore.test.js

@@ -115,3 +115,93 @@ test('ignore a column', async ({ pass, teardown, equal }) => {
     equal(Category.fields.find((f) => f.name === 'name'), undefined, 'name column is ignored')
   }
 })
+
+test('ignore a table via sql-graphql option', async ({ pass, teardown, equal }) => {
+  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, {
+    ignore: {
+      categories: true
+    }
+  })
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            __schema {
+              types {
+                name
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'introspection query status code')
+    const data = res.json().data
+    equal(data.__schema.types.find((t) => t.name === 'Category'), undefined, 'Category type is ignored')
+  }
+})
+
+test('ignore a column via sql-graphql option', async ({ pass, teardown, equal }) => {
+  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, {
+    ignore: {
+      categories: {
+        name: true
+      }
+    }
+  })
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            __schema {
+              types {
+                name
+                fields {
+                  name
+                }
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'introspection query status code')
+    const data = res.json().data
+    const Category = data.__schema.types.find((t) => t.name === 'Category')
+    equal(Category.fields.find((f) => f.name === 'name'), undefined, 'name column is ignored')
+  }
+})

package/test/simple.test.js

@@ -4,7 +4,7 @@ const { test } = require('tap')
 const sqlGraphQL = require('..')
 const sqlMapper = require('@platformatic/sql-mapper')
 const fastify = require('fastify')
-const { clear, connInfo, isSQLite, isMysql, isMariaDB } = require('./helper')
+const { clear, connInfo, isSQLite, isMysql, isMariaDB, isPg } = require('./helper')
 
 async function createBasicPages (db, sql) {
   if (isSQLite) {
@@ -901,3 +901,59 @@ test('deserialize JSON columns', { skip: isSQLite }, async (t) => {
     same(json.data.getPageById.metadata, jsonData)
   }
 })
+
+test('deserialize JSONB columns', { skip: !isPg }, async (t) => {
+  const { pass, teardown, same } = t
+  const app = fastify()
+  const jsonData = {
+    foo: 'bar',
+    baz: 42,
+    items: ['foo', 'bar'],
+    nested: {
+      hello: 'world'
+    }
+  }
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`CREATE TABLE pages (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(255) NOT NULL,
+        metadata JSONB NOT NULL
+      );`)
+
+      await db.query(sql`INSERT INTO pages (id, title, metadata) VALUES (1, 'Hello World', ${JSON.stringify(jsonData)})`)
+    }
+  })
+  app.register(sqlGraphQL, {
+    graphiql: false
+  })
+  teardown(app.close.bind(app))
+
+  await app.ready()
+  const res = await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+        query {
+          getPageById(id: 1) {
+            id
+            title
+            metadata
+          }
+        }
+      `
+    }
+  })
+  const json = res.json()
+  if (isMariaDB) {
+    same(json.data.getPageById.metadata, JSON.stringify(jsonData))
+  } else {
+    same(json.data.getPageById.metadata, jsonData)
+  }
+})

package/test/subscription.test.js

@@ -33,7 +33,7 @@ function createWebSocketClient (t, app) {
   return { client, ws }
 }
 
-test('subscription - crud', { only: true }, async t => {
+test('subscription - crud', async t => {
   const app = Fastify()
   t.teardown(() => app.close())
 

package/test/where.test.js

@@ -812,3 +812,291 @@ test('delete all', async ({ pass, teardown, same, equal }) => {
     }, 'posts response')
   }
 })
+
+test('like', async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      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
+        );`)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  const posts = [{
+    title: 'Dog',
+    longText: 'The dog barks',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'The cat meows',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'The mouse likes cheese',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+          mutation batch($inputs : [PostInput]!) {
+            insertPosts(inputs: $inputs) {
+              id
+              title
+            }
+          }
+        `,
+      variables: {
+        inputs: posts
+      }
+    }
+  })
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'posts status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '1',
+          title: 'Dog',
+          longText: 'The dog barks',
+          counter: 10
+        }, {
+          id: '2',
+          title: 'Cat',
+          longText: 'The cat meows',
+          counter: 20
+        }, {
+          id: '3',
+          title: 'Mouse',
+          longText: 'The mouse likes cheese',
+          counter: 30
+        }, {
+          id: '4',
+          title: 'Duck',
+          longText: 'A duck tale',
+          counter: 40
+        }]
+      }
+    }, 'posts response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts(where: { longText: { like: "The%" } }) {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'where: { longText: { like: "The%" } } status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '1',
+          title: 'Dog',
+          longText: 'The dog barks',
+          counter: 10
+        }, {
+          id: '2',
+          title: 'Cat',
+          longText: 'The cat meows',
+          counter: 20
+        }, {
+          id: '3',
+          title: 'Mouse',
+          longText: 'The mouse likes cheese',
+          counter: 30
+        }]
+      }
+    }, 'where: { longText: { like: "The%" } } response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts(where: { longText: { like: "%s" } }) {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'where: { longText: { like: "%s" } } status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '1',
+          title: 'Dog',
+          longText: 'The dog barks',
+          counter: 10
+        }, {
+          id: '2',
+          title: 'Cat',
+          longText: 'The cat meows',
+          counter: 20
+        }]
+      }
+    }, 'where: { longText: { like: "%s" } } response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts(where: { longText: { like: "%o%" } }) {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'where: { longText: { like: "%o%" } } status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '1',
+          title: 'Dog',
+          longText: 'The dog barks',
+          counter: 10
+        }, {
+          id: '2',
+          title: 'Cat',
+          longText: 'The cat meows',
+          counter: 20
+        }, {
+          id: '3',
+          title: 'Mouse',
+          longText: 'The mouse likes cheese',
+          counter: 30
+        }]
+      }
+    }, 'where: { longText: { like: "%o%" } } response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts(where: { counter: { like: 10 } }) {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'where: { counter: { like: 10 } } status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '1',
+          title: 'Dog',
+          longText: 'The dog barks',
+          counter: 10
+        }]
+      }
+    }, 'where: { counter: { like: 10 } } response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            posts(where: { counter: { like: 40 } }) {
+              id
+              title
+              longText
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'where: { counter: { like: 40 } } status code')
+    same(res.json(), {
+      data: {
+        posts: [{
+          id: '4',
+          title: 'Duck',
+          longText: 'A duck tale',
+          counter: 40
+        }]
+      }
+    }, 'where: { counter: { like: 40 } } response')
+  }
+})