@platformatic/sql-graphql 0.12.1 → 0.13.1

package/lib/entity-to-type.js

@@ -49,13 +49,19 @@ function constructGraph (app, entity, opts, ignore) {
     // sqlite doesn't support enums
     /* istanbul ignore next */
     if (field.enum) {
-      const enumValues = field.enum.reduce((acc, enumValue) => {
-        const valueStartsWithLetterOrUnderscore = !!enumValue.match(/^[_a-zA-Z]/g)
-        if (!valueStartsWithLetterOrUnderscore) {
-          enumValue = `_${enumValue}`
+      const enumValues = field.enum.reduce((acc, enumValue, index) => {
+        let key = enumValue.replace(/[^\w\s]/g, '_')
+
+        const keyStartsWithLetterOrUnderscore = !!key.match(/^[_a-zA-Z]/g)
+        if (!keyStartsWithLetterOrUnderscore) {
+          key = `_${key}`
+        }
+
+        if (key.startsWith('__')) {
+          key = key.replace('__', `enum${++index}`)
         }
 
-        acc[enumValue.replace(/[^\w\s]/g, '_')] = { value: enumValue }
+        acc[key] = { value: enumValue }
         return acc
       }, {})
       try {

package/lib/relationship.js

@@ -23,7 +23,7 @@ module.exports = function establishRelations (app, relations, resolvers, loaders
 
     const current = entitiesTypeMap[entityName]
     const foreign = entitiesTypeMap[foreignEntityName]
-    assert(foreign !== undefined, `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}`)
+    assert(foreign !== undefined, `No foreign table named "${foreign_table_name}" was found ${enhanceAssertLogMsg}. Relation: ${JSON.stringify(relation, null, 2)}`)
 
     // current to foreign, we skip this if the foreign table has a composite primary key
     // TODO implement support for this case

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-graphql",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "Map SQL dbs to GraphQL",
   "main": "index.js",
   "repository": {
@@ -20,8 +20,8 @@
     "tap": "^16.3.2",
     "tsd": "^0.25.0",
     "ws": "^8.11.0",
-    "@platformatic/sql-events": "0.12.1",
-    "@platformatic/sql-mapper": "0.12.1"
+    "@platformatic/sql-events": "0.13.1",
+    "@platformatic/sql-mapper": "0.13.1"
   },
   "dependencies": {
     "camelcase": "^6.3.0",

package/test/enum.test.js

@@ -98,3 +98,128 @@ test('should not fail if tables have duplicate enum names', { skip: isSQLite },
     same(true, false, 'Previous call should never fail')
   }
 })
+
+test('should not fail if tables have enum with special characters', { skip: isSQLite }, async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isPg) {
+        await db.query(sql`
+          CREATE TYPE custom_enum AS ENUM('.', ',');
+
+          CREATE TABLE enum_tests (
+            id INTEGER NOT NULL,
+            test_enum custom_enum,
+            PRIMARY KEY (id)
+          );
+        `)
+      } else {
+        await db.query(sql`
+          CREATE TABLE enum_tests (
+            id INTEGER NOT NULL,
+            test_enum ENUM ('.', ',') DEFAULT NULL,
+            PRIMARY KEY (id)
+          );
+        `)
+      }
+    }
+  })
+
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+    same(true, true, 'custom_enum have special chars, but app does not throws')
+  } catch (err) {
+    console.log(err)
+    same(true, false, 'Previous call should never fail')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation ($input: EnumTestInput!) {
+              saveEnumTest(input: $input) {
+                id
+              }
+            }
+          `,
+        variables: { input: { id: 1 } }
+      }
+    })
+    equal(res.statusCode, 200)
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation ($input: EnumTestInput!) {
+              saveEnumTest(input: $input) {
+                id
+              }
+            }
+          `,
+        variables: { input: { id: 2 } }
+      }
+    })
+    equal(res.statusCode, 200)
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query { enumTests { id } }
+          `
+      }
+    })
+    equal(res.statusCode, 200)
+    same(res.json(), { data: { enumTests: [{ id: 1 }, { id: 2 }] } })
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation ($input: EnumTestWhereArgumentsid!) {
+              deleteEnumTests(where: {id: $input}) {
+                id
+              }
+            }
+          `,
+        variables: { input: { eq: 1 } }
+      }
+    })
+    equal(res.statusCode, 200)
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query { enumTests { id } }
+          `
+      }
+    })
+    equal(res.statusCode, 200)
+    same(res.json(), { data: { enumTests: [{ id: 2 }] } })
+  }
+})

package/test/helper.js

@@ -127,6 +127,16 @@ module.exports.clear = async function (db, sql) {
   } catch (err) {
   }
 
+  try {
+    await db.query(sql`DROP TABLE test4.books`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP TABLE test3.authors`)
+  } catch (err) {
+  }
+
   try {
     await db.query(sql`DROP TABLE test2.books`)
   } catch (err) {
@@ -137,6 +147,16 @@ module.exports.clear = async function (db, sql) {
   } catch (err) {
   }
 
+  try {
+    await db.query(sql`DROP SCHEMA test4`)
+  } catch (err) {
+  }
+
+  try {
+    await db.query(sql`DROP SCHEMA test3`)
+  } catch (err) {
+  }
+
   try {
     await db.query(sql`DROP SCHEMA test2`)
   } catch (err) {

package/test/schema.test.js

@@ -4,7 +4,7 @@ const { test } = require('tap')
 const sqlGraphQL = require('..')
 const sqlMapper = require('@platformatic/sql-mapper')
 const fastify = require('fastify')
-const { isSQLite, connInfo, isMysql, clear } = require('./helper')
+const { isSQLite, isPg, connInfo, isMysql, clear } = require('./helper')
 
 test('should handle relationships with different schemas', { skip: isSQLite }, async ({ pass, teardown, same, equal }) => {
   const app = fastify()
@@ -165,3 +165,113 @@ test('should handle relationships with different schemas', { skip: isSQLite }, a
     }, 'query authors response')
   }
 })
+
+test('should not throw if all of the schema with contraint references are loaded on the config', { skip: !isPg }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    schema: ['test1', 'test2', 'test3', 'test4'],
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test3;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test4;`)
+      await db.query(sql`
+        CREATE TABLE test1.authors (
+          id INTEGER PRIMARY KEY,
+          name VARCHAR(42)
+        );
+        
+        CREATE TABLE test2.books (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          author_id INTEGER
+        );
+        
+        CREATE TABLE test3.authors (
+          id INTEGER PRIMARY KEY,
+          name VARCHAR(42)
+        );
+        
+        CREATE TABLE test4.books (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          author_id INTEGER
+        );
+        
+        ALTER TABLE ONLY test2.books
+          ADD CONSTRAINT authors_fkey FOREIGN KEY (author_id) REFERENCES test1.authors(id);
+        
+        ALTER TABLE ONLY test4.books
+          ADD CONSTRAINT authors_fkey FOREIGN KEY (author_id) REFERENCES test3.authors(id);
+      `)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+  } catch (error) {
+    same(true, false, 'app should not throw')
+  }
+})
+
+test('should not throw if some of the schema with contraint references are not passed to the config', { skip: !isPg }, async ({ pass, teardown, same }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    schema: ['test1', 'test2'],
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test3;`)
+      await db.query(sql`CREATE SCHEMA IF NOT EXISTS test4;`)
+      await db.query(sql`
+        CREATE TABLE test1.authors (
+          id INTEGER PRIMARY KEY,
+          name VARCHAR(42)
+        );
+        
+        CREATE TABLE test2.books (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          author_id INTEGER
+        );
+        
+        CREATE TABLE test3.authors (
+          id INTEGER PRIMARY KEY,
+          name VARCHAR(42)
+        );
+        
+        CREATE TABLE test4.books (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          author_id INTEGER
+        );
+        
+        ALTER TABLE ONLY test2.books
+          ADD CONSTRAINT authors_fkey FOREIGN KEY (author_id) REFERENCES test1.authors(id);
+        
+        ALTER TABLE ONLY test4.books
+          ADD CONSTRAINT authors_fkey FOREIGN KEY (author_id) REFERENCES test3.authors(id);
+      `)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  try {
+    await app.ready()
+  } catch (error) {
+    same(true, false, 'we expect the app to not throw')
+  }
+})