@platformatic/sql-graphql 0.1.0 → 0.3.0

package/index.js

@@ -9,7 +9,6 @@ const scalars = require('graphql-scalars')
 
 async function mapperToGraphql (app, opts) {
   const mapper = app.platformatic
-  const autoTimestamp = opts.autoTimestamp
   const queryTopFields = {}
   const mutationTopFields = {}
   const resolvers = {}
@@ -23,42 +22,48 @@ async function mapperToGraphql (app, opts) {
     resolvers,
     loaders,
     federationReplacements,
-    federationMetadata: opts.federationMetadata,
-    autoTimestamp
-  }
-
-  const metaMap = new Map()
-  for (const entity of Object.values(mapper.entities)) {
-    relations.push(...entity.relations)
-    const meta = constructGraph(app, entity, graphOpts)
-    metaMap.set(entity, meta)
+    federationMetadata: opts.federationMetadata
   }
+  if (Object.keys(mapper.entities).length === 0) {
+    // no schema
+    queryTopFields.hello = { type: graphql.GraphQLString }
+    resolvers.Query = {
+      hello: () => 'Hello Platformatic!'
+    }
+  } else {
+    const metaMap = new Map()
+    for (const entity of Object.values(mapper.entities)) {
+      relations.push(...entity.relations)
+      const meta = constructGraph(app, entity, graphOpts)
+      metaMap.set(entity, meta)
+    }
 
-  establishRelations(app, relations, resolvers, loaders, queryTopFields, opts.resolvers || {}, metaMap)
+    establishRelations(app, relations, resolvers, loaders, queryTopFields, opts.resolvers || {}, metaMap)
 
-  if (opts.resolvers) {
-    for (const key of Object.keys(opts.resolvers)) {
-      if (!resolvers[key]) {
-        resolvers[key] = {}
-      }
+    if (opts.resolvers) {
+      for (const key of Object.keys(opts.resolvers)) {
+        if (!resolvers[key]) {
+          resolvers[key] = {}
+        }
 
-      const type = opts.resolvers[key]
-      for (const resolver of Object.keys(type)) {
-        if (type[resolver] === false) {
-          if (resolvers[key][resolver]) {
-            delete resolvers[key][resolver]
-          }
-          if (loaders[key]) {
-            delete loaders[key][resolver]
+        const type = opts.resolvers[key]
+        for (const resolver of Object.keys(type)) {
+          if (type[resolver] === false) {
+            if (resolvers[key][resolver]) {
+              delete resolvers[key][resolver]
+            }
+            if (loaders[key]) {
+              delete loaders[key][resolver]
+            }
+            /* istanbul ignore else */
+            if (key === 'Mutation') {
+              delete mutationTopFields[resolver]
+            } else if (key === 'Query') {
+              delete queryTopFields[resolver]
+            }
+          } else {
+            resolvers[key][resolver] = type[resolver]
           }
-          /* istanbul ignore else */
-          if (key === 'Mutation') {
-            delete mutationTopFields[resolver]
-          } else if (key === 'Query') {
-            delete queryTopFields[resolver]
-          }
-        } else {
-          resolvers[key][resolver] = type[resolver]
         }
       }
     }
@@ -93,7 +98,6 @@ async function mapperToGraphql (app, opts) {
     sdl += '\n'
     sdl += opts.schema
   }
-
   // Ignoriring because SQLite doesn't support dates
   /* istanbul ignore next */
   if (sdl.match(/scalar Date\n/)) {

package/lib/entity-to-type.js

@@ -16,12 +16,12 @@ const ascDesc = new graphql.GraphQLEnumType({
 })
 
 function constructGraph (app, entity, opts) {
-  const primaryKey = entity.primaryKey
-
+  const primaryKey = camelcase(entity.primaryKey)
+  const relationalFields = entity.relations
+    .map((relation) => relation.column_name)
   const entityName = entity.name
   const singular = entity.singularName
   const plural = entity.pluralName
-
   const {
     queryTopFields,
     mutationTopFields,
@@ -128,7 +128,7 @@ 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)
-    return entity.find({ ...query, fields: requestedFields, ctx })
+    return entity.find({ ...query, fields: [...requestedFields, ...relationalFields], ctx })
   }
 
   const inputType = new graphql.GraphQLInputObjectType({
@@ -143,6 +143,29 @@ function constructGraph (app, entity, opts) {
     }, {})
   })
 
+  const count = camelcase(['count', plural])
+
+  const countType = new graphql.GraphQLObjectType({
+    name: `${plural}Count`,
+    fields: {
+      total: { type: graphql.GraphQLInt }
+    }
+  })
+
+  queryTopFields[count] = {
+    type: countType,
+    args: {
+      where: { type: whereArgType }
+    }
+  }
+
+  resolvers.Query[count] = async (_, query, ctx, info) => {
+    const requestedFields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
+    requestedFields.push(primaryKey)
+    const total = await entity.count({ ...query, fields: [...requestedFields, ...relationalFields], ctx })
+    return { total }
+  }
+
   const save = camelcase(['save', singular])
 
   mutationTopFields[save] = {
@@ -154,7 +177,7 @@ function constructGraph (app, entity, opts) {
 
   resolvers.Mutation[save] = async (_, { input }, ctx, info) => {
     const fields = fromSelectionSet(info.fieldNodes[0].selectionSet)
-    return entity.save({ input, ctx, fields: [...fields] })
+    return entity.save({ input, ctx, fields: [...fields, ...relationalFields] })
   }
 
   const insert = camelcase(['insert', plural])
@@ -168,7 +191,7 @@ function constructGraph (app, entity, opts) {
 
   resolvers.Mutation[insert] = (_, { inputs }, ctx, info) => {
     const fields = fromSelectionSet(info.fieldNodes[0].selectionSet)
-    return entity.insert({ inputs, ctx, fields: [...fields] })
+    return entity.insert({ inputs, ctx, fields: [...fields, ...relationalFields] })
   }
 
   const deleteKey = camelcase(['delete', plural])
@@ -181,7 +204,7 @@ function constructGraph (app, entity, opts) {
 
   resolvers.Mutation[deleteKey] = (_, args, ctx, info) => {
     const fields = info.fieldNodes[0].selectionSet.selections.map((s) => s.name.value)
-    return entity.delete({ ...args, fields, ctx })
+    return entity.delete({ ...args, fields: [...fields, ...relationalFields], ctx })
   }
 
   federationReplacements.push({
@@ -236,11 +259,12 @@ function constructGraph (app, entity, opts) {
   }
 
   function getFields (queries) {
-    const fields = new Set()
+    const fields = new Set([...relationalFields])
     fields.add(primaryKey)
     for (const query of queries) {
       fromSelectionSet(query.info.fieldNodes[0].selectionSet, fields)
     }
+    fields.delete(undefined)
     return [...fields]
   }
 }

package/lib/relationship.js

@@ -51,7 +51,7 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
         resolvers[foreign.type] = resolvers[foreign.type] || {}
         resolvers[foreign.type][lowered] = async function (obj, args, ctx, info) {
           const fields = fromSelectionSet(info.fieldNodes[0].selectionSet, new Set())
-          const toSearch = { ...args, fields: [...fields], ctx }
+          const toSearch = { ...args, fields: [...fields, relation.column_name], ctx }
           toSearch.where = toSearch.where || {}
           toSearch.where[camelcase(relation.column_name)] = { eq: obj.id }
           return current.entity.find(toSearch)

package/lib/utils.js

@@ -2,6 +2,7 @@
 
 const graphql = require('graphql')
 const scalars = require('graphql-scalars')
+const { GraphQLJSONObject } = require('graphql-type-json')
 
 // The sqlTypeToGraphQL is shared between
 // all database adapters.
@@ -51,6 +52,8 @@ function sqlTypeToGraphQL (sqlType) {
       return scalars.GraphQLDateTime
     case 'uuid':
       return graphql.GraphQLString
+    case 'json':
+      return GraphQLJSONObject
     default:
       return graphql.GraphQLString
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
   "repository": {
@@ -14,7 +14,7 @@
   },
   "homepage": "https://github.com/plaformatic/platformatic#readme",
   "devDependencies": {
-    "@platformatic/sql-mapper": "0.1.0",
+    "@platformatic/sql-mapper": "0.3.0",
     "fastify": "^4.6.0",
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
@@ -26,6 +26,7 @@
     "fastify-plugin": "^4.1.0",
     "graphql": "^16.6.0",
     "graphql-scalars": "^1.13.1",
+    "graphql-type-json": "^0.3.2",
     "inflected": "^2.1.0",
     "mercurius": "^11.0.0"
   },
@@ -33,6 +34,7 @@
     "directory": "test/types"
   },
   "scripts": {
+    "lint": "standard",
     "test": "standard | snazzy && npm run test:typescript && npm run test:postgresql && npm run test:mariadb && npm run test:mysql && npm run test:mysql8 && npm run test:sqlite",
     "test:postgresql": "DB=postgresql tap test/*.test.js",
     "test:mariadb": "DB=mariadb tap test/*.test.js",

package/test/count.test.js

@@ -0,0 +1,126 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite } = require('./helper')
+
+test('count', 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: 'Foo',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [PostInput]!) {
+              insertPosts(inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+        variables: {
+          inputs: posts
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'posts status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            countPosts {
+              total
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'posts status code')
+    same(res.json(), {
+      data: {
+        countPosts: {
+          total: 4
+        }
+      }
+    }, 'posts response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            countPosts(where: { counter: { gt: 20 } }) {
+              total
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'posts status code')
+    same(res.json(), {
+      data: {
+        countPosts: {
+          total: 2
+        }
+      }
+    }, 'posts response')
+  }
+})

package/test/helper.js

@@ -13,6 +13,7 @@ if (!process.env.DB || process.env.DB === 'postgresql') {
   connInfo.connectionString = 'mysql://root@127.0.0.1:3307/graph'
   connInfo.poolSize = 10
   module.exports.isMysql = true
+  module.exports.isMariaDB = true
 } else if (process.env.DB === 'mysql') {
   connInfo.connectionString = 'mysql://root@127.0.0.1/graph'
   connInfo.poolSize = 10

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 } = require('./helper')
+const { clear, connInfo, isSQLite, isMysql, isMariaDB } = require('./helper')
 
 async function createBasicPages (db, sql) {
   if (isSQLite) {
@@ -706,3 +706,198 @@ test('graphiql can be disabled', async ({ pass, teardown, same, equal }) => {
   const res = await app.inject('/graphiql')
   equal(res.statusCode, 404)
 })
+
+test('default query hello should be created when no entities are found', async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+      await clear(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  const res = await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: 'query { hello }'
+    }
+  })
+  equal(res.statusCode, 200)
+  same(res.json(), {
+    data: {
+      hello: 'Hello Platformatic!'
+    }
+  })
+})
+
+test('default query hello should not be created when entities are found', async ({ pass, teardown, same, 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)
+  teardown(app.close.bind(app))
+
+  const res = await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: 'query { hello }'
+    }
+  })
+  equal(res.statusCode, 400)
+  const json = res.json()
+  same(json.data, null)
+  same(json.errors[0].message, 'Cannot query field "hello" on type "Query".')
+})
+
+test('primary key snake_case', async ({ pass, teardown, same, equal }) => {
+  async function createBasicPagesWithSnakeCasePK (db, sql) {
+    if (isSQLite) {
+      await db.query(sql`CREATE TABLE pages (
+      page_id INTEGER PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE pages (
+      page_id SERIAL PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+    }
+  }
+
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPagesWithSnakeCasePK(db, sql)
+    }
+  })
+  app.register(sqlGraphQL, {
+    graphiql: false
+  })
+  teardown(app.close.bind(app))
+
+  const res = await app.inject('/graphiql')
+  equal(res.statusCode, 404)
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation {
+            savePage(input: { title: "Hello" }) {
+              pageId
+              title
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    same(res.json(), {
+      data: {
+        savePage: {
+          pageId: 1,
+          title: 'Hello'
+        }
+      }
+    }, 'savePage response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            getPageByPageId(pageId: 1) {
+              pageId
+              title
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        getPageByPageId: {
+          pageId: 1,
+          title: 'Hello'
+        }
+      }
+    }, 'pages response')
+  }
+})
+
+test('deserialize JSON columns', { skip: isSQLite }, 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 JSON 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/types/index.test-d.ts

@@ -5,7 +5,6 @@ import plugin, { SQLGraphQLPluginOptions } from '../../index'
 
 const pluginOptions: SQLGraphQLPluginOptions = {
   graphiql: true,
-  autoTimestamp: true,
   federationMetadata: true,
   resolvers: {
     Mutation: {