spiceflow 1.8.0 → 1.9.1

package/src/mcp.ts

@@ -6,21 +6,12 @@ import {
   ListToolsRequestSchema,
   ReadResourceRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
-import { zodToJsonSchema } from 'zod-to-json-schema'
-import { SSEServerTransportSpiceflow } from './mcp-transport.js'
-import { isZodSchema, Spiceflow } from './spiceflow.js'
 import { OpenAPIV3 } from 'openapi-types'
+import { SSEServerTransportSpiceflow } from './mcp-transport.js'
 import { openapi } from './openapi.js'
+import { Spiceflow } from './spiceflow.js'
+
 
-function getJsonSchema(schema: any) {
-  if (!schema) return undefined
-  if (isZodSchema(schema)) {
-    return zodToJsonSchema(schema, {
-      removeAdditionalStrategy: 'strict',
-    })
-  }
-  return schema
-}
 const transports = new Map<string, SSEServerTransportSpiceflow>()
 function getOperationRequestBody(
   operation: OpenAPIV3.OperationObject,

package/src/openapi.ts

@@ -221,56 +221,54 @@ const registerSchemaPath = ({
         },
       }
     } else {
-      Object.entries(responseSchema as Record<string, TypeSchema>).forEach(
-        ([key, value]) => {
-          if (typeof value === 'string') {
-            if (!models[value]) return
-
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const {
-              type,
-              properties,
-              required,
-              additionalProperties: _1,
-              patternProperties: _2,
-              ...rest
-            } = getJsonSchema(models[value])
-
-            openapiResponse[key] = {
-              ...rest,
-              description: rest.description as any,
-              content: mapTypesResponse(contentTypes, value),
-            }
-          } else {
-            const schema = getJsonSchema(value)
-            const {
-              type,
-              properties,
-              required,
-              additionalProperties,
-              patternProperties,
-              ...rest
-            } = schema
-
-            openapiResponse[key] = {
-              ...rest,
-              description: (rest.description as any) || '',
-              content: mapTypesResponse(
-                contentTypes,
-                type === 'object' || type === 'array'
-                  ? ({
-                      type,
-                      properties,
-                      patternProperties,
-                      items: rest.items,
-                      required,
-                    } as any)
-                  : schema,
-              ),
-            }
+      Object.entries(responseSchema).forEach(([key, value]) => {
+        if (typeof value === 'string') {
+          if (!models[value]) return
+
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const {
+            type,
+            properties,
+            required,
+            additionalProperties: _1,
+            patternProperties: _2,
+            ...rest
+          } = getJsonSchema(models[value])
+
+          openapiResponse[key] = {
+            ...rest,
+            description: rest.description as any,
+            content: mapTypesResponse(contentTypes, value),
           }
-        },
-      )
+        } else {
+          const schema = getJsonSchema(value)
+          const {
+            type,
+            properties,
+            required,
+            additionalProperties,
+            patternProperties,
+            ...rest
+          } = schema
+
+          openapiResponse[key] = {
+            ...rest,
+            description: (rest.description as any) || '',
+            content: mapTypesResponse(
+              contentTypes,
+              type === 'object' || type === 'array'
+                ? ({
+                    type,
+                    properties,
+                    patternProperties,
+                    items: rest.items,
+                    required,
+                  } as any)
+                : schema,
+            ),
+          }
+        }
+      })
     }
   } else if (typeof responseSchema === 'string') {
     if (!(responseSchema in models)) return

package/src/spiceflow.test.ts

@@ -238,7 +238,7 @@ test('onError fires on validation errors', async () => {
   )
 
   expect(res.status).toBe(400)
-  expect(errorMessage).toContain('data/name must be string')
+  expect(errorMessage).toMatchInlineSnapshot(`"name: Expected string, received number"`)
   expect(await res.text()).toMatchInlineSnapshot(`"Error"`)
 })
 
@@ -447,7 +447,7 @@ test('validate body works, request fails', async () => {
     )
   expect(res.status).toBe(422)
   expect(await res.text()).toMatchInlineSnapshot(
-    `"{"code":"VALIDATION","status":422,"message":"data must have required property 'requiredField'"}"`,
+    `"{"code":"VALIDATION","status":422,"message":"requiredField: Required"}"`,
   )
 })
 
@@ -820,7 +820,7 @@ test('can pass additional props to body schema', async () => {
       name: z.string(),
       age: z.number(),
       email: z.string().email(),
-    }),
+    }).passthrough(),
   })
 
   const res = await app.handle(

package/src/spiceflow.ts

@@ -1,6 +1,5 @@
-import addFormats from 'ajv-formats'
+import { createServer } from 'spiceflow/_node_utils'
 import lodashCloneDeep from 'lodash.clonedeep'
-
 import superjson from 'superjson'
 import {
   ComposeSpiceflowResponse,
@@ -25,52 +24,34 @@ import {
   TypeSchema,
   UnwrapRoute,
 } from './types.js'
-let globalIndex = 0
 
 import OriginalRouter from '@medley/router'
-import Ajv, { ValidateFunction } from 'ajv'
-import type { IncomingMessage, ServerResponse } from 'http'
+import { type IncomingMessage, type ServerResponse } from 'http'
 import { z, ZodType } from 'zod'
-import { zodToJsonSchema } from 'zod-to-json-schema'
+
 import { MiddlewareContext } from './context.js'
 import { isProduction, ValidationError } from './error.js'
 import { isAsyncIterable, isResponse, redirect } from './utils.js'
-
-const ajv = (addFormats.default || addFormats)(
-  new (Ajv.default || Ajv)({ useDefaults: true }),
-  [
-    'date-time',
-    'time',
-    'date',
-    'email',
-    'hostname',
-    'ipv4',
-    'ipv6',
-    'uri',
-    'uri-reference',
-    'uuid',
-    'uri-template',
-    'json-pointer',
-    'relative-json-pointer',
-    'regex',
-  ],
-)
-
-// Should be exported from `hono/router`
+import { StandardSchemaV1 } from '@standard-schema/spec'
+let globalIndex = 0
 
 type AsyncResponse = Response | Promise<Response>
 
 type OnError = (x: { error: any; request: Request }) => AsyncResponse
 
+type ValidationFunction = (
+  value: unknown,
+) => StandardSchemaV1.Result<any> | Promise<StandardSchemaV1.Result<any>>
+
 export type InternalRoute = {
   method: HTTPMethod
   path: string
   type: ContentType
   handler: InlineHandler<any, any, any>
   hooks: LocalHook<any, any, any, any, any, any, any>
-  validateBody?: ValidateFunction
-  validateQuery?: ValidateFunction
-  validateParams?: ValidateFunction
+  validateBody?: ValidationFunction
+  validateQuery?: ValidationFunction
+  validateParams?: ValidationFunction
   // prefix: string
 }
 
@@ -744,7 +725,7 @@ export class Spiceflow<
     } = route
     const middlewares = appsInScope.flatMap((x) => x.middlewares)
 
-    let state = customState || cloneDeep(defaultState)
+    let state = customState || lodashCloneDeep(defaultState)
 
     let content = route?.internalRoute?.hooks?.content
 
@@ -817,11 +798,11 @@ export class Spiceflow<
           return handlerResponse
         }
 
-        context.query = runValidation(
+        context.query = await runValidation(
           context.query,
           route.internalRoute?.validateQuery,
         )
-        context.params = runValidation(
+        context.params = await runValidation(
           context.params,
           route.internalRoute?.validateParams,
         )
@@ -949,8 +930,6 @@ export class Spiceflow<
     return this.listenNode(port, hostname)
   }
   async listenNode(port: number, hostname: string = '0.0.0.0') {
-    const { createServer } = await import('http')
-
     const server = createServer((req, res) => {
       return this.handleNode(req, res)
     })
@@ -975,7 +954,7 @@ export class Spiceflow<
         'req.body is defined, you should disable your framework body parser to be able to use the request in Spiceflow',
       )
     }
-    const { Readable } = await import('stream')
+
     const abortController = new AbortController()
     const { signal } = abortController
 
@@ -1172,60 +1151,6 @@ export class Spiceflow<
   }
 }
 
-// async function getRequestBody({
-// 	request,
-// 	content,
-// }: {
-// 	content
-// 	request: Request
-// }) {
-// 	let body: string | Record<string, any> | undefined
-// 	if (request.method === 'GET' || request.method === 'HEAD') {
-// 		return
-// 	}
-
-// 	const contentType =
-// 		content || request.headers.get('content-type')?.split(';')?.[0]
-
-// 	if (!contentType) {
-// 		return
-// 	}
-
-// 	switch (contentType) {
-// 		case 'application/json':
-// 			body = (await request.json()) as any
-// 			break
-
-// 		case 'text/plain':
-// 			body = await request.text()
-// 			break
-
-// 		case 'application/x-www-form-urlencoded':
-// 			body = parseQuery.parse(await request.text()) as any
-// 			break
-
-// 		case 'application/octet-stream':
-// 			body = await request.arrayBuffer()
-// 			break
-
-// 		case 'multipart/form-data':
-// 			body = {}
-
-// 			const form = await request.formData()
-// 			for (const key of form.keys()) {
-// 				if (body[key]) continue
-
-// 				const value = form.getAll(key)
-// 				if (value.length === 1) body[key] = value[0]
-// 				else body[key] = value
-// 			}
-
-// 			break
-// 	}
-
-// 	return body
-// }
-
 const METHODS = [
   'ALL',
   'CONNECT',
@@ -1260,7 +1185,7 @@ function bfsFind<T>(
   return
 }
 export class SpiceflowRequest<T = any> extends Request {
-  validateBody?: ValidateFunction
+  validateBody?: ValidationFunction
 
   async json(): Promise<T> {
     const body = (await super.json()) as Promise<T>
@@ -1365,7 +1290,7 @@ export type AnySpiceflow = Spiceflow<any, any, any, any, any, any>
 
 export function isZodSchema(value: unknown): value is ZodType {
   return (
-    value instanceof z.ZodType ||
+    value instanceof ZodType ||
     (typeof value === 'object' &&
       value !== null &&
       'parse' in value &&
@@ -1375,27 +1300,42 @@ export function isZodSchema(value: unknown): value is ZodType {
   )
 }
 
-function getValidateFunction(schema: TypeSchema) {
-  if (isZodSchema(schema)) {
-    let jsonSchema = zodToJsonSchema(schema, {
-      removeAdditionalStrategy: 'strict',
-    })
-    return ajv.compile(jsonSchema)
+function getValidateFunction(
+  schema: TypeSchema,
+): ValidationFunction | undefined {
+  if (!schema) {
+    return
   }
-
-  if (schema) {
-    return ajv.compile(schema)
+  try {
+    return schema['~standard'].validate
+  } catch (error) {
+    console.log(`not a standard schema: ${schema}`)
+    return undefined
   }
 }
 
-function runValidation(value: any, validate?: ValidateFunction) {
+async function runValidation(value: any, validate?: ValidationFunction) {
   if (!validate) return value
-  const valid = validate(value)
-  if (!valid) {
-    const error = ajv.errorsText(validate.errors, {
-      separator: '\n',
-    })
-    throw new ValidationError(error)
+
+  let result = validate(value)
+  if (result instanceof Promise) {
+    result = await result
+  }
+
+  if (result.issues && result.issues.length > 0) {
+    const errorMessages = result.issues
+      .map((issue) => {
+        let pathString = ''
+        if (issue.path && issue.path.length > 0) {
+          pathString = issue.path.join('.') + ': '
+        }
+        return pathString + issue.message
+      })
+      .join('\\n')
+    throw new ValidationError(errorMessages || 'Validation failed')
+  }
+  if ('value' in result) {
+    return result.value
   }
   return value
 }