spiceflow 1.17.11 → 1.18.0

package/src/client/types.ts

@@ -28,7 +28,7 @@ type And<A extends boolean, B extends boolean> = A extends true
     : false
   : false
 
-type ReplaceGeneratorWithAsyncGenerator<
+export type ReplaceGeneratorWithAsyncGenerator<
   in out RecordType extends Record<string, unknown>,
 > = {
   [K in keyof RecordType]: RecordType[K] extends any
@@ -132,6 +132,7 @@ export namespace SpiceflowClient {
   export interface Config {
     // fetch?: Omit<RequestInit, 'headers' | 'method'>
     fetch?: typeof fetch
+    state?: Record<string, any>
     headers?: MaybeArray<
       | RequestInit['headers']
       | ((path: string, options: RequestInit) => RequestInit['headers'] | void)
@@ -140,6 +141,7 @@ export namespace SpiceflowClient {
       (path: string, options: RequestInit) => MaybePromise<RequestInit | void>
     >
     onResponse?: MaybeArray<(response: Response) => MaybePromise<unknown>>
+    retries?: number
 
     // keepDomain?: boolean
   }

package/src/client.test.ts

@@ -327,3 +327,55 @@ describe('client as promise', () => {
     expect(data).toEqual({ test: 'value' })
   }, 200)
 })
+
+describe('client retries', () => {
+  it('should retry on 500 errors and succeed on third attempt', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-success', () => {
+      attemptCount++
+      if (attemptCount < 3) {
+        throw new Response('Server error', { status: 500 })
+      }
+      return { success: true, attempts: attemptCount }
+    })
+
+    const retryClient = createSpiceflowClient(retryApp, { retries: 2 })
+    const { data, error } = await retryClient['retry-success'].get()
+
+    expect(error).toBeNull()
+    expect(data).toEqual({ success: true, attempts: 3 })
+    expect(attemptCount).toBe(3)
+  })
+
+  it('should fail after all retries are exhausted', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-fail', () => {
+      attemptCount++
+      throw new Response('Server error', { status: 500 })
+    })
+
+    const retryClient = createSpiceflowClient(retryApp, { retries: 2 })
+    const { data, error } = await retryClient['retry-fail'].get()
+
+    expect(data).toBeNull()
+    expect(error).toBeDefined()
+    expect(error?.status).toBe(500)
+    expect(attemptCount).toBe(3)
+  })
+
+  it('should not retry on non-500 errors', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-400', () => {
+      attemptCount++
+      throw new Response('Bad request', { status: 400 })
+    })
+
+    const retryClient = createSpiceflowClient(retryApp, { retries: 2 })
+    const { data, error } = await retryClient['retry-400'].get()
+
+    expect(data).toBeNull()
+    expect(error).toBeDefined()
+    expect(error?.status).toBe(400)
+    expect(attemptCount).toBe(1)
+  })
+})

package/src/fetch-client.test.ts

@@ -0,0 +1,411 @@
+import { z } from 'zod'
+import { createSpiceflowFetch } from './client/fetch.ts'
+import { Spiceflow } from './spiceflow.ts'
+import { SpiceflowFetchError } from './client/errors.ts'
+
+import { describe, expect, it } from 'vitest'
+
+const app = new Spiceflow()
+  .state('someState', 1 as number | undefined)
+  .get('/', () => 'a')
+  .post('/', () => 'a')
+  .get('/number', () => 1)
+  .get('/someState', ({ state }) => state.someState)
+  .get('/true', () => true)
+  .get('/false', () => false)
+  .post('/array', async ({ request }) => await request.json(), {
+    body: z.array(z.string()),
+  })
+  .route({
+    method: 'POST',
+    path: '/mirror',
+    handler: async ({ request }) => await request.json(),
+  })
+  .route({
+    method: 'POST',
+    path: '/body',
+    handler: async ({ request }) => await request.text(),
+    body: z.string(),
+  })
+  .route({
+    method: 'DELETE',
+    path: '/empty',
+    handler: async ({ request }) => {
+      const body = await request.text()
+      return { body: body || null }
+    },
+  })
+  .route({
+    method: 'POST',
+    path: '/deep/nested/mirror',
+    handler: async ({ request }) => await request.json(),
+    body: z.object({
+      username: z.string(),
+      password: z.string(),
+    }),
+  })
+  .get('/throws', () => {
+    throw new Response('Custom error', { status: 400 })
+  })
+  .get('/throws-307', () => {
+    throw new Response('Redirect', {
+      status: 307,
+      headers: { location: 'http://example.com' },
+    })
+  })
+  .get('/throws-200', () => {
+    throw new Response('this string will not be parsed as json', {
+      status: 200,
+    })
+  })
+  .get('/throws-402-json', () => {
+    throw new Response(
+      JSON.stringify({ reason: 'Payment required', code: 4021 }),
+      {
+        status: 402,
+        headers: { 'content-type': 'application/json' },
+      },
+    )
+  })
+  .use(
+    new Spiceflow({ basePath: '/nested' }).get('/data', ({ params }) => 'hi'),
+  )
+  .get(
+    '/validationError',
+    // @ts-expect-error
+    () => {
+      return 'this errors because validation is wrong'
+    },
+    {
+      response: {
+        200: z.object({
+          x: z.string(),
+        }),
+      },
+    },
+  )
+  .get('/dateObject', () => ({ date: new Date() }))
+  .get('/redirect', ({ redirect }) => redirect('http://localhost:8083/true'))
+  .post('/redirect', ({ redirect }) => redirect('http://localhost:8083/true'), {
+    body: z.object({
+      username: z.string(),
+    }),
+  })
+  .get('/stream', function* stream() {
+    yield 'a'
+    yield 'b'
+    yield 'c'
+  })
+  .get('/stream-async', async function* stream() {
+    yield 'a'
+    yield 'b'
+    yield 'c'
+  })
+  .get('/stream-return', function* stream() {
+    return 'a'
+  })
+  .get('/stream-return-async', function* stream() {
+    return 'a'
+  })
+  .get('/id/:id', ({ params: { id } }) => id)
+  .get('/items/:id/:id2', ({ params }) => params)
+  .get(
+    '/search',
+    ({ query }) => query,
+    { query: z.object({ q: z.string(), page: z.coerce.number().optional() }) },
+  )
+
+const f = createSpiceflowFetch(app)
+
+describe('fetch client', () => {
+  it('get index', async () => {
+    const result = await f('/')
+    if (result instanceof Error) throw result
+
+    expect(result).toBe('a')
+  })
+
+  it('post index', async () => {
+    const result = await f('/', { method: 'POST' })
+    if (result instanceof Error) throw result
+
+    expect(result).toBe('a')
+  })
+
+  it('parse number', async () => {
+    const result = await f('/number')
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(1)
+  })
+
+  it('parse true', async () => {
+    const result = await f('/true')
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(true)
+  })
+
+  it('parse false', async () => {
+    const result = await f('/false')
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(false)
+  })
+
+  it('post array', async () => {
+    const result = await f('/array', {
+      method: 'POST',
+      body: ['a', 'b'],
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(['a', 'b'])
+  })
+
+  it('post body', async () => {
+    const result = await f('/body', {
+      method: 'POST',
+      body: 'a',
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual('a')
+  })
+
+  it('post mirror', async () => {
+    const body = { username: 'A', password: 'B' }
+
+    const result = await f('/mirror', {
+      method: 'POST',
+      body,
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(body)
+  })
+
+  it('delete empty', async () => {
+    const result = await f('/empty', { method: 'DELETE' })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual({ body: null })
+  })
+
+  it('post deep nested mirror', async () => {
+    const body = { username: 'A', password: 'B' }
+
+    const result = await f('/deep/nested/mirror', {
+      method: 'POST',
+      body,
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual(body)
+  })
+
+  it('get nested data', async () => {
+    const result = await f('/nested/data')
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual('hi')
+  })
+
+  it('handles thrown response', async () => {
+    const result = await f('/throws')
+
+    expect(result).toBeInstanceOf(SpiceflowFetchError)
+    if (!(result instanceof Error)) throw new Error('Expected error')
+    expect(result.status).toBe(400)
+    expect(result.message).toBe('Custom error')
+  })
+
+  it('handles thrown response with 307', async () => {
+    const result = await f('/throws-307')
+
+    expect(result).toBeInstanceOf(SpiceflowFetchError)
+    if (!(result instanceof Error)) throw new Error('Expected error')
+    expect(result.status).toBe(307)
+    expect(result.message).toBe('Redirect')
+  })
+
+  it('handles thrown response with 200', async () => {
+    const result = await f('/throws-200')
+    if (result instanceof Error) throw result
+
+    expect(result).toMatchInlineSnapshot(
+      `"this string will not be parsed as json"`,
+    )
+  })
+
+  it('surfaces json payload in error value for 402 responses', async () => {
+    const result = await f('/throws-402-json')
+
+    expect(result).toBeInstanceOf(SpiceflowFetchError)
+    if (!(result instanceof SpiceflowFetchError)) throw new Error('Expected SpiceflowFetchError')
+    expect(result.status).toBe(402)
+    expect(result.value).toEqual({ reason: 'Payment required', code: 4021 })
+  })
+
+  it('stream', async () => {
+    const result = await f('/stream')
+    if (result instanceof Error) throw result
+
+    let all = ''
+    for await (const chunk of result) {
+      all += chunk + '-'
+    }
+    expect(all).toEqual('a-b-c-')
+  })
+
+  it('stream async', async () => {
+    const result = await f('/stream-async')
+    if (result instanceof Error) throw result
+
+    let all = ''
+    for await (const chunk of result) {
+      all += chunk + '-'
+    }
+    expect(all).toEqual('a-b-c-')
+  })
+
+  it('stream return', async () => {
+    const result = await f('/stream-return')
+    if (result instanceof Error) throw result
+
+    let all = ''
+    for await (const chunk of result) {
+      all += chunk
+    }
+    expect(all).toEqual('a')
+  })
+
+  it('stream return async', async () => {
+    const result = await f('/stream-return-async')
+    if (result instanceof Error) throw result
+
+    let all = ''
+    for await (const chunk of result) {
+      all += chunk
+    }
+    expect(all).toEqual('a')
+  })
+
+  it('path params', async () => {
+    const result = await f('/id/:id', {
+      params: { id: '123' },
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual('123')
+  })
+
+  it('query params', async () => {
+    const result = await f('/search', {
+      query: { q: 'hello', page: 1 },
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual({ q: 'hello', page: 1 })
+  })
+
+  it('overlapping param names', async () => {
+    const result = await f('/items/:id/:id2', {
+      params: { id: 'A', id2: 'B' },
+    })
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual({ id: 'A', id2: 'B' })
+  })
+
+  it('untyped URL falls back gracefully', async () => {
+    const untypedFetch = createSpiceflowFetch(app)
+    const result = await (untypedFetch as any)('/number')
+    if (result instanceof Error) throw result
+    expect(result).toEqual(1)
+  })
+})
+
+describe('fetch client type safety', () => {
+  it('requires params for parameterized paths', () => {
+    // @ts-expect-error - missing required params for /id/:id
+    f('/id/:id')
+  })
+
+  it('requires query when route schema demands it', () => {
+    // @ts-expect-error - missing required query for /search
+    f('/search')
+  })
+
+  it('requires body for POST with typed body schema', () => {
+    // @ts-expect-error - missing required body for /deep/nested/mirror POST
+    f('/deep/nested/mirror', { method: 'POST' })
+  })
+
+  it('allows GET without options on routes with no required fields', async () => {
+    const result = await f('/number')
+    if (result instanceof Error) throw result
+    expect(result).toEqual(1)
+  })
+})
+
+describe('fetch client with state', () => {
+  it('should return state value', async () => {
+    const f = createSpiceflowFetch(app, { state: { someState: 3 } })
+    const result = await f('/someState')
+    if (result instanceof Error) throw result
+    expect(result).toBe(3)
+  })
+})
+
+describe('fetch client retries', () => {
+  it('should retry on 500 errors and succeed on third attempt', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-success', () => {
+      attemptCount++
+      if (attemptCount < 3) {
+        throw new Response('Server error', { status: 500 })
+      }
+      return { success: true, attempts: attemptCount }
+    })
+
+    const retryFetch = createSpiceflowFetch(retryApp, { retries: 2 })
+    const result = await retryFetch('/retry-success')
+    if (result instanceof Error) throw result
+
+    expect(result).toEqual({ success: true, attempts: 3 })
+    expect(attemptCount).toBe(3)
+  })
+
+  it('should fail after all retries are exhausted', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-fail', () => {
+      attemptCount++
+      throw new Response('Server error', { status: 500 })
+    })
+
+    const retryFetch = createSpiceflowFetch(retryApp, { retries: 2 })
+    const result = await retryFetch('/retry-fail')
+
+    expect(result).toBeInstanceOf(SpiceflowFetchError)
+    if (!(result instanceof Error)) throw new Error('Expected error')
+    expect(result.status).toBe(500)
+    expect(attemptCount).toBe(3)
+  })
+
+  it('should not retry on non-500 errors', async () => {
+    let attemptCount = 0
+    const retryApp = new Spiceflow().get('/retry-400', () => {
+      attemptCount++
+      throw new Response('Bad request', { status: 400 })
+    })
+
+    const retryFetch = createSpiceflowFetch(retryApp, { retries: 2 })
+    const result = await retryFetch('/retry-400')
+
+    expect(result).toBeInstanceOf(SpiceflowFetchError)
+    if (!(result instanceof Error)) throw new Error('Expected error')
+    expect(result.status).toBe(400)
+    expect(attemptCount).toBe(1)
+  })
+})

package/src/index.ts

@@ -1,6 +1,6 @@
 import { SpiceflowRequest, WaitUntil, Method } from './spiceflow.ts'
 
-export { Spiceflow } from './spiceflow.ts'
+export { Spiceflow, createSafePath } from './spiceflow.ts'
 export type { AnySpiceflow, WaitUntil } from './spiceflow.ts'
 export { ValidationError } from './error.ts'
 export { preventProcessExitIfBusy } from './prevent-process-exit-if-busy.ts'

package/src/mcp-client-transport.ts

@@ -68,8 +68,11 @@ export class FetchMCPCLientTransport implements Transport {
         `SSE connection failed (HTTP ${sseRes.status})\nURL: ${this.sseUrl}\nText: ${text}`,
       )
     }
-    for await (const evt of streamSSEResponse(sseRes, (x) => {
-      return x
+    for await (const evt of streamSSEResponse({
+      response: sseRes,
+      map: (x) => {
+        return x
+      },
     }) as AsyncGenerator<{
       event: string
       data: any