feat: use zod for transformation and validation

Signed-off-by: Berend Sliedrecht <[email protected]>

packages/action-menu/package.json

@@ -3,9 +3,7 @@
   "main": "build/index",
   "types": "build/index",
   "version": "0.4.2",
-  "files": [
-    "build"
-  ],
+  "files": ["build"],
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -25,12 +23,10 @@
   },
   "dependencies": {
     "@credo-ts/core": "0.4.2",
-    "class-transformer": "0.5.1",
-    "class-validator": "0.14.1",
-    "rxjs": "^7.2.0"
+    "zod": "^3.22.4"
   },
   "devDependencies": {
-    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.2.0",
     "rimraf": "^4.4.0",
     "typescript": "~4.9.5"
   }

packages/action-menu/src/ActionMenuEvents.ts

@@ -1,5 +1,5 @@
 import type { ActionMenuState } from './ActionMenuState'
-import type { ActionMenuRecord } from './repository'
+import type ActionMenuRecord from './repository'
 import type { BaseEvent } from '@credo-ts/core'
 
 /**

packages/action-menu/src/messages/MenuMessage.ts

@@ -1,60 +1,43 @@
-import type { ActionMenuOptionOptions } from '../models'
-
-import { AgentMessage, IsValidMessageType, parseMessageType } from '@credo-ts/core'
-import { Expose, Type } from 'class-transformer'
-import { IsInstance, IsOptional, IsString } from 'class-validator'
+import { AgentMessage, parseMessageType, utils } from '@credo-ts/core'
+import { z } from 'zod'
 
 import { ActionMenuOption } from '../models'
+import { actionMenuOptionSchema } from '../models/ActionMenuOption'
+import { arrIntoCls } from '../models/ActionMenuOptionForm'
+
+const menuMessageSchema = z
+  .object({
+    id: z.string().default(utils.uuid()),
+    title: z.string(),
+    description: z.string(),
+    errormsg: z.string().optional(),
+    options: z.array(actionMenuOptionSchema).transform(arrIntoCls<ActionMenuOption>(ActionMenuOption)),
+    threadId: z.string().optional(),
+  })
+  .transform((o) => ({
+    ...o,
+    errorMessage: o.errormsg,
+  }))
+
+export type MenuMessageOptions = z.input<typeof menuMessageSchema>
 
-/**
- * @internal
- */
-export interface MenuMessageOptions {
-  id?: string
-  title: string
-  description: string
-  errorMessage?: string
-  options: ActionMenuOptionOptions[]
-  threadId?: string
-}
-
-/**
- * @internal
- */
 export class MenuMessage extends AgentMessage {
-  public constructor(options: MenuMessageOptions) {
-    super()
-
-    if (options) {
-      this.id = options.id ?? this.generateId()
-      this.title = options.title
-      this.description = options.description
-      this.errorMessage = options.errorMessage
-      this.options = options.options.map((p) => new ActionMenuOption(p))
-      if (options.threadId) {
-        this.setThread({
-          threadId: options.threadId,
-        })
-      }
-    }
-  }
-
-  @IsValidMessageType(MenuMessage.type)
   public readonly type = MenuMessage.type.messageTypeUri
   public static readonly type = parseMessageType('https://didcomm.org/action-menu/1.0/menu')
 
-  @IsString()
-  public title!: string
-
-  @IsString()
-  public description!: string
-
-  @Expose({ name: 'errormsg' })
-  @IsString()
-  @IsOptional()
+  public title: string
+  public description: string
   public errorMessage?: string
+  public options: Array<ActionMenuOption>
 
-  @IsInstance(ActionMenuOption, { each: true })
-  @Type(() => ActionMenuOption)
-  public options!: ActionMenuOption[]
+  public constructor(options: MenuMessageOptions) {
+    super()
+
+    const parsedOptions = menuMessageSchema.parse(options)
+    this.id = parsedOptions.id
+    this.title = parsedOptions.title
+    this.description = parsedOptions.description
+    this.errorMessage = parsedOptions.errorMessage
+    this.options = parsedOptions.options
+  }
 }

packages/action-menu/src/messages/PerformMessage.ts

@@ -1,41 +1,33 @@
-import { AgentMessage, IsValidMessageType, parseMessageType } from '@credo-ts/core'
-import { IsOptional, IsString } from 'class-validator'
+import { AgentMessage, parseMessageType, utils } from '@credo-ts/core'
+import { z } from 'zod'
 
-/**
- * @internal
- */
-export interface PerformMessageOptions {
-  id?: string
-  name: string
-  params?: Record<string, string>
-  threadId: string
-}
+const performMessageSchema = z.object({
+  id: z.string().default(utils.uuid()),
 
-/**
- * @internal
- */
-export class PerformMessage extends AgentMessage {
-  public constructor(options: PerformMessageOptions) {
-    super()
+  // TODO(zod): validate the name like is done in `@IsValidMessageType(PerformMessage.type)`
+  name: z.string(),
+  params: z.record(z.string()).optional(),
+  threadId: z.string(),
+})
 
-    if (options) {
-      this.id = options.id ?? this.generateId()
-      this.name = options.name
-      this.params = options.params
-      this.setThread({
-        threadId: options.threadId,
-      })
-    }
-  }
+export type PerformMessageOptions = z.input<typeof performMessageSchema>
 
-  @IsValidMessageType(PerformMessage.type)
+export class PerformMessage extends AgentMessage {
   public readonly type = PerformMessage.type.messageTypeUri
   public static readonly type = parseMessageType('https://didcomm.org/action-menu/1.0/perform')
 
-  @IsString()
-  public name!: string
-
-  @IsString({ each: true })
-  @IsOptional()
+  public name: string
   public params?: Record<string, string>
+
+  public constructor(options: PerformMessageOptions) {
+    super()
+
+    const parsedOptions = performMessageSchema.parse(options)
+    this.id = parsedOptions.id
+    this.name = parsedOptions.name
+    this.params = parsedOptions.params
+    this.setThread({
+      threadId: parsedOptions.threadId,
+    })
+  }
 }

packages/action-menu/src/models/ActionMenu.ts

@@ -1,38 +1,25 @@
-import type { ActionMenuOptionOptions } from './ActionMenuOption'
+import { z } from 'zod'
 
-import { Type } from 'class-transformer'
-import { IsInstance, IsString } from 'class-validator'
+import { ActionMenuOption, actionMenuOptionSchema } from './ActionMenuOption'
+import { arrIntoCls } from './ActionMenuOptionForm'
 
-import { ActionMenuOption } from './ActionMenuOption'
+export const actionMenuSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  options: z.array(actionMenuOptionSchema).transform(arrIntoCls<ActionMenuOption>(ActionMenuOption)),
+})
 
-/**
- * @public
- */
-export interface ActionMenuOptions {
-  title: string
-  description: string
-  options: ActionMenuOptionOptions[]
-}
+export type ActionMenuOptions = z.input<typeof actionMenuSchema>
 
-/**
- * @public
- */
 export class ActionMenu {
+  public title: string
+  public description: string
+  public options: Array<ActionMenuOption>
+
   public constructor(options: ActionMenuOptions) {
-    if (options) {
-      this.title = options.title
-      this.description = options.description
-      this.options = options.options.map((p) => new ActionMenuOption(p))
-    }
+    const parsedOptions = actionMenuSchema.parse(options)
+    this.title = parsedOptions.title
+    this.description = parsedOptions.description
+    this.options = parsedOptions.options
   }
-
-  @IsString()
-  public title!: string
-
-  @IsString()
-  public description!: string
-
-  @IsInstance(ActionMenuOption, { each: true })
-  @Type(() => ActionMenuOption)
-  public options!: ActionMenuOption[]
 }

packages/action-menu/src/models/ActionMenuOption.ts

@@ -1,52 +1,30 @@
-import type { ActionMenuFormOptions } from './ActionMenuOptionForm'
+import { z } from 'zod'
 
-import { Type } from 'class-transformer'
-import { IsBoolean, IsInstance, IsOptional, IsString } from 'class-validator'
+import { ActionMenuForm, actionMenuFormSchema, intoOptCls } from './ActionMenuOptionForm'
 
-import { ActionMenuForm } from './ActionMenuOptionForm'
+export const actionMenuOptionSchema = z.object({
+  name: z.string(),
+  title: z.string(),
+  description: z.string(),
+  disabled: z.boolean().optional(),
+  form: actionMenuFormSchema.optional().transform(intoOptCls<ActionMenuForm>(ActionMenuForm)),
+})
 
-/**
- * @public
- */
-export interface ActionMenuOptionOptions {
-  name: string
-  title: string
-  description: string
-  disabled?: boolean
-  form?: ActionMenuFormOptions
-}
+export type ActionMenuOptionOptions = z.input<typeof actionMenuOptionSchema>
 
-/**
- * @public
- */
 export class ActionMenuOption {
-  public constructor(options: ActionMenuOptionOptions) {
-    if (options) {
-      this.name = options.name
-      this.title = options.title
-      this.description = options.description
-      this.disabled = options.disabled
-      if (options.form) {
-        this.form = new ActionMenuForm(options.form)
-      }
-    }
-  }
-
-  @IsString()
-  public name!: string
-
-  @IsString()
-  public title!: string
-
-  @IsString()
-  public description!: string
-
-  @IsBoolean()
-  @IsOptional()
+  public name: string
+  public title: string
+  public description: string
   public disabled?: boolean
-
-  @IsInstance(ActionMenuForm)
-  @Type(() => ActionMenuForm)
-  @IsOptional()
   public form?: ActionMenuForm
+
+  public constructor(options: ActionMenuOptionOptions) {
+    const parsedOptions = actionMenuOptionSchema.parse(options)
+    this.name = parsedOptions.name
+    this.title = parsedOptions.title
+    this.description = parsedOptions.description
+    this.disabled = parsedOptions.disabled
+    this.form = parsedOptions.form
+  }
 }

packages/action-menu/src/models/ActionMenuOptionForm.ts

@@ -1,39 +1,39 @@
-import type { ActionMenuFormParameterOptions } from './ActionMenuOptionFormParameter'
+import { z } from 'zod'
 
-import { Expose, Type } from 'class-transformer'
-import { IsInstance, IsString } from 'class-validator'
+import { ActionMenuFormParameter, actionMenuFormParameterSchema } from './ActionMenuOptionFormParameter'
 
-import { ActionMenuFormParameter } from './ActionMenuOptionFormParameter'
+// TODO(zod): these should not have any ts-expect-error and should return the type based on `Cls` input, not the generic
+export const intoCls =
+  <T>(Cls: unknown) =>
+  (i: unknown): T =>
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //  @ts-expect-error
+    new Cls(i)
+export const arrIntoCls =
+  <T>(Cls: unknown) =>
+  (o: Array<unknown>): Array<T> =>
+    o.map(intoCls(Cls))
+export const intoOptCls =
+  <T>(Cls: unknown) =>
+  (i?: unknown): undefined | T =>
+    i ? intoCls<T>(Cls)(i) : undefined
 
-/**
- * @public
- */
-export interface ActionMenuFormOptions {
-  description: string
-  params: ActionMenuFormParameterOptions[]
-  submitLabel: string
-}
+export const actionMenuFormSchema = z.object({
+  description: z.string(),
+  params: z
+    .array(actionMenuFormParameterSchema)
+    .transform(arrIntoCls<ActionMenuFormParameter>(ActionMenuFormParameter)),
+})
+
+export type ActionMenuFormOptions = z.input<typeof actionMenuFormSchema>
 
-/**
- * @public
- */
 export class ActionMenuForm {
+  public description: string
+  public params: Array<ActionMenuFormParameter>
+
   public constructor(options: ActionMenuFormOptions) {
-    if (options) {
-      this.description = options.description
-      this.params = options.params.map((p) => new ActionMenuFormParameter(p))
-      this.submitLabel = options.submitLabel
-    }
+    const parsedOptions = actionMenuFormSchema.parse(options)
+    this.description = parsedOptions.description
+    this.params = parsedOptions.params
   }
-
-  @IsString()
-  public description!: string
-
-  @Expose({ name: 'submit-label' })
-  @IsString()
-  public submitLabel!: string
-
-  @IsInstance(ActionMenuFormParameter, { each: true })
-  @Type(() => ActionMenuFormParameter)
-  public params!: ActionMenuFormParameter[]
 }