spiceflow 1.1.14 → 1.1.16

package/src/openapi.ts

@@ -137,7 +137,7 @@ export const registerSchemaPath = ({
   const contentTypes =
     typeof contentType === 'string'
       ? [contentType]
-      : (contentType ?? ['application/json'])
+      : contentType ?? ['application/json']
 
   const bodySchema = getJsonSchema(hook?.body)
   const paramsSchema = hook?.params
@@ -164,7 +164,7 @@ export const registerSchemaPath = ({
       openapiResponse = {
         '200': {
           ...rest,
-          description: rest.description as any,
+          description: (rest.description as any) || '',
           content: mapTypesResponse(
             contentTypes,
             type === 'object' || type === 'array'
@@ -213,7 +213,7 @@ export const registerSchemaPath = ({
 
             openapiResponse[key] = {
               ...rest,
-              description: rest.description as any,
+              description: rest.description as any || '',
               content: mapTypesResponse(
                 contentTypes,
                 type === 'object' || type === 'array'
@@ -247,7 +247,9 @@ export const registerSchemaPath = ({
     openapiResponse = {
       // @ts-ignore
       '200': {
+        description: '',
         ...rest,
+
         content: mapTypesResponse(contentTypes, responseSchema),
       },
     }
@@ -265,7 +267,7 @@ export const registerSchemaPath = ({
       ...((paramsSchema || querySchema || bodySchema
         ? ({ parameters } as any)
         : {}) satisfies OpenAPIV3.ParameterObject),
-      ...(openapiResponse
+      ...(!isObjEmpty(openapiResponse)
         ? {
             responses: openapiResponse,
           }
@@ -371,7 +373,7 @@ export const openapi = <Path extends string = '/openapi'>({
     }
 
     return {
-      openapi: '3.0.3',
+      openapi: '3.1.3',
       ...{
         ...documentation,
         // tags: documentation.tags?.filter(
@@ -412,3 +414,7 @@ function getJsonSchema(schema: TypeSchema): JSONSchemaType<any> {
 
   return schema as any
 }
+
+function isObjEmpty(obj: Record<string, any>) {
+  return obj === undefined || Object.keys(obj).length === 0
+}

package/src/spiceflow.test.ts

@@ -2,6 +2,7 @@ import { test, describe, expect } from 'vitest'
 import { Type } from '@sinclair/typebox'
 import { bfs, Spiceflow } from './spiceflow.js'
 import { z } from 'zod'
+import { createSpiceflowClient } from './client/index.js'
 
 test('works', async () => {
   const res = await new Spiceflow()
@@ -557,3 +558,127 @@ test('errors inside basPath works', async () => {
     // expect(await res.json()).toEqual('nested'))
   }
 })
+
+test('basepath with root route', async () => {
+  let handlerCalled = false
+  const app = new Spiceflow({ basePath: '/api' }).get('/', ({ request }) => {
+    handlerCalled = true
+    return new Response('Root route of API')
+  })
+
+  const res = await app.handle(new Request('http://localhost/api'))
+  expect(handlerCalled).toBe(true)
+  expect(res.status).toBe(200)
+  expect(await res.text()).toBe('Root route of API')
+
+  // Test that non-root paths are not matched
+  handlerCalled = false
+  const res2 = await app.handle(new Request('http://localhost/api/other'))
+  expect(handlerCalled).toBe(false)
+  expect(res2.status).toBe(404)
+})
+
+describe('Trailing slashes and base paths', () => {
+  test('App without trailing slash, request with trailing slash', async () => {
+    const app = new Spiceflow({ basePath: '/api' }).get(
+      '/users',
+      () => new Response('Users list'),
+    )
+
+    const res = await app.handle(new Request('http://localhost/api/users/'))
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('Users list')
+  })
+
+  test('App with trailing slash, request without trailing slash', async () => {
+    const app = new Spiceflow({ basePath: '/api/' }).get(
+      '/users/',
+      () => new Response('Users list'),
+    )
+
+    const res = await app.handle(new Request('http://localhost/api/users'))
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('Users list')
+  })
+
+  test('Nested routes with and without trailing slashes', async () => {
+    const app = new Spiceflow({ basePath: '/api' }).use(
+      new Spiceflow()
+        .get('/products', () => new Response('Products list'))
+        .get('/categories/', () => new Response('Categories list')),
+    )
+
+    const resProducts = await app.handle(
+      new Request('http://localhost/api/products/'),
+    )
+    expect(resProducts.status).toBe(200)
+    expect(await resProducts.text()).toBe('Products list')
+
+    const resCategories = await app.handle(
+      new Request('http://localhost/api/categories'),
+    )
+    expect(resCategories.status).toBe(200)
+    expect(await resCategories.text()).toBe('Categories list')
+  })
+})
+
+test('async generators handle non-ASCII characters correctly', async () => {
+  const app = new Spiceflow()
+    .get('/cyrillic', async function* () {
+      yield 'Привет' // Hello in Russian
+      yield 'Κόσμος' // World in Greek
+    })
+    .get('/mixed-scripts', async function* () {
+      // Mix of Cyrillic and Greek letters that look like Latin
+      yield { text: 'РΡ' } // Cyrillic and Greek P
+      yield { text: 'ΟО' } // Greek and Cyrillic O
+      yield { text: 'КΚ' } // Cyrillic and Greek K
+    })
+
+  const client = createSpiceflowClient(app)
+
+  const { data: cyrillicData } = await client.cyrillic.get()
+  let cyrillicText = ''
+  for await (const chunk of cyrillicData!) {
+    cyrillicText += chunk
+  }
+  expect(cyrillicText).toBe('ПриветΚόσμος')
+
+  const { data: mixedData } = await client['mixed-scripts'].get()
+  const mixedResults = [] as any[]
+  for await (const chunk of mixedData!) {
+    mixedResults.push(chunk)
+  }
+  expect(mixedResults).toEqual([{ text: 'РΡ' }, { text: 'ΟО' }, { text: 'КΚ' }])
+})
+
+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(),
+    }),
+  })
+
+  const res = await app.handle(
+    new Request('http://localhost/user', {
+      method: 'POST',
+
+      body: JSON.stringify({
+        name: 'John',
+        age: 25,
+        email: 'john@example.com',
+        additionalProp: 'extra data',
+      }),
+    }),
+  )
+
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({
+    name: 'John',
+    age: 25,
+    email: 'john@example.com',
+    additionalProp: 'extra data',
+  })
+})

package/src/spiceflow.ts

@@ -145,6 +145,15 @@ export class Spiceflow<
     let validateQuery = getValidateFunction(hooks?.query)
     let validateParams = getValidateFunction(hooks?.params)
 
+    if (typeof handler === 'function' && !handler.name) {
+      Object.defineProperty(handler, 'name', {
+        value: path,
+        configurable: true,
+      })
+    }
+
+    // remove trailing slash which can cause problems
+    path = path?.replace(/\/$/, '') || '/'
     const store = this.router.register(path)
     let route: InternalRoute = {
       ...rest,
@@ -163,18 +172,22 @@ export class Spiceflow<
   private match(method: string, path: string) {
     let root = this
     let foundApp: AnySpiceflow | undefined
+    // remove trailing slash which can cause problems
+    path = path.replace(/\/$/, '') || '/'
     const result = bfsFind(this, (app) => {
       app.topLevelApp = root
       let prefix = this.getAppAndParents(app)
         .map((x) => x.prefix)
         .join('')
+        .replace(/\/$/, '')
       if (prefix && !path.startsWith(prefix)) {
         return
       }
       let pathWithoutPrefix = path
       if (prefix) {
-        pathWithoutPrefix = path.replace(prefix, '')
+        pathWithoutPrefix = path.replace(prefix, '') || '/'
       }
+
       const medleyRoute = app.router.find(pathWithoutPrefix)
       if (!medleyRoute) {
         foundApp = app
@@ -884,7 +897,9 @@ export class Spiceflow<
   }
 
   async listen(port: number, hostname: string = '127.0.0.1') {
+    // @ts-ignore
     if (typeof Bun !== 'undefined') {
+      // @ts-ignore
       const server = Bun.serve({
         port,
         development: !isProduction,

package/src/types.ts

@@ -1,8 +1,7 @@
 // https://github.com/remorses/elysia/blob/main/src/types.ts#L6
-/// <reference types="bun-types" />
+
 import z from 'zod'
 
-import type { BunFile, Server } from 'bun'
 
 import type {
   OptionalKind,
@@ -202,19 +201,11 @@ export interface UnwrapRoute<
   params: UnwrapSchema<Schema['params'], Definitions>
   response: Schema['response'] extends TypeSchema | string
     ? {
-        200: CoExist<
-          UnwrapSchema<Schema['response'], Definitions>,
-          File,
-          BunFile
-        >
+        200: UnwrapSchema<Schema['response'], Definitions>
       }
     : Schema['response'] extends Record<number, TypeSchema | string>
       ? {
-          [k in keyof Schema['response']]: CoExist<
-            UnwrapSchema<Schema['response'][k], Definitions>,
-            File,
-            BunFile
-          >
+          [k in keyof Schema['response']]: UnwrapSchema<Schema['response'][k], Definitions>
         }
       : unknown | void
 }
@@ -612,7 +603,7 @@ export interface InternalRoute {
   hooks: LocalHook<any, any, any, any, any, any, any>
 }
 
-export type ListenCallback = (server: Server) => MaybePromise<void>
+
 
 export type AddPrefix<Prefix extends string, T> = {
   [K in keyof T as Prefix extends string ? `${Prefix}${K & string}` : K]: T[K]
@@ -660,7 +651,7 @@ export type ComposeSpiceflowResponse<Response, Handle> = Handle extends (
   ...a: any[]
 ) => infer A
   ? _ComposeSpiceflowResponse<Response, Awaited<A>>
-  : _ComposeSpiceflowResponse<Response, Replace<Awaited<Handle>, BunFile, File>>
+  : _ComposeSpiceflowResponse<Response, Awaited<Handle>>
 
 type _ComposeSpiceflowResponse<Response, Handle> = Prettify<
   {} extends Response