spiceflow 1.9.0 → 1.10.0

package/src/spiceflow.test.ts

@@ -1,9 +1,8 @@
 import { test, describe, expect } from 'vitest'
 
-import { bfs, cloneDeep, Spiceflow } from './spiceflow.js'
+import { bfs, cloneDeep, Spiceflow } from './spiceflow.ts'
 import { z } from 'zod'
-import { createSpiceflowClient } from './client/index.js'
-import { Type } from 'ajv/dist/compile/util.js'
+import { createSpiceflowClient } from './client/index.ts'
 
 test('works', async () => {
   const res = await new Spiceflow()
@@ -30,7 +29,6 @@ describe('cloneDeep', () => {
   })
 })
 
-
 test('can encode superjson types', async () => {
   const app = new Spiceflow().post('/superjson', () => {
     const item = {
@@ -238,7 +236,9 @@ test('onError fires on validation errors', async () => {
   )
 
   expect(res.status).toBe(400)
-  expect(errorMessage).toMatchInlineSnapshot(`"name: Expected string, received number"`)
+  expect(errorMessage).toMatchInlineSnapshot(
+    `"name: Expected string, received number"`,
+  )
   expect(await res.text()).toMatchInlineSnapshot(`"Error"`)
 })
 
@@ -816,11 +816,13 @@ test('async generators handle non-ASCII characters correctly', async () => {
 
 test('can pass additional props to body schema', async () => {
   const app = new Spiceflow().post('/user', ({ request }) => request.json(), {
-    body: z.object({
-      name: z.string(),
-      age: z.number(),
-      email: z.string().email(),
-    }).passthrough(),
+    body: z
+      .object({
+        name: z.string(),
+        age: z.number(),
+        email: z.string().email(),
+      })
+      .passthrough(),
   })
 
   const res = await app.handle(

package/src/spiceflow.ts

@@ -1,38 +1,38 @@
-import { createServer } from 'spiceflow/_node_utils'
 import lodashCloneDeep from 'lodash.clonedeep'
-import superjson from 'superjson'
 import {
-  ComposeSpiceflowResponse,
-  ContentType,
-  CreateClient,
-  DefinitionBase,
-  ErrorHandler,
-  HTTPMethod,
-  InlineHandler,
-  InputSchema,
-  IsAny,
-  JoinPath,
-  LocalHook,
-  MaybeArray,
-  MetadataBase,
-  MiddlewareHandler,
-  Reconcile,
-  ResolvePath,
-  RouteBase,
-  RouteSchema,
-  SingletonBase,
-  TypeSchema,
-  UnwrapRoute,
-} from './types.js'
+    ComposeSpiceflowResponse,
+    ContentType,
+    CreateClient,
+    DefinitionBase,
+    ErrorHandler,
+    HTTPMethod,
+    InlineHandler,
+    InputSchema,
+    IsAny,
+    JoinPath,
+    LocalHook,
+    MetadataBase,
+    MiddlewareHandler,
+    Reconcile,
+    ResolvePath,
+    RouteBase,
+    RouteSchema,
+    SingletonBase,
+    TypeSchema,
+    UnwrapRoute
+} from './types.ts'
 
 import OriginalRouter from '@medley/router'
-import { type IncomingMessage, type ServerResponse } from 'http'
-import { z, ZodType } from 'zod'
+import { ZodType } from 'zod'
 
-import { MiddlewareContext } from './context.js'
-import { isProduction, ValidationError } from './error.js'
-import { isAsyncIterable, isResponse, redirect } from './utils.js'
 import { StandardSchemaV1 } from '@standard-schema/spec'
+import { IncomingMessage, ServerResponse } from 'node:http'
+import { handleForNode, listenForNode } from 'spiceflow/_node-server'
+import { MiddlewareContext } from './context.ts'
+import { ValidationError } from './error.ts'
+import { superjsonSerialize } from './serialize.ts'
+import { isAsyncIterable, isResponse, redirect } from './utils.ts'
+
 let globalIndex = 0
 
 type AsyncResponse = Response | Promise<Response>
@@ -52,7 +52,6 @@ export type InternalRoute = {
   validateBody?: ValidationFunction
   validateQuery?: ValidationFunction
   validateParams?: ValidationFunction
-  // prefix: string
 }
 
 type MedleyRouter = {
@@ -673,12 +672,7 @@ export class Spiceflow<
           : Routes & CreateClient<BasePath, NewSpiceflow['_routes']>
       >
   use<const Schema extends RouteSchema>(
-    handler: MiddlewareHandler<
-      Schema,
-      {
-        state: Singleton['state']
-      }
-    >,
+    handler: MiddlewareHandler<Schema, Singleton>,
   ): this
 
   use(appOrHandler) {
@@ -692,7 +686,7 @@ export class Spiceflow<
   }
 
   onError<const Schema extends RouteSchema>(
-    handler: MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>,
+    handler: ErrorHandler<Definitions['error'], Schema, Singleton>,
   ): this {
     this.onErrorHandlers ??= []
     this.onErrorHandlers.push(handler as any)
@@ -898,12 +892,11 @@ export class Spiceflow<
   }
 
   async listen(port: number, hostname: string = '0.0.0.0') {
-    // @ts-ignore
+    const app = this
     if (typeof Bun !== 'undefined') {
-      // @ts-ignore
       const server = Bun.serve({
         port,
-        development: !isProduction,
+        development: (Bun.env.NODE_ENV ?? Bun.env.ENV) !== 'production',
         hostname,
         reusePort: true,
         error(error) {
@@ -915,115 +908,54 @@ export class Spiceflow<
             },
           )
         },
-
-        fetch: async (request) => {
-          const res = await this.handle(request)
+        async fetch(request) {
+          const res = await app.handle(request)
           return res
         },
       })
+
       process.on('beforeExit', () => {
         server.stop()
       })
-      console.log(`Listening on http://localhost:${port}`)
+
+      const displayedHost =
+        server.hostname === '0.0.0.0' ? 'localhost' : server.hostname
+      console.log(`Listening on http://${displayedHost}:${server.port}`)
+
       return server
     }
-    return this.listenNode(port, hostname)
-  }
-  async listenNode(port: number, hostname: string = '0.0.0.0') {
-    const server = createServer((req, res) => {
-      return this.handleNode(req, res)
-    })
-
-    await new Promise((resolve, reject) => {
-      server.listen(port, hostname, () => {
-        console.log(`Listening on http://localhost:${port}`)
-        resolve(null)
-      })
-    })
 
-    return server
+    return this.listenForNode(port, hostname)
   }
 
+  /**
+   * @deprecated Use `handleForNode` instead.
+   */
   async handleNode(
     req: IncomingMessage,
     res: ServerResponse,
     context: { state?: Singleton['state'] } = {},
   ) {
-    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()
-      }
-    })
+    return this.handleForNode(req, res, context)
+  }
 
-    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',
-    })
+  async handleForNode(
+    req: IncomingMessage,
+    res: ServerResponse,
+    context: { state?: Singleton['state'] } = {},
+  ) {
+    return handleForNode(this, req, res, context)
+  }
 
-    try {
-      const response = await this.handle(typedRequest, context)
-      res.writeHead(
-        response.status,
-        Object.fromEntries(response.headers.entries()),
+  async listenForNode(port: number, hostname: string = '0.0.0.0') {
+    if (typeof Bun !== 'undefined') {
+      console.warn(
+        "Server is being started with node:http but the current runtime is Bun, not Node. Consider using the method 'handle' with 'Bun.serve' instead.",
       )
-
-      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' }))
     }
+    return listenForNode(this, port, hostname)
   }
+
   private async handleStream({
     onErrorHandlers,
     generator,
@@ -1277,15 +1209,6 @@ export async function turnHandlerResultIntoResponse(
   })
 }
 
-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 {
@@ -1300,6 +1223,13 @@ export function isZodSchema(value: unknown): value is ZodType {
   )
 }
 
+import type * as z4 from 'zod/v4/core'
+
+/** `true` ⇒ the value was created by Zod 4, `false` ⇒ Zod 3 */
+export function isZod4(schema: any): schema is z4.$ZodObject {
+  return '_zod' in schema // ⇦ only v4 adds this marker
+}
+
 function getValidateFunction(
   schema: TypeSchema,
 ): ValidationFunction | undefined {
@@ -1334,6 +1264,9 @@ async function runValidation(value: any, validate?: ValidationFunction) {
       .join('\\n')
     throw new ValidationError(errorMessages || 'Validation failed')
   }
+  if ('value' in result) {
+    return result.value
+  }
   return value
 }
 

package/src/static-node.ts

@@ -1,7 +1,7 @@
 import { stat } from 'fs/promises'
 import fs from 'fs'
-import { ServeStaticOptions, serveStatic as baseServeStatic } from './static.js'
-import { MiddlewareHandler } from './types.js'
+import { ServeStaticOptions, serveStatic as baseServeStatic } from './static.ts'
+import { MiddlewareHandler } from './types.ts'
 
 export const serveStatic = (options: ServeStaticOptions): MiddlewareHandler => {
   const getContent = (path: string) => {

package/src/static.benchmark.ts

@@ -1,7 +1,7 @@
 import { bench } from 'vitest'
 
-import { Spiceflow } from './spiceflow.js'
-import { serveStatic } from './static-node.js'
+import { Spiceflow } from './spiceflow.ts'
+import { serveStatic } from './static-node.ts'
 
 bench('Spiceflow static', async () => {
   const app = new Spiceflow()

package/src/static.ts

@@ -1,5 +1,5 @@
-import { MiddlewareHandler } from './types.js'
-import { isResponse } from './utils.js'
+import { MiddlewareHandler } from './types.ts'
+import { isResponse } from './utils.ts'
 
 type Env = {}
 type Context<E extends Env = Env> = {}

package/src/stream.test.ts

@@ -2,9 +2,9 @@ import { describe, it, expect } from 'vitest'
 
 import { createParser } from 'eventsource-parser'
 
-import { Spiceflow } from './spiceflow.js'
+import { Spiceflow } from './spiceflow.ts'
 
-import { req, sleep } from './utils.js'
+import { req, sleep } from './utils.ts'
 
 function textEventStream(items: string[]) {
   return items
@@ -321,7 +321,6 @@ describe('Stream', () => {
       "
     `)
     expect(parseTextEventStreamItem(text)).toMatchInlineSnapshot(`"hello"`)
-    
   })
 
   it('handle object and array', async () => {

package/src/types.test.ts

@@ -1,7 +1,7 @@
 import { expect, test } from 'vitest'
-import { createSpiceflowClient } from './client/index.js'
-import { Spiceflow } from './spiceflow.js'
-import { Prettify } from './types.js'
+import { createSpiceflowClient } from './client/index.ts'
+import { Spiceflow } from './spiceflow.ts'
+import { Prettify } from './types.ts'
 
 test('`use` on non Spiceflow return', async () => {
   function nonSpiceflowReturn() {

package/src/types.ts

@@ -1,19 +1,19 @@
 // https://github.com/remorses/elysia/blob/main/src/types.ts#L6
 
-import z from 'zod'
 import { StandardSchemaV1 } from '@standard-schema/spec'
+import z from 'zod'
 
 import type { OpenAPIV3 } from 'openapi-types'
 
-import { ZodObject, ZodTypeAny } from 'zod'
-import type { Context, ErrorContext, MiddlewareContext } from './context.js'
+import { ZodTypeAny } from 'zod'
+import type { Context, ErrorContext, MiddlewareContext } from './context.ts'
 import {
-  SPICEFLOW_RESPONSE,
-  InternalServerError,
-  ParseError,
-  ValidationError,
-} from './error.js'
-import { Spiceflow } from './spiceflow.js'
+    InternalServerError,
+    ParseError,
+    SPICEFLOW_RESPONSE,
+    ValidationError,
+} from './error.ts'
+import { Spiceflow } from './spiceflow.ts'
 
 export type MaybeArray<T> = T | T[]
 export type MaybePromise<T> = T | Promise<T>
@@ -161,7 +161,7 @@ export type RouteSchema = {
 
 export type TypeSchema = StandardSchemaV1
 
-export type TypeObject = ZodObject<any, any, any>
+export type TypeObject = StandardSchemaV1
 
 export type UnwrapSchema<
   Schema extends TypeSchema | string | undefined,
@@ -169,14 +169,14 @@ export type UnwrapSchema<
 > = Schema extends undefined
   ? unknown
   : Schema extends StandardSchemaV1
-  ? StandardSchemaV1.InferOutput<Schema>
-  : Schema extends ZodTypeAny
-  ? z.infer<Schema>
-  : Schema extends string
-  ? Definitions extends Record<Schema, infer NamedSchema>
-    ? NamedSchema
-    : Definitions
-  : unknown
+    ? StandardSchemaV1.InferOutput<Schema>
+    : Schema extends ZodTypeAny
+      ? z.infer<Schema>
+      : Schema extends string
+        ? Definitions extends Record<Schema, infer NamedSchema>
+          ? NamedSchema
+          : Definitions
+        : unknown
 
 export interface UnwrapRoute<
   in out Schema extends InputSchema<any>,

package/src/zod.test.ts

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

package/dist/_node_utils.d.ts

@@ -1,3 +0,0 @@
-import { createServer } from 'http';
-export { createServer };
-//# sourceMappingURL=_node_utils.d.ts.map

package/dist/_node_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_node_utils.d.ts","sourceRoot":"","sources":["../src/_node_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/_node_utils.js

@@ -1,2 +0,0 @@
-import { createServer } from 'http';
-export { createServer };

package/dist/_node_utils_browser.d.ts

@@ -1,2 +0,0 @@
-export declare function createServer(): void;
-//# sourceMappingURL=_node_utils_browser.d.ts.map

package/dist/_node_utils_browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_node_utils_browser.d.ts","sourceRoot":"","sources":["../src/_node_utils_browser.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,SAE3B"}

package/dist/_node_utils_browser.js

@@ -1,3 +0,0 @@
-export function createServer() {
-    throw new Error('createServer is not supported in non Node.js environments');
-}

package/dist/mcp.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mcp.test.d.ts.map

package/dist/mcp.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.test.d.ts","sourceRoot":"","sources":["../src/mcp.test.ts"],"names":[],"mappings":""}