spiceflow 1.7.2 → 1.9.0

package/dist/types.test.js

@@ -14,6 +14,17 @@ test('`use` on non Spiceflow return', async () => {
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual('hi');
 });
+test('`handle` accepts state as second argument in object', async () => {
+    const app = new Spiceflow().state('counter', 0).post('/state-test', (c) => {
+        return { counter: c.state.counter };
+    });
+    const res = await app.handle(new Request('http://localhost/state-test', { method: 'POST' }), { state: { counter: 42 } });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ counter: 42 });
+    const invalidRes = await app.handle(new Request('http://localhost/state-test', { method: 'POST' }), 
+    // @ts-expect-error - Invalid state key
+    { state: { invalidKey: 100 } });
+});
 test('`use` on Spiceflow return', async () => {
     function nonSpiceflowReturn() {
         return new Spiceflow().post('/usePost', () => 'hi');

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,GAAI,OAAO,GAAG,QAOpC,CAAA;AAED,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,EAAE,UAAU,WAAW,YACN,CAAA;AAEjD,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,cAAc,CAAC,GAAG,CAAC,CASpE;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DZ,CAAA;AAEV,eAAO,MAAM,iBAAiB,EAEzB,GACF,CAAC,IAAI,MAAM,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAC1C,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA;AACxC,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,MAAM,EACX,SAAQ,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAS,aACR,CAAA;AAEnC,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,QAAQ,CAoB1D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,UAAW,GAAG,QAOpC,CAAA;AAED,eAAO,MAAM,GAAG,SAAU,MAAM,YAAY,WAAW,YACN,CAAA;AAEjD,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,cAAc,CAAC,GAAG,CAAC,CASpE;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DZ,CAAA;AAEV,eAAO,MAAM,iBAAiB,EAEzB,GACF,CAAC,IAAI,MAAM,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAC1C,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA;AACxC,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,QACd,MAAM,WACH,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,aACF,CAAA;AAEnC,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,QAAQ,CAoB1D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spiceflow",
-  "version": "1.7.2",
+  "version": "1.9.0",
   "description": "Simple API framework with RPC and type safety",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,13 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./_node_utils": {
+      "types": "./dist/_node_utils.d.ts",
+      "browser": "./dist/_node_utils_browser.js",
+      "workerd": "./dist/_node_utils_browser.js",
+      "edge-light": "./dist/_node_utils_browser.js",
+      "default": "./dist/_node_utils.js"
+    },
     "./cors": {
       "types": "./dist/cors.d.ts",
       "default": "./dist/cors.js"
@@ -41,9 +48,6 @@
   "license": "",
   "dependencies": {
     "@medley/router": "^0.2.1",
-    "@sinclair/typebox": "^0.34.33",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
     "eventsource-parser": "^3.0.0",
     "lodash.clonedeep": "^4.5.0",
     "openapi-types": "^12.1.3",

package/src/_node_utils.ts

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

package/src/_node_utils_browser.ts

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

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
 }
 
@@ -719,7 +700,10 @@ export class Spiceflow<
     return this
   }
 
-  async handle(request: Request): Promise<Response> {
+  async handle(
+    request: Request,
+    { state: customState }: { state?: Singleton['state'] } = {},
+  ): Promise<Response> {
     let u = new URL(request.url, 'http://localhost')
     const self = this
     let path = u.pathname + u.search
@@ -741,7 +725,7 @@ export class Spiceflow<
     } = route
     const middlewares = appsInScope.flatMap((x) => x.middlewares)
 
-    let state = cloneDeep(defaultState)
+    let state = customState || lodashCloneDeep(defaultState)
 
     let content = route?.internalRoute?.hooks?.content
 
@@ -814,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,
         )
@@ -946,10 +930,8 @@ 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, hostname)
+      return this.handleNode(req, res)
     })
 
     await new Promise((resolve, reject) => {
@@ -965,14 +947,14 @@ export class Spiceflow<
   async handleNode(
     req: IncomingMessage,
     res: ServerResponse,
-    hostname: string = '0.0.0.0',
+    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 { Readable } = await import('stream')
+
     const abortController = new AbortController()
     const { signal } = abortController
 
@@ -991,7 +973,7 @@ export class Spiceflow<
 
     const url = new URL(
       req.url || '',
-      `http://${req.headers.host || hostname || 'localhost'}`,
+      `http://${req.headers.host || 'localhost'}`,
     )
     const typedRequest = new SpiceflowRequest(url.toString(), {
       method: req.method,
@@ -1021,7 +1003,7 @@ export class Spiceflow<
     })
 
     try {
-      const response = await this.handle(typedRequest)
+      const response = await this.handle(typedRequest, context)
       res.writeHead(
         response.status,
         Object.fromEntries(response.headers.entries()),
@@ -1169,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',
@@ -1257,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>
@@ -1362,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 &&
@@ -1372,27 +1300,39 @@ 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')
   }
   return value
 }

package/src/types.test.ts

@@ -22,6 +22,27 @@ test('`use` on non Spiceflow return', async () => {
   expect(res.status).toBe(200)
   expect(await res.json()).toEqual('hi')
 })
+
+test('`handle` accepts state as second argument in object', async () => {
+  const app = new Spiceflow().state('counter', 0).post('/state-test', (c) => {
+    return { counter: c.state.counter }
+  })
+
+  const res = await app.handle(
+    new Request('http://localhost/state-test', { method: 'POST' }),
+    { state: { counter: 42 } },
+  )
+
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({ counter: 42 })
+
+  const invalidRes = await app.handle(
+    new Request('http://localhost/state-test', { method: 'POST' }),
+    // @ts-expect-error - Invalid state key
+    { state: { invalidKey: 100 } },
+  )
+})
+
 test('`use` on Spiceflow return', async () => {
   function nonSpiceflowReturn() {
     return new Spiceflow().post('/usePost', () => 'hi')