graphql-shield-node23 7.6.5

package/tests/generator.test.ts

@@ -0,0 +1,356 @@
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import { applyMiddleware } from 'graphql-middleware'
+import { shield, rule } from '../src'
+import { graphql } from 'graphql'
+
+describe('generates correct middleware', () => {
+  test('correctly applies schema rule to schema', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String
+        type: Type
+      }
+      type Type {
+        a: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        type: () => ({}),
+      },
+      Type: {
+        a: () => 'a',
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const permissions = shield(rule({ cache: 'no_cache' })(allowMock))
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+    const query = `
+      query {
+        a
+        type {
+          a
+        }
+      }
+    `
+
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        type: {
+          a: 'a',
+        },
+      },
+    })
+    expect(allowMock).toBeCalledTimes(3)
+  })
+
+  test('correctly applies type rule to type', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String
+        type: Type
+      }
+      type Type {
+        a: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        type: () => ({}),
+      },
+      Type: {
+        a: () => 'a',
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const permissions = shield({
+      Query: rule({ cache: 'no_cache' })(allowMock),
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+    const query = `
+      query {
+        a
+        type {
+          a
+        }
+      }
+    `
+
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        type: {
+          a: 'a',
+        },
+      },
+    })
+    expect(allowMock).toBeCalledTimes(2)
+  })
+
+  test('correctly applies field rule to field', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String
+        type: Type
+      }
+      type Type {
+        a: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        type: () => ({}),
+      },
+      Type: {
+        a: () => 'a',
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const permissions = shield({
+      Query: { a: rule({ cache: 'no_cache' })(allowMock) },
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+    const query = `
+      query {
+        a
+        type {
+          a
+        }
+      }
+    `
+
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        type: {
+          a: 'a',
+        },
+      },
+    })
+    expect(allowMock).toBeCalledTimes(1)
+  })
+
+  test('correctly applies wildcard rule to type', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String
+        b: String
+        type: Type
+      }
+      type Type {
+        field1: String
+        field2: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        type: () => ({
+          field1: 'field1',
+          field2: 'field2',
+        }),
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const defaultQueryMock = jest.fn().mockResolvedValue(true)
+    const defaultTypeMock = jest.fn().mockResolvedValue(true)
+
+    const permissions = shield({
+      Query: {
+        a: rule({ cache: 'no_cache' })(allowMock),
+        type: rule({ cache: 'no_cache' })(jest.fn().mockResolvedValue(true)),
+        '*': rule({ cache: 'no_cache' })(defaultQueryMock),
+      },
+      Type: {
+        '*': rule({ cache: 'no_cache' })(defaultTypeMock),
+      },
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+    const query = `
+      query {
+        a
+        b
+        type {
+          field1
+          field2
+        }
+      }
+    `
+
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        type: {
+          field1: 'field1',
+          field2: 'field2',
+        },
+      },
+    })
+    expect(allowMock).toBeCalledTimes(1)
+    expect(defaultQueryMock).toBeCalledTimes(1)
+    expect(defaultTypeMock).toBeCalledTimes(2)
+  })
+
+  test('correctly allows multiple uses of the same wildcard rule', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String
+        b: String
+        type: Type
+      }
+      type Type {
+        field1: String
+        field2: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        type: () => ({
+          field1: 'field1',
+          field2: 'field2',
+        }),
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const defaultQueryMock = jest.fn().mockResolvedValue(true)
+    const defaultTypeMock = jest.fn().mockResolvedValue(true)
+
+    const permissions = shield({
+      Query: {
+        a: rule({ cache: 'no_cache' })(allowMock),
+        type: rule({ cache: 'no_cache' })(jest.fn().mockResolvedValue(true)),
+        '*': rule({ cache: 'no_cache' })(defaultQueryMock),
+      },
+      Type: {
+        '*': rule({ cache: 'no_cache' })(defaultTypeMock),
+      },
+    })
+
+    /* First usage */
+    applyMiddleware(schema, permissions)
+
+    /* Second usage */
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+    const query = `
+      query {
+        a
+        b
+        type {
+          field1
+          field2
+        }
+      }
+    `
+
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        type: {
+          field1: 'field1',
+          field2: 'field2',
+        },
+      },
+    })
+    expect(allowMock).toBeCalledTimes(1)
+    expect(defaultQueryMock).toBeCalledTimes(1)
+    expect(defaultTypeMock).toBeCalledTimes(2)
+  })
+})

package/tests/input.test.ts

@@ -0,0 +1,63 @@
+import { graphql } from 'graphql'
+import { applyMiddleware } from 'graphql-middleware'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import { shield, inputRule } from '../src'
+
+describe('input rule', () => {
+  test('schema validation works as expected', async () => {
+    const typeDefs = `
+      type Query {
+        hello: String!
+      }
+
+      type Mutation {
+        login(email: String!): String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        hello: () => 'world',
+      },
+      Mutation: {
+        login: () => 'pass',
+      },
+    }
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    // Permissions
+    const permissions = shield({
+      Mutation: {
+        login: inputRule()((yup) =>
+          yup.object({
+            email: yup.string().email('It has to be an email!').required(),
+          }),
+        ),
+      },
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      mutation {
+        success: login(email: "shield@graphql.com")
+        failure: login(email: "notemail")
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+    })
+
+    /* Tests */
+
+    expect(res.data).toEqual({
+      success: 'pass',
+      failure: null,
+    })
+    expect(res.errors).toMatchSnapshot()
+  })
+})

package/tests/integration.test.ts

@@ -0,0 +1,65 @@
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import { gql, ApolloServer } from 'apollo-server'
+import fetch from 'node-fetch'
+import { applyMiddleware } from 'graphql-middleware'
+
+import { shield, allow, deny } from '../src'
+
+describe('integration tests', () => {
+  test('works with ApolloServer', async () => {
+    /* Schema */
+
+    const typeDefs = gql`
+      type Query {
+        allow: String
+        deny: String
+      }
+    `
+
+    const resolvers = {
+      Query: {
+        allow: () => 'allow',
+        deny: () => 'deny',
+      },
+    }
+
+    /* Permissions */
+
+    const permissions = shield({
+      Query: {
+        allow: allow,
+        deny: deny,
+      },
+    })
+
+    const server = new ApolloServer({
+      schema: applyMiddleware(makeExecutableSchema({ typeDefs, resolvers }), permissions),
+    })
+
+    await server.listen({ port: 8008 })
+    const uri = `http://localhost:8008/`
+
+    /* Tests */
+
+    const query = `
+      query {
+        allow
+        deny
+      }
+    `
+
+    const res = await fetch(uri, {
+      method: 'POST',
+      body: JSON.stringify({ query }),
+      headers: { 'Content-Type': 'application/json' },
+    }).then((res) => res.json())
+
+    expect(res.data).toEqual({
+      allow: 'allow',
+      deny: null,
+    })
+    expect(res.errors.length).toBe(1)
+
+    await server.stop()
+  })
+})