spiceflow 1.4.0 → 1.5.0

package/src/spiceflow.test.ts

@@ -11,6 +11,122 @@ test('works', async () => {
   expect(res.status).toBe(200)
   expect(await res.json()).toEqual('hi')
 })
+test('can encode superjson types', async () => {
+  const app = new Spiceflow().post('/superjson', () => {
+    const item = {
+      date: new Date('2025-01-20T18:01:57.852Z'),
+      map: new Map([['a', 1]]),
+      set: new Set([1, 2, 3]),
+      bigint: BigInt(123),
+    }
+    return { items: Array(2).fill(item) }
+  })
+  const res = await app.handle(
+    new Request('http://localhost/superjson', { method: 'POST' }),
+  )
+  expect(res.status).toBe(200)
+  const client = createSpiceflowClient(app)
+  expect(await client.superjson.post().then((x) => x.data))
+    .toMatchInlineSnapshot(`
+      {
+        "items": [
+          {
+            "bigint": 123n,
+            "date": 2025-01-20T18:01:57.852Z,
+            "map": Map {
+              "a" => 1,
+            },
+            "set": Set {
+              1,
+              2,
+              3,
+            },
+          },
+          {
+            "bigint": 123n,
+            "date": 2025-01-20T18:01:57.852Z,
+            "map": Map {
+              "a" => 1,
+            },
+            "set": Set {
+              1,
+              2,
+              3,
+            },
+          },
+        ],
+      }
+    `)
+  expect(await res.json()).toMatchInlineSnapshot(`
+    {
+      "__superjsonMeta": {
+        "referentialEqualities": {
+          "items.0": [
+            "items.1",
+          ],
+        },
+        "values": {
+          "items.0.bigint": [
+            "bigint",
+          ],
+          "items.0.date": [
+            "Date",
+          ],
+          "items.0.map": [
+            "map",
+          ],
+          "items.0.set": [
+            "set",
+          ],
+          "items.1.bigint": [
+            "bigint",
+          ],
+          "items.1.date": [
+            "Date",
+          ],
+          "items.1.map": [
+            "map",
+          ],
+          "items.1.set": [
+            "set",
+          ],
+        },
+      },
+      "items": [
+        {
+          "bigint": "123",
+          "date": "2025-01-20T18:01:57.852Z",
+          "map": [
+            [
+              "a",
+              1,
+            ],
+          ],
+          "set": [
+            1,
+            2,
+            3,
+          ],
+        },
+        {
+          "bigint": "123",
+          "date": "2025-01-20T18:01:57.852Z",
+          "map": [
+            [
+              "a",
+              1,
+            ],
+          ],
+          "set": [
+            1,
+            2,
+            3,
+          ],
+        },
+      ],
+    }
+  `)
+})
 test('dynamic route', async () => {
   const res = await new Spiceflow()
     .post('/ids/:id', () => 'hi')
@@ -311,7 +427,7 @@ test('validate body works, request fails', async () => {
     )
   expect(res.status).toBe(422)
   expect(await res.text()).toMatchInlineSnapshot(
-    `"{"message":"data must have required property 'requiredField'"}"`,
+    `"{"code":"VALIDATION","status":422,"message":"data must have required property 'requiredField'"}"`,
   )
 })
 
@@ -578,7 +694,9 @@ test('errors inside basPath works', async () => {
     expect(onErrorTriggered).toEqual(['root', 'two', 'nested'])
     expect(onReqTriggered).toEqual(['root', 'two', 'nested'])
     expect(res.status).toBe(500)
-    expect(await res.text()).toMatchInlineSnapshot(`"{"message":"error message"}"`)
+    expect(await res.text()).toMatchInlineSnapshot(
+      `"{"message":"error message"}"`,
+    )
     // expect(await res.json()).toEqual('nested'))
   }
 })

package/src/spiceflow.ts

@@ -1,8 +1,5 @@
-import { Type } from '@sinclair/typebox'
-
-export { Type as t }
-
 import addFormats from 'ajv-formats'
+import superjson from 'superjson'
 import {
   ComposeSpiceflowResponse,
   ContentType,
@@ -35,6 +32,7 @@ import { zodToJsonSchema } from 'zod-to-json-schema'
 import { Context, MiddlewareContext } from './context.js'
 import { isProduction, ValidationError } from './error.js'
 import { isAsyncIterable, isResponse, redirect } from './utils.js'
+import { json } from 'stream/consumers'
 
 const ajv = (addFormats.default || addFormats)(
   new (Ajv.default || Ajv)({ useDefaults: true }),
@@ -777,7 +775,10 @@ export class Spiceflow<
 
       let status = err?.status ?? 500
       res ||= new Response(
-        JSON.stringify({ message: err?.message || 'Internal Server Error' }),
+        superjsonSerialize({
+          ...err,
+          message: err?.message || 'Internal Server Error',
+        }),
         {
           status,
           headers: {
@@ -922,7 +923,7 @@ export class Spiceflow<
         error(error) {
           console.error(error)
           return new Response(
-            JSON.stringify({ message: 'Internal Server Error' }),
+            superjsonSerialize({ message: 'Internal Server Error' }),
             {
               status: 500,
             },
@@ -1002,7 +1003,7 @@ export class Spiceflow<
       } catch (error) {
         console.error('Error handling request:', error)
         res.statusCode = 500
-        res.end(JSON.stringify({ message: 'Internal Server Error' }))
+        res.end(superjsonSerialize({ message: 'Internal Server Error' }))
       }
     })
 
@@ -1054,6 +1055,7 @@ export class Spiceflow<
             // 1. return() allows for cleanup in finally blocks
             // 2. throw() would trigger error handling which isn't needed for normal aborts
             // 3. return() is the more graceful way to stop iteration
+
             if ('return' in generator) {
               try {
                 await generator.return(undefined)
@@ -1072,7 +1074,9 @@ export class Spiceflow<
           if (init?.value !== undefined && init?.value !== null)
             controller.enqueue(
               Buffer.from(
-                'event: message\ndata: ' + JSON.stringify(init.value) + '\n\n',
+                'event: message\ndata: ' +
+                  superjsonSerialize(init.value, false) +
+                  '\n\n',
               ),
             )
 
@@ -1083,7 +1087,9 @@ export class Spiceflow<
 
               controller.enqueue(
                 Buffer.from(
-                  'event: message\ndata: ' + JSON.stringify(chunk) + '\n\n',
+                  'event: message\ndata: ' +
+                    superjsonSerialize(chunk, false) +
+                    '\n\n',
                 ),
               )
             }
@@ -1096,7 +1102,13 @@ export class Spiceflow<
             controller.enqueue(
               Buffer.from(
                 'event: error\ndata: ' +
-                  JSON.stringify(error.message || error.name || 'Error') +
+                  superjsonSerialize(
+                    {
+                      ...error,
+                      message: error.message || error.name || 'Error',
+                    },
+                    false,
+                  ) +
                   '\n\n',
               ),
             )
@@ -1292,13 +1304,23 @@ export async function turnHandlerResultIntoResponse(
       })
     }
   }
-  return new Response(JSON.stringify(result ?? null, null, 2), {
+
+  return new Response(superjsonSerialize(result), {
     headers: {
       'content-type': 'application/json',
     },
   })
 }
 
+function superjsonSerialize(value: any, indent = false) {
+  // return JSON.stringify(value)
+  const { json, meta } = superjson.serialize(value)
+  if (json && meta) {
+    json['__superjsonMeta'] = meta
+  }
+  return JSON.stringify(json ?? null, null, indent ? 2 : undefined)
+}
+
 export type AnySpiceflow = Spiceflow<any, any, any, any, any, any>
 
 export function isZodSchema(value: unknown): value is ZodType {

package/src/stream.test.ts

@@ -69,8 +69,16 @@ describe('Stream', () => {
 
     const response = await app.handle(req('/')).then((x) => x.text())
 
-    expect(response).toBe(
-      'event: message\ndata: "a"\n\nevent: error\ndata: "an error"\n\n',
+    expect(response).toMatchInlineSnapshot(
+      `
+      "event: message
+      data: "a"
+
+      event: error
+      data: {"message":"an error"}
+
+      "
+    `,
     )
   })
 

package/src/zod.test.ts

@@ -1,8 +1,7 @@
-import { test, describe, expect } from 'vitest'
-import { Type } from '@sinclair/typebox'
+import { expect, test } from 'vitest'
+import { z } from 'zod'
 import { Spiceflow } from './spiceflow.js'
 import { req } from './utils.js'
-import { z } from 'zod'
 
 test('body is parsed as json', async () => {
   let name = ''