@platformatic/sql-graphql 0.46.1 → 0.46.2

package/test/enum.test.js

@@ -1,225 +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 properly setup the enum types', { 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('1', '2', '3');
-
-        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 ('1', '2', '3') DEFAULT NULL,
-          PRIMARY KEY (id)
-        );`)
-      }
-    }
-  })
-
-  app.register(sqlGraphQL)
-  teardown(app.close.bind(app))
-
-  try {
-    await app.ready()
-    same(true, true, 'Enum values are properly interpreted')
-  } catch (err) {
-    console.log(err)
-    same(true, false, 'Previous call should never fail')
-  }
-})
-
-test('should not fail if tables have duplicate enum names', { 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('1', '2', '3');
-        CREATE TYPE simple_enum AS ENUM('4', '5', '6');
-        
-        CREATE TABLE enum_tests (
-          id INTEGER NOT NULL,
-          test_enum custom_enum,
-          PRIMARY KEY (id)
-        );
-        CREATE TABLE simple_types (
-          pk INTEGER NOT NULL,
-          test_enum simple_enum,
-          PRIMARY KEY (pk)
-        );`)
-      } else {
-        await db.query(sql`
-        CREATE TABLE enum_tests (
-          id INTEGER NOT NULL,
-          test_enum ENUM ('1', '2', '3') DEFAULT NULL,
-          PRIMARY KEY (id)
-        );
-        CREATE TABLE simple_types (
-          pk INTEGER NOT NULL,
-          test_enum ENUM ('4', '5', '6') DEFAULT NULL,
-          PRIMARY KEY (pk)
-        );`)
-      }
-    }
-  })
-
-  app.register(sqlGraphQL)
-  teardown(app.close.bind(app))
-
-  try {
-    await app.ready()
-    same(true, true, 'test_enum is used twice but app not throws')
-  } catch (err) {
-    console.log(err)
-    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/federation.test.js

@@ -1,312 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const Fastify = require('fastify')
-const Gateway = require('@mercuriusjs/gateway')
-const { mercuriusFederationPlugin } = require('@mercuriusjs/federation')
-const sqlGraphQL = require('..')
-const sqlMapper = require('@platformatic/sql-mapper')
-const { clear, connInfo, isSQLite } = require('./helper')
-
-async function createTestService (t, schema, resolvers = {}) {
-  const service = Fastify({ logger: { level: 'error' } })
-  service.register(mercuriusFederationPlugin, {
-    schema,
-    resolvers
-  })
-  await service.listen({ port: 0 })
-  return [service, service.server.address().port]
-}
-
-const categories = {
-  c1: {
-    id: 'c1',
-    name: 'Food'
-  },
-  c2: {
-    id: 'c2',
-    name: 'Places'
-  }
-}
-
-// This works because the database is reset between tests
-const postCategory = {
-  1: 'c1',
-  2: 'c2',
-  3: 'c1',
-  4: 'c1'
-}
-
-const categoryPost = Object.keys(postCategory).reduce((acc, key) => {
-  acc[postCategory[key]] = acc[postCategory[key]] || []
-  acc[postCategory[key]].push(key)
-  return acc
-}, {})
-
-const posts = [{
-  title: 'Post 1',
-  longText: 'This is a long text 1'
-}, {
-  title: 'Post 2',
-  longText: 'This is a long text 2'
-}, {
-  title: 'Post 3',
-  longText: 'This is a long text 3'
-}, {
-  title: 'Post 4',
-  longText: 'This is a long text 4'
-}]
-
-async function createTestGatewayServer (t, cacheOpts) {
-  const categoryServiceSchema = `
-  type Query @extends {
-    categories: [Category]
-  }
-
-  type Category @key(fields: "id") {
-    id: ID! 
-    name: String
-    posts: [Post]
-  }
-
-  type Post @key(fields: "id") @extends {
-    id: ID! @external
-    category: Category
-  }
-`
-  const categoryServiceResolvers = {
-    Query: {
-      categories: (root, args, context, info) => {
-        t.pass('Query.categories resolved')
-        return Object.values(categories)
-      }
-    },
-    Category: {
-      posts: (root, args, context, info) => {
-        t.pass('Category.posts resolved')
-        return categoryPost[root.id]
-          ? categoryPost[root.id].map(id => ({ id }))
-          : []
-      },
-      __resolveReference: (category, args, context, info) => {
-        t.pass('Category.__resolveReference')
-        return categories[category.id]
-      }
-    },
-    Post: {
-      category: (root, args, context, info) => {
-        t.pass('Post.category resolved')
-        return categories[postCategory[root.id]]
-      }
-    }
-  }
-  const [categoryService, categoryServicePort] = await createTestService(t, categoryServiceSchema, categoryServiceResolvers)
-
-  const postService = Fastify()
-  postService.register(sqlMapper, {
-    ...connInfo,
-    async onDatabaseLoad (db, sql) {
-      t.pass('onDatabaseLoad called')
-
-      await clear(db, sql)
-
-      if (isSQLite) {
-        await db.query(sql`CREATE TABLE posts (
-          id INTEGER PRIMARY KEY,
-          title VARCHAR(42),
-          long_text TEXT
-        );`)
-      } else {
-        await db.query(sql`CREATE TABLE posts (
-          id SERIAL PRIMARY KEY,
-          title VARCHAR(42),
-          long_text TEXT
-        );`)
-      }
-    }
-  })
-  postService.register(sqlGraphQL, {
-    federationMetadata: true
-  })
-  await postService.listen({ port: 0 })
-  const postServicePort = postService.server.address().port
-
-  await postService.inject({
-    method: 'POST',
-    url: '/graphql',
-    body: {
-      query: `
-          mutation batch($inputs : [PostInput]!) {
-            insertPosts(inputs: $inputs) {
-              id
-              title
-            }
-          }
-        `,
-      variables: {
-        inputs: posts
-      }
-    }
-  })
-
-  const gateway = Fastify()
-  t.teardown(async () => {
-    await gateway.close()
-    await categoryService.close()
-    await postService.close()
-  })
-  gateway.register(Gateway, {
-    gateway: {
-      services: [{
-        name: 'category',
-        url: `http://localhost:${categoryServicePort}/graphql`
-      }, {
-        name: 'post',
-        url: `http://localhost:${postServicePort}/graphql`
-      }]
-    }
-  })
-
-  return gateway
-}
-
-test('extendable', async (t) => {
-  const app = await createTestGatewayServer(t)
-
-  const query = `query {
-    categories {
-      id
-      name
-      posts {
-        id
-        title
-        longText
-        category {
-          id
-          name
-        }
-      }
-    }
-    posts {
-      id
-      title
-      category {
-        id
-        name
-      }
-    }
-  }`
-
-  const expected = {
-    data: {
-      categories: [
-        {
-          id: 'c1',
-          name: 'Food',
-          posts: [
-            {
-              id: '1',
-              title: 'Post 1',
-              longText: 'This is a long text 1',
-              category: {
-                id: 'c1',
-                name: 'Food'
-              }
-            },
-            {
-              id: '3',
-              title: 'Post 3',
-              longText: 'This is a long text 3',
-              category: {
-                id: 'c1',
-                name: 'Food'
-              }
-            },
-            {
-              id: '4',
-              title: 'Post 4',
-              longText: 'This is a long text 4',
-              category: {
-                id: 'c1',
-                name: 'Food'
-              }
-            }
-          ]
-        },
-        {
-          id: 'c2',
-          name: 'Places',
-          posts: [
-            {
-              id: '2',
-              title: 'Post 2',
-              longText: 'This is a long text 2',
-              category: {
-                id: 'c2',
-                name: 'Places'
-              }
-            }
-          ]
-        }
-      ],
-      posts: [
-        {
-          id: '1',
-          title: 'Post 1',
-          category: {
-            id: 'c1',
-            name: 'Food'
-          }
-        },
-        {
-          id: '2',
-          title: 'Post 2',
-          category: {
-            id: 'c2',
-            name: 'Places'
-          }
-        },
-        {
-          id: '3',
-          title: 'Post 3',
-          category: {
-            id: 'c1',
-            name: 'Food'
-          }
-        },
-        {
-          id: '4',
-          title: 'Post 4',
-          category: {
-            id: 'c1',
-            name: 'Food'
-          }
-        }
-      ]
-    }
-  }
-
-  t.comment('first request')
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: { query }
-    })
-
-    t.same(res.json(), expected)
-  }
-
-  t.comment('second request')
-
-  {
-    const res = await app.inject({
-      method: 'POST',
-      url: '/graphql',
-      body: { query }
-    })
-
-    t.same(res.json(), expected)
-  }
-})

package/test/fix-428.test.js

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