@platformatic/sql-graphql 0.3.0 → 0.5.0

package/test/relations.test.js

@@ -7,14 +7,12 @@ const { join } = require('path')
 const sqlGraphQL = require('..')
 const sqlMapper = require('@platformatic/sql-mapper')
 const fastify = require('fastify')
-const { isSQLite } = require('./helper')
-
-if (!isSQLite) {
-  skip('The db is not SQLite')
-  process.exit(0)
-}
+const { isSQLite, connInfo, isMysql, clear } = require('./helper')
 
 test('should fail when an unknown foreign key relationship exists', async ({ pass, rejects, same, teardown }) => {
+  if (!isSQLite) {
+    skip('The db is not SQLite')
+  }
   const file = join(tmpdir(), randomUUID())
   const app = fastify()
   app.register(sqlMapper, {
@@ -58,3 +56,331 @@ test('should fail when an unknown foreign key relationship exists', async ({ pas
     }
   }), new Error('No foreign table named "subcategories" was found'))
 })
+
+test('should handle multi references', 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 authors (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255)
+          );
+          CREATE TABLE books (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            author_id BIGINT UNSIGNED,
+            another_author_id BIGINT UNSIGNED,
+            FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE CASCADE,
+            FOREIGN KEY (another_author_id) REFERENCES authors(id) ON DELETE CASCADE
+          );
+        `)
+      } else if (isSQLite) {
+        await db.query(sql`
+          CREATE TABLE authors (
+            id INTEGER PRIMARY KEY,
+            name VARCHAR(255)
+          );
+        `)
+        await db.query(sql`
+          CREATE TABLE books (
+            id INTEGER PRIMARY KEY,
+            title VARCHAR(42),
+            author_id BIGINT UNSIGNED,
+            another_author_id BIGINT UNSIGNED,
+            FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE CASCADE,
+            FOREIGN KEY (another_author_id) REFERENCES authors(id) ON DELETE CASCADE
+          );
+        `)
+      } else {
+        await db.query(sql`
+          CREATE TABLE authors (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42)
+          );
+          CREATE TABLE books (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(42),
+            author_id INTEGER REFERENCES authors(id),
+            another_author_id INTEGER REFERENCES authors(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  const authors = [{
+    id: 1,
+    name: 'Mark'
+  }]
+
+  const books = [{
+    id: 1,
+    title: 'Harry',
+    authorId: 1,
+    anotherAuthorId: 1
+  }]
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [AuthorInput]!) {
+              insertAuthors(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+        variables: {
+          inputs: authors
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'authors status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [BookInput]!) {
+              insertBooks(inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+        variables: {
+          inputs: books
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'books status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query {
+              books {
+                id
+                author {
+                  id
+                }
+                anotherAuthor {
+                  id
+                }
+              }
+            }
+          `
+      }
+    })
+    equal(res.statusCode, 200, 'query books')
+    same(res.json(), {
+      data: {
+        books: [{
+          id: 1,
+          author: {
+            id: 1
+          },
+          anotherAuthor: {
+            id: 1
+          }
+        }]
+      }
+    }, 'query book response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query {
+              authors {
+                id
+                books {
+                  id
+                }
+              }
+            }
+          `
+      }
+    })
+    equal(res.statusCode, 200, 'query authors')
+    same(res.json(), {
+      data: {
+        authors: [{
+          id: 1,
+          books: [{
+            id: 1
+          }]
+        }]
+      }
+    }, 'query authors response')
+  }
+})
+
+test('cut out id exactly from ending when forming a name of relation', 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 individuals (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255)
+          );
+          CREATE TABLE organizations (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42),
+            individual_id BIGINT UNSIGNED,
+            FOREIGN KEY (individual_id) REFERENCES individuals(id) ON DELETE CASCADE
+          );
+        `)
+      } else if (isSQLite) {
+        await db.query(sql`
+          CREATE TABLE individuals (
+            id INTEGER PRIMARY KEY,
+            name VARCHAR(255)
+          );
+        `)
+        await db.query(sql`
+          CREATE TABLE organizations (
+            id INTEGER PRIMARY KEY,
+            name VARCHAR(42),
+            individual_id BIGINT UNSIGNED,
+            FOREIGN KEY (individual_id) REFERENCES individuals(id) ON DELETE CASCADE
+          );
+        `)
+      } else {
+        await db.query(sql`
+          CREATE TABLE individuals (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42)
+          );
+          CREATE TABLE organizations (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(42),
+            individual_id INTEGER REFERENCES individuals(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  const individuals = [{
+    id: 1,
+    name: 'Mark'
+  }]
+
+  const organization = [{
+    id: 1,
+    name: 'Platformatic',
+    individualId: 1
+  }]
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [IndividualInput]!) {
+              insertIndividuals(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+        variables: {
+          inputs: individuals
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'individuals status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            mutation batch($inputs : [OrganizationInput]!) {
+              insertOrganizations(inputs: $inputs) {
+                id
+                name
+              }
+            }
+          `,
+        variables: {
+          inputs: organization
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'organization status code')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+            query {
+              organizations {
+                id
+                name
+                individual {
+                  id
+                  name
+                }
+              }
+            }
+          `
+      }
+    })
+    equal(res.statusCode, 200, 'query organization')
+    same(res.json(), {
+      data: {
+        organizations: [{
+          id: 1,
+          name: 'Platformatic',
+          individual: {
+            id: 1,
+            name: 'Mark'
+          }
+        }]
+      }
+    }, 'query organization response')
+  }
+})

package/test/subscription.test.js

@@ -0,0 +1,336 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const WebSocket = require('ws')
+const { once } = require('events')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const sqlEvents = require('@platformatic/sql-events')
+const { clear, connInfo, isSQLite } = require('./helper')
+const stream = require('stream')
+const graphql = require('graphql')
+
+async function createBasicPages (db, sql) {
+  if (isSQLite) {
+    await db.query(sql`CREATE TABLE pages (
+      id INTEGER PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+  } else {
+    await db.query(sql`CREATE TABLE pages (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+  }
+}
+
+function createWebSocketClient (t, app) {
+  const ws = new WebSocket('ws://localhost:' + (app.server.address()).port + '/graphql', 'graphql-ws')
+  const client = WebSocket.createWebSocketStream(ws, { encoding: 'utf8', objectMode: true })
+  t.teardown(client.destroy.bind(client))
+  client.setEncoding('utf8')
+  return { client, ws }
+}
+
+test('subscription - crud', { only: true }, async t => {
+  const app = Fastify()
+  t.teardown(() => app.close())
+
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlEvents)
+  app.register(sqlGraphQL)
+
+  await app.listen({ port: 0 })
+
+  const { client } = createWebSocketClient(t, app)
+
+  client.write(JSON.stringify({
+    type: 'connection_init'
+  }))
+
+  {
+    const query = `subscription {
+      pageSaved {
+        id
+        title
+      }
+    }`
+    client.write(JSON.stringify({
+      id: 1,
+      type: 'start',
+      payload: {
+        query
+      }
+    }))
+  }
+
+  {
+    const query = `subscription {
+      pageDeleted {
+        id
+      }
+    }`
+    client.write(JSON.stringify({
+      id: 1,
+      type: 'start',
+      payload: {
+        query
+      }
+    }))
+  }
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.equal(data.type, 'connection_ack')
+  }
+
+  t.comment('sending mutation')
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+        mutation {
+          savePage(input: { title: "Hello World" }) {
+            id
+          }
+        }
+      `
+    }
+  })
+
+  t.comment('mutation sent')
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.same(data, {
+      id: 1,
+      type: 'data',
+      payload: {
+        data: {
+          pageSaved: {
+            id: '1',
+            title: 'Hello World'
+          }
+        }
+      }
+    })
+  }
+
+  t.comment('updating entity')
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+        mutation {
+          savePage(input: { id: 1, title: "Harry Potter" }) {
+            id
+          }
+        }
+      `
+    }
+  })
+
+  t.comment('entity updated')
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.same(data, {
+      id: 1,
+      type: 'data',
+      payload: {
+        data: {
+          pageSaved: {
+            id: '1',
+            title: 'Harry Potter'
+          }
+        }
+      }
+    })
+  }
+
+  t.comment('deleting entity')
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+        mutation {
+          deletePages(where: { id: { eq: 1 } }) {
+            id
+          }
+        }
+      `
+    }
+  })
+
+  t.comment('entity deleted')
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.same(data, {
+      id: '1',
+      type: 'data',
+      payload: {
+        data: {
+          pageDeleted: {
+            id: '1'
+          }
+        }
+      }
+    })
+  }
+
+  t.comment('sending mutation')
+
+  {
+    const [
+      received,
+      stored
+    ] = await Promise.all(([
+      (async function () {
+        const res = await app.inject({
+          method: 'POST',
+          url: '/graphql',
+          body: {
+            query: `
+            mutation batch($inputs : [PageInput]!) {
+              insertPages (inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+            variables: {
+              inputs: [
+                { title: 'Page 1' },
+                { title: 'Page 2' },
+                { title: 'Page 3' }
+              ]
+            }
+          }
+        })
+        t.comment('mutation sent')
+        const pages = res.json().data.insertPages
+        t.comment(JSON.stringify(pages, null, 2))
+        return pages
+      })(),
+      (async function () {
+        const pages = []
+        const second = new stream.PassThrough({ objectMode: true })
+        client.pipe(second)
+        for await (const chunk of second) {
+          const data = JSON.parse(chunk)
+          pages.push(data.payload.data.pageSaved)
+          if (pages.length === 3) {
+            break
+          }
+        }
+        t.comment('received all pages', JSON.stringify(pages, null, 2))
+        return pages
+      })()
+    ]))
+
+    t.same(received, stored)
+  }
+})
+
+test('subscription - ignore', async t => {
+  const app = Fastify()
+  t.teardown(() => app.close())
+
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlEvents)
+  app.register(sqlGraphQL, {
+    subscriptionIgnore: ['page']
+  })
+
+  await app.ready()
+  t.equal(graphql.printSchema(app.graphql.schema).indexOf('type Subscription'), -1)
+})
+
+test('subscription - crud with two schemas and a ignore', async t => {
+  const app = Fastify()
+  t.teardown(() => app.close())
+
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE categories (
+          id INTEGER PRIMARY KEY,
+          name VARCHAR(42)
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE categories (
+          id SERIAL PRIMARY KEY,
+          name VARCHAR(42)
+        );`)
+      }
+    }
+  })
+  app.register(sqlEvents)
+  app.register(sqlGraphQL, {
+    subscriptionIgnore: ['category']
+  })
+
+  await app.listen({ port: 0 })
+
+  const { client } = createWebSocketClient(t, app)
+  t.teardown(() => client.destroy())
+
+  client.write(JSON.stringify({
+    type: 'connection_init'
+  }))
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.equal(data.type, 'connection_ack')
+  }
+
+  {
+    const query = `subscription {
+      categorySaved {
+        id
+      }
+    }`
+    client.write(JSON.stringify({
+      id: 1,
+      type: 'start',
+      payload: {
+        query
+      }
+    }))
+  }
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.equal(data.payload, 'The subscription field "categorySaved" is not defined.')
+  }
+})