fix: Disable schema validation by default (#278)

* add `schemaValidation` flag to `IAgentOptions` to enable validation of inputs and outputs. * update config templates to set `schemaValidation` flag to false * update integration tests to consider validation Closes #255 Closes #275
decentralized-identity · Nov 23, 2020 · 7bb77cd · 7bb77cd
1 parent b97ff3b
commit 7bb77cd
Show file tree

Hide file tree

Showing 13 changed files with 118 additions and 38 deletions.
diff --git a/__tests__/localAgent.test.ts b/__tests__/localAgent.test.ts
@@ -6,6 +6,7 @@ import {
   IKeyManager,
   IDataStore,
   IMessageHandler,
+  IAgentOptions,
 } from '../packages/daf-core/src'
 import { MessageHandler } from '../packages/daf-message-handler/src'
 import { KeyManager } from '../packages/daf-key-manager/src'
@@ -61,7 +62,7 @@ let agent: TAgent<
 >
 let dbConnection: Promise<Connection>
 
-const setup = async (): Promise<boolean> => {
+const setup = async (options?: IAgentOptions): Promise<boolean> => {
   dbConnection = createConnection({
     type: 'sqlite',
     database: databaseFile,
@@ -81,6 +82,7 @@ const setup = async (): Promise<boolean> => {
       ICredentialIssuer &
       ISelectiveDisclosure
   >({
+    ...options,
     context: {
       // authenticatedDid: 'did:example:3456'
     },

diff --git a/__tests__/restAgent.test.ts b/__tests__/restAgent.test.ts
@@ -8,6 +8,7 @@ import {
   IKeyManager,
   IDataStore,
   IMessageHandler,
+  IAgentOptions,
 } from '../packages/daf-core/src'
 import { MessageHandler } from '../packages/daf-message-handler/src'
 import { KeyManager } from '../packages/daf-key-manager/src'
@@ -59,27 +60,29 @@ let dbConnection: Promise<Connection>
 let serverAgent: IAgent
 let restServer: Server
 
-const getAgent = () => createAgent<
-  IIdentityManager &
-    IKeyManager &
-    IDataStore &
-    IDataStoreORM &
-    IResolver &
-    IMessageHandler &
-    IDIDComm &
-    ICredentialIssuer &
-    ISelectiveDisclosure
->({
-  plugins: [
-    new AgentRestClient({
-      url: 'http://localhost:' + port + basePath,
-      enabledMethods: Object.keys(serverAgent.getSchema().components.methods),
-      schema: serverAgent.getSchema()
-    }),
-  ],
-})
+const getAgent = (options?: IAgentOptions) =>
+  createAgent<
+    IIdentityManager &
+      IKeyManager &
+      IDataStore &
+      IDataStoreORM &
+      IResolver &
+      IMessageHandler &
+      IDIDComm &
+      ICredentialIssuer &
+      ISelectiveDisclosure
+  >({
+    ...options,
+    plugins: [
+      new AgentRestClient({
+        url: 'http://localhost:' + port + basePath,
+        enabledMethods: Object.keys(serverAgent.getSchema().components.methods),
+        schema: serverAgent.getSchema(),
+      }),
+    ],
+  })
 
-const setup = async (): Promise<boolean> => {
+const setup = async (options?: IAgentOptions): Promise<boolean> => {
   dbConnection = createConnection({
     type: 'sqlite',
     database: databaseFile,
@@ -89,6 +92,7 @@ const setup = async (): Promise<boolean> => {
   })
 
   serverAgent = new Agent({
+    ...options,
     plugins: [
       new KeyManager({
         store: new KeyStore(dbConnection, new SecretBox(secretKey)),
@@ -139,7 +143,7 @@ const setup = async (): Promise<boolean> => {
   const agentRouter = AgentRouter({
     getAgentForRequest: async (req) => serverAgent,
     exposedMethods: serverAgent.availableMethods(),
-    basePath
+    basePath,
   })
 
   return new Promise((resolve) => {

diff --git a/__tests__/shared/keyManager.ts b/__tests__/shared/keyManager.ts
@@ -1,10 +1,10 @@
-import { TAgent, IIdentityManager, IKeyManager } from '../../packages/daf-core/src'
+import { TAgent, IIdentityManager, IKeyManager, IAgentOptions } from '../../packages/daf-core/src'
 
 type ConfiguredAgent = TAgent<IIdentityManager & IKeyManager>
 
 export default (testContext: {
   getAgent: () => ConfiguredAgent
-  setup: () => Promise<boolean>
+  setup: (options?: IAgentOptions) => Promise<boolean>
   tearDown: () => Promise<boolean>
 }) => {
   describe('key manager', () => {
@@ -64,7 +64,7 @@ export default (testContext: {
           //@ts-ignore
           type: 'foobar',
         }),
-      ).rejects.toThrow('No enum match for: foobar')
+      ).rejects.toThrow('Key type not supported: foobar')
     })
 
     it('should create key with meta data', async () => {

diff --git a/__tests__/shared/resolveDid.ts b/__tests__/shared/resolveDid.ts
@@ -1,10 +1,10 @@
-import { TAgent, IResolver, ValidationError } from '../../packages/daf-core/src'
+import { TAgent, IResolver, ValidationError, IAgentOptions } from '../../packages/daf-core/src'
 
 type ConfiguredAgent = TAgent<IResolver>
 
 export default (testContext: {
-  getAgent: () => ConfiguredAgent
-  setup: () => Promise<boolean>
+  getAgent: (options?: IAgentOptions) => ConfiguredAgent
+  setup: (options?: IAgentOptions) => Promise<boolean>
   tearDown: () => Promise<boolean>
 }) => {
   describe('resolving didUrl', () => {
@@ -24,17 +24,38 @@ export default (testContext: {
     })
 
     it('should throw an error for unsupported did methods', async () => {
-      await expect(agent.resolveDid({ didUrl: 'did:foo:bar' })).rejects.toThrow("Unsupported DID method: 'foo'")
+      await expect(agent.resolveDid({ didUrl: 'did:foo:bar' })).rejects.toThrow(
+        "Unsupported DID method: 'foo'",
+      )
     })
 
+    it('should throw error when resolving garbage', async () => {
+      //@ts-ignore
+      await expect(agent.resolveDid()).rejects.toHaveProperty('name', 'Error')
+      //@ts-ignore
+      await expect(agent.resolveDid({})).rejects.toHaveProperty('name', 'Error')
+      //@ts-ignore
+      await expect(agent.resolveDid({ didUrl: 1 })).rejects.toThrow()
+    })
+  })
+
+  describe('resolving didUrl with validation', () => {
+    let agent: ConfiguredAgent
+
+    beforeAll(async () => {
+      await testContext.setup({ schemaValidation: true })
+      agent = testContext.getAgent({ schemaValidation: true })
+      return true
+    })
+    afterAll(testContext.tearDown)
+
     it('should throw validation error', async () => {
       //@ts-ignore
       await expect(agent.resolveDid()).rejects.toHaveProperty('name', 'ValidationError')
       //@ts-ignore
       await expect(agent.resolveDid({})).rejects.toHaveProperty('name', 'ValidationError')
       //@ts-ignore
-      await expect(agent.resolveDid({didUrl: 1})).rejects.toHaveProperty('name', 'ValidationError')
-
+      await expect(agent.resolveDid({ didUrl: 1 })).rejects.toHaveProperty('name', 'ValidationError')
     })
   })
 }
diff --git a/docs/api/daf-core.iagentoptions.md b/docs/api/daf-core.iagentoptions.md
@@ -24,4 +24,5 @@ export interface IAgentOptions
 |  [context](./daf-core.iagentoptions.context.md) | Record&lt;string, any&gt; | The context object that will be available to the plugin methods |
 |  [overrides](./daf-core.iagentoptions.overrides.md) | [IPluginMethodMap](./daf-core.ipluginmethodmap.md) | The map of plugin methods. Can be used to override methods provided by plugins, or to add additional methods without writing a plugin |
 |  [plugins](./daf-core.iagentoptions.plugins.md) | [IAgentPlugin](./daf-core.iagentplugin.md)<!-- -->\[\] | The array of agent plugins |
+|  [schemaValidation](./daf-core.iagentoptions.schemavalidation.md) | boolean | Flag that enables schema validation for plugin methods. false |
 
diff --git a/docs/api/daf-core.iagentoptions.schemavalidation.md b/docs/api/daf-core.iagentoptions.schemavalidation.md
@@ -0,0 +1,15 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [daf-core](./daf-core.md) &gt; [IAgentOptions](./daf-core.iagentoptions.md) &gt; [schemaValidation](./daf-core.iagentoptions.schemavalidation.md)
+
+## IAgentOptions.schemaValidation property
+
+Flag that enables schema validation for plugin methods.
+
+ false
+
+<b>Signature:</b>
+
+```typescript
+schemaValidation?: boolean;
+```
diff --git a/package.json b/package.json
@@ -12,7 +12,7 @@
     "docs:reference": "api-documenter markdown -i ./temp -o ./docs/api",
     "docs:clean-temp": "rm -rf ./temp",
     "test": "jest --config=jest.json --maxWorkers=2",
-    "test:watch": "jest --config=jest.json --watch --verbose",
+    "test:watch": "jest --config=jest.json --watch --verbose --coverage=false",
     "daf": "./packages/daf-cli/bin/daf.js",
     "prettier": "prettier --write '{packages,__tests__, !build}/**/*.ts'",
     "prettier:examples": "prettier --write __tests__/shared/documentationExamples.ts",

diff --git a/packages/daf-cli/default/client.yml b/packages/daf-cli/default/client.yml
@@ -18,7 +18,8 @@ server:
 agent:
   $require: daf-core#Agent
   $args:
-    - plugins:
+    - schemaValidation: false
+      plugins:
         - $require: daf-rest#AgentRestClient
           $args:
             - url: http://localhost:3332

diff --git a/packages/daf-cli/default/default.yml b/packages/daf-cli/default/default.yml
@@ -46,7 +46,8 @@ messageHandler:
 agent:
   $require: daf-core#Agent
   $args:
-    - plugins:
+    - schemaValidation: true
+      plugins:
         - $require: daf-key-manager#KeyManager
           $args:
             - store:

diff --git a/packages/daf-core/api/daf-core.api.json b/packages/daf-core/api/daf-core.api.json
@@ -850,6 +850,31 @@
                 "startIndex": 1,
                 "endIndex": 3
               }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "daf-core!IAgentOptions#schemaValidation:member",
+              "docComment": "/**\n * Flag that enables schema validation for plugin methods.\n *\n * @default false\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "schemaValidation?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "releaseTag": "Public",
+              "name": "schemaValidation",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
             }
           ],
           "extendsTokenRanges": []

diff --git a/packages/daf-core/api/daf-core.api.md b/packages/daf-core/api/daf-core.api.md
@@ -57,6 +57,7 @@ export interface IAgentOptions {
   context?: Record<string, any>
   overrides?: IPluginMethodMap
   plugins?: IAgentPlugin[]
+  schemaValidation?: boolean
 }
 
 // @public

diff --git a/packages/daf-core/src/__tests__/agent.subscriber.test.ts b/packages/daf-core/src/__tests__/agent.subscriber.test.ts
@@ -178,14 +178,13 @@ describe('daf-core agent', () => {
     const errorHandler: IEventListener = {
       eventTypes: ['error'],
       onEvent: async () => {
-        console.log('throwing error in error handler')
         throw new Error('barError')
       },
     }
     const agent = new Agent({
       plugins: [plugin, errorHandler],
     })
 
-    await expect(agent.emit('foo', {})).rejects.toThrowError('ErrorEventHandlerError')
+    await expect(agent.emit('foo', {})).rejects.toThrow('ErrorEventHandlerError')
   })
 })
diff --git a/packages/daf-core/src/agent.ts b/packages/daf-core/src/agent.ts
@@ -66,6 +66,13 @@ export interface IAgentOptions {
    * ```
    */
   context?: Record<string, any>
+
+  /**
+   * Flag that enables schema validation for plugin methods.
+   *
+   * @default false
+   */
+  schemaValidation?: boolean
 }
 
 /**
@@ -85,6 +92,7 @@ export class Agent implements IAgent {
   readonly methods: IPluginMethodMap = {}
 
   private schema: IAgentPluginSchema
+  private schemaValidation: boolean
   private context?: Record<string, any>
   private protectedMethods = ['execute', 'availableMethods', 'emit']
 
@@ -167,6 +175,8 @@ export class Agent implements IAgent {
         this[method] = async (args: any) => this.execute(method, args)
       }
     }
+
+    this.schemaValidation = options?.schemaValidation || false
   }
 
   /**
@@ -215,11 +225,11 @@ export class Agent implements IAgent {
     Debug('daf:agent:' + method)('%o', args)
     if (!this.methods[method]) throw Error('Method not available: ' + method)
     const _args = args || {}
-    if (this.schema.components.methods[method]) {
+    if (this.schemaValidation && this.schema.components.methods[method]) {
       validateArguments(method, _args, this.schema)
     }
     const result = await this.methods[method](_args, { ...this.context, agent: this })
-    if (this.schema.components.methods[method]) {
+    if (this.schemaValidation && this.schema.components.methods[method]) {
       validateReturnType(method, result, this.schema)
     }
     Debug('daf:agent:' + method + ':result')('%o', result)