feat: Support custom hash function

Ability to specify your own hash function
maticzav · Jun 19, 2019 · 2371ea6 · 2371ea6
2 parents c491937 + f24adb9
commit 2371ea6
Show file tree

Hide file tree

Showing 7 changed files with 117 additions and 22 deletions.
diff --git a/README.md b/README.md
@@ -231,13 +231,16 @@ interface IRuleTypeMap {
 
 type IRules = ShieldRule | IRuleTypeMap
 
+type IHashFunction = (arg: { parent: any; args: any }) => string
+
 // Generator Options
 
 interface IOptions {
   debug?: boolean
   allowExternalErrors?: boolean
   fallbackRule?: ShieldRule
   fallbackError?: string | Error
+  hashFunction?: IHashFunction
 }
 
 declare function shield(
@@ -358,12 +361,13 @@ const server = GraphQLServer({
 
 #### `options`
 
-| Property            | Required | Default                  | Description                                        |
-| ------------------- | -------- | ------------------------ | -------------------------------------------------- |
-| allowExternalErrors | false    | false                    | Toggle catching internal errors.                   |
-| debug               | false    | false                    | Toggle debug mode.                                 |
-| fallbackRule        | false    | allow                    | The default rule for every "rule-undefined" field. |
-| fallbackError       | false    | Error('Not Authorised!') | Error Permission system fallbacks to.              |
+| Property            | Required | Default                                              | Description                                        |
+| ------------------- | -------- | ---------------------------------------------------- | -------------------------------------------------- |
+| allowExternalErrors | false    | false                                                | Toggle catching internal errors.                   |
+| debug               | false    | false                                                | Toggle debug mode.                                 |
+| fallbackRule        | false    | allow                                                | The default rule for every "rule-undefined" field. |
+| fallbackError       | false    | Error('Not Authorised!')                             | Error Permission system fallbacks to.              |
+| hashFunction        | false    | [object-hash](https://github.com/puleos/object-hash) | Hashing function to use for `strict` cache         |
 
 By default `shield` ensures no internal data is exposed to client if it was not meant to be. Therefore, all thrown errors during execution resolve in `Not Authorised!` error message if not otherwise specified using `error` wrapper. This can be turned off by setting `allowExternalErrors` option to true.
 

diff --git a/src/generator.ts b/src/generator.ts
@@ -10,7 +10,13 @@ import {
   isIntrospectionType,
   GraphQLResolveInfo,
 } from 'graphql'
-import { IRules, IOptions, ShieldRule, IRuleFieldMap } from './types'
+import {
+  IRules,
+  IOptions,
+  ShieldRule,
+  IRuleFieldMap,
+  IShieldContext,
+} from './types'
 import {
   isRuleFunction,
   isRuleFieldMap,
@@ -36,20 +42,19 @@ function generateFieldMiddlewareFromRule(
     resolve: (parent, args, ctx, info) => any,
     parent: { [key: string]: any },
     args: { [key: string]: any },
-    ctx: any,
+    ctx: IShieldContext,
     info: GraphQLResolveInfo,
   ) {
     // Cache
     if (!ctx) {
-      ctx = {}
+      ctx = {} as IShieldContext
     }
 
     if (!ctx._shield) {
-      ctx._shield = {}
-    }
-
-    if (!ctx._shield.cache) {
-      ctx._shield.cache = {}
+      ctx._shield = {
+        cache: {},
+        hashFunction: options.hashFunction,
+      }
     }
 
     // Execution

diff --git a/src/rules.ts b/src/rules.ts
@@ -1,4 +1,3 @@
-import * as hash from 'object-hash'
 import * as Yup from 'yup'
 import {
   IRuleFunction,
@@ -12,6 +11,7 @@ import {
   ShieldRule,
   IRuleResult,
   IOptions,
+  IShieldContext,
 } from './types'
 import { isLogicRule } from './utils'
 
@@ -44,7 +44,7 @@ export class Rule implements IRule {
   async resolve(
     parent,
     args,
-    ctx,
+    ctx: IShieldContext,
     info,
     options: IOptions,
   ): Promise<IRuleResult> {
@@ -146,13 +146,11 @@ export class Rule implements IRule {
    * Generates cache key based on cache option.
    *
    */
-  private generateCacheKey(parent, args, ctx, info): string {
+  private generateCacheKey(parent, args, ctx: IShieldContext, info): string {
     switch (this.cache) {
       case 'strict': {
-        const key = hash({
-          parent,
-          args,
-        })
+        const key = ctx._shield.hashFunction({ parent, args })
+
         return `${this.name}-${key}`
       }
       case 'contextual': {

diff --git a/src/shield.ts b/src/shield.ts
@@ -1,6 +1,13 @@
+import * as hash from 'object-hash'
 import { middleware, IMiddlewareGenerator } from 'graphql-middleware'
 import { ValidationError, validateRuleTree } from './validation'
-import { IRules, IOptions, IOptionsConstructor, ShieldRule } from './types'
+import {
+  IRules,
+  IOptions,
+  IOptionsConstructor,
+  ShieldRule,
+  IHashFunction,
+} from './types'
 import { generateMiddlewareGeneratorFromRuleTree } from './generator'
 import { allow } from './constructors'
 import { withDefault } from './utils'
@@ -25,6 +32,7 @@ function normalizeOptions(options: IOptionsConstructor): IOptions {
     fallbackError: withDefault(new Error('Not Authorised!'))(
       options.fallbackError,
     ),
+    hashFunction: withDefault<IHashFunction>(hash)(options.hashFunction),
   }
 }
 

diff --git a/src/types.ts b/src/types.ts
@@ -64,23 +64,34 @@ export interface IRuleFieldMap {
 
 export type IRules = ShieldRule | IRuleTypeMap
 
+export type IHashFunction = (arg: { parent: any; args: any }) => string
+
 // Generator Options
 
 export interface IOptions {
   debug: boolean
   allowExternalErrors: boolean
   fallbackRule: ShieldRule
   fallbackError: Error
+  hashFunction: IHashFunction
 }
 
 export interface IOptionsConstructor {
   debug?: boolean
   allowExternalErrors?: boolean
   fallbackRule?: ShieldRule
   fallbackError?: string | Error
+  hashFunction?: IHashFunction
 }
 
 export declare function shield<TSource = any, TContext = any, TArgs = any>(
   ruleTree: IRules,
   options: IOptions,
 ): IMiddlewareGenerator<TSource, TContext, TArgs>
+
+export interface IShieldContext {
+  _shield: {
+    cache: { [key: string]: IRuleResult | Promise<IRuleResult> }
+    hashFunction: IHashFunction
+  }
+}
diff --git a/tests/cache.test.ts b/tests/cache.test.ts
@@ -2,6 +2,7 @@ import { graphql } from 'graphql'
 import { applyMiddleware } from 'graphql-middleware'
 import { makeExecutableSchema } from 'graphql-tools'
 import { shield, rule } from '../src/index'
+import { IHashFunction } from '../src/types'
 
 describe('Caching works as expected', () => {
   test('Strict cache - Rule is called multiple times, based on different parent.', async () => {
@@ -263,6 +264,73 @@ describe('Caching works as expected', () => {
   })
 })
 
+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(schemaWithPermissions, query, undefined, {})
+
+  /* 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 */

diff --git a/tests/logic.test.ts b/tests/logic.test.ts
@@ -228,6 +228,7 @@ describe('internal execution', () => {
         debug: false,
         fallbackRule: undefined,
         fallbackError: new Error(),
+        hashFunction: () => `${Math.random()}`,
       },
     )