@getvision/server 0.2.7 → 0.3.1-3b055ce-develop

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @getvision/server
 
+## 0.3.0
+
+### Minor Changes
+
+- 28c86e6: Added support for runtime-specific `start` options. Introduced new `VisionStartOptions` type for better handling of configuration parameters.
+  Added support for configurable worker concurrency per handler and default event bus settings
+
+### Patch Changes
+
+- 2d4e753: Fix priority for dynamic and static routes
+
 ## 0.2.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/server",
-  "version": "0.2.7",
+  "version": "0.3.1-3b055ce-develop",
   "type": "module",
   "description": "Vision Server - Meta-framework with built-in observability, pub/sub, and type-safe APIs",
   "exports": {
@@ -26,6 +26,7 @@
     "@repo/eslint-config": "0.0.1",
     "@repo/typescript-config": "0.0.1",
     "@types/node": "^20.14.9",
+    "@types/bun": "^1.3.5",
     "typescript": "5.9.3"
   },
   "keywords": [

package/src/event-bus.ts

@@ -11,6 +11,10 @@ export interface EventBusConfig {
     port?: number
     password?: string
   }
+  /**
+   * Default BullMQ worker concurrency (per event). Per-handler options override this.
+   */
+  workerConcurrency?: number
   // Dev mode - use in-memory (no Redis required)
   devMode?: boolean
 }
@@ -72,6 +76,7 @@ export class EventBus {
     this.config = {
       devMode: resolvedDevMode,
       redis: mergedRedis,
+      workerConcurrency: config.workerConcurrency,
     }
   }
 
@@ -178,7 +183,14 @@ export class EventBus {
    */
   registerHandler<T>(
     eventName: string,
-    handler: (data: T) => Promise<void>
+    handler: (data: T) => Promise<void>,
+    options?: {
+      /**
+       * Max number of concurrent jobs this handler will process.
+       * Defaults to config.workerConcurrency (or 1).
+       */
+      concurrency?: number
+    }
   ): void {
     if (this.config.devMode) {
       // Dev mode - store handlers in memory
@@ -191,6 +203,15 @@ export class EventBus {
         host: 'localhost',
         port: 6379,
       }
+      const workerKey = `${eventName}-handler`
+      
+      // Close existing worker if it exists
+      const existingWorker = this.workers.get(workerKey)
+      if (existingWorker) {
+        void existingWorker.close().catch(() => {})
+        this.workers.delete(workerKey)
+      }
+      
       const worker = new Worker(
         eventName,
         async (job) => {
@@ -203,10 +224,11 @@ export class EventBus {
         },
         {
           connection,
+          concurrency: options?.concurrency ?? this.config.workerConcurrency ?? 1,
         }
       )
 
-      this.workers.set(`${eventName}-${Date.now()}`, worker)
+      this.workers.set(workerKey, worker)
 
       // Listen to queue events
       if (!this.queueEvents.has(eventName)) {
@@ -253,6 +275,15 @@ export class EventBus {
         host: 'localhost',
         port: 6379,
       }
+      const cronWorkerKey = `${cronName}-handler`
+      
+      // Close existing cron worker if it exists
+      const existingCronWorker = this.workers.get(cronWorkerKey)
+      if (existingCronWorker) {
+        void existingCronWorker.close().catch(() => {})
+        this.workers.delete(cronWorkerKey)
+      }
+      
       const worker = new Worker(
         cronName,
         async (job) => {
@@ -274,7 +305,7 @@ export class EventBus {
         }
       )
 
-      this.workers.set(`${cronName}-${Date.now()}`, worker)
+      this.workers.set(cronWorkerKey, worker)
 
       // Listen to cron job events
       if (!this.queueEvents.has(cronName)) {

package/src/router.ts

@@ -27,6 +27,10 @@ export async function loadSubApps(app: Hono, routesDir: string = './app/routes',
     return '/' + segments.join('/')
   }
 
+  function isDynamicSegment(name: string): boolean {
+    return name.startsWith('[') && name.endsWith(']')
+  }
+
   async function scan(dir: string) {
     const entries = readdirSync(dir)
     // If folder contains index.ts or index.js, treat it as a sub-app root
@@ -73,7 +77,16 @@ export async function loadSubApps(app: Hono, routesDir: string = './app/routes',
       }
     }
     // Recurse into child directories
-    for (const name of entries) {
+    // Sort entries: static folders first, then dynamic [param] folders
+    // This ensures static routes have priority over dynamic routes
+    const sortedEntries = [...entries].sort((a, b) => {
+      const aIsDynamic = isDynamicSegment(a)
+      const bIsDynamic = isDynamicSegment(b)
+      if (aIsDynamic && !bIsDynamic) return 1  // dynamic after static
+      if (!aIsDynamic && bIsDynamic) return -1 // static before dynamic
+      return a.localeCompare(b) // alphabetical within same type
+    })
+    for (const name of sortedEntries) {
       const full = join(dir, name)
       const st = statSync(full)
       if (st.isDirectory()) await scan(full)

package/src/service.ts

@@ -240,6 +240,11 @@ export class ServiceBuilder<
       description?: string
       icon?: string
       tags?: string[]
+      /**
+       * Max number of concurrent jobs this handler will process.
+       * Falls back to EventBus config.workerConcurrency (or 1).
+       */
+      concurrency?: number
       handler: (event: T, c: Context<E, any, I>) => Promise<void>
     }
   ): ServiceBuilder<TEvents & { [key in K]: T }, E, I> {
@@ -268,7 +273,9 @@ export class ServiceBuilder<
     )
     
     // Register wrapped handler in event bus
-    this.eventBus.registerHandler(eventName, wrappedHandler)
+    this.eventBus.registerHandler(eventName, wrappedHandler, {
+      concurrency: config.concurrency,
+    })
     
     // Store for later reference
     this.eventHandlers.set(eventName, config)

package/src/vision-app.ts

@@ -8,6 +8,7 @@ import { spawn, spawnSync, type ChildProcess } from 'child_process'
 import { ServiceBuilder } from './service'
 import { EventBus } from './event-bus'
 import { eventRegistry } from './event-registry'
+import type { serve as honoServe } from '@hono/node-server'
 
 export interface VisionALSContext {
   vision: VisionCore
@@ -17,6 +18,12 @@ export interface VisionALSContext {
 
 const visionContext = new AsyncLocalStorage<VisionALSContext>()
 
+type BunServeOptions = Parameters<typeof Bun['serve']>[0]
+type NodeServeOptions = Parameters<typeof honoServe>[0]
+
+type VisionStartOptions = Omit<Partial<BunServeOptions>, 'fetch' | 'port'> &
+  Omit<Partial<NodeServeOptions>, 'fetch' | 'port'>
+
 // Simple deep merge utility (objects only, arrays are overwritten by source)
 function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
   const output: any = { ...target }
@@ -75,6 +82,10 @@ export interface VisionConfig {
     }
     devMode?: boolean  // Use in-memory event bus (no Redis required)
     eventBus?: EventBus  // Share EventBus instance across apps (for sub-apps)
+    /**
+     * Default BullMQ worker concurrency for all handlers (overridable per handler)
+     */
+    workerConcurrency?: number
   }
 }
 
@@ -203,6 +214,7 @@ export class Vision<
     this.eventBus = this.config.pubsub?.eventBus || new EventBus({
       redis: this.config.pubsub?.redis,
       devMode: this.config.pubsub?.devMode,
+      workerConcurrency: this.config.pubsub?.workerConcurrency,
     })
     
     // Register JSON-RPC methods for events/cron
@@ -567,7 +579,11 @@ export class Vision<
   /**
    * Start the server (convenience method)
    */
-  async start(port: number = 3000, options?: { hostname?: string }) {
+  async start(port: number = 3000, options?: VisionStartOptions) {
+    const { hostname, ...restOptions } = options || {}
+    const { fetch: _bf, port: _bp, ...bunRest } = restOptions as Partial<BunServeOptions>
+    const { fetch: _nf, port: _np, ...nodeRest } = restOptions as Partial<NodeServeOptions>
+
     // Build all services WITHOUT registering to VisionCore yet
     const rootSummaries = this.buildAllServices()
     // Autoload file-based Vision/Hono sub-apps if enabled (returns merged sub-app summaries)
@@ -608,6 +624,10 @@ export class Vision<
       if (this.shuttingDown) return
       this.shuttingDown = true
       console.log('🛑 Shutting down...')
+      try {
+        // Clear AsyncLocalStorage to prevent memory leaks
+        visionContext.disable()
+      } catch {}
       try {
         if (this.bunServer && typeof this.bunServer.stop === 'function') {
           try { this.bunServer.stop() } catch {}
@@ -616,6 +636,7 @@ export class Vision<
       } catch {}
       try { stopDrizzleStudio() } catch {}
       try { await this.eventBus.close() } catch {}
+      try { eventRegistry.clear() } catch {}
     }
     
     const wrappedCleanup = async () => {
@@ -625,6 +646,17 @@ export class Vision<
     process.once('SIGINT', wrappedCleanup)
     process.once('SIGTERM', wrappedCleanup)
     try { process.once('SIGQUIT', wrappedCleanup) } catch {}
+
+    // Bun hot-reload: ensure resources are released between reloads.
+    // Note: dispose must NOT call process.exit().
+    try {
+      const hot = (import.meta as any)?.hot
+      if (hot && typeof hot.dispose === 'function') {
+        hot.dispose(() => {
+          void cleanup()
+        })
+      }
+    } catch {}
     
     // Prefer Bun if available, then Node.js; otherwise instruct the user to serve manually
     if (typeof process !== 'undefined' && process.versions?.bun) {
@@ -638,9 +670,10 @@ export class Vision<
           }
         } catch {}
         this.bunServer = BunServe({
+          ...bunRest,
           fetch: this.fetch.bind(this),
           port,
-          hostname: options?.hostname
+          hostname
         })
         try { (globalThis as any).__vision_bun_server = this.bunServer } catch {}
       } else {
@@ -651,9 +684,10 @@ export class Vision<
       const { serve } = await import('@hono/node-server')
       console.log(`Node.js detected`)
       serve({
+        ...nodeRest,
         fetch: this.fetch.bind(this),
         port,
-        hostname: options?.hostname
+        hostname
       })
     } else {
       // For other runtimes, just return the app
@@ -756,6 +790,8 @@ function startDrizzleStudio(port: number): boolean {
  */
 function stopDrizzleStudio(): void {
   if (drizzleStudioProcess) {
+    // Remove all event listeners to prevent memory leaks
+    drizzleStudioProcess.removeAllListeners()
     drizzleStudioProcess.kill()
     drizzleStudioProcess = null
     console.log('🛑 Drizzle Studio stopped')