spiceflow 1.9.1 → 1.10.0

package/src/_node-server.ts

@@ -0,0 +1,115 @@
+import {
+  type Server,
+  type IncomingMessage,
+  type ServerResponse,
+  createServer,
+} from 'node:http'
+import { AddressInfo } from 'node:net'
+import { type Spiceflow, SpiceflowRequest } from './spiceflow.ts'
+import { superjsonSerialize } from './serialize.ts'
+
+export async function listenForNode(
+  app: Spiceflow<any, any, any, any, any, any>,
+  port: number,
+  hostname: string = '0.0.0.0',
+): Promise<Server<typeof IncomingMessage, typeof ServerResponse>> {
+  const server = createServer((req, res) => {
+    return app.handleForNode(req, res)
+  })
+
+  await new Promise((resolve) => {
+    server.listen(port, hostname, () => {
+      // We could print from what we take as arguments of `serve`, but by reading
+      // the `server` object, we can ensure that they are properly set.
+      const addressInfo = server.address() as AddressInfo
+      const displayedHost =
+        addressInfo.address === '0.0.0.0' ? 'localhost' : addressInfo.address
+      console.log(`Listening on http://${displayedHost}:${addressInfo.port}`)
+      resolve(null)
+    })
+  })
+
+  return server
+}
+
+export async function handleForNode(
+  app: Spiceflow<any, any, any, any, any, any>,
+  req: IncomingMessage,
+  res: ServerResponse,
+  context: { state?: {} | undefined } = {},
+): Promise<void> {
+  if (req?.['body']) {
+    throw new Error(
+      'req.body is defined, you should disable your framework body parser to be able to use the request in Spiceflow',
+    )
+  }
+
+  const abortController = new AbortController()
+  const { signal } = abortController
+
+  req.on('error', (err) => {
+    abortController.abort()
+  })
+  req.on('aborted', (err) => {
+    abortController.abort()
+  })
+  res.on('close', function () {
+    let aborted = !res.writableFinished
+    if (aborted) {
+      abortController.abort()
+    }
+  })
+
+  const url = new URL(
+    req.url || '',
+    `http://${req.headers.host || 'localhost'}`,
+  )
+  const typedRequest = new SpiceflowRequest(url.toString(), {
+    method: req.method,
+    headers: req.headers as HeadersInit,
+    body:
+      req.method !== 'GET' && req.method !== 'HEAD'
+        ? new ReadableStream({
+            start(controller) {
+              req.on('data', (chunk) => {
+                controller.enqueue(
+                  new Uint8Array(
+                    chunk.buffer,
+                    chunk.byteOffset,
+                    chunk.byteLength,
+                  ),
+                )
+              })
+              req.on('end', () => {
+                controller.close()
+              })
+            },
+          })
+        : null,
+    signal,
+    // @ts-ignore
+    duplex: 'half',
+  })
+
+  try {
+    const response = await app.handle(typedRequest, context)
+    res.writeHead(
+      response.status,
+      Object.fromEntries(response.headers.entries()),
+    )
+
+    if (response.body) {
+      const reader = response.body.getReader()
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        res.write(value)
+      }
+    }
+    res.end()
+  } catch (error) {
+    console.error('Error handling request:', error)
+    res.statusCode = 500
+    res.end(superjsonSerialize({ message: 'Internal Server Error' }))
+  }
+}

package/src/client/index.ts

@@ -1,17 +1,17 @@
 /* eslint-disable no-extra-semi */
 /* eslint-disable no-case-declarations */
 /* eslint-disable prefer-const */
-import type { Spiceflow } from '../spiceflow.js'
+import type { Spiceflow } from '../spiceflow.ts'
 import superjson from 'superjson'
 import { EventSourceParserStream } from 'eventsource-parser/stream'
 
-import type { SpiceflowClient } from './types.js'
+import type { SpiceflowClient } from './types.ts'
 
 export { SpiceflowClient }
 
-import { SpiceflowFetchError } from './errors.js'
+import { SpiceflowFetchError } from './errors.ts'
 
-import { parseStringifiedValue } from './utils.js'
+import { parseStringifiedValue } from './utils.ts'
 
 const method = [
   'get',

package/src/client/types.ts

@@ -1,7 +1,7 @@
 /// <reference lib="dom" />
-import type { Spiceflow } from '../spiceflow.js'
+import type { Spiceflow } from '../spiceflow.ts'
 
-import { SpiceflowFetchError } from './errors.js'
+import { SpiceflowFetchError } from './errors.ts'
 
 export type Prettify<T> = {
   [K in keyof T]: T[K]
@@ -15,11 +15,11 @@ type ReplaceBlobWithFiles<in out RecordType extends Record<string, unknown>> = {
   [K in keyof RecordType]: RecordType[K] extends any
     ? RecordType[K]
     : RecordType[K] extends
-        | Blob
-        | Blob[]
-        | { arrayBuffer: () => Promise<ArrayBuffer> }
-    ? Files
-    : RecordType[K]
+          | Blob
+          | Blob[]
+          | { arrayBuffer: () => Promise<ArrayBuffer> }
+      ? Files
+      : RecordType[K]
 } & {}
 
 type And<A extends boolean, B extends boolean> = A extends true
@@ -34,18 +34,18 @@ type ReplaceGeneratorWithAsyncGenerator<
   [K in keyof RecordType]: RecordType[K] extends any
     ? RecordType[K]
     : RecordType[K] extends Generator<infer A, infer B, infer C>
-    ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
-      ? AsyncGenerator<A, B, C>
-      : And<IsNever<A>, void extends B ? false : true> extends true
-      ? B
-      : AsyncGenerator<A, B, C> | B
-    : RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
-    ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
-      ? AsyncGenerator<A, B, C>
-      : And<IsNever<A>, void extends B ? false : true> extends true
-      ? B
-      : AsyncGenerator<A, B, C> | B
-    : RecordType[K]
+      ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
+        ? AsyncGenerator<A, B, C>
+        : And<IsNever<A>, void extends B ? false : true> extends true
+          ? B
+          : AsyncGenerator<A, B, C> | B
+      : RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
+        ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
+          ? AsyncGenerator<A, B, C>
+          : And<IsNever<A>, void extends B ? false : true> extends true
+            ? B
+            : AsyncGenerator<A, B, C> | B
+        : RecordType[K]
 } & {}
 
 type MaybeArray<T> = T | T[]
@@ -97,40 +97,38 @@ export namespace SpiceflowClient {
                 ClientResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
               >
           : K extends 'get' | 'head'
-          ? (
-              options: Prettify<Param & ClientParam>,
-            ) => Promise<
-              ClientResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
-            >
-          : (
-              body: Body extends Record<string, unknown>
-                ? ReplaceBlobWithFiles<Body>
-                : Body,
-              options: Prettify<Param & ClientParam>,
-            ) => Promise<
-              ClientResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
-            >
+            ? (
+                options: Prettify<Param & ClientParam>,
+              ) => Promise<
+                ClientResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+              >
+            : (
+                body: Body extends Record<string, unknown>
+                  ? ReplaceBlobWithFiles<Body>
+                  : Body,
+                options: Prettify<Param & ClientParam>,
+              ) => Promise<
+                ClientResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+              >
         : never
       : CreateParams<Route[K]>
   }
 
-  type CreateParams<Route extends Record<string, any>> = Extract<
-    keyof Route,
-    `:${string}`
-  > extends infer Path extends string
-    ? IsNever<Path> extends true
-      ? Prettify<Sign<Route>>
-      : // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
-        (((params: {
-          [param in Path extends `:${infer Param}`
-            ? Param extends `${infer Param}?`
-              ? Param
-              : Param
-            : never]: string | number
-        }) => Prettify<Sign<Route[Path]>> & CreateParams<Route[Path]>) &
-          Prettify<Sign<Route>>) &
-          (Path extends `:${string}?` ? CreateParams<Route[Path]> : {})
-    : never
+  type CreateParams<Route extends Record<string, any>> =
+    Extract<keyof Route, `:${string}`> extends infer Path extends string
+      ? IsNever<Path> extends true
+        ? Prettify<Sign<Route>>
+        : // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
+          (((params: {
+            [param in Path extends `:${infer Param}`
+              ? Param extends `${infer Param}?`
+                ? Param
+                : Param
+              : never]: string | number
+          }) => Prettify<Sign<Route[Path]>> & CreateParams<Route[Path]>) &
+            Prettify<Sign<Route>>) &
+            (Path extends `:${string}?` ? CreateParams<Route[Path]> : {})
+      : never
 
   export interface Config {
     // fetch?: Omit<RequestInit, 'headers' | 'method'>

package/src/client.test.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod'
-import { createSpiceflowClient } from './client/index.js'
-import { Spiceflow } from './spiceflow.js'
-
+import { createSpiceflowClient } from './client/index.ts'
+import { Spiceflow } from './spiceflow.ts'
 
 import { describe, expect, it } from 'vitest'
 const app = new Spiceflow()

package/src/context.ts

@@ -2,7 +2,7 @@ import type {
   StatusMap,
   InvertedStatusMap,
   redirect as Redirect,
-} from './utils.js'
+} from './utils.ts'
 
 import type {
   RouteSchema,
@@ -10,9 +10,9 @@ import type {
   ResolvePath,
   SingletonBase,
   HTTPHeaders,
-} from './types.js'
+} from './types.ts'
 
-import { SpiceflowRequest } from './spiceflow.js'
+import { SpiceflowRequest } from './spiceflow.ts'
 
 export type ErrorContext<
   in out Route extends RouteSchema = {},

package/src/cors.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest'
 import { z } from 'zod'
-import { cors } from './cors.js'
-import { Spiceflow } from './spiceflow.js'
+import { cors } from './cors.ts'
+import { Spiceflow } from './spiceflow.ts'
 
 function request(path, method = 'GET') {
   return new Request(`http://localhost/${path}`, {
@@ -50,9 +50,9 @@ describe('cors middleware', () => {
 })
 
 test('CORS headers are set when an error is thrown', async () => {
-  let errorRouteCallCount = 0;
+  let errorRouteCallCount = 0
   const errorApp = new Spiceflow().use(cors()).get('/error', () => {
-    errorRouteCallCount++;
+    errorRouteCallCount++
     throw new Error('Test error')
   })
 
@@ -64,29 +64,31 @@ test('CORS headers are set when an error is thrown', async () => {
 })
 
 test('CORS headers are set for OPTIONS request when an error is thrown', async () => {
-  let errorRouteCallCount = 0;
+  let errorRouteCallCount = 0
   const errorApp = new Spiceflow().use(cors()).options('/error', () => {
-    errorRouteCallCount++;
+    errorRouteCallCount++
     throw new Error('Test error')
   })
 
   const res = await errorApp.handle(request('error', 'OPTIONS'))
   expect(res.status).toBe(204)
   expect(res.headers.get('Access-Control-Allow-Origin')).toBe('*')
-  expect(res.headers.get('Access-Control-Allow-Methods')).toBe('GET,HEAD,PUT,POST,DELETE,PATCH')
+  expect(res.headers.get('Access-Control-Allow-Methods')).toBe(
+    'GET,HEAD,PUT,POST,DELETE,PATCH',
+  )
   expect(errorRouteCallCount).toBe(1)
 })
 
 // TODO should middleware errors be handled? errors can be a way to short circuit other middlewares
 test('CORS headers are set when an error is thrown in middleware', async () => {
-  let errorRouteCallCount = 0;
+  let errorRouteCallCount = 0
   const errorApp = new Spiceflow()
     .use((c) => {
       throw new Error('middleware error')
     })
     .use(cors())
     .get('/error', () => {
-      errorRouteCallCount++;
+      errorRouteCallCount++
       throw new Error('Test error')
     })
 

package/src/cors.ts

@@ -1,4 +1,4 @@
-import { MiddlewareHandler } from './types.js'
+import { MiddlewareHandler } from './types.ts'
 /**
  * Options for configuring CORS (Cross-Origin Resource Sharing) middleware.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS MDN CORS documentation}
@@ -15,9 +15,10 @@ type CORSOptions = {
   /** Configures the Access-Control-Allow-Credentials CORS header */
   credentials?: boolean
   /** Configures the Access-Control-Expose-Headers CORS header */
-  exposeHeaders?: string[]
+  exposeHeaders?: string[] | boolean
   /** Configures browser and CDN caching duration for CORS preflight requests in seconds. Set to 0 to disable. */
   cacheAge?: number
+  
 }
 
 export const cors = (options?: CORSOptions): MiddlewareHandler => {
@@ -25,8 +26,8 @@ export const cors = (options?: CORSOptions): MiddlewareHandler => {
     origin: '*',
     allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
     allowHeaders: [],
-    exposeHeaders: [],
     credentials: true,
+    exposeHeaders: true,
     cacheAge: 21600, // 6 hours default
   }
   const opts = {
@@ -81,8 +82,9 @@ export const cors = (options?: CORSOptions): MiddlewareHandler => {
     if (opts.credentials) {
       set('Access-Control-Allow-Credentials', 'true')
     }
-
-    if (opts.exposeHeaders?.length) {
+    if (opts.exposeHeaders === true) {
+      set('Access-Control-Expose-Headers', '*')
+    } else if (opts.exposeHeaders && opts.exposeHeaders?.length) {
       set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','))
     }
 

package/src/error.ts

@@ -1,21 +1,9 @@
-// ? Cloudflare worker support
-const env =
-  // @ts-ignore
-  typeof Bun !== 'undefined'
-    ? // @ts-ignore
-      Bun.env
-    : typeof process !== 'undefined'
-      ? process?.env
-      : undefined
-
 export const ERROR_CODE = Symbol('SpiceflowErrorCode')
 export type ERROR_CODE = typeof ERROR_CODE
 
 export const SPICEFLOW_RESPONSE = Symbol('SpiceflowResponse')
 export type SPICEFLOW_RESPONSE = typeof SPICEFLOW_RESPONSE
 
-export const isProduction = (env?.NODE_ENV ?? env?.ENV) === 'production'
-
 export class ValidationError extends Error {
   code = 'VALIDATION'
   status = 422

package/src/index.ts

@@ -1,3 +1,3 @@
-export { Spiceflow } from './spiceflow.js'
-export type { AnySpiceflow } from './spiceflow.js'
-export { InternalServerError, ParseError, ValidationError } from './error.js'
+export { Spiceflow } from './spiceflow.ts'
+export type { AnySpiceflow } from './spiceflow.ts'
+export { InternalServerError, ParseError, ValidationError } from './error.ts'

package/src/mcp-transport.ts

@@ -1,5 +1,5 @@
 // https://github.com/modelcontextprotocol/typescript-sdk/blob/3164da64d085ec4e022ae881329eee7b72f208d4/src/server/sse.ts
-import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.ts'
 import {
   JSONRPCMessage,
   JSONRPCMessageSchema,
@@ -65,12 +65,6 @@ export class SSEServerTransportSpiceflow implements Transport {
         }\n\n`,
       ),
     )
-
-    // readable.getReader().closed.then(() => {
-    //   this.response = undefined
-    //   this._writableStream = undefined
-    //   this.onclose?.()
-    // })
   }
 
   /**
@@ -78,10 +72,7 @@ export class SSEServerTransportSpiceflow implements Transport {
    *
    * This should be called when a POST request is made to send a message to the server.
    */
-  async handlePostMessage(
-    req: Request,
-    parsedBody?: unknown,
-  ): Promise<Response> {
+  async handlePostMessage(req: Request): Promise<Response> {
     if (!this.response) {
       const message = 'SSE connection not established'
       throw new Error(message)

package/src/mcp.ts

@@ -7,10 +7,9 @@ import {
   ReadResourceRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
 import { OpenAPIV3 } from 'openapi-types'
-import { SSEServerTransportSpiceflow } from './mcp-transport.js'
-import { openapi } from './openapi.js'
-import { Spiceflow } from './spiceflow.js'
-
+import { SSEServerTransportSpiceflow } from './mcp-transport.ts'
+import { openapi } from './openapi.ts'
+import { Spiceflow } from './spiceflow.ts'
 
 const transports = new Map<string, SSEServerTransportSpiceflow>()
 function getOperationRequestBody(

package/src/middleware.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest'
 import { z } from 'zod'
-import { Spiceflow } from './spiceflow.js'
+import { Spiceflow } from './spiceflow.ts'
 
 test('middleware with next changes the response', async () => {
   const res = await new Spiceflow()
@@ -36,7 +36,6 @@ test('middleware with no handlers works', async () => {
   expect(await res.text()).toEqual('ok')
 })
 
-
 test('middleware calling next() without returning it works', async () => {
   const res = await new Spiceflow()
     .use(async ({ request }, next) => {
@@ -331,7 +330,6 @@ test('middleware returning response and middleware adding header with mounted Sp
   expect(res.headers.get('X-Added-Header')).toBe('HeaderValue')
 })
 
-
 test('each middleware and route is called exactly once if an error is thrown', async () => {
   const callOrder: string[] = []
 
@@ -357,20 +355,29 @@ test('each middleware and route is called exactly once if an error is thrown', a
   const res = await app.handle(new Request('http://localhost/test'))
 
   expect(res.status).toBe(500)
-  expect(await res.text()).toMatchInlineSnapshot(`"{"message":"Route response"}"`)
-  expect(callOrder).toEqual(['middleware1', 'middleware2', 'middleware3', 'route'])
-  
+  expect(await res.text()).toMatchInlineSnapshot(
+    `"{"message":"Route response"}"`,
+  )
+  expect(callOrder).toEqual([
+    'middleware1',
+    'middleware2',
+    'middleware3',
+    'route',
+  ])
+
   // Check that each middleware and route is called exactly once
-  const counts = callOrder.reduce((acc, item) => {
-    acc[item] = (acc[item] || 0) + 1
-    return acc
-  }, {} as Record<string, number>)
+  const counts = callOrder.reduce(
+    (acc, item) => {
+      acc[item] = (acc[item] || 0) + 1
+      return acc
+    },
+    {} as Record<string, number>,
+  )
 
   expect(counts).toEqual({
     middleware1: 1,
     middleware2: 1,
     middleware3: 1,
-    route: 1
+    route: 1,
   })
 })
-

package/src/openapi.test.ts

@@ -1,10 +1,11 @@
 import { expect, test } from 'vitest'
-import { Spiceflow } from './spiceflow.js'
-import { openapi } from './openapi.js'
 import { z } from 'zod'
+import { z as z4 } from 'zod/v4'
+import { openapi } from './openapi.ts'
+import { Spiceflow } from './spiceflow.ts'
 
 test('openapi response', async () => {
-  const app = await new Spiceflow()
+  const app = new Spiceflow()
     .use(
       openapi({
         info: {
@@ -43,8 +44,8 @@ test('openapi response', async () => {
         return body
       },
       {
-        body: z.object({
-          name: z.string(),
+        body: z4.object({
+          name: z4.string(),
         }),
         response: z.object({
           name: z.string().optional(),
@@ -148,8 +149,8 @@ test('openapi response', async () => {
         '/ids/:id',
         ({ params }) => params.id,
         {
-          params: z.object({
-            id: z.string(),
+          params: z4.object({
+            id: z4.string(),
           }),
         },
       ),
@@ -243,7 +244,6 @@ test('openapi response', async () => {
               "content": {
                 "application/json": {
                   "schema": {
-                    "additionalProperties": true,
                     "properties": {
                       "name": {
                         "type": "string",

package/src/openapi.ts

@@ -1,14 +1,13 @@
-import { JSONSchemaType } from 'ajv'
-import { InternalRoute, isZodSchema, Spiceflow } from './spiceflow.js'
+import { InternalRoute, isZod4, isZodSchema, Spiceflow } from './spiceflow.ts'
 
 import type { OpenAPIV3 } from 'openapi-types'
 
 let excludeMethods = ['OPTIONS']
 
-import type { TypeSchema } from './types.js'
+import type { TypeSchema } from './types.ts'
 
-import { z } from 'zod'
 import { zodToJsonSchema } from 'zod-to-json-schema'
+import { z } from 'zod/v4'
 
 const extractParamNames = (path: string): string[] => {
   return path.split('/').reduce((params: string[], segment) => {
@@ -455,8 +454,24 @@ export const openapi = <Path extends string = '/openapi'>({
   return app
 }
 
-function getJsonSchema(schema: TypeSchema): JSONSchemaType<any> {
+function getJsonSchema(schema: TypeSchema) {
   if (!schema) return undefined as any
+
+  if (isZod4(schema)) {
+    let jsonSchema = z.toJSONSchema(schema, {
+      override(ctx) {
+        const schema = ctx.zodSchema
+        if (
+          schema instanceof z.core.$ZodObject &&
+          schema._zod.def.catchall === undefined
+        ) {
+          delete ctx.jsonSchema.additionalProperties
+        }
+      },
+    })
+    const { $schema, ...rest } = jsonSchema
+    return rest as any
+  }
   if (isZodSchema(schema)) {
     let jsonSchema = zodToJsonSchema(schema, {
       removeAdditionalStrategy: 'strict',

package/src/serialize.ts

@@ -0,0 +1,10 @@
+import superjson from 'superjson'
+
+export 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)
+}

package/src/simple.benchmark.ts

@@ -1,6 +1,6 @@
 import { bench } from 'vitest'
 
-import { Spiceflow } from './spiceflow.js'
+import { Spiceflow } from './spiceflow.ts'
 
 bench('Spiceflow basic routing', async () => {
   const app = new Spiceflow()