@platformatic/sql-graphql 0.46.1 → 0.46.2

package/test/special-chars.test.js

@@ -1,47 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const sqlGraphQL = require('..')
-const sqlMapper = require('@platformatic/sql-mapper')
-const fastify = require('fastify')
-const { clear, connInfo, isSQLite, isPg } = require('./helper')
-
-test('should correctly get the special characters', { skip: isSQLite }, async ({ pass, teardown, same }) => {
-  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 ('application/pdf', 'image/jpeg', 'image/png');
-        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 ('application/pdf', 'image/jpeg', 'image/png'),
-          PRIMARY KEY (id)
-        );`)
-      }
-    }
-  })
-
-  app.register(sqlGraphQL)
-  teardown(app.close.bind(app))
-
-  try {
-    await app.ready()
-    same(true, true, 'Special characters are properly configured')
-  } catch (err) {
-    console.log(err)
-    same(true, false, 'Previous call should never fail')
-  }
-})

package/test/sqlite.test.js

@@ -1,274 +0,0 @@
-'use strict'
-
-const fastify = require('fastify')
-const sqlGraphQL = require('..')
-const sqlMapper = require('@platformatic/sql-mapper')
-const { isSQLite } = require('./helper')
-const { test, skip } = require('tap')
-const { tmpdir } = require('os')
-const { join } = require('path')
-const { randomUUID } = require('crypto')
-
-if (!isSQLite) {
-  skip('The db is not SQLite')
-  process.exit(0)
-}
-
-test('store, close and load', async ({ pass, same, equal }) => {
-  const file = join(tmpdir(), randomUUID())
-  {
-    const app = fastify()
-    app.register(sqlMapper, {
-      connectionString: `sqlite://${file}`,
-      async onDatabaseLoad (db, sql) {
-        pass('onDatabaseLoad called')
-
-        await db.query(sql`CREATE TABLE pages (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42)
-        );`)
-      }
-    })
-    app.register(sqlGraphQL)
-
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-          mutation {
-            savePage(input: { title: "Hello" }) {
-              id
-              title
-            }
-          }
-        `
-      }
-    })
-    equal(res.statusCode, 200, 'savePage status code')
-    same(res.json(), {
-      data: {
-        savePage: {
-          id: 1,
-          title: 'Hello'
-        }
-      }
-    }, 'savePage response')
-
-    await app.close()
-  }
-
-  {
-    const app = fastify()
-    app.register(sqlMapper, {
-      connectionString: `sqlite://${file}`
-    })
-    app.register(sqlGraphQL)
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-          query {
-            getPageById(id: 1) {
-              id
-              title
-            }
-          }
-        `
-      }
-    })
-    equal(res.statusCode, 200, 'pages status code')
-    same(res.json(), {
-      data: {
-        getPageById: {
-          id: 1,
-          title: 'Hello'
-        }
-      }
-    }, 'pages response')
-    await app.close()
-  }
-})
-
-test('demo', async ({ pass, same, equal, teardown }) => {
-  const file = join(tmpdir(), randomUUID())
-  const app = fastify()
-  app.register(sqlMapper, {
-    connectionString: `sqlite://${file}`,
-    async onDatabaseLoad (db, sql) {
-      pass('onDatabaseLoad called')
-
-      await db.query(sql`
-          CREATE TABLE categories (
-            id INTEGER PRIMARY KEY,
-            name TEXT NOT NULL
-          );`)
-
-      await db.query(sql`
-          CREATE TABLE pages (
-            id INTEGER PRIMARY KEY,
-            title TEXT,
-            body TEXT,
-            category_id INTEGER,
-            FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE CASCADE
-          );`)
-    }
-  })
-  app.register(sqlGraphQL)
-  teardown(app.close.bind(app))
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-            mutation {
-              saveCategory(input: { name: "pets" }) {
-                id
-                name
-              }
-            }
-          `
-      }
-    })
-    equal(res.statusCode, 200, 'saveCategory status code')
-    same(res.json(), {
-      data: {
-        saveCategory: {
-          id: 1,
-          name: 'pets'
-        }
-      }
-    }, 'saveCategory response')
-  }
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-            mutation {
-              savePage(input: { title: "Dogs", body: "Dogs are cool", categoryId: "1" }) {
-                id
-                title
-                category {
-                  id
-                  name
-                }
-              }
-            }
-          `
-      }
-    })
-    equal(res.statusCode, 200, 'savePage status code')
-    same(res.json(), {
-      data: {
-        savePage: {
-          id: 1,
-          title: 'Dogs',
-          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
-                }
-              }
-            }
-          `
-      }
-    })
-    equal(res.statusCode, 200, 'getPageById status code')
-    same(res.json(), {
-      data: {
-        getPageById: {
-          id: 1,
-          title: 'Dogs',
-          category: {
-            id: 1,
-            name: 'pets'
-          }
-        }
-      }
-    }, 'saveCategory response')
-  }
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-          query allPages {
-            pages {
-              title
-              category {
-                name
-              }
-            }
-          }
-        `
-      }
-    })
-    equal(res.statusCode, 200, 'pages status code')
-    same(res.json(), {
-      data: {
-        pages: [{
-          title: 'Dogs',
-          category: {
-            name: 'pets'
-          }
-        }]
-      }
-    }, 'pages response')
-  }
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: {
-        query: `
-          query allCategories {
-            categories {
-              name
-              pages {
-                title
-              }
-            }
-          }
-        `
-      }
-    })
-    equal(res.statusCode, 200, 'categories status code')
-    same(res.json(), {
-      data: {
-        categories: [{
-          name: 'pets',
-          pages: [{
-            title: 'Dogs'
-          }]
-        }]
-      }
-    }, 'categories response')
-  }
-})

package/test/subscription.test.js

@@ -1,336 +0,0 @@
-'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', 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.')
-  }
-})

package/test/types/errors.test-d.ts

@@ -1,15 +0,0 @@
-import { expectType } from 'tsd'
-import { FastifyError } from '@fastify/error'
-import {
-  errors
-} from '../../index'
-
-// Errors
-type ErrorWithNoParams = () => FastifyError
-type ErrorWithOneParam = (param: string) => FastifyError
-
-expectType<ErrorWithNoParams>(errors.UnableToGenerateGraphQLEnumTypeError)
-expectType<ErrorWithOneParam>(errors.UnsupportedKindError)
-expectType<ErrorWithNoParams>(errors.ErrorPrintingGraphQLSchema)
-
-

package/test/types/index.test-d.ts

@@ -1,32 +0,0 @@
-import { expectType } from 'tsd'
-import { fastify, FastifyInstance } from 'fastify'
-import { MercuriusPlugin } from 'mercurius'
-import plugin, { SQLGraphQLPluginOptions } from '../../index'
-
-const pluginOptions: SQLGraphQLPluginOptions = {
-  graphiql: true,
-  federationMetadata: true,
-  resolvers: {
-    Mutation: {
-      savePage: false,
-      deletePages: false,
-      insertPages: false
-    },
-    Query: {
-      async getCategory (root, args, context, info) {
-        return { id: 1, name: 'Hello' }
-      }
-    },
-  },
-  schema: `
-    extend type Query {
-      add(a: Int!, b: Int!): Int
-    }
-  `
-}
-
-const instance: FastifyInstance = fastify()
-instance.register(plugin, pluginOptions)
-instance.register(async (instance) => {
-  expectType<MercuriusPlugin>(instance.graphql)
-})