graphql-shield-node23 7.6.5

package/tests/cache.test.ts

@@ -0,0 +1,545 @@
+import { graphql } from 'graphql'
+import { applyMiddleware } from 'graphql-middleware'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import { shield, rule } from '../src/index'
+import { IHashFunction } from '../src/types'
+
+describe('caching:', () => {
+  test('Strict cache - Rule is called multiple times, based on different parent.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        test: [Test!]!
+      }
+  
+      type Test {
+        value: String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        test: () => [
+          { value: 'pass-A' },
+          { value: 'pass-A' },
+          { value: 'pass-B' },
+        ],
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const permissions = shield({
+      Test: rule({ cache: 'strict' })(allowMock),
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      query {
+        test {
+          value
+        }
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    expect(res).toEqual({
+      data: {
+        test: [{ value: 'pass-A' }, { value: 'pass-A' }, { value: 'pass-B' }],
+      },
+    })
+    expect(allowMock).toBeCalledTimes(2)
+  })
+
+  test('Strict cache - Rule is called multiple times, based on different arguments.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String!
+        b: String!
+        c(arg: String): String!
+        d(arg: String): String!
+        e(arg: String): String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        c: () => 'c',
+        d: () => 'd',
+        e: () => 'e',
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Tests */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+
+    const permissions = shield({
+      Query: rule({ cache: 'strict' })(allowMock),
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      query {
+        a
+        b
+        c(arg: "foo")
+        d(arg: "bar")
+        e
+        f: c(arg: "foo")
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd',
+        e: 'e',
+        f: 'c',
+      },
+    })
+    expect(allowMock).toBeCalledTimes(3)
+  })
+
+  test('Contextual Cache - rules get executed only once if reused.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String!
+        b: String!
+        c(arg: String): String!
+        d(arg: String): String!
+        e(arg: String): String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        c: () => 'c',
+        d: () => 'd',
+        e: () => 'e',
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Permissions */
+
+    const ruleOneMock = jest.fn().mockResolvedValue(true)
+    const ruleOne = rule({ cache: 'contextual' })(ruleOneMock)
+
+    const ruleTwoMock = jest.fn().mockResolvedValue(true)
+    const ruleTwo = rule({ cache: 'contextual' })(ruleTwoMock)
+
+    const permissions = shield({
+      Query: {
+        a: ruleOne,
+        b: ruleOne,
+        c: ruleOne,
+        d: ruleTwo,
+        e: ruleTwo,
+      },
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    // Execution
+    const query = `
+      query {
+        a
+        b
+        c(arg: "foo")
+        d(arg: "bar")
+        e
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd',
+        e: 'e',
+      },
+    })
+    expect(ruleOneMock).toBeCalledTimes(1)
+    expect(ruleTwoMock).toBeCalledTimes(1)
+  })
+
+  test('No Cache - rule is reexecuted every time.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String!
+        b: String!
+        c(arg: String): String!
+        d(arg: String): String!
+        e(arg: String): String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        c: () => 'c',
+        d: () => 'd',
+        e: () => 'e',
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const allow = rule({ cache: 'no_cache' })(allowMock)
+
+    const permissions = shield({
+      Query: allow,
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      query {
+        a
+        b
+        c(arg: "foo")
+        d(arg: "bar")
+        e
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd',
+        e: 'e',
+      },
+    })
+    expect(allowMock).toBeCalledTimes(5)
+  })
+
+  test('Custom cache key function - Rule is called based on custom cache key', async () => {
+    /* Schema */
+    const typeDefs = `
+      type Query {
+        a(arg: String): String!
+        b(arg: String): String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Tests */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+
+    const permissions = shield({
+      Query: rule({
+        cache: (parent, args, ctx, info) => {
+          return JSON.stringify(args)
+        },
+      })(allowMock),
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      query {
+        a(arg: "foo")
+        b(arg: "bar")
+        a2: a(arg: "foo")
+        a3: a(arg: "boo")
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        a2: 'a',
+        a3: 'a',
+      },
+    })
+    expect(allowMock).toBeCalledTimes(3)
+  })
+})
+
+test('Customize hash function', async () => {
+  /* Schema */
+  const typeDefs = `
+      type Query {
+        a(arg: String): String!
+        b(arg: String): String!
+      }
+    `
+  const resolvers = {
+    Query: {
+      a: () => 'a',
+      b: () => 'b',
+    },
+  }
+
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers,
+  })
+
+  /* Tests */
+
+  const allowMock = jest.fn().mockResolvedValue(true)
+
+  const hashFunction: IHashFunction = jest.fn((opts) => JSON.stringify(opts))
+
+  const permissions = shield(
+    {
+      Query: rule({ cache: 'strict' })(allowMock),
+    },
+    {
+      hashFunction,
+    },
+  )
+
+  const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+  /* Execution */
+
+  const query = `
+      query {
+        a(arg: "foo")
+        b(arg: "bar")
+      }
+    `
+  const res = await graphql({
+    schema: schemaWithPermissions,
+    source: query,
+    contextValue: {},
+  })
+
+  /* Tests */
+
+  expect(res).toEqual({
+    data: {
+      a: 'a',
+      b: 'b',
+    },
+  })
+  expect(allowMock).toBeCalledTimes(2)
+  expect(hashFunction).toHaveBeenCalledTimes(2)
+  expect(hashFunction).toHaveBeenCalledWith({
+    parent: undefined,
+    args: { arg: 'foo' },
+  })
+  expect(hashFunction).toHaveBeenCalledWith({
+    parent: undefined,
+    args: { arg: 'bar' },
+  })
+})
+
+describe('legacy cache:', () => {
+  test('Strict cache - Rule is called multiple times, based on different parent.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        test: [Test!]!
+      }
+  
+      type Test {
+        value: String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        test: () => [
+          { value: 'pass-A' },
+          { value: 'pass-A' },
+          { value: 'pass-B' },
+        ],
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Permissions */
+
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const permissions = shield({
+      Test: rule({ cache: true })(allowMock),
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    /* Execution */
+
+    const query = `
+      query {
+        test {
+          value
+        }
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    /* Tests */
+
+    expect(res).toEqual({
+      data: {
+        test: [{ value: 'pass-A' }, { value: 'pass-A' }, { value: 'pass-B' }],
+      },
+    })
+    expect(allowMock).toBeCalledTimes(2)
+  })
+
+  test('No Cache - rule is reexecuted every time.', async () => {
+    /* Schema */
+
+    const typeDefs = `
+      type Query {
+        a: String!
+        b: String!
+        c(arg: String): String!
+        d(arg: String): String!
+        e(arg: String): String!
+      }
+    `
+    const resolvers = {
+      Query: {
+        a: () => 'a',
+        b: () => 'b',
+        c: () => 'c',
+        d: () => 'd',
+        e: () => 'e',
+      },
+    }
+
+    const schema = makeExecutableSchema({
+      typeDefs,
+      resolvers,
+    })
+
+    /* Permissions */
+    const allowMock = jest.fn().mockResolvedValue(true)
+    const allow = rule({ cache: false })(allowMock)
+
+    const permissions = shield({
+      Query: allow,
+    })
+
+    const schemaWithPermissions = applyMiddleware(schema, permissions)
+
+    // Execution
+    const query = `
+      query {
+        a
+        b
+        c(arg: "foo")
+        d(arg: "bar")
+        e
+      }
+    `
+    const res = await graphql({
+      schema: schemaWithPermissions,
+      source: query,
+      contextValue: {},
+    })
+
+    expect(res).toEqual({
+      data: {
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd',
+        e: 'e',
+      },
+    })
+    expect(allowMock).toBeCalledTimes(5)
+  })
+})

package/tests/constructors.test.ts

@@ -0,0 +1,136 @@
+import * as Yup from 'yup'
+import { rule, and, or, not, allow, deny, inputRule, chain } from '../src/constructors'
+import { RuleAnd, RuleOr, RuleNot, RuleTrue, RuleFalse, Rule, InputRule, RuleChain } from '../src/rules'
+
+describe('rule constructor', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  test('correctly constructs from no arguments', async () => {
+    /* Mocks */
+
+    const n = Math.random()
+    jest.spyOn(Math, 'random').mockReturnValue(n)
+
+    /* Tests */
+
+    const func = () => true
+
+    expect(rule()(func)).toEqual(new Rule(n.toString(), func, {}))
+  })
+
+  test('correctly constructs with name and options', async () => {
+    const func = () => true
+
+    expect(
+      rule('name', {
+        cache: 'contextual',
+        fragment: 'fragment',
+      })(func),
+    ).toEqual(new Rule('name', func, { cache: 'contextual', fragment: 'fragment' }))
+  })
+
+  test('correctly constructs with name but no options', async () => {
+    const func = () => true
+
+    expect(rule('name')(func)).toEqual(new Rule('name', func, {}))
+  })
+
+  test('correctly constructs with options', async () => {
+    /* Mocks */
+    const n = Math.random()
+    jest.spyOn(Math, 'random').mockReturnValue(n)
+
+    /* Tests */
+
+    const func = () => true
+
+    expect(
+      rule({
+        cache: 'contextual',
+        fragment: 'fragment',
+      })(func),
+    ).toEqual(
+      new Rule(n.toString(), func, {
+        cache: 'contextual',
+        fragment: 'fragment',
+      }),
+    )
+  })
+})
+
+describe('input rules constructor', () => {
+  test('correnctly constructs an input rule with name', async () => {
+    const name = Math.random().toString()
+    let schema: Yup.ObjectSchema<{}>
+
+    const rule = inputRule(name)((yup) => {
+      schema = yup.object().shape({}).required()
+      return schema
+    })
+    expect(JSON.stringify(rule)).toEqual(JSON.stringify(new InputRule(name, () => schema)))
+  })
+
+  test('correnctly constructs an input rule', async () => {
+    const n = Math.random()
+    jest.spyOn(Math, 'random').mockReturnValue(n)
+
+    let schema: Yup.ObjectSchema<{}>
+
+    const rule = inputRule()((yup) => {
+      schema = yup.object().shape({}).required()
+      return schema
+    })
+    expect(JSON.stringify(rule)).toEqual(JSON.stringify(new InputRule(n.toString(), () => schema)))
+  })
+
+  test('correctly contructs an input rule with validation options', async () => {
+    const n = Math.random()
+    jest.spyOn(Math, 'random').mockReturnValue(n)
+
+    let schema: Yup.ObjectSchema<{}>
+    let options = { abortEarly: false }
+
+    const rule = inputRule()((yup) => {
+      schema = yup.object().shape({}).required()
+      return schema
+    }, options)
+    expect(JSON.stringify(rule)).toEqual(JSON.stringify(new InputRule(n.toString(), () => schema, options)))
+  })
+})
+
+describe('logic rules constructors', () => {
+  test('and correctly constructs rule and', async () => {
+    const ruleA = rule()(() => true)
+    const ruleB = rule()(() => true)
+    expect(and(ruleA, ruleB)).toEqual(new RuleAnd([ruleA, ruleB]))
+  })
+
+  test('chain correctly constructs rule chain', async () => {
+    const ruleA = rule()(() => true)
+    const ruleB = rule()(() => true)
+    expect(chain(ruleA, ruleB)).toEqual(new RuleChain([ruleA, ruleB]))
+  })
+
+  test('or correctly constructs rule or', async () => {
+    const ruleA = rule()(() => true)
+    const ruleB = rule()(() => true)
+    expect(or(ruleA, ruleB)).toEqual(new RuleOr([ruleA, ruleB]))
+  })
+
+  test('not correctly constructs rule not', async () => {
+    const ruleA = rule()(() => true)
+    expect(not(ruleA)).toEqual(new RuleNot(ruleA))
+  })
+})
+
+describe('basic rules', () => {
+  test('rule allow', async () => {
+    expect(allow).toEqual(new RuleTrue())
+  })
+
+  test('rule deny', async () => {
+    expect(deny).toEqual(new RuleFalse())
+  })
+})