@platformatic/sql-graphql 0.0.23

package/test/no-modification-of-entity.test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+
+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)
+    );`)
+  }
+}
+
+test('no modification of entity', async ({ teardown, equal, pass }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+      await createBasicPages(db, sql)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  equal(app.platformatic.entities.page.type, undefined, 'no type in entity')
+
+  for (const field of Object.values(app.platformatic.entities.page.fields)) {
+    equal(field.type, undefined, `no type in field ${field.camelcase}`)
+  }
+})
+
+test('no modification of entity with nested data', 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_id BIGINT UNSIGNED,
+            FOREIGN KEY (category_id) 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_id 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_id INTEGER REFERENCES categories(id)
+          );
+        `)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  equal(app.platformatic.entities.page.type, undefined, 'no type in entity')
+
+  for (const field of Object.values(app.platformatic.entities.page.fields)) {
+    equal(field.type, undefined, `no type in field ${field.camelcase}`)
+  }
+
+  equal(app.platformatic.entities.category.type, undefined, 'no type in entity')
+
+  for (const field of Object.values(app.platformatic.entities.category.fields)) {
+    equal(field.type, undefined, `no type in field ${field.camelcase}`)
+  }
+})

package/test/order_by.test.js

@@ -0,0 +1,397 @@
+'use strict'
+
+const { test } = require('tap')
+const sqlGraphQL = require('..')
+const sqlMapper = require('@platformatic/sql-mapper')
+const fastify = require('fastify')
+const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+
+test('one-level order by', async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE pages (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          counter INTEGER
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE pages (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          counter INTEGER
+        );`)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation batch($inputs : [PageInput]!) {
+            insertPages (inputs: $inputs) {
+              id
+              title
+              counter
+            }
+          }
+        `,
+        variables: {
+          inputs: [
+            { title: 'Page 1', counter: 3 },
+            { title: 'Page 2', counter: 2 },
+            { title: 'Page 3', counter: 1 }
+          ]
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    same(res.json(), {
+      data: {
+        insertPages: [
+          { id: 1, title: 'Page 1', counter: 3 },
+          { id: 2, title: 'Page 2', counter: 2 },
+          { id: 3, title: 'Page 3', counter: 1 }
+        ]
+      }
+    }, 'savePage response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages (orderBy: { field: counter, direction: ASC }) {
+              id
+              title
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        pages: [
+          { id: 3, title: 'Page 3', counter: 1 },
+          { id: 2, title: 'Page 2', counter: 2 },
+          { id: 1, title: 'Page 1', counter: 3 }
+        ]
+      }
+    }, 'pages response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages (orderBy: { field: counter, direction: DESC }) {
+              id
+              title
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        pages: [
+          { id: 1, title: 'Page 1', counter: 3 },
+          { id: 2, title: 'Page 2', counter: 2 },
+          { id: 3, title: 'Page 3', counter: 1 }
+        ]
+      }
+    }, 'pages response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages (orderBy: { field: counter}) {
+              id
+              title
+              counter
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 400, 'pages status code')
+    same(res.json(), {
+      data: null,
+      errors: [{
+        message: 'Field "PageOrderByArguments.direction" of required type "OrderByDirection!" was not provided.',
+        locations: [{
+          line: 3,
+          column: 29
+        }
+        ]
+      }]
+    })
+  }
+})
+
+test('list order by', async ({ pass, teardown, same, equal }) => {
+  const app = fastify()
+  app.register(sqlMapper, {
+    ...connInfo,
+    async onDatabaseLoad (db, sql) {
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE pages (
+          id INTEGER PRIMARY KEY,
+          counter INTEGER,
+          counter2 INTEGER
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE pages (
+          id SERIAL PRIMARY KEY,
+          counter INTEGER,
+          counter2 INTEGER
+        );`)
+      }
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await app.ready()
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          mutation batch($inputs : [PageInput]!) {
+            insertPages (inputs: $inputs) {
+              id
+              counter
+              counter2
+            }
+          }
+        `,
+        variables: {
+          inputs: [
+            { counter: 3, counter2: 3 },
+            { counter: 3, counter2: 2 },
+            { counter: 1, counter2: 1 }
+          ]
+        }
+      }
+    })
+    equal(res.statusCode, 200, 'savePage status code')
+    same(res.json(), {
+      data: {
+        insertPages: [
+          { id: 1, counter: 3, counter2: 3 },
+          { id: 2, counter: 3, counter2: 2 },
+          { id: 3, counter: 1, counter2: 1 }
+        ]
+      }
+    }, 'savePage response')
+  }
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            pages (orderBy: [{ field: counter, direction: ASC }, { field: counter2, direction: DESC }]) {
+              id
+              counter,
+              counter2
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'pages status code')
+    same(res.json(), {
+      data: {
+        pages: [
+          { id: 3, counter: 1, counter2: 1 },
+          { id: 1, counter: 3, counter2: 3 },
+          { id: 2, counter: 3, counter2: 2 }
+        ]
+      }
+    }, 'pages response')
+  }
+})
+
+test('nested order by', 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_id BIGINT UNSIGNED,
+            FOREIGN KEY (category_id) 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_id 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_id 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 pages = [{
+    title: 'foo',
+    categoryId: 1
+  }, {
+    title: 'bar',
+    categoryId: 1
+  }]
+
+  await app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+            mutation batch($inputs: [PageInput]!) {
+              insertPages(inputs: $inputs) {
+                id
+                title
+              }
+            }
+          `,
+      variables: {
+        inputs: pages
+      }
+    }
+  })
+
+  {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/graphql',
+      body: {
+        query: `
+          query {
+            categories {
+              id
+              name
+              pages(orderBy: { field: title, direction: ASC }) {
+                id
+                title
+              }
+            }
+          }
+        `
+      }
+    })
+    equal(res.statusCode, 200, 'categories.posts status code')
+    same(res.json(), {
+      data: {
+        categories: [{
+          id: 1,
+          name: 'Pets',
+          pages: [{
+            id: 2,
+            title: 'bar'
+          }, {
+            id: 1,
+            title: 'foo'
+          }]
+        }, {
+          id: 2,
+          name: 'Food',
+          pages: []
+        }]
+      }
+    }, 'categories.posts response')
+  }
+})

package/test/relations.test.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const { skip, test } = require('tap')
+const { tmpdir } = require('os')
+const { randomUUID } = require('crypto')
+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)
+}
+
+test('should fail when an unknown foreign key relationship exists', async ({ pass, rejects, same, 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 subcategories(id) ON DELETE CASCADE
+          );
+        );`)
+    }
+  })
+  app.register(sqlGraphQL)
+  teardown(app.close.bind(app))
+
+  await rejects(app.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+          mutation {
+            saveCategory(input: { name: "pets" }) {
+              id
+              name
+            }
+          }
+        `
+    }
+  }), new Error('No foreign table named "subcategories" was found'))
+})