Add support for zod validation error callback in schema stream

public-packages/schemaStream/README.md

@@ -253,6 +253,15 @@ class SchemaStream<T extends ZodObject<any>> {
   parse(options?: {
     stringBufferSize?: number;
     handleUnescapedNewLines?: boolean;
+    onComplete: (data: { 
+      isValid: boolean,;
+      errors: ZodError[];
+      data: data:
+          | {
+              [x: string]: any
+            }
+          | undefined
+    }) => void
   }): TransformStream;
 }
 ```
@@ -335,6 +344,7 @@ const parser = new SchemaStream(schema, {
 
 - `stringBufferSize`: Size of the buffer for string values (default: 0)
 - `handleUnescapedNewLines`: Handle unescaped newlines in JSON (default: true)
+-  onSchemaInvalid: Callback that will return any zod errors found during validation if provided schema is strict. (default: (err: ZodError) => {})
 
 ### Schema Stub Utility
 

public-packages/schemaStream/src/utils/streaming-json-parser.ts

@@ -1,5 +1,6 @@
 import { lensPath, set, view } from "ramda"
 import { z, ZodObject, ZodOptional, ZodRawShape, ZodTypeAny } from "zod"
+import type { ZodIssue } from "zod"
 
 import JSONParser from "./json-parser"
 import { ParsedTokenInfo, StackElement, TokenParserMode, TokenParserState } from "./token-parser"
@@ -65,6 +66,7 @@ type OnKeyCompleteCallback = (data: OnKeyCompleteCallbackParams) => void | undef
 
 export class SchemaStream {
   private schemaInstance: NestedObject
+  private schemaType: SchemaType
   private activePath: (string | number | undefined)[] = []
   private completedPaths: (string | number | undefined)[][] = []
   private onKeyComplete?: OnKeyCompleteCallback
@@ -84,6 +86,7 @@ export class SchemaStream {
   ) {
     const { defaultData, onKeyComplete, typeDefaults } = opts
 
+    this.schemaType = schema
     this.schemaInstance = this.createBlankObject(schema, defaultData, typeDefaults)
     this.onKeyComplete = onKeyComplete
   }
@@ -222,7 +225,20 @@ export class SchemaStream {
     opts: {
       stringBufferSize?: number
       handleUnescapedNewLines?: boolean
-    } = { stringBufferSize: 0, handleUnescapedNewLines: true }
+      onComplete?: ({
+        isValid,
+        errors,
+        data
+      }: {
+        isValid: boolean
+        errors: ZodIssue[]
+        data:
+          | {
+              [x: string]: any
+            }
+          | undefined
+      }) => void
+    } = { stringBufferSize: 0, handleUnescapedNewLines: true, onComplete: () => null }
   ) {
     const textEncoder = new TextEncoder()
 
@@ -233,6 +249,16 @@ export class SchemaStream {
 
     parser.onToken = this.handleToken.bind(this)
     parser.onValue = () => void 0
+    parser.onEnd = () => {
+      const parsedResult = this.schemaType.safeParse(this.schemaInstance)
+
+      opts.onComplete &&
+        opts.onComplete({
+          isValid: parsedResult.success,
+          errors: parsedResult.error?.errors ?? [],
+          data: parsedResult.data
+        })
+    }
 
     const stream = new TransformStream({
       transform: async (chunk, controller): Promise<void> => {

public-packages/schemaStream/tests/zod-types.test.ts

@@ -2,6 +2,7 @@ import { SchemaStream } from "@/utils/streaming-json-parser"
 import { describe, expect, test } from "bun:test"
 import { lensPath, view } from "ramda"
 import { z, ZodObject, ZodRawShape } from "zod"
+import type { ZodIssue } from "zod"
 
 const checkPathValue = (obj: object, path: (string | number)[]) => {
   const lens = lensPath(path)
@@ -13,14 +14,20 @@ const checkPathValue = (obj: object, path: (string | number)[]) => {
 
 async function runTest<T extends ZodRawShape>(schema: ZodObject<T>, jsonData: object) {
   let completed: (string | number)[][] = []
+  let errors: ZodIssue[] = []
 
   const parser = new SchemaStream(schema, {
     onKeyComplete({ completedPaths }) {
       completed = completedPaths as (string | number)[][]
     }
   })
 
-  const stream = parser.parse()
+  const stream = parser.parse({
+    onComplete: ({ errors: validationErrors }) => {
+      errors = validationErrors
+    }
+  })
+
   const decoder = new TextDecoder()
   const encoder = new TextEncoder()
 
@@ -63,7 +70,7 @@ async function runTest<T extends ZodRawShape>(schema: ZodObject<T>, jsonData: ob
     result = value
   }
 
-  return { result: JSON.parse(decoder.decode(result)), completed }
+  return { result: JSON.parse(decoder.decode(result)), errors, completed }
 }
 
 describe("schema stream types", () => {
@@ -192,4 +199,20 @@ describe("schema stream types", () => {
       expect(checkPathValue(data, path)).toBe(true)
     })
   })
+
+  test("zod with incorrect schema", async () => {
+    const schema = z
+      .object({
+        someString: z.string().default("test"),
+        someNumber: z.number().default(420)
+      })
+      .strict()
+
+    const data = {
+      cats: 48
+    }
+
+    const { errors } = await runTest(schema, data)
+    expect(errors).not.toBeEmpty()
+  })
 })