spiceflow 1.12.1 → 1.13.0

package/src/openapi.ts

@@ -121,8 +121,10 @@ const registerSchemaPath = ({
   schema,
   route,
   models,
+  basePath,
 }: {
   schema: Partial<OpenAPIV3.PathsObject>
+  basePath: string
   route: InternalRoute
   models: Record<string, TypeSchema>
 }) => {
@@ -377,6 +379,7 @@ export const openapi = <Path extends string = '/openapi'>({
   const relativePath = path.startsWith('/') ? path.slice(1) : path
 
   const app = new Spiceflow({ name: 'openapi' }).get(path, ({}) => {
+    const basePath = app.topLevelApp!.basePath // TODO this does not work
     let routes = app.getAllRoutes()
     if (routes.length !== totalRoutes) {
       const ALLOWED_METHODS = [
@@ -392,6 +395,7 @@ export const openapi = <Path extends string = '/openapi'>({
       totalRoutes = routes.length
 
       routes.forEach((route: InternalRoute) => {
+        if (route.path.startsWith('_mcp_')) return
         if (route.hooks?.detail?.hide === true) return
         // TODO: route.hooks?.detail?.hide !== false  add ability to hide: false to prevent excluding
         if (excludeMethods.includes(route.method)) return
@@ -404,9 +408,10 @@ export const openapi = <Path extends string = '/openapi'>({
         if (route.method === 'ALL') {
           ALLOWED_METHODS.forEach((method) => {
             registerSchemaPath({
+              basePath,
               schema,
               route: { ...route, method },
-              // @ts-ignore
+
               models: app.definitions?.type,
             })
           })
@@ -414,6 +419,7 @@ export const openapi = <Path extends string = '/openapi'>({
         }
 
         registerSchemaPath({
+          basePath,
           schema,
           route,
           // @ts-ignore
@@ -473,9 +479,9 @@ function getJsonSchema(schema: TypeSchema) {
     return rest as any
   }
   if (isZodSchema(schema)) {
-    let jsonSchema = zodToJsonSchema(schema, {
+    let jsonSchema = zodToJsonSchema(schema as any, {
       removeAdditionalStrategy: 'strict',
-    })
+    }) as any
     const { $schema, ...rest } = jsonSchema
     return rest as any
   }

package/src/spiceflow.test.ts

@@ -36,6 +36,18 @@ test('* param is a path without front slash', async () => {
   }
 })
 
+test('should error if passing .request option to .route with method GET', () => {
+  new Spiceflow().route({
+    method: 'GET',
+    path: '/abc',
+    handler: () => 'ok',
+    // @ts-expect-error .request is not allowed for GET routes
+    request: z.object({
+      abc: z.string(),
+    }),
+  })
+})
+
 test('this works to reference app in handler', async () => {
   const res = await new Spiceflow()
     .route({
@@ -600,7 +612,7 @@ test('getRouteAndParents', async () => {
   let routers = bfs(app)
   let last = routers[routers.length - 1]
 
-  expect(app['getAppAndParents'](last).map((x) => x.prefix))
+  expect(app['getAppAndParents'](last).map((x) => x.basePath))
     .toMatchInlineSnapshot(`
 			[
 			  "/one",
@@ -626,7 +638,7 @@ test('getAppsInScope include all parent apps', async () => {
   let routers = bfs(app)
   let secondLast = routers[routers.length - 2]
 
-  expect(app['getAppsInScope'](secondLast).map((x) => x.prefix))
+  expect(app['getAppsInScope'](secondLast).map((x) => x.basePath))
     .toMatchInlineSnapshot(`
 			[
 			  "/one",
@@ -652,7 +664,7 @@ test('getAppsInScope include all parent apps and non scoped apps', async () => {
   let routers = bfs(app)
   let secondLast = routers[routers.length - 2]
 
-  expect(app['getAppsInScope'](secondLast).map((x) => x.prefix))
+  expect(app['getAppsInScope'](secondLast).map((x) => x.basePath))
     .toMatchInlineSnapshot(`
 			[
 			  "/one",
@@ -932,7 +944,9 @@ describe('safePath', () => {
     expect(app.safePath('/posts')).toBe('/posts')
     // @ts-expect-error
     app.safePath('/posts/*')
-    expect(app.safePath('/posts/*', { '*': 'some/key' })).toBe('/posts/some/key')
+    expect(app.safePath('/posts/*', { '*': 'some/key' })).toBe(
+      '/posts/some/key',
+    )
   })
 
   test('handles paths with required parameters', () => {

package/src/spiceflow.ts

@@ -1,4 +1,5 @@
 import { copy } from 'copy-anything'
+import superjson from 'superjson'
 
 import { SpiceflowFetchError } from './client/errors.ts'
 import { ValidationError } from './error.ts'
@@ -34,7 +35,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { handleForNode, listenForNode } from 'spiceflow/_node-server'
 import { MiddlewareContext } from './context.ts'
-import { superjsonSerialize } from './serialize.ts'
+
 import { isAsyncIterable, isResponse, redirect } from './utils.ts'
 
 let globalIndex = 0
@@ -46,6 +47,8 @@ export type SpiceflowServerError =
   | SpiceflowFetchError<number, any>
   | Error
 
+export type WaitUntil = (promise: Promise<any>) => void
+
 type OnError = (x: {
   error: SpiceflowServerError
   request: Request
@@ -104,7 +107,8 @@ export class Spiceflow<
   private onErrorHandlers: OnError[] = []
   private routes: InternalRoute[] = []
   private defaultState: Record<any, any> = {}
-  topLevelApp?: AnySpiceflow
+  topLevelApp?: AnySpiceflow = this
+  private waitUntilFn: WaitUntil
 
   _types = {
     Prefix: '' as BasePath,
@@ -117,7 +121,7 @@ export class Spiceflow<
   }
 
   /** @internal */
-  prefix?: string
+  basePath?: string = ''
 
   /** @internal */
   childrenApps: AnySpiceflow[] = []
@@ -128,7 +132,7 @@ export class Spiceflow<
     const allApps = bfs(root) || []
     const allRoutes = allApps.flatMap((x) => {
       const prefix = this.getAppAndParents(x)
-        .map((x) => x.prefix)
+        .map((x) => x.basePath)
         .join('')
 
       return x.routes.map((x) => ({ ...x, path: prefix + x.path }))
@@ -181,7 +185,7 @@ export class Spiceflow<
     const result = bfsFind(this, (app) => {
       app.topLevelApp = root
       let prefix = this.getAppAndParents(app)
-        .map((x) => x.prefix)
+        .map((x) => x.basePath)
         .join('')
         .replace(/\/$/, '')
       if (prefix && !path.startsWith(prefix)) {
@@ -283,13 +287,22 @@ export class Spiceflow<
     options: {
       name?: string
       scoped?: Scoped
-
+      waitUntil?: WaitUntil
       basePath?: BasePath
     } = {},
   ) {
     this.scoped = options.scoped
-
-    this.prefix = options.basePath
+    
+    // Set up waitUntil function - use provided one, global one, or noop
+    this.waitUntilFn = options.waitUntil || 
+      (typeof globalThis !== 'undefined' && 'waitUntil' in globalThis 
+        ? (globalThis as any).waitUntil 
+        : () => {})
+
+    this.basePath = options.basePath || ''
+    if (this.basePath === '/') {
+      this.basePath = ''
+    }
   }
 
   post<
@@ -454,13 +467,16 @@ export class Spiceflow<
       path: Path
       method: Method
       handler: Handle
-    } & LocalHook<
-      LocalSchema,
-      Schema,
-      Singleton,
-      Definitions['error'],
-      Metadata['macro'],
-      JoinPath<BasePath, Path>
+    } & Omit<
+      LocalHook<
+        LocalSchema,
+        Schema,
+        Singleton,
+        Definitions['error'],
+        Metadata['macro'],
+        JoinPath<BasePath, Path>
+      >,
+      Method extends 'GET' | 'HEAD' ? 'request' : never
     >,
   ): Spiceflow<
     BasePath,
@@ -778,6 +794,7 @@ export class Spiceflow<
 
   use(appOrHandler) {
     if (appOrHandler instanceof Spiceflow) {
+      appOrHandler.topLevelApp = this
       this.childrenApps.push(appOrHandler)
     } else if (typeof appOrHandler === 'function') {
       this.middlewares ??= []
@@ -843,6 +860,7 @@ export class Spiceflow<
       query: parseQuery((u.search || '').slice(1)),
       params: _params,
       redirect,
+      waitUntil: this.waitUntilFn,
     } satisfies MiddlewareContext<any>
     let handlerResponse: Response | undefined
     async function getResForError(err: any) {
@@ -1422,3 +1440,12 @@ function parseQuery(queryString: string) {
 export function cloneDeep(x) {
   return copy(x)
 }
+
+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/waitUntil.test.ts

@@ -0,0 +1,168 @@
+import { describe, test, expect, vi } from 'vitest'
+import { Spiceflow } from './spiceflow.ts'
+
+describe('waitUntil', () => {
+  test('waitUntil is available in handler context', async () => {
+    let waitUntilCalled = false
+    let waitUntilPromise: Promise<any> | null = null
+
+    const mockWaitUntil = vi.fn((promise: Promise<any>) => {
+      waitUntilCalled = true
+      waitUntilPromise = promise
+    })
+
+    const app = new Spiceflow({
+      waitUntil: mockWaitUntil
+    }).route({
+      method: 'GET',
+      path: '/test',
+      handler({ waitUntil }) {
+        expect(typeof waitUntil).toBe('function')
+        
+        const backgroundTask = Promise.resolve('background work done')
+        waitUntil(backgroundTask)
+        
+        return { success: true }
+      }
+    })
+
+    const response = await app.handle(new Request('http://localhost/test'))
+    const data = await response.json()
+
+    expect(data).toEqual({ success: true })
+    expect(waitUntilCalled).toBe(true)
+    expect(mockWaitUntil).toHaveBeenCalledTimes(1)
+    expect(waitUntilPromise).toBeInstanceOf(Promise)
+  })
+
+  test('waitUntil defaults to noop when not provided', async () => {
+    const app = new Spiceflow().route({
+      method: 'GET',
+      path: '/test',
+      handler({ waitUntil }) {
+        expect(typeof waitUntil).toBe('function')
+        
+        // Should not throw when called
+        waitUntil(Promise.resolve('test'))
+        
+        return { success: true }
+      }
+    })
+
+    const response = await app.handle(new Request('http://localhost/test'))
+    const data = await response.json()
+
+    expect(data).toEqual({ success: true })
+  })
+
+  test('waitUntil can be called multiple times', async () => {
+    const mockWaitUntil = vi.fn()
+
+    const app = new Spiceflow({
+      waitUntil: mockWaitUntil
+    }).route({
+      method: 'POST',
+      path: '/multi',
+      handler({ waitUntil }) {
+        waitUntil(Promise.resolve('task 1'))
+        waitUntil(Promise.resolve('task 2'))
+        waitUntil(Promise.resolve('task 3'))
+        
+        return { taskCount: 3 }
+      }
+    })
+
+    const response = await app.handle(new Request('http://localhost/multi', {
+      method: 'POST'
+    }))
+    const data = await response.json()
+
+    expect(data).toEqual({ taskCount: 3 })
+    expect(mockWaitUntil).toHaveBeenCalledTimes(3)
+  })
+
+  test('waitUntil works with middleware context', async () => {
+    const mockWaitUntil = vi.fn()
+
+    const app = new Spiceflow({
+      waitUntil: mockWaitUntil
+    })
+      .use(({ waitUntil }, next) => {
+        expect(typeof waitUntil).toBe('function')
+        waitUntil(Promise.resolve('middleware task'))
+        return next()
+      })
+      .route({
+        method: 'GET',
+        path: '/middleware',
+        handler({ waitUntil }) {
+          waitUntil(Promise.resolve('handler task'))
+          return { success: true }
+        }
+      })
+
+    const response = await app.handle(new Request('http://localhost/middleware'))
+    const data = await response.json()
+
+    expect(data).toEqual({ success: true })
+    expect(mockWaitUntil).toHaveBeenCalledTimes(2)
+  })
+
+  test('waitUntil uses global waitUntil when available', async () => {
+    // Mock global waitUntil
+    const originalGlobal = globalThis as any
+    const mockGlobalWaitUntil = vi.fn()
+    originalGlobal.waitUntil = mockGlobalWaitUntil
+
+    try {
+      const app = new Spiceflow().route({
+        method: 'GET',
+        path: '/global',
+        handler({ waitUntil }) {
+          waitUntil(Promise.resolve('using global'))
+          return { usingGlobal: true }
+        }
+      })
+
+      const response = await app.handle(new Request('http://localhost/global'))
+      const data = await response.json()
+
+      expect(data).toEqual({ usingGlobal: true })
+      expect(mockGlobalWaitUntil).toHaveBeenCalledTimes(1)
+    } finally {
+      // Clean up
+      delete originalGlobal.waitUntil
+    }
+  })
+
+  test('custom waitUntil overrides global waitUntil', async () => {
+    // Mock global waitUntil
+    const originalGlobal = globalThis as any
+    const mockGlobalWaitUntil = vi.fn()
+    const mockCustomWaitUntil = vi.fn()
+    originalGlobal.waitUntil = mockGlobalWaitUntil
+
+    try {
+      const app = new Spiceflow({
+        waitUntil: mockCustomWaitUntil
+      }).route({
+        method: 'GET',
+        path: '/custom',
+        handler({ waitUntil }) {
+          waitUntil(Promise.resolve('using custom'))
+          return { usingCustom: true }
+        }
+      })
+
+      const response = await app.handle(new Request('http://localhost/custom'))
+      const data = await response.json()
+
+      expect(data).toEqual({ usingCustom: true })
+      expect(mockCustomWaitUntil).toHaveBeenCalledTimes(1)
+      expect(mockGlobalWaitUntil).not.toHaveBeenCalled()
+    } finally {
+      // Clean up
+      delete originalGlobal.waitUntil
+    }
+  })
+})

package/dist/serialize.d.ts

@@ -1,2 +0,0 @@
-export declare function superjsonSerialize(value: any, indent?: boolean): string;
-//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../src/serialize.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,UAAQ,UAO5D"}

package/dist/serialize.js

@@ -1,9 +0,0 @@
-import superjson from 'superjson';
-export function superjsonSerialize(value, 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/serialize.ts

@@ -1,10 +0,0 @@
-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)
-}