@platformatic/sql-graphql 0.9.2 → 0.10.0

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.10.0",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
   "repository": {
@@ -14,8 +14,8 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
-    "@platformatic/sql-events": "0.9.2",
-    "@platformatic/sql-mapper": "0.9.2",
+    "@platformatic/sql-events": "0.10.0",
+    "@platformatic/sql-mapper": "0.10.0",
     "fastify": "^4.6.0",
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",

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/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')
+  }
+})