nmtjs 0.15.0-beta.13 → 0.15.0-beta.15

package/src/runtime/server/pool.ts

@@ -6,9 +6,11 @@ import { MessageChannel, Worker } from 'node:worker_threads'
 import type {
   JobTaskResult,
   ServerPortMessageTypes,
+  ThreadErrorMessage,
   ThreadPortMessage,
   ThreadPortMessageTypes,
   WorkerJobTask,
+  WorkerThreadError,
 } from '../types.ts'
 
 const omitExecArgv = ['--expose-gc']
@@ -22,7 +24,7 @@ export type ThreadState =
 
 export class Thread extends EventEmitter<
   {
-    error: [error: Error]
+    error: [error: WorkerThreadError]
     ready: [ThreadPortMessageTypes['ready']]
     task: [ThreadPortMessageTypes['task']]
     terminate: []
@@ -34,6 +36,8 @@ export class Thread extends EventEmitter<
 > {
   worker: Worker
   state: ThreadState = 'pending'
+  protected readyMessage?: ThreadPortMessageTypes['ready']
+  protected startPromise?: Promise<void>
 
   constructor(
     readonly port: MessagePort,
@@ -46,40 +50,99 @@ export class Thread extends EventEmitter<
       execArgv: process.execArgv.filter((f) => !omitExecArgv.includes(f)),
     })
 
-    const handler = (msg: ThreadPortMessage) => {
+    this.port.on('message', (msg: ThreadPortMessage) => {
       const { type, data } = msg
-      this.emit(type, data as any)
-      if (type === 'task') {
-        const { id, task } = data as ThreadPortMessageTypes['task']
-        this.emit(`task-${id}`, task)
+      switch (type) {
+        case 'ready': {
+          this.state = 'ready'
+          this.readyMessage = data
+          this.emit('ready', data)
+          break
+        }
+        case 'error': {
+          const error = createWorkerThreadError(data as ThreadErrorMessage)
+          this.state = 'error'
+          this.emit('error', error)
+          break
+        }
+        case 'task': {
+          this.emit('task', data as ThreadPortMessageTypes['task'])
+          const { id, task } = data as ThreadPortMessageTypes['task']
+          this.emit(`task-${id}`, task)
+          break
+        }
       }
-    }
+    })
 
-    this.port.on('message', handler)
+    this.worker.once('exit', (code) => {
+      if (this.state === 'terminating') return
+      const error = createWorkerThreadError(
+        {
+          message: `Worker thread ${this.worker.threadId} exited unexpectedly with code ${code}`,
+          name: 'WorkerThreadExitError',
+          origin: 'runtime',
+          fatal: code !== 0,
+        },
+        false,
+      )
+      this.state = 'error'
+      this.emit('error', error)
+    })
   }
 
   async start() {
+    if (this.state === 'ready') return
+    if (this.startPromise) return this.startPromise
     switch (this.state) {
       case 'error':
       case 'terminating':
       case 'starting':
         throw new Error('Cannot start worker thread in current state')
-      case 'pending': {
-        // TODO: make timeout configurable
-        const signal = AbortSignal.timeout(15000)
-        try {
-          await once(this, 'ready', { signal })
-        } catch (err) {
-          const error = new Error(
-            'Worker thread did not become ready in time',
-            { cause: err },
-          )
-          this.emit('error', error)
-          this.stop()
-          throw error
-        }
-      }
+      case 'pending':
+        break
     }
+    this.state = 'starting'
+    this.startPromise = new Promise<void>((resolve, reject) => {
+      let settled = false
+      let timer: NodeJS.Timeout
+      const cleanup = () => {
+        if (settled) return
+        settled = true
+        if (timer) clearTimeout(timer)
+        this.off('ready', handleReady)
+        this.off('error', handleError)
+        this.startPromise = undefined
+      }
+      const handleReady = () => {
+        cleanup()
+        resolve()
+      }
+      const handleError = (error: WorkerThreadError) => {
+        cleanup()
+        reject(error)
+      }
+
+      this.once('ready', handleReady)
+      this.once('error', handleError)
+
+      timer = setTimeout(() => {
+        const error = createWorkerThreadError(
+          {
+            message: 'Worker thread did not become ready in time',
+            name: 'WorkerStartupTimeoutError',
+            origin: 'start',
+            fatal: true,
+          },
+          false,
+        )
+        cleanup()
+        this.state = 'error'
+        this.emit('error', error)
+        reject(error)
+      }, 15000)
+    })
+    await this.startPromise
+    this.startPromise = undefined
   }
 
   async stop() {
@@ -126,6 +189,20 @@ export class Thread extends EventEmitter<
   }
 }
 
+function createWorkerThreadError(
+  message: ThreadErrorMessage,
+  includeStack = true,
+): WorkerThreadError {
+  const error = new Error(message.message) as WorkerThreadError
+  if (message.name) error.name = message.name
+  if (includeStack && message.stack) {
+    error.stack = message.stack
+  }
+  error.origin = message.origin
+  error.fatal = message.fatal
+  return error
+}
+
 export class Pool extends EventEmitter<{
   workerReady: [worker: Worker]
   workerTaskResult: [worker: Worker]

package/src/runtime/server/proxy.ts

@@ -49,7 +49,13 @@ export class ApplicationServerProxy {
       tls: config.tls
         ? { keyPath: config.tls.key, certPath: config.tls.cert }
         : undefined,
-      applications: [],
+      applications: Object.entries(config.applications)
+        .filter(([_, options]) => options !== undefined)
+        .map(([app, options]) => ({
+          name: app,
+          routing: options!.routing,
+          sni: options!.sni,
+        })),
     })
 
     this.onAdd = (application, upstream) => {

package/src/runtime/server/server.ts

@@ -1,9 +1,14 @@
+import type EventEmitter from 'node:events'
 import type { Worker } from 'node:worker_threads'
 
 import type { Logger } from '@nmtjs/core'
 import { createLogger } from '@nmtjs/core'
 
-import type { Store } from '../types.ts'
+import type {
+  Store,
+  ThreadPortMessageTypes,
+  WorkerThreadError,
+} from '../types.ts'
 import type { ServerConfig } from './config.ts'
 import { createStoreClient } from '../store/index.ts'
 import { ApplicationServerApplications } from './applications.ts'
@@ -16,10 +21,27 @@ export type ApplicationServerRunOptions = {
   jobs: boolean
 }
 
+export type ApplicationWorkerReadyEvent = {
+  application: string
+  threadId: number
+  hosts?: ThreadPortMessageTypes['ready']['hosts']
+}
+
+export type ApplicationWorkerErrorEvent = {
+  application: string
+  threadId: number
+  error: WorkerThreadError
+}
+
 export type ApplicationServerWorkerConfig = {
   path: string
   workerData?: any
   worker?: (worker: Worker) => any
+  events?: EventEmitter<{
+    worker: [Worker]
+    'worker-ready': [ApplicationWorkerReadyEvent]
+    'worker-error': [ApplicationWorkerErrorEvent]
+  }>
 }
 
 export class ApplicationServer {

package/src/runtime/types.ts

@@ -7,6 +7,21 @@ import type { ApplicationConfig } from './application/config.ts'
 import type { BaseRuntime } from './core/runtime.ts'
 import type { LifecycleHook, StoreType } from './enums.ts'
 
+export type WorkerThreadErrorOrigin = 'bootstrap' | 'start' | 'runtime'
+
+export type ThreadErrorMessage = {
+  message: string
+  name?: string
+  stack?: string
+  origin: WorkerThreadErrorOrigin
+  fatal: boolean
+}
+
+export type WorkerThreadError = Error & {
+  origin?: WorkerThreadErrorOrigin
+  fatal?: boolean
+}
+
 export type ServerPortMessageTypes = {
   stop: undefined
   task: { id: string; task: WorkerJobTask }
@@ -14,7 +29,7 @@ export type ServerPortMessageTypes = {
 
 export type ThreadPortMessageTypes = {
   ready: { hosts?: { type: ProxyableTransportType; url: string }[] }
-  error: { error: Error }
+  error: ThreadErrorMessage
   task: { id: string; task: JobTaskResult }
 }
 

package/src/runtime/workers/application.ts

@@ -11,6 +11,7 @@ import type {
   AnyMiddleware,
   AnyProcedure,
   AnyRouter,
+  kDefaultProcedure as kDefaultProcedureKey,
 } from '../application/index.ts'
 import type { ServerConfig } from '../server/config.ts'
 import { ApplicationApi } from '../application/api/api.ts'
@@ -19,6 +20,7 @@ import {
   isProcedure,
   isRootRouter,
   isRouter,
+  kDefaultProcedure,
   kRootRouter,
 } from '../application/index.ts'
 import { LifecycleHook, WorkerType } from '../enums.ts'
@@ -37,7 +39,10 @@ export class ApplicationWorkerRuntime extends BaseWorkerRuntime {
   transports!: GatewayOptions['transports']
 
   routers = new Map<string | kRootRouter, AnyRouter>()
-  procedures = new Map<string, { procedure: AnyProcedure; path: AnyRouter[] }>()
+  procedures = new Map<
+    string | kDefaultProcedureKey,
+    { procedure: AnyProcedure; path: AnyRouter[] }
+  >()
   filters = new Set<AnyFilter>()
   middlewares = new Set<AnyMiddleware>()
   guards = new Set<AnyGuard>()
@@ -166,6 +171,16 @@ export class ApplicationWorkerRuntime extends BaseWorkerRuntime {
     this.routers.set(kRootRouter, router)
     this.registerRouter(router, [])
 
+    if (router.default) {
+      if (!isProcedure(router.default)) {
+        throw new Error('Root router default must be a procedure')
+      }
+      this.procedures.set(kDefaultProcedure, {
+        procedure: router.default,
+        path: [router],
+      })
+    }
+
     for (const filter of filters) this.filters.add(filter)
     for (const middleware of middlewares) this.middlewares.add(middleware)
     for (const guard of guards) this.guards.add(guard)

package/src/vite/servers/worker.ts

@@ -17,11 +17,17 @@ import { buildPlugins } from '../plugins.ts'
 import { createBroadcastChannel } from '../runners/worker.ts'
 import { createServer } from '../server.ts'
 
+export type WorkerServerEventMap = {
+  worker: [Worker]
+  'worker-error': [unknown]
+  'worker-ready': [unknown]
+}
+
 export async function createWorkerServer(
   options: ViteConfigOptions,
   mode: 'development' | 'production',
   neemataConfig: NeemataConfig,
-  events: EventEmitter<{ worker: [Worker] }>,
+  events: EventEmitter<WorkerServerEventMap>,
 ): Promise<ViteDevServer> {
   const config = createConfig(options)
   const applicationEntries = Object.values(options.applicationImports).map(
@@ -94,6 +100,36 @@ export async function createWorkerServer(
           },
         }
 
+        let lastError: any
+
+        events.on('worker-error', (payload: any) => {
+          lastError = payload?.error ?? payload
+          const error =
+            lastError instanceof Error
+              ? lastError
+              : new Error(String(lastError))
+          const message = {
+            type: 'error',
+            err: {
+              message: error.message,
+              stack: error.stack ?? '',
+              plugin: 'neemata:worker',
+            },
+          } satisfies HotPayload
+          for (const client of clients.values()) {
+            client.send(message)
+          }
+        })
+
+        events.on('worker-ready', () => {
+          if (!lastError) return
+          lastError = undefined
+          const message: HotPayload = { type: 'full-reload' }
+          for (const client of clients.values()) {
+            client.send(message)
+          }
+        })
+
         const environment = new DevEnvironment(name, config, {
           hot: mode === 'development',
           transport,