@platformatic/sql-graphql 0.8.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,7 +15,12 @@ const ascDesc = new graphql.GraphQLEnumType({
   }
 })
 
-function constructGraph (app, entity, opts) {
+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)
@@ -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
@@ -134,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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "0.8.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.8.0",
-    "@platformatic/sql-mapper": "0.8.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

@@ -4,6 +4,7 @@ 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 }) => {
@@ -76,6 +77,7 @@ test('composite primary keys', async ({ equal, same, teardown, rejects }) => {
     ...connInfo,
     onDatabaseLoad
   })
+  app.register(sqlEvents) // needed as if it's present it might throw
   app.register(sqlGraphQL)
   teardown(app.close.bind(app))
 
@@ -329,3 +331,144 @@ test('composite primary keys', async ({ equal, same, teardown, rejects }) => {
     }, '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/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')
+  }
+})