address copilot review: safeParse, instanceof ZodError, trim notice message, fix callback schemas and tests

Author: CKodidela

src/adapters/web-socket-adapter.ts

@@ -2,6 +2,7 @@ import cluster from 'cluster'
 import { EventEmitter } from 'stream'
 import { IncomingMessage as IncomingHttpMessage } from 'http'
 import { WebSocket } from 'ws'
+import { ZodError } from 'zod'
 
 import { ContextMetadata, Factory } from '../@types/base'
 import { createNoticeMessage, createOutgoingEventMessage } from '../utils/messages'
@@ -179,9 +180,12 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
       if (error instanceof Error) {
         if (error.name === 'AbortError') {
           console.error(`web-socket-adapter: abort from client ${this.clientId} (${this.getClientAddress()})`)
-        } else if (error.name === 'SyntaxError' || error.name === 'ZodError') {
+        } else if (error.name === 'SyntaxError' || error instanceof ZodError) {
           debug('invalid message client %s (%s): %s', this.clientId, this.getClientAddress(), error.message)
-          this.sendMessage(createNoticeMessage(`invalid: ${error.message}`))
+          const notice = error instanceof ZodError
+            ? `invalid: ${error.issues[0]?.message ?? error.message}`
+            : `invalid: ${error.message}`
+          this.sendMessage(createNoticeMessage(notice))
         } else {
           console.error('web-socket-adapter: unable to handle message:', error)
         }

src/schemas/nodeless-callback-schema.ts

@@ -1,15 +1,15 @@
 import { pubkeySchema } from './base-schema'
-import Schema from 'joi'
+import { z } from 'zod'
 
-export const nodelessCallbackBodySchema = Schema.object({
-  id: Schema.string(),
-  uuid: Schema.string().required(),
-  status: Schema.string().required(),
-  amount: Schema.number().required(),
-  metadata: Schema.object({
-    requestId: pubkeySchema.label('metadata.requestId').required(),
-    description: Schema.string().optional(),
-    unit: Schema.string().optional(),
-    createdAt: Schema.alternatives().try(Schema.string(), Schema.date()).optional(),
-  }).unknown(true).required(),
-}).unknown(false)
+export const nodelessCallbackBodySchema = z.object({
+  id: z.string().optional(),
+  uuid: z.string(),
+  status: z.string(),
+  amount: z.number(),
+  metadata: z.object({
+    requestId: pubkeySchema,
+    description: z.string().optional(),
+    unit: z.string().optional(),
+    createdAt: z.union([z.string(), z.date()]).optional(),
+  }).passthrough(),
+}).strict()

src/utils/validation.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod'
 
 export const validateSchema = (schema: z.ZodTypeAny) => (input: unknown) => {
-  try {
-    return { value: schema.parse(input), error: undefined }
-  } catch (error) {
-    return { value: undefined, error: error as z.ZodError }
+  const result = schema.safeParse(input)
+  if (!result.success) {
+    return { value: undefined, error: (result as z.SafeParseError<unknown>).error }
   }
+  return { value: result.data, error: undefined }
 }
 
 export const attemptValidation = (schema: z.ZodTypeAny) => (input: unknown) => schema.parse(input)

test/unit/schemas/lnbits-callback-schema.spec.ts

@@ -13,12 +13,14 @@ describe('LNbits Callback Schema', () => {
 
     it('returns error if hmac is missing', () => {
       const result = validateSchema(lnbitsCallbackQuerySchema)({})
-      expect(result.error).to.have.nested.property('message', '"hmac" is required')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['hmac'])
     })
 
     it('returns error if hmac format is invalid', () => {
       const result = validateSchema(lnbitsCallbackQuerySchema)({ hmac: 'not-an-hmac' })
-      expect(result.error).to.have.nested.property('message').that.matches(/"hmac" with value "not-an-hmac" fails to match the required pattern/)
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['hmac'])
     })
   })
 
@@ -31,7 +33,8 @@ describe('LNbits Callback Schema', () => {
 
     it('returns error if payment_hash is not 64 chars hex', () => {
       const result = validateSchema(lnbitsCallbackBodySchema)({ payment_hash: 'abc' })
-      expect(result.error).to.have.nested.property('message', '"payment_hash" length must be 64 characters long')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['payment_hash'])
     })
   })
 })

test/unit/schemas/nodeless-callback-schema.spec.ts

@@ -19,11 +19,11 @@ describe('Nodeless Callback Schema', () => {
     })
 
     it('returns no error if body contains additional metadata', () => {
-      const body = { 
-        ...validBody, 
-        metadata: { 
-          ...validBody.metadata, 
-          createdAt: '2023-01-01T00:00:00Z', 
+      const body = {
+        ...validBody,
+        metadata: {
+          ...validBody.metadata,
+          createdAt: '2023-01-01T00:00:00Z',
           description: 'test payment',
           unit: 'sats',
         },
@@ -36,13 +36,15 @@ describe('Nodeless Callback Schema', () => {
       const body = { ...validBody }
       delete (body as any).uuid
       const result = validateSchema(nodelessCallbackBodySchema)(body)
-      expect(result.error).to.have.nested.property('message', '"uuid" is required')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['uuid'])
     })
 
     it('returns error if metadata.requestId is not a valid pubkey', () => {
       const body = { ...validBody, metadata: { requestId: 'deadbeef' } }
       const result = validateSchema(nodelessCallbackBodySchema)(body)
-      expect(result.error).to.have.nested.property('message', '"metadata.requestId" length must be 64 characters long')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['metadata', 'requestId'])
     })
   })
 })

test/unit/schemas/opennode-callback-schema.spec.ts

@@ -16,9 +16,9 @@ describe('OpenNode Callback Schema', () => {
     })
 
     it('returns no error if body contains additional expected fields', () => {
-      const body = { 
-        ...validBody, 
-        amount: 1000, 
+      const body = {
+        ...validBody,
+        amount: 1000,
         created_at: 1672531200,
         lightning_invoice: { payreq: 'lnbc1...' },
       }
@@ -30,7 +30,8 @@ describe('OpenNode Callback Schema', () => {
       const body = { ...validBody }
       delete (body as any).order_id
       const result = validateSchema(opennodeCallbackBodySchema)(body)
-      expect(result.error).to.have.nested.property('message', '"order_id" is required')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['order_id'])
     })
   })
 })

test/unit/schemas/zebedee-callback-schema.spec.ts

@@ -22,9 +22,9 @@ describe('Zebedee Callback Schema', () => {
     })
 
     it('returns no error if body contains unknown additional fields', () => {
-      const body = { 
-        ...validBody, 
-        extraProperty: true, 
+      const body = {
+        ...validBody,
+        extraProperty: true,
       }
       const result = validateSchema(zebedeeCallbackBodySchema)(body)
       expect(result.error).to.be.undefined
@@ -33,7 +33,8 @@ describe('Zebedee Callback Schema', () => {
     it('returns error if internalId is not a valid pubkey', () => {
       const body = { ...validBody, internalId: 'deadbeef' }
       const result = validateSchema(zebedeeCallbackBodySchema)(body)
-      expect(result.error).to.have.nested.property('message', '"internalId" length must be 64 characters long')
+      expect(result.error).to.exist
+      expect(result.error?.issues[0].path).to.deep.equal(['internalId'])
     })
   })
 })