spiceflow 1.17.3 → 1.17.5

package/src/middleware.test.ts

@@ -381,3 +381,234 @@ test('each middleware and route is called exactly once if an error is thrown', a
     route: 1,
   })
 })
+
+test('middleware with try/finally correctly tracks operations even when errors are thrown', async () => {
+  let operationCount = 0
+  let finallyExecuted = false
+
+  const createTrackingMiddleware = () => {
+    return async (_: any, next: any) => {
+      operationCount++
+      try {
+        await next()
+      } finally {
+        operationCount--
+        finallyExecuted = true
+      }
+    }
+  }
+
+  // Test 1: Normal successful request
+  operationCount = 0
+  finallyExecuted = false
+  const app1 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .get('/success', () => ({ message: 'success' }))
+
+  const res1 = await app1.handle(new Request('http://localhost/success'))
+  expect(res1.status).toBe(200)
+  expect(operationCount).toBe(0) // Should be decremented back to 0
+  expect(finallyExecuted).toBe(true)
+
+  // Test 2: Route throws an error
+  operationCount = 0
+  finallyExecuted = false
+  const app2 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .get('/error', () => {
+      throw new Error('Route error')
+    })
+
+  const res2 = await app2.handle(new Request('http://localhost/error'))
+  expect(res2.status).toBe(500)
+  expect(operationCount).toBe(0) // Should be decremented back to 0
+  expect(finallyExecuted).toBe(true)
+
+  // Test 3: Route throws a Response
+  operationCount = 0
+  finallyExecuted = false
+  const app3 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .get('/response', () => {
+      throw new Response('Custom response', { status: 403 })
+    })
+
+  const res3 = await app3.handle(new Request('http://localhost/response'))
+  expect(res3.status).toBe(403)
+  expect(operationCount).toBe(0) // Should be decremented back to 0
+  expect(finallyExecuted).toBe(true)
+
+  // Test 4: Multiple concurrent requests
+  operationCount = 0
+  const app4 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .get('/concurrent', async () => {
+      await new Promise(resolve => setTimeout(resolve, 50))
+      return { ok: true }
+    })
+
+  // Start 3 concurrent requests
+  const concurrentRequests = Promise.all([
+    app4.handle(new Request('http://localhost/concurrent')),
+    app4.handle(new Request('http://localhost/concurrent')),
+    app4.handle(new Request('http://localhost/concurrent'))
+  ])
+
+  // Wait a bit to ensure requests are in flight
+  await new Promise(resolve => setTimeout(resolve, 10))
+  
+  // Operation count should be 3 while requests are in flight
+  expect(operationCount).toBe(3)
+
+  // Wait for all requests to complete
+  const results = await concurrentRequests
+  results.forEach(res => expect(res.status).toBe(200))
+  
+  // Operation count should be back to 0
+  expect(operationCount).toBe(0)
+})
+
+test('middleware with try/finally tracks operations correctly with child apps', async () => {
+  let operationCount = 0
+  let finallyExecuted = false
+
+  const createTrackingMiddleware = () => {
+    return async (_: any, next: any) => {
+      operationCount++
+      try {
+        await next()
+      } finally {
+        operationCount--
+        finallyExecuted = true
+      }
+    }
+  }
+
+  // Test 1: Middleware on parent, route in child app
+  operationCount = 0
+  finallyExecuted = false
+  const childApp1 = new Spiceflow()
+    .get('/child/route', () => ({ message: 'from child' }))
+  
+  const parentApp1 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp1)
+
+  const res1 = await parentApp1.handle(new Request('http://localhost/child/route'))
+  expect(res1.status).toBe(200)
+  expect(operationCount).toBe(0)
+  expect(finallyExecuted).toBe(true)
+
+  // Test 2: Middleware on parent, error thrown in child route
+  operationCount = 0
+  finallyExecuted = false
+  const childApp2 = new Spiceflow()
+    .get('/child/error', () => {
+      throw new Error('Child route error')
+    })
+  
+  const parentApp2 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp2)
+
+  const res2 = await parentApp2.handle(new Request('http://localhost/child/error'))
+  expect(res2.status).toBe(500)
+  expect(operationCount).toBe(0)
+  expect(finallyExecuted).toBe(true)
+
+  // Test 3: Multiple nested child apps with middleware
+  operationCount = 0
+  finallyExecuted = false
+  const grandchildApp = new Spiceflow()
+    .get('/level3/route', () => ({ level: 3 }))
+  
+  const childApp3 = new Spiceflow({ basePath: '/level2' })
+    .use(grandchildApp)
+  
+  const parentApp3 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp3)
+
+  const res3 = await parentApp3.handle(new Request('http://localhost/level2/level3/route'))
+  expect(res3.status).toBe(200)
+  expect(operationCount).toBe(0)
+  expect(finallyExecuted).toBe(true)
+
+  // Test 4: Middleware on both parent and child
+  operationCount = 0
+  const childApp4 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .get('/child/both', () => ({ from: 'both' }))
+  
+  const parentApp4 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp4)
+
+  const res4 = await parentApp4.handle(new Request('http://localhost/child/both'))
+  expect(res4.status).toBe(200)
+  expect(operationCount).toBe(0) // Both middlewares increment and decrement
+
+  // Test 5: Child app with basePath
+  operationCount = 0
+  finallyExecuted = false
+  const childApp5 = new Spiceflow({ basePath: '/api/v1' })
+    .get('/users', () => ({ users: [] }))
+  
+  const parentApp5 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp5)
+
+  const res5 = await parentApp5.handle(new Request('http://localhost/api/v1/users'))
+  expect(res5.status).toBe(200)
+  expect(operationCount).toBe(0)
+  expect(finallyExecuted).toBe(true)
+
+  // Test 6: Concurrent requests to child app routes
+  operationCount = 0
+  const childApp6 = new Spiceflow()
+    .get('/child/slow', async () => {
+      await new Promise(resolve => setTimeout(resolve, 50))
+      return { ok: true }
+    })
+  
+  const parentApp6 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp6)
+
+  // Start 3 concurrent requests
+  const concurrentRequests = Promise.all([
+    parentApp6.handle(new Request('http://localhost/child/slow')),
+    parentApp6.handle(new Request('http://localhost/child/slow')),
+    parentApp6.handle(new Request('http://localhost/child/slow'))
+  ])
+
+  // Wait a bit to ensure requests are in flight
+  await new Promise(resolve => setTimeout(resolve, 10))
+  
+  // Operation count should be 3 while requests are in flight
+  expect(operationCount).toBe(3)
+
+  // Wait for all requests to complete
+  const results = await concurrentRequests
+  results.forEach(res => expect(res.status).toBe(200))
+  
+  // Operation count should be back to 0
+  expect(operationCount).toBe(0)
+
+  // Test 7: Child app throws Response
+  operationCount = 0
+  finallyExecuted = false
+  const childApp7 = new Spiceflow()
+    .get('/child/response', () => {
+      throw new Response('Custom child response', { status: 403 })
+    })
+  
+  const parentApp7 = new Spiceflow()
+    .use(createTrackingMiddleware())
+    .use(childApp7)
+
+  const res7 = await parentApp7.handle(new Request('http://localhost/child/response'))
+  expect(res7.status).toBe(403)
+  expect(operationCount).toBe(0)
+  expect(finallyExecuted).toBe(true)
+})

package/src/openapi.test.ts

@@ -375,7 +375,6 @@ test('openapi response', async () => {
               "content": {
                 "application/json": {
                   "schema": {
-                    "additionalProperties": true,
                     "properties": {
                       "name": {
                         "type": "string",

package/src/prevent-process-exit-if-busy.js

@@ -0,0 +1,60 @@
+import { Spiceflow } from 'spiceflow'
+
+/**
+ * Creates a Spiceflow middleware that tracks in-flight requests and prevents
+ * the process from exiting while requests are being processed.
+ * 
+ * @param {Object} options - Configuration options
+ * @param {number} [options.maxWaitSeconds=300] - Maximum time to wait for requests to complete
+ * @param {number} [options.checkIntervalMs=250] - Interval to check if requests are complete
+ * @returns {Spiceflow} Spiceflow app that can be mounted with .use()
+ */
+export function preventProcessExitIfBusy(options = {}) {
+    const { maxWaitSeconds = 300, checkIntervalMs = 250 } = options
+    
+    // Track in-flight requests in closure
+    let inFlightRequests = 0
+    let isShuttingDown = false
+    
+    // Sleep utility
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))
+    
+    // Graceful shutdown handler
+    async function handleShutdown(signal) {
+        if (isShuttingDown) return // Prevent multiple shutdown attempts
+        isShuttingDown = true
+        
+        console.log(`${signal} received – waiting for ${inFlightRequests} request(s) to complete...`)
+        
+        const deadline = Date.now() + (maxWaitSeconds * 1000)
+        
+        while (inFlightRequests > 0 && Date.now() < deadline) {
+            await sleep(checkIntervalMs)
+        }
+        
+        if (inFlightRequests > 0) {
+            console.log(`Shutdown timeout reached; ${inFlightRequests} request(s) still in progress`)
+        } else {
+            console.log('All requests completed')
+        }
+        
+        process.exit(inFlightRequests > 0 ? 1 : 0)
+    }
+    
+    // Register shutdown handlers only in Node.js environments
+    if (typeof process !== 'undefined' && process.prependListener) {
+        ;['SIGINT', 'SIGTERM'].forEach(sig => {
+            process.prependListener(sig, handleShutdown)
+        })
+    }
+    
+    // Return Spiceflow middleware
+    return new Spiceflow().use(async (_, next) => {
+        inFlightRequests++
+        try {
+            await next()
+        } finally {
+            inFlightRequests--
+        }
+    })
+}

package/src/spiceflow.test.ts

@@ -376,7 +376,7 @@ test('onError fires on validation errors', async () => {
 
   expect(res.status).toBe(400)
   expect(errorMessage).toMatchInlineSnapshot(
-    `"name: Expected string, received number"`,
+    `"name: Invalid input: expected string, received number"`,
   )
   expect(await res.text()).toMatchInlineSnapshot(`"Error"`)
 })
@@ -603,7 +603,7 @@ test('validate body works, request fails', async () => {
     )
   expect(res.status).toBe(422)
   expect(await res.text()).toMatchInlineSnapshot(
-    `"{"code":"VALIDATION","status":422,"message":"requiredField: Required"}"`,
+    `"{"code":"VALIDATION","status":422,"message":"requiredField: Invalid input: expected string, received undefined"}"`,
   )
 })
 

package/src/types.ts

@@ -339,6 +339,13 @@ export type CoExist<Original, Target, With> =
         ? Original | With
         : Original
 
+
+type ResponseLike = {
+  status: number
+  headers?: any
+  body?: any
+}
+
 export type InlineHandler<
   This,
   Route extends RouteSchema = {},
@@ -353,7 +360,7 @@ export type InlineHandler<
     ? Prettify<MacroContext & Context<Route, Singleton, Path>>
     : Context<Route, Singleton, Path>,
 ) =>
-  | Response
+  | ResponseLike
   | MaybePromiseIterable<
       {} extends Route['response']
         ? unknown