feat: add validation to JSON transformer

packages/core/src/agent/MessageReceiver.ts

@@ -209,7 +209,7 @@ export class MessageReceiver {
     }
 
     // Cast the plain JSON object to specific instance of Message extended from AgentMessage
-    return JsonTransformer.fromJSON(message, MessageClass)
+    return JsonTransformer.fromJSON(message, MessageClass, { validate: true })
   }
 
   /**

packages/core/src/agent/__tests__/AgentMessage.test.ts

@@ -1,6 +1,6 @@
 import { TestMessage } from '../../../tests/TestMessage'
+import { ClassValidationError } from '../../error/ClassValidationError'
 import { JsonTransformer } from '../../utils'
-import { MessageValidator } from '../../utils/MessageValidator'
 import { IsValidMessageType, parseMessageType } from '../../utils/messageType'
 import { AgentMessage } from '../AgentMessage'
 
@@ -32,7 +32,7 @@ describe('AgentMessage', () => {
 
       const message = JsonTransformer.fromJSON(json, CustomProtocolMessage)
 
-      await expect(MessageValidator.validate(message)).resolves.toBeUndefined()
+      expect(message).toBeInstanceOf(CustomProtocolMessage)
     })
 
     it('successfully validates if the message type minor version is lower than the supported message type', async () => {
@@ -43,32 +43,51 @@ describe('AgentMessage', () => {
 
       const message = JsonTransformer.fromJSON(json, CustomProtocolMessage)
 
-      await expect(MessageValidator.validate(message)).resolves.toBeUndefined()
+      await expect(message).toBeInstanceOf(CustomProtocolMessage)
     })
 
-    it('successfully validates if the message type minor version is higher than the supported message type', async () => {
+    it('successfully validates if the message type minor version is higher than the supported message type', () => {
       const json = {
         '@id': 'd61c7e3d-d4af-469b-8d42-33fd14262e17',
         '@type': 'https://didcomm.org/fake-protocol/1.8/message',
       }
 
       const message = JsonTransformer.fromJSON(json, CustomProtocolMessage)
 
-      await expect(MessageValidator.validate(message)).resolves.toBeUndefined()
+      expect(message).toBeInstanceOf(CustomProtocolMessage)
     })
 
     it('throws a validation error if the message type major version differs from the supported message type', async () => {
-      expect.assertions(1)
-
       const json = {
         '@id': 'd61c7e3d-d4af-469b-8d42-33fd14262e17',
         '@type': 'https://didcomm.org/fake-protocol/2.0/message',
       }
 
-      const message = JsonTransformer.fromJSON(json, CustomProtocolMessage)
-
-      await expect(MessageValidator.validate(message)).rejects.toMatchObject([
+      expect(() => JsonTransformer.fromJSON(json, CustomProtocolMessage)).toThrowError(ClassValidationError)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let thrownError: any
+      try {
+        JsonTransformer.fromJSON(json, CustomProtocolMessage)
+      } catch (e) {
+        thrownError = e
+      }
+      expect(thrownError.message).toContain('Failed to validate class.')
+      expect(thrownError.validationErrors).toMatchObject([
         {
+          target: {
+            appendedAttachments: undefined,
+            id: 'd61c7e3d-d4af-469b-8d42-33fd14262e17',
+            l10n: undefined,
+            pleaseAck: undefined,
+            service: undefined,
+            thread: undefined,
+            timing: undefined,
+            transport: undefined,
+            type: 'https://didcomm.org/fake-protocol/2.0/message',
+          },
+          value: 'https://didcomm.org/fake-protocol/2.0/message',
+          property: 'type',
+          children: [],
           constraints: {
             isValidMessageType: 'type does not match the expected message type (only minor version may be lower)',
           },

packages/core/src/decorators/ack/AckDecorator.test.ts

@@ -1,6 +1,8 @@
+import { wordSize } from 'bn.js'
+
 import { BaseMessage } from '../../agent/BaseMessage'
+import { ClassValidationError } from '../../error/ClassValidationError'
 import { JsonTransformer } from '../../utils/JsonTransformer'
-import { MessageValidator } from '../../utils/MessageValidator'
 import { Compose } from '../../utils/mixins'
 
 import { AckDecorated } from './AckDecoratorExtension'
@@ -25,107 +27,56 @@ describe('Decorators | AckDecoratorExtension', () => {
   })
 
   test('transforms Json to AckDecorator class', () => {
-    const transformed = JsonTransformer.fromJSON({ '~please_ack': {} }, TestMessage)
-
-    expect(transformed).toEqual({
-      pleaseAck: {
-        on: ['RECEIPT'],
-      },
-    })
-    expect(transformed).toBeInstanceOf(TestMessage)
-  })
-
-  test('successfully transforms ack decorator with on field present', () => {
-    const transformed = JsonTransformer.fromJSON(
-      {
-        '~please_ack': {
-          on: ['RECEIPT'],
+    const transformed = () =>
+      JsonTransformer.fromJSON(
+        {
+          '~please_ack': {},
+          '@id': undefined,
+          '@type': undefined,
         },
-        '@id': '7517433f-1150-46f2-8495-723da61b872a',
-        '@type': 'https://didcomm.org/test-protocol/1.0/test-message',
-      },
-      TestMessage
-    )
+        TestMessage,
+        {
+          validate: true,
+        }
+      )
 
-    expect(transformed).toEqual({
-      id: '7517433f-1150-46f2-8495-723da61b872a',
-      type: 'https://didcomm.org/test-protocol/1.0/test-message',
-      pleaseAck: {
-        on: ['RECEIPT'],
-      },
-    })
-    expect(transformed).toBeInstanceOf(TestMessage)
-  })
-
-  // this covers the pre-aip 2 please ack decorator
-  test('sets `on` value to `receipt` if `on` is not present in ack decorator', () => {
-    const transformed = JsonTransformer.fromJSON(
-      {
-        '~please_ack': {},
-        '@id': '7517433f-1150-46f2-8495-723da61b872a',
-        '@type': 'https://didcomm.org/test-protocol/1.0/test-message',
-      },
-      TestMessage
-    )
-
-    expect(transformed).toEqual({
-      id: '7517433f-1150-46f2-8495-723da61b872a',
-      type: 'https://didcomm.org/test-protocol/1.0/test-message',
-      pleaseAck: {
-        on: ['RECEIPT'],
-      },
-    })
-    expect(transformed).toBeInstanceOf(TestMessage)
-  })
-
-  test('successfully validates please ack decorator', async () => {
-    const transformedWithDefault = JsonTransformer.fromJSON(
-      {
-        '~please_ack': {},
-        '@id': '7517433f-1150-46f2-8495-723da61b872a',
-        '@type': 'https://didcomm.org/test-protocol/1.0/test-message',
-      },
-      TestMessage
-    )
-
-    await expect(MessageValidator.validate(transformedWithDefault)).resolves.toBeUndefined()
-
-    const transformedWithoutDefault = JsonTransformer.fromJSON(
+    expect(() => transformed()).toThrow(ClassValidationError)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let caughtError: any
+    try {
+      transformed()
+    } catch (e) {
+      caughtError = e
+    }
+    expect(caughtError.message.includes('An instance of TestMessage has failed the validation')).toBeTruthy()
+    expect(caughtError.message.includes('property id has failed the following constraints: matches')).toBeTruthy()
+    expect(caughtError.message.includes('- property type has failed the following constraints: matches')).toBeTruthy()
+    expect(caughtError.validationErrors).toMatchObject([
       {
-        '~please_ack': {
-          on: ['OUTCOME'],
+        children: [],
+        constraints: {
+          matches: 'id must match /[-_./a-zA-Z0-9]{8,64}/ regular expression',
         },
-        '@id': '7517433f-1150-46f2-8495-723da61b872a',
-        '@type': 'https://didcomm.org/test-protocol/1.0/test-message',
-      },
-      TestMessage
-    )
-
-    await expect(MessageValidator.validate(transformedWithoutDefault)).resolves.toBeUndefined()
-
-    const transformedWithIncorrectValue = JsonTransformer.fromJSON(
-      {
-        '~please_ack': {
-          on: ['NOT_A_VALID_VALUE'],
+        property: 'id',
+        target: {
+          pleaseAck: {
+            on: ['RECEIPT'],
+          },
         },
-        '@id': '7517433f-1150-46f2-8495-723da61b872a',
-        '@type': 'https://didcomm.org/test-protocol/1.0/test-message',
+        value: undefined,
       },
-      TestMessage
-    )
-
-    await expect(MessageValidator.validate(transformedWithIncorrectValue)).rejects.toMatchObject([
       {
-        children: [
-          {
-            children: [],
-            constraints: { isEnum: 'each value in on must be a valid enum value' },
-            property: 'on',
-            target: { on: ['NOT_A_VALID_VALUE'] },
-            value: ['NOT_A_VALID_VALUE'],
+        children: [],
+        constraints: {
+          matches: 'type must match /(.*?)([a-zA-Z0-9._-]+)\\/(\\d[^/]*)\\/([a-zA-Z0-9._-]+)$/ regular expression',
+        },
+        property: 'type',
+        target: {
+          pleaseAck: {
+            on: ['RECEIPT'],
           },
-        ],
-        property: 'pleaseAck',
+        },
+        value: undefined,
       },
     ])
   })

packages/core/src/decorators/service/ServiceDecorator.test.ts

@@ -25,7 +25,7 @@ describe('Decorators | ServiceDecoratorExtension', () => {
   })
 
   test('transforms Json to ServiceDecorator class', () => {
-    const transformed = JsonTransformer.fromJSON({ '~service': service }, TestMessage)
+    const transformed = JsonTransformer.fromJSON({ '~service': service }, TestMessage, { validate: false })
 
     expect(transformed.service).toEqual(service)
     expect(transformed).toBeInstanceOf(TestMessage)

packages/core/src/decorators/transport/TransportDecorator.test.ts

@@ -4,11 +4,11 @@ import { MessageValidator } from '../../utils/MessageValidator'
 import { TransportDecorator, ReturnRouteTypes } from './TransportDecorator'
 
 const validTransport = (transportJson: Record<string, unknown>) =>
-  MessageValidator.validate(JsonTransformer.fromJSON(transportJson, TransportDecorator))
+  MessageValidator.validate(JsonTransformer.fromJSON(transportJson, TransportDecorator, { validate: true }))
 const expectValid = (transportJson: Record<string, unknown>) =>
   expect(validTransport(transportJson)).resolves.toBeUndefined()
 const expectInvalid = (transportJson: Record<string, unknown>) =>
-  expect(validTransport(transportJson)).rejects.not.toBeNull()
+  expect(() => validTransport(transportJson)).toThrowError('Failed to validate class.')
 
 const valid = {
   all: {

packages/core/src/error/ClassValidationError.ts

@@ -0,0 +1,20 @@
+import type { ValidationError } from 'class-validator'
+
+import { AriesFrameworkError } from './AriesFrameworkError'
+
+export class ClassValidationError extends AriesFrameworkError {
+  public validationErrors?: ValidationError[] | undefined
+
+  public validationErrorsToString() {
+    return this.validationErrors?.map((error) => error.toString(true)).join('\n') ?? ''
+  }
+
+  public constructor(
+    message: string,
+    { classType, cause, validationErrors }: { classType: string; cause?: Error; validationErrors?: ValidationError[] }
+  ) {
+    const validationErrorsStringified = validationErrors?.map((error) => error.toString()).join('\n')
+    super(`${classType}: ${message}\n${validationErrorsStringified}`, { cause })
+    this.validationErrors = validationErrors
+  }
+}

packages/core/src/error/ValidationErrorUtils.ts

@@ -0,0 +1,14 @@
+import { ValidationError } from 'class-validator'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isValidationErrorArray(e: any): boolean {
+  if (Array.isArray(e)) {
+    const isErrorArray =
+      e.length > 0 &&
+      e.every((err) => {
+        return err instanceof ValidationError
+      })
+    return isErrorArray
+  }
+  return false
+}

packages/core/src/error/index.ts

@@ -2,3 +2,4 @@ export * from './AriesFrameworkError'
 export * from './RecordNotFoundError'
 export * from './RecordDuplicateError'
 export * from './IndySdkError'
+export * from './ClassValidationError'

packages/core/src/modules/connections/DidExchangeProtocol.ts

@@ -479,7 +479,7 @@ export class DidExchangeProtocol {
     const payload = JsonEncoder.toBuffer(json)
     const { isValid, signerVerkeys } = await this.jwsService.verifyJws({ jws, payload })
 
-    const didDocument = JsonTransformer.fromJSON(json, DidDocument)
+    const didDocument = JsonTransformer.fromJSON(json, DidDocument, { validate: false })
     const didDocumentKeysBase58 = didDocument.authentication
       ?.map((authentication) => {
         const verificationMethod =

packages/core/src/modules/connections/__tests__/ConnectionInvitationMessage.test.ts

@@ -1,6 +1,7 @@
 import { validateOrReject } from 'class-validator'
 import { parseUrl } from 'query-string'
 
+import { ClassValidationError } from '../../../error/ClassValidationError'
 import { JsonEncoder } from '../../../utils/JsonEncoder'
 import { JsonTransformer } from '../../../utils/JsonTransformer'
 import { ConnectionInvitationMessage } from '../messages/ConnectionInvitationMessage'
@@ -15,7 +16,7 @@ describe('ConnectionInvitationMessage', () => {
       label: 'test',
     }
     const invitation = JsonTransformer.fromJSON(json, ConnectionInvitationMessage)
-    await expect(validateOrReject(invitation)).resolves.toBeUndefined()
+    expect(invitation).toBeInstanceOf(ConnectionInvitationMessage)
   })
 
   it('should throw error if both did and inline keys / endpoint are missing', async () => {
@@ -24,8 +25,8 @@ describe('ConnectionInvitationMessage', () => {
       '@id': '04a2c382-999e-4de9-a1d2-9dec0b2fa5e4',
       label: 'test',
     }
-    const invitation = JsonTransformer.fromJSON(json, ConnectionInvitationMessage)
-    await expect(validateOrReject(invitation)).rejects.not.toBeNull()
+
+    expect(() => JsonTransformer.fromJSON(json, ConnectionInvitationMessage)).toThrowError(ClassValidationError)
   })
 
   it('should replace legacy did:sov:BzCbsNYhMrjHiqZDTUASHg;spec prefix with https://didcomm.org in message type', async () => {
@@ -42,7 +43,7 @@ describe('ConnectionInvitationMessage', () => {
     expect(invitation.type).toBe('https://didcomm.org/connections/1.0/invitation')
 
     // Assert validation also works with the transformation
-    await expect(validateOrReject(invitation)).resolves.toBeUndefined()
+    expect(invitation).toBeInstanceOf(ConnectionInvitationMessage)
   })
 
   describe('toUrl', () => {

packages/core/src/modules/connections/messages/ConnectionInvitationMessage.ts

@@ -6,7 +6,6 @@ import { AgentMessage } from '../../../agent/AgentMessage'
 import { AriesFrameworkError } from '../../../error'
 import { JsonEncoder } from '../../../utils/JsonEncoder'
 import { JsonTransformer } from '../../../utils/JsonTransformer'
-import { MessageValidator } from '../../../utils/MessageValidator'
 import { IsValidMessageType, parseMessageType, replaceLegacyDidSovPrefix } from '../../../utils/messageType'
 
 export interface BaseInvitationOptions {
@@ -127,9 +126,7 @@ export class ConnectionInvitationMessage extends AgentMessage {
 
     if (typeof encodedInvitation === 'string') {
       const invitationJson = JsonEncoder.fromBase64(encodedInvitation)
-      const invitation = JsonTransformer.fromJSON(invitationJson, ConnectionInvitationMessage)
-
-      await MessageValidator.validate(invitation)
+      const invitation = JsonTransformer.fromJSON(invitationJson, ConnectionInvitationMessage, { validate: false })
 
       return invitation
     } else {

packages/core/src/modules/connections/services/ConnectionService.ts

@@ -18,7 +18,6 @@ import { InjectionSymbols } from '../../../constants'
 import { signData, unpackAndVerifySignatureDecorator } from '../../../decorators/signature/SignatureDecoratorUtils'
 import { AriesFrameworkError } from '../../../error'
 import { JsonTransformer } from '../../../utils/JsonTransformer'
-import { MessageValidator } from '../../../utils/MessageValidator'
 import { indyDidFromPublicKeyBase58 } from '../../../utils/did'
 import { Wallet } from '../../../wallet/Wallet'
 import { DidKey, Key, IndyAgentService } from '../../dids'
@@ -285,12 +284,7 @@ export class ConnectionService {
       throw error
     }
 
-    const connection = JsonTransformer.fromJSON(connectionJson, Connection)
-    try {
-      await MessageValidator.validate(connection)
-    } catch (error) {
-      throw new Error(error)
-    }
+    const connection = JsonTransformer.fromJSON(connectionJson, Connection, { validate: true })
 
     // Per the Connection RFC we must check if the key used to sign the connection~sig is the same key
     // as the recipient key(s) in the connection invitation message