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

package/src/entrypoints/main.ts

@@ -2,10 +2,16 @@ import type { Worker } from 'node:worker_threads'
 import EventEmitter from 'node:events'
 import { fileURLToPath } from 'node:url'
 
-import type { ServerConfig } from 'nmtjs/runtime'
+import type {
+  ApplicationWorkerErrorEvent,
+  ApplicationWorkerReadyEvent,
+  ServerConfig,
+} from 'nmtjs/runtime'
 import type { ViteDevServer } from 'vite'
 import { ApplicationServer, isServerConfig } from 'nmtjs/runtime'
 
+import type { WorkerServerEventMap as BaseWorkerServerEventMap } from '../vite/servers/worker.ts'
+
 declare global {
   const __VITE_CONFIG__: string
   const __APPLICATIONS_CONFIG__: string
@@ -27,15 +33,22 @@ const applicationsConfig: Record<
   { type: 'neemata' | 'custom'; specifier: string }
 > = __APPLICATIONS_CONFIG__ ? JSON.parse(__APPLICATIONS_CONFIG__) : {}
 
-let _viteServerEvents: EventEmitter<{ worker: [Worker] }> | undefined
+type WorkerEventMap = BaseWorkerServerEventMap & {
+  'worker-error': [ApplicationWorkerErrorEvent]
+  'worker-ready': [ApplicationWorkerReadyEvent]
+}
+
+let _viteServerEvents: EventEmitter<WorkerEventMap> | undefined
 let _viteWorkerServer: ViteDevServer | undefined
 
-let server: ApplicationServer
+let server: ApplicationServer | undefined
+let hasActiveWorkerError = false
+const isDev = _vite?.mode === 'development'
 
 if (import.meta.env.DEV && import.meta.hot) {
   import.meta.hot.accept('#server', async (module) => {
-    await server.stop()
-    await createServer(module?.default)
+    await shutdownServer()
+    await bootWithHandling(module?.default)
   })
 }
 
@@ -45,7 +58,9 @@ if (_vite) {
     /* @vite-ignore */
     _vite.options.configPath
   ).then((m) => m.default as import('../config.ts').NeemataConfig)
-  _viteServerEvents = new EventEmitter<{ worker: [Worker] }>()
+  _viteServerEvents = new EventEmitter<WorkerEventMap>()
+  _viteServerEvents.on('worker-error', handleWorkerError)
+  _viteServerEvents.on('worker-ready', handleWorkerReady)
   _viteWorkerServer = await createWorkerServer(
     _vite.options,
     _vite.mode,
@@ -54,18 +69,41 @@ if (_vite) {
   )
 }
 
-async function createServer(config: ServerConfig) {
-  if (!isServerConfig(config)) throw new InvalidServerConfigError()
-  server = new ApplicationServer(config, applicationsConfig, {
+async function bootServer(configValue: ServerConfig | undefined) {
+  if (!isServerConfig(configValue)) throw new InvalidServerConfigError()
+  const workerConfig = {
     path: fileURLToPath(import.meta.resolve(`./thread${_ext}`)),
     workerData: { vite: _vite?.mode },
     worker: _viteServerEvents
-      ? (worker) => {
+      ? (worker: Worker) => {
           _viteServerEvents.emit('worker', worker)
         }
       : undefined,
-  })
-  await server.start()
+    events: _viteServerEvents,
+  }
+  const appServer = new ApplicationServer(
+    configValue,
+    applicationsConfig,
+    workerConfig,
+  )
+
+  try {
+    await appServer.start()
+    server = appServer
+    clearWorkerErrorOverlay()
+  } catch (error) {
+    await appServer.stop().catch(() => {})
+    throw error
+  }
+}
+
+async function bootWithHandling(configValue: ServerConfig | undefined) {
+  try {
+    await bootServer(configValue)
+  } catch (error) {
+    handleStartupError(error)
+    if (!isDev) throw error
+  }
 }
 
 let isTerminating = false
@@ -73,7 +111,7 @@ let isTerminating = false
 async function handleTermination() {
   if (isTerminating) return
   isTerminating = true
-  await server?.stop()
+  await shutdownServer()
   _viteWorkerServer?.close()
   process.exit(0)
 }
@@ -82,17 +120,66 @@ function handleUnexpectedError(error: Error) {
   console.error(new Error('Unexpected Error:', { cause: error }))
 }
 
+async function shutdownServer() {
+  if (!server) return
+  try {
+    await server.stop()
+  } catch (error) {
+    console.error(
+      new Error('Failed to stop application server', { cause: error as Error }),
+    )
+  } finally {
+    server = undefined
+  }
+}
+
+function handleWorkerError(event: ApplicationWorkerErrorEvent) {
+  hasActiveWorkerError = true
+  console.error(
+    new Error(`Worker ${event.application} thread ${event.threadId} error`, {
+      cause: event.error,
+    }),
+  )
+}
+
+function handleWorkerReady(_: ApplicationWorkerReadyEvent) {
+  clearWorkerErrorOverlay()
+}
+
+function handleStartupError(error: unknown) {
+  const normalized = error instanceof Error ? error : new Error(String(error))
+  if (_viteServerEvents) {
+    _viteServerEvents.emit('worker-error', {
+      application: 'server',
+      threadId: -1,
+      error: normalized,
+    } as ApplicationWorkerErrorEvent)
+  } else {
+    hasActiveWorkerError = true
+    console.error(
+      new Error('Failed to start application server', { cause: normalized }),
+    )
+  }
+}
+
+function clearWorkerErrorOverlay() {
+  if (!hasActiveWorkerError) return
+  hasActiveWorkerError = false
+}
+
 process.once('SIGTERM', handleTermination)
 process.once('SIGINT', handleTermination)
 process.on('uncaughtException', handleUnexpectedError)
 process.on('unhandledRejection', handleUnexpectedError)
 
-await createServer(
+await bootWithHandling(
   await import(
     // @ts-expect-error
     '#server'
   ).then((m) => m.default),
-)
+).catch(() => {
+  if (!isDev) process.exit(1)
+})
 
 const { format } = Intl.NumberFormat('en', {
   notation: 'compact',
@@ -108,5 +195,6 @@ const printMem = () => {
     `Memory Usage: RSS=${format(memoryUsage.rss)}, HeapTotal=${format(memoryUsage.heapTotal)}, HeapUsed=${format(memoryUsage.heapUsed)}, External=${format(memoryUsage.external)}, ArrayBuffers=${format(memoryUsage.arrayBuffers)}`,
   )
 }
+void printMem
 // printMem()
 // setInterval(printMem, 5000)

package/src/entrypoints/thread.ts

@@ -2,7 +2,11 @@ import type { MessagePort } from 'node:worker_threads'
 import { fileURLToPath } from 'node:url'
 import { workerData as _workerData } from 'node:worker_threads'
 
-import type { ThreadPortMessage } from 'nmtjs/runtime'
+import type {
+  ThreadErrorMessage,
+  ThreadPortMessage,
+  WorkerThreadErrorOrigin,
+} from 'nmtjs/runtime'
 import type { ModuleRunner } from 'vite/module-runner'
 
 export type RunWorkerOptions = {
@@ -18,56 +22,163 @@ const workerData = _workerData as RunWorkerOptions
 const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
 const workerPath = fileURLToPath(import.meta.resolve(`./worker${ext}`))
 
+type WorkerModule = typeof import('./worker.ts')
+type WorkerRuntime = Awaited<ReturnType<WorkerModule['run']>>
+
+const kReportedError = Symbol.for('nmtjs.worker.reported-error')
+
+let runner: ModuleRunner | undefined
+let workerModule: WorkerModule
+let runtime: WorkerRuntime | undefined
+let runtimeStarted = false
+
 process.on('uncaughtException', (error) => {
-  console.error(new Error('Uncaught Exception:', { cause: error }))
+  reportError(error, 'runtime', { fatal: true })
 })
 
 process.on('unhandledRejection', (error) => {
-  console.error(new Error('Unhandled Promise Rejection:', { cause: error }))
+  reportError(error, 'runtime', { fatal: true })
 })
 
-process.on('exit', async (code) => {
-  await runner?.close()
+process.on('exit', () => {
+  void cleanup()
 })
 
-let runner: ModuleRunner
-let workerModule: typeof import('./worker.ts')
-
-try {
-  if (workerData.vite) {
-    const { createModuleRunner } = (await import(
-      '../vite/runners/worker.ts'
-    )) as typeof import('../vite/runners/worker.ts')
-
-    runner = createModuleRunner(workerData.vite)
-    workerModule = await runner.import(workerPath)
-  } else {
-    runner = undefined as any
-    workerModule = await import(
-      /* @vite-ignore */
-      workerPath
-    )
+async function cleanup() {
+  await stopRuntime()
+  await closeRunner()
+}
+
+async function closeRunner() {
+  if (!runner) return
+  try {
+    await runner.close()
+  } catch (error) {
+    reportError(error, 'runtime', { fatal: false })
+  } finally {
+    runner = undefined
   }
+}
 
-  const runtime = await workerModule.run(workerData.runtime)
+async function stopRuntime() {
+  if (!runtime) return
+  try {
+    if (runtimeStarted) {
+      await runtime.stop()
+    }
+  } catch (error) {
+    reportError(error, 'runtime', { fatal: false })
+  } finally {
+    runtimeStarted = false
+  }
+}
 
-  process.on('exit', async () => {
-    await runtime.stop()
-  })
+function normalizeError(value: unknown): Error {
+  if (value instanceof Error) return value
+  if (typeof value === 'string') return new Error(value)
+  if (value && typeof value === 'object') {
+    try {
+      return new Error(JSON.stringify(value))
+    } catch {}
+  }
+  return new Error(String(value))
+}
+
+function serializeError(
+  error: Error,
+  origin: WorkerThreadErrorOrigin,
+  fatal: boolean,
+): ThreadErrorMessage {
+  return {
+    message: error.message,
+    name: error.name,
+    stack: error.stack,
+    origin,
+    fatal,
+  }
+}
+
+function reportError(
+  value: unknown,
+  origin: WorkerThreadErrorOrigin,
+  options: { fatal?: boolean } = {},
+): Error {
+  const fatal = options.fatal ?? origin !== 'runtime'
+  const error = normalizeError(value)
+  if (!(error as any)[kReportedError]) {
+    try {
+      workerData.port.postMessage({
+        type: 'error',
+        data: serializeError(error, origin, fatal),
+      } satisfies ThreadPortMessage)
+    } catch {}
+    console.error(new Error(`Worker thread ${origin} error`, { cause: error }))
+    ;(error as any)[kReportedError] = true
+  }
+  return error
+}
+
+async function loadWorkerModule() {
+  try {
+    if (workerData.vite) {
+      const { createModuleRunner } = (await import(
+        '../vite/runners/worker.ts'
+      )) as typeof import('../vite/runners/worker.ts')
+
+      runner = createModuleRunner(workerData.vite)
+      workerModule = await runner.import(workerPath)
+    } else {
+      runner = undefined
+      workerModule = await import(
+        /* @vite-ignore */
+        workerPath
+      )
+    }
+  } catch (error) {
+    throw reportError(error, 'bootstrap')
+  }
+}
+
+async function initializeRuntime() {
+  try {
+    runtime = await workerModule.run(workerData.runtime)
+  } catch (error) {
+    throw reportError(error, 'bootstrap')
+  }
 
   workerData.port.on('message', async (msg) => {
     if (msg.type === 'stop') {
-      await runtime.stop()
+      await cleanup()
       process.exit(0)
     }
   })
+}
 
-  const hosts = (await runtime?.start()) || undefined
+async function startRuntime() {
+  if (!runtime) return
+  try {
+    const hosts = (await runtime.start()) || undefined
+    runtimeStarted = true
+    workerData.port.postMessage({
+      type: 'ready',
+      data: { hosts },
+    } satisfies ThreadPortMessage)
+  } catch (error) {
+    throw reportError(error, 'start')
+  }
+}
 
-  workerData.port.postMessage({
-    type: 'ready',
-    data: { hosts },
-  } satisfies ThreadPortMessage)
-} catch (error) {
-  console.error(new Error('Worker thread error:', { cause: error }))
+async function main() {
+  await loadWorkerModule()
+  await initializeRuntime()
+  await startRuntime()
 }
+
+main().catch(async (error) => {
+  const normalized = error instanceof Error ? error : normalizeError(error)
+  if (!(normalized as any)[kReportedError]) {
+    reportError(normalized, 'bootstrap')
+  }
+  await cleanup()
+  process.exit(1)
+})

package/src/runtime/application/api/api.ts

@@ -17,12 +17,14 @@ import { ProtocolError } from '@nmtjs/protocol/server'
 import { NeemataTypeError, registerDefaultLocale, type } from '@nmtjs/type'
 import { prettifyError } from 'zod/mini'
 
+import type { kDefaultProcedure as kDefaultProcedureKey } from './constants.ts'
 import type { AnyFilter } from './filters.ts'
 import type { AnyGuard } from './guards.ts'
 import type { AnyMiddleware } from './middlewares.ts'
 import type { AnyProcedure } from './procedure.ts'
 import type { AnyRouter } from './router.ts'
 import type { ApiCallContext } from './types.ts'
+import { kDefaultProcedure } from './constants.ts'
 
 registerDefaultLocale()
 
@@ -39,7 +41,10 @@ export type ApiOptions = {
   timeout?: number
   container: Container
   logger: Logger
-  procedures: Map<string, { procedure: AnyProcedure; path: AnyRouter[] }>
+  procedures: Map<
+    string | kDefaultProcedureKey,
+    { procedure: AnyProcedure; path: AnyRouter[] }
+  >
   guards: Set<AnyGuard>
   middlewares: Set<AnyMiddleware>
   filters: Set<AnyFilter>
@@ -57,8 +62,12 @@ export class ApplicationApi implements GatewayApi {
   constructor(public options: ApiOptions) {}
 
   find(procedureName: string) {
-    const result = this.options.procedures.get(procedureName)
-    if (result) return result
+    const procedure = this.options.procedures.get(procedureName)
+    if (procedure) return procedure
+
+    const fallback = this.options.procedures.get(kDefaultProcedure)
+    if (fallback) return fallback
+
     throw NotFound()
   }
 

package/src/runtime/application/api/constants.ts

@@ -1,6 +1,11 @@
 export const kProcedure: unique symbol = Symbol.for('neemata:ProcedureKey')
 export type kProcedure = typeof kProcedure
 
+export const kDefaultProcedure: unique symbol = Symbol.for(
+  'neemata:DefaultProcedureKey',
+)
+export type kDefaultProcedure = typeof kDefaultProcedure
+
 export const kRouter: unique symbol = Symbol.for('neemata:RouterKey')
 export type kRouter = typeof kRouter
 

package/src/runtime/application/api/router.ts

@@ -6,6 +6,7 @@ import type {
   TRouteContract,
   TRouterContract,
 } from '@nmtjs/contract'
+import type { AnyType } from '@nmtjs/type/any'
 import { c, IsRouterContract } from '@nmtjs/contract'
 
 import type { AnyGuard } from './guards.ts'
@@ -25,6 +26,7 @@ export interface AnyRouter {
 export interface AnyRootRouter extends AnyRouter {
   [kRootRouter]: any
   contract: TAnyRouterContract<Record<string, TRouteContract>, undefined>
+  default?: AnyProcedure<any>
 }
 
 export interface Router<Contract extends TAnyRouterContract> extends AnyRouter {
@@ -56,6 +58,7 @@ export interface RootRouter<
   >,
 > extends Router<Contract> {
   [kRootRouter]: any
+  default?: AnyProcedure<any>
 }
 
 export type MergeRoutersRoutesContracts<
@@ -79,17 +82,24 @@ export type ExtractRouterContracts<
   : []
 
 export function createRootRouter<Routers extends readonly AnyRouter[]>(
-  ...routers: Routers
+  routers: Routers,
+  defaultProcedure?: AnyProcedure<
+    TProcedureContract<AnyType, AnyType, true | undefined, string | undefined>
+  >,
 ): RootRouter<
   TRouterContract<
-    MergeRoutersRoutesContracts<ExtractRouterContracts<Routers>>,
+    MergeRoutersRoutesContracts<ExtractRouterContracts<[...Routers]>>,
     undefined
   >
 > {
   const routes: Record<string, any> = {}
   for (const router of routers) Object.assign(routes, router.routes)
   const router = createRouter({ name: undefined, routes: routes })
-  return Object.freeze({ ...router, [kRootRouter]: true }) as any
+  return Object.freeze({
+    ...router,
+    default: defaultProcedure,
+    [kRootRouter]: true,
+  }) as any
 }
 
 export function createRouter<

package/src/runtime/server/applications.ts

@@ -3,9 +3,14 @@ import { EventEmitter } from 'node:events'
 import type { Logger } from '@nmtjs/core'
 import type { ProxyableTransportType } from '@nmtjs/gateway'
 
+import type { ThreadPortMessageTypes, WorkerThreadError } from '../types.ts'
 import type { ServerApplicationConfig, ServerConfig } from './config.ts'
 import type { Thread } from './pool.ts'
-import type { ApplicationServerWorkerConfig } from './server.ts'
+import type {
+  ApplicationServerWorkerConfig,
+  ApplicationWorkerErrorEvent,
+  ApplicationWorkerReadyEvent,
+} from './server.ts'
 import { Pool } from './pool.ts'
 
 export type ApplicationProxyUpstream = {
@@ -48,6 +53,10 @@ export class ApplicationServerApplications extends EventEmitter<{
     })
   }
 
+  get appsNames() {
+    return this.params.applications
+  }
+
   async start() {
     const { logger, applications, applicationsConfig, serverConfig } =
       this.params
@@ -88,29 +97,45 @@ export class ApplicationServerApplications extends EventEmitter<{
         })
 
         thread.on('ready', ({ hosts }) => {
-          if (!hosts?.length) return
+          this.removeThreadUpstreams(thread)
 
           const keys: Array<{ application: string; key: string }> = []
+          const sanitizedHosts: ThreadPortMessageTypes['ready']['hosts'] = []
 
-          for (const host of hosts) {
-            const url = new URL(host.url)
-            // Convert 0.0.0.0 to 127.0.0.1 for local proxy access
-            if (url.hostname === '0.0.0.0') url.hostname = '127.0.0.1'
+          if (hosts?.length) {
+            for (const host of hosts) {
+              const url = new URL(host.url)
+              if (url.hostname === '0.0.0.0') url.hostname = '127.0.0.1'
 
-            const upstream: ApplicationProxyUpstream = {
-              type: host.type,
-              url: url.toString(),
-            }
+              const normalizedUrl = url.toString()
+              sanitizedHosts.push({ type: host.type, url: normalizedUrl })
+
+              const upstream: ApplicationProxyUpstream = {
+                type: host.type,
+                url: normalizedUrl,
+              }
 
-            const key = `${upstream.type}:${upstream.url}`
-            keys.push({ application: applicationName, key })
-            this.addUpstream(applicationName, key, upstream)
+              const key = `${upstream.type}:${upstream.url}`
+              keys.push({ application: applicationName, key })
+              this.addUpstream(applicationName, key, upstream)
+            }
           }
 
           this.upstreamsByThread.set(thread, keys)
+
+          this.emitWorkerReady({
+            application: applicationName,
+            threadId: thread.worker.threadId,
+            hosts: sanitizedHosts.length ? sanitizedHosts : undefined,
+          })
         })
 
-        thread.once('error', () => {
+        thread.on('error', (error: WorkerThreadError) => {
+          this.emitWorkerError({
+            application: applicationName,
+            threadId: thread.worker.threadId,
+            error,
+          })
           this.removeThreadUpstreams(thread)
         })
 
@@ -168,4 +193,18 @@ export class ApplicationServerApplications extends EventEmitter<{
       }
     }
   }
+
+  protected emitWorkerReady(event: ApplicationWorkerReadyEvent) {
+    this.params.workerConfig.events?.emit('worker-ready', event)
+  }
+
+  protected emitWorkerError(event: ApplicationWorkerErrorEvent) {
+    this.params.logger.error(
+      new Error(
+        `Worker [${event.application}] thread ${event.threadId} error`,
+        { cause: event.error },
+      ),
+    )
+    this.params.workerConfig.events?.emit('worker-error', event)
+  }
 }

package/src/runtime/server/config.ts

@@ -1,6 +1,7 @@
 import type { TSError } from '@nmtjs/common'
 import type { LoggingOptions } from '@nmtjs/core'
 import type { Transport } from '@nmtjs/gateway'
+import type { ApplicationOptions, PortUpstreamOptions } from '@nmtjs/proxy'
 import type { Applications } from 'nmtjs/runtime/types'
 
 import type { ApplicationConfig } from '../application/config.ts'
@@ -64,6 +65,9 @@ export interface ServerConfig {
   proxy?: {
     port: number
     hostname: string
+    applications: {
+      [K in keyof Applications]?: Omit<ApplicationOptions, 'name'>
+    }
     threads?: number
     healthChecks?: { interval?: number }
     tls?: { key: string; cert: string }