@getvision/server 0.3.0 → 0.3.1-9c3a582-develop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/server",
-  "version": "0.3.0",
+  "version": "0.3.1-9c3a582-develop",
   "type": "module",
   "description": "Vision Server - Meta-framework with built-in observability, pub/sub, and type-safe APIs",
   "exports": {

package/src/event-bus.ts

@@ -203,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) => {
@@ -219,7 +228,7 @@ export class EventBus {
         }
       )
 
-      this.workers.set(`${eventName}-${Date.now()}`, worker)
+      this.workers.set(workerKey, worker)
 
       // Listen to queue events
       if (!this.queueEvents.has(eventName)) {
@@ -266,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) => {
@@ -287,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/vision-app.ts

@@ -18,6 +18,51 @@ export interface VisionALSContext {
 
 const visionContext = new AsyncLocalStorage<VisionALSContext>()
 
+// Global instance tracking for hot-reload cleanup
+// Must attach to globalThis because module-scoped variables are reset when the module is reloaded
+const GLOBAL_VISION_KEY = '__vision_instance_state'
+interface VisionGlobalState {
+  instance: Vision<any, any, any> | null
+  drizzleProcess: ChildProcess | null
+}
+
+// Initialize global state if needed
+if (!(globalThis as any)[GLOBAL_VISION_KEY]) {
+  (globalThis as any)[GLOBAL_VISION_KEY] = {
+    instance: null,
+    drizzleProcess: null
+  }
+}
+
+function getGlobalState(): VisionGlobalState {
+  return (globalThis as any)[GLOBAL_VISION_KEY]
+}
+
+async function cleanupVisionInstance(instance: Vision<any, any, any>): Promise<void> {
+  const existing = (instance as any)._cleanupPromise as Promise<void> | undefined
+  if (existing) return existing;
+
+  (instance as any)._cleanupPromise = (async () => {
+    const server = (instance as any).bunServer
+    const hasBunServer = server && typeof server.stop === 'function'
+
+    try {
+      if (hasBunServer) {
+        server.stop()
+      }
+      if ((globalThis as any).__vision_bun_server === server) {
+        (globalThis as any).__vision_bun_server = undefined
+      }
+    } catch {}
+
+    try { stopDrizzleStudio({ log: false }) } catch {}
+    try { await (instance as any).eventBus?.close() } catch {}
+    try { eventRegistry.clear() } catch {}
+  })()
+
+  return (instance as any)._cleanupPromise
+}
+
 type BunServeOptions = Parameters<typeof Bun['serve']>[0]
 type NodeServeOptions = Parameters<typeof honoServe>[0]
 
@@ -119,7 +164,8 @@ export class Vision<
   private serviceBuilders: ServiceBuilder<any, E>[] = []
   private fileBasedRoutes: RouteMetadata[] = []
   private bunServer?: any
-  private shuttingDown = false
+  private _cleanupPromise?: Promise<void>
+  private signalHandler?: () => Promise<void>
 
   constructor(config?: VisionConfig) {
     super()
@@ -616,37 +662,63 @@ export class Vision<
       console.log(`✅ Registered ${servicesToRegister.length} total services (${flatRoutes.length} routes)`)
     }
     
+    // Cleanup previous instance before starting new one (hot-reload)
+    const state = getGlobalState()
+    if (state.instance && state.instance !== this) {
+      await cleanupVisionInstance(state.instance)
+    }
+    state.instance = this
+
     console.log(`🚀 Starting ${this.config.service.name}...`)
     console.log(`📡 API Server: http://localhost:${port}`)
     
-    // Setup cleanup on exit (ensure it runs once)
-    const cleanup = async () => {
-      if (this.shuttingDown) return
-      this.shuttingDown = true
-      console.log('🛑 Shutting down...')
-      try {
-        if (this.bunServer && typeof this.bunServer.stop === 'function') {
-          try { this.bunServer.stop() } catch {}
+    // Register signal handlers (cleaned up on dispose)
+    if (!this.signalHandler) {
+      this.signalHandler = async () => {
+        const s = getGlobalState()
+        if (s.instance) {
+          await cleanupVisionInstance(s.instance)
         }
-        try { if ((globalThis as any).__vision_bun_server === this.bunServer) (globalThis as any).__vision_bun_server = undefined } catch {}
-      } catch {}
-      try { stopDrizzleStudio() } catch {}
-      try { await this.eventBus.close() } catch {}
-    }
-    
-    const wrappedCleanup = async () => {
-      await cleanup()
-      try { process.exit(0) } catch {}
+        try { process.exit(0) } catch {}
+      }
     }
-    process.once('SIGINT', wrappedCleanup)
-    process.once('SIGTERM', wrappedCleanup)
-    try { process.once('SIGQUIT', wrappedCleanup) } catch {}
+
+    const handleSignal = this.signalHandler
+
+    process.removeListener('SIGINT', handleSignal)
+    process.removeListener('SIGTERM', handleSignal)
+    try { process.removeListener('SIGQUIT', handleSignal) } catch {}
+
+    process.on('SIGINT', handleSignal)
+    process.on('SIGTERM', handleSignal)
+    try { process.on('SIGQUIT', handleSignal) } catch {}
+      
+    // Bun hot-reload: register dispose callback
+    try {
+      const hot = (import.meta as any)?.hot
+      if (hot && typeof hot.dispose === 'function') {
+        hot.dispose(async () => {
+          console.log('♻️ Hot reload: reloading...')
+
+          // 1. Remove signal listeners to prevent accumulation
+          process.off('SIGINT', handleSignal)
+          process.off('SIGTERM', handleSignal)
+          try { process.off('SIGQUIT', handleSignal) } catch {}
+
+          // 2. Cleanup this instance
+          const s = getGlobalState()
+          await cleanupVisionInstance(this)
+          if (s.instance === this) {
+            s.instance = null
+          }
+        })
+      }
+    } catch {}
     
     // Prefer Bun if available, then Node.js; otherwise instruct the user to serve manually
     if (typeof process !== 'undefined' && process.versions?.bun) {
       const BunServe = (globalThis as any).Bun?.serve
       if (typeof BunServe === 'function') {
-        console.log(`Bun detected`)
         try {
           const existing = (globalThis as any).__vision_bun_server
           if (existing && typeof existing.stop === 'function') {
@@ -666,7 +738,6 @@ export class Vision<
       }
     } else if (typeof process !== 'undefined' && process.versions?.node) {
       const { serve } = await import('@hono/node-server')
-      console.log(`Node.js detected`)
       serve({
         ...nodeRest,
         fetch: this.fetch.bind(this),
@@ -699,8 +770,6 @@ export function getVisionContext(): VisionALSContext | undefined {
 // Drizzle Studio Integration
 // ============================================================================
 
-let drizzleStudioProcess: ChildProcess | null = null
-
 /**
  * Detect Drizzle configuration
  */
@@ -723,7 +792,8 @@ function detectDrizzle(): { detected: boolean; configPath?: string } {
  * Start Drizzle Studio
  */
 function startDrizzleStudio(port: number): boolean {
-  if (drizzleStudioProcess) {
+  const state = getGlobalState()
+  if (state.drizzleProcess) {
     console.log('⚠️  Drizzle Studio is already running')
     return false
   }
@@ -746,19 +816,27 @@ function startDrizzleStudio(port: number): boolean {
   } catch {}
 
   try {
-    drizzleStudioProcess = spawn('npx', ['drizzle-kit', 'studio', '--port', String(port), '--host', '0.0.0.0'], {
+    const proc = spawn('npx', ['drizzle-kit', 'studio', '--port', String(port), '--host', '0.0.0.0'], {
       stdio: 'inherit',
       detached: false,
+      shell: process.platform === 'win32',
     })
+    
+    state.drizzleProcess = proc
 
-    drizzleStudioProcess.on('error', (error) => {
+    proc.on('error', (error) => {
       console.error('❌ Failed to start Drizzle Studio:', error.message)
     })
 
-    drizzleStudioProcess.on('exit', (code) => {
+    proc.on('exit', (code) => {
       if (code !== 0 && code !== null) {
         console.error(`❌ Drizzle Studio exited with code ${code}`)
       }
+      // Clear global state if it matches this process
+      const s = getGlobalState()
+      if (s.drizzleProcess === proc) {
+        s.drizzleProcess = null
+      }
     })
 
     console.log(`✅ Drizzle Studio: https://local.drizzle.studio`)
@@ -772,10 +850,17 @@ function startDrizzleStudio(port: number): boolean {
 /**
  * Stop Drizzle Studio
  */
-function stopDrizzleStudio(): void {
-  if (drizzleStudioProcess) {
-    drizzleStudioProcess.kill()
-    drizzleStudioProcess = null
-    console.log('🛑 Drizzle Studio stopped')
+function stopDrizzleStudio(options?: { log?: boolean }): boolean {
+  const state = getGlobalState()
+  if (state.drizzleProcess) {
+    // Remove all event listeners to prevent memory leaks
+    state.drizzleProcess.removeAllListeners()
+    state.drizzleProcess.kill()
+    state.drizzleProcess = null
+    if (options?.log !== false) {
+      console.log('🛑 Drizzle Studio stopped')
+    }
+    return true
   }
+  return false
 }