nmtjs 0.16.0 → 0.17.0-beta.1

package/src/entrypoints/main.ts

@@ -1,317 +0,0 @@
-import type { MessagePort, Worker } from 'node:worker_threads'
-import EventEmitter from 'node:events'
-import { fileURLToPath } from 'node:url'
-
-import type { ViteDevServer } from 'vite'
-import { createLogger } from '@nmtjs/core'
-
-import type { ServerConfig } from '../runtime/index.ts'
-import type { WorkerServerEventMap } from '../vite/servers/worker.ts'
-import {
-  ApplicationServer,
-  defaultPoolFactory,
-  defaultWorkerFactory,
-  isServerConfig,
-} from '../runtime/index.ts'
-import { createRuntimeEnvironment } from '../runtime/server/environment.ts'
-import { getErrorPolicy } from '../runtime/server/error-policy.ts'
-import { HMRCoordinator } from '../runtime/server/hmr-coordinator.ts'
-import { ServerLifecycle } from '../runtime/server/lifecycle.ts'
-
-declare global {
-  const __VITE_CONFIG__: string
-  const __APPLICATIONS_CONFIG__: string
-}
-
-class InvalidServerConfigError extends Error {
-  constructor() {
-    super(
-      `Server config file does not have a default export, or it is not a valid server config. Please, make sure the server config is defined using defineServer().`,
-    )
-    this.name = 'InvalidServerConfigError'
-  }
-}
-
-const _ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
-const _vite = __VITE_CONFIG__ ? JSON.parse(__VITE_CONFIG__) : undefined
-const applicationsConfig: Record<
-  string,
-  { type: 'neemata' | 'custom'; specifier: string }
-> = __APPLICATIONS_CONFIG__ ? JSON.parse(__APPLICATIONS_CONFIG__) : {}
-
-// Runtime environment setup
-const mode = _vite?.mode === 'development' ? 'development' : 'production'
-const isDev = mode === 'development'
-const errorPolicy = getErrorPolicy(mode)
-const bootstrapLogger = createLogger(
-  { pinoOptions: { level: isDev ? 'debug' : 'info' } },
-  'Main',
-)
-
-// Logger for main process (created lazily with config-based level)
-let logger: ReturnType<typeof createLogger> = bootstrapLogger
-
-// Vite server and events (dev only)
-let _viteServerEvents: EventEmitter<WorkerServerEventMap> | undefined
-let _viteServer: ViteDevServer | undefined
-
-// Server lifecycle management
-let lifecycle: ServerLifecycle | undefined
-let hmrCoordinator: HMRCoordinator | undefined
-
-// Current server config (updated on HMR)
-let currentServerConfig: ServerConfig | undefined
-
-// Track termination state
-let isTerminating = false
-
-function resolveViteRunnerTimeoutMs(): number | undefined {
-  const raw = process.env.NMTJS_VITE_RUNNER_TIMEOUT_MS
-  if (!raw) return undefined
-
-  const parsed = Number.parseInt(raw, 10)
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    logger.warn(
-      { value: raw },
-      'Invalid NMTJS_VITE_RUNNER_TIMEOUT_MS, falling back to default',
-    )
-    return undefined
-  }
-
-  return parsed
-}
-
-/**
- * Create the ApplicationServer instance using currentServerConfig.
- */
-function createServer(): ApplicationServer {
-  if (!currentServerConfig) {
-    throw new Error('Server config not initialized')
-  }
-
-  const workerConfig = {
-    path: fileURLToPath(new URL(`./thread${_ext}`, import.meta.url)),
-    workerData: {
-      vite: _vite?.mode,
-      viteModuleRunnerTimeoutMs: resolveViteRunnerTimeoutMs(),
-    },
-    worker: _viteServerEvents
-      ? ({ worker, vitePort }: { worker: Worker; vitePort?: MessagePort }) => {
-          _viteServerEvents!.emit('worker', { worker, vitePort })
-        }
-      : undefined,
-    events: _viteServerEvents,
-  }
-
-  return new ApplicationServer(
-    currentServerConfig,
-    applicationsConfig,
-    workerConfig,
-    undefined, // runOptions
-    errorPolicy,
-    defaultWorkerFactory,
-    defaultPoolFactory,
-  )
-}
-
-/**
- * Initialize Vite dev server (dev mode only).
- */
-async function initializeVite() {
-  if (!_vite) return
-
-  const { createViteServer } = await import('../vite/servers/worker.ts')
-  const neemataConfig = await import(
-    /* @vite-ignore */
-    _vite.options.configPath
-  ).then((m) => m.default as import('../config.ts').NeemataConfig)
-
-  _viteServerEvents = new EventEmitter<WorkerServerEventMap>()
-  _viteServerEvents.on('hmr-update', handleHMRUpdate)
-
-  _viteServer = await createViteServer(
-    _vite.options,
-    _vite.mode,
-    neemataConfig,
-    _viteServerEvents,
-  )
-}
-
-/**
- * Initialize the server lifecycle (called once at startup).
- */
-function initializeLifecycle(configValue: ServerConfig) {
-  if (!isServerConfig(configValue)) throw new InvalidServerConfigError()
-
-  // Store initial config
-  currentServerConfig = configValue
-  const loggerOptions = currentServerConfig?.logger ?? {
-    pinoOptions: { level: isDev ? 'debug' : 'info' },
-  }
-  logger = createLogger(loggerOptions, 'Main')
-
-  // Create runtime environment
-  const env = createRuntimeEnvironment(mode, {
-    vite: _viteServer ?? undefined,
-    hmr: undefined, // hmrCoordinator created after lifecycle
-  })
-
-  // Create lifecycle (singleton)
-  lifecycle = new ServerLifecycle(env, createServer, logger)
-
-  // Create HMR coordinator (dev only, singleton)
-  if (isDev) {
-    hmrCoordinator = new HMRCoordinator(lifecycle, logger)
-  }
-
-  // Listen for lifecycle errors (once)
-  lifecycle.on('error', (error, handled) => {
-    if (!handled) {
-      logger.error(new Error('Unhandled lifecycle error', { cause: error }))
-    }
-  })
-}
-
-/**
- * Set up HMR acceptance for server config changes.
- */
-function setupHMR() {
-  if (!import.meta.env.DEV || !import.meta.hot) return
-
-  import.meta.hot.accept('#server', async (module) => {
-    if (!module) return
-    if (!isServerConfig(module.default)) throw new InvalidServerConfigError()
-
-    // Update the config (createServer will use this on next reload)
-    currentServerConfig = module.default
-
-    // Use HMR coordinator to handle the reload
-    if (hmrCoordinator) {
-      try {
-        await hmrCoordinator.scheduleReload()
-      } catch (cause) {
-        logger.error(new Error('Error during HMR reload', { cause }))
-      }
-    }
-  })
-}
-
-/**
- * Handle HMR update event.
- * When an application file is updated and there are failed workers, restart them.
- */
-async function handleHMRUpdate(_event: { file: string }) {
-  // If server is in failed state, try to start it
-  if (lifecycle?.currentState === 'failed') {
-    try {
-      await lifecycle.start()
-    } catch {
-      // Error will be handled by lifecycle
-    }
-    return
-  }
-
-  // If server is running, restart any failed workers
-  const server = lifecycle?.getServer()
-  if (server) {
-    try {
-      const restarted = await server.restartFailedWorkers()
-      if (restarted > 0) {
-        logger.info(
-          { count: restarted },
-          'Restarted failed workers after HMR update',
-        )
-      }
-    } catch (error) {
-      logger.error(
-        new Error('Failed to restart workers after HMR update', {
-          cause: error,
-        }),
-      )
-    }
-  }
-}
-
-/**
- * Handle startup error.
- */
-function handleStartupError(error: unknown) {
-  const normalized = error instanceof Error ? error : new Error(String(error))
-  logger.error(
-    new Error('Failed to start application server', { cause: normalized }),
-  )
-}
-
-/**
- * Handle process termination signals.
- */
-async function handleTermination() {
-  if (isTerminating) return
-  isTerminating = true
-
-  logger.info('Shutting down...')
-
-  try {
-    await lifecycle?.stop()
-  } catch (error) {
-    logger.error(new Error('Failed to stop server', { cause: error as Error }))
-  }
-
-  try {
-    await _viteServer?.close()
-  } catch (error) {
-    logger.error(new Error('Failed to close Vite server', { cause: error }))
-  }
-  process.exit(0)
-}
-
-/**
- * Handle unexpected errors.
- */
-function handleUnexpectedError(error: unknown) {
-  const normalized = error instanceof Error ? error : new Error(String(error))
-  logger.error(new Error('Unexpected Error', { cause: normalized }))
-}
-
-/**
- * Main entry point.
- */
-async function main() {
-  // Set up process handlers
-  process.once('SIGTERM', handleTermination)
-  process.once('SIGINT', handleTermination)
-  process.on('uncaughtException', handleUnexpectedError)
-  process.on('unhandledRejection', handleUnexpectedError)
-
-  // Initialize Vite (dev mode only)
-  await initializeVite()
-
-  // Load server config
-  const serverConfig = await import(
-    // @ts-expect-error
-    '#server'
-  ).then((m) => m.default)
-
-  // Initialize lifecycle (sync, creates singletons)
-  initializeLifecycle(serverConfig)
-
-  // Set up HMR
-  setupHMR()
-
-  // Start the server
-  try {
-    await lifecycle!.start()
-  } catch (error) {
-    handleStartupError(error)
-    if (!isDev) {
-      process.exit(1)
-    }
-  }
-}
-
-main().catch((error) => {
-  logger.fatal(new Error('Fatal error during startup', { cause: error }))
-  if (!isDev) {
-    process.exit(1)
-  }
-})

package/src/entrypoints/thread.ts

@@ -1,223 +0,0 @@
-import type { MessagePort } from 'node:worker_threads'
-import { fileURLToPath } from 'node:url'
-import { workerData as _workerData } from 'node:worker_threads'
-
-import type { ModuleRunner } from 'vite/module-runner'
-import { createLogger } from '@nmtjs/core'
-
-import type {
-  ThreadErrorMessage,
-  ThreadPortMessage,
-  WorkerThreadErrorOrigin,
-} from '../runtime/index.ts'
-
-export type RunWorkerOptions = {
-  port: MessagePort
-  vitePort?: MessagePort
-  runtime:
-    | { type: 'application'; name: string; path: string; transportsData: any }
-    | { type: 'jobs'; jobWorkerPool: string }
-  vite?: 'development' | 'production'
-  viteModuleRunnerTimeoutMs?: number
-}
-
-const workerData = _workerData as RunWorkerOptions
-
-const logger = createLogger(
-  {
-    pinoOptions: {
-      level: workerData.vite === 'development' ? 'debug' : 'info',
-    },
-  },
-  'Thread',
-)
-
-const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
-const workerPath = fileURLToPath(new URL(`./worker${ext}`, import.meta.url))
-
-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
-let cleanupPromise: Promise<void> | null = null
-
-process.on('uncaughtException', (error) => {
-  reportError(error, 'runtime', { fatal: true })
-})
-
-process.on('unhandledRejection', (error) => {
-  reportError(error, 'runtime', { fatal: true })
-})
-
-process.once('SIGTERM', () => {
-  void terminate(0)
-})
-
-process.once('SIGINT', () => {
-  void terminate(0)
-})
-
-process.once('beforeExit', () => {
-  if (!cleanupPromise && (runtimeStarted || runner)) {
-    void cleanup()
-  }
-})
-
-async function cleanup() {
-  if (cleanupPromise) return cleanupPromise
-
-  cleanupPromise = (async () => {
-    await stopRuntime()
-    await closeRunner()
-  })().finally(() => {
-    cleanupPromise = null
-  })
-
-  return cleanupPromise
-}
-
-async function terminate(code: number) {
-  await cleanup()
-  process.exit(code)
-}
-
-async function closeRunner() {
-  if (!runner) return
-  try {
-    await runner.close()
-  } catch (error) {
-    reportError(error, 'runtime', { fatal: false })
-  } finally {
-    runner = undefined
-  }
-}
-
-async function stopRuntime() {
-  if (!runtime) return
-  try {
-    if (runtimeStarted) {
-      await runtime.stop()
-    }
-  } catch (error) {
-    reportError(error, 'runtime', { fatal: false })
-  } finally {
-    runtimeStarted = false
-  }
-}
-
-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 {}
-    logger.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.vitePort,
-        workerData.vite,
-        workerData.viteModuleRunnerTimeoutMs,
-      )
-      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 terminate(0)
-    }
-  })
-}
-
-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')
-  }
-}
-
-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 terminate(1)
-})

package/src/entrypoints/worker.ts

@@ -1,174 +0,0 @@
-import { workerData } from 'node:worker_threads'
-
-import type { ServerConfig } from '../runtime/index.ts'
-import type { RunWorkerOptions } from './thread.ts'
-import {
-  ApplicationWorkerRuntime,
-  isApplicationHostDefinition,
-  JobWorkerRuntime,
-} from '../runtime/index.ts'
-
-/**
- * Worker entry point.
- *
- * Handles initialization of application or job worker runtimes.
- * Includes HMR supersede logic for application workers.
- */
-export async function run(options: RunWorkerOptions['runtime']) {
-  const serverConfig: ServerConfig = await import(
-    // @ts-expect-error
-    '#server'
-  ).then((m) => m.default)
-
-  if (options.type === 'application') {
-    return initializeApplicationWorker(options, serverConfig)
-  } else if (options.type === 'jobs') {
-    return initializeJobWorker(options, serverConfig)
-  } else {
-    throw new Error(`Unknown runtime type: ${(options as any).type}`)
-  }
-}
-
-/**
- * Initialize an application worker with HMR support.
- */
-async function initializeApplicationWorker(
-  options: Extract<RunWorkerOptions['runtime'], { type: 'application' }>,
-  serverConfig: ServerConfig,
-) {
-  const { name, path, transportsData } = options
-
-  // Load initial application host definition
-  const hostDefinition = await import(
-    /* @vite-ignore */
-    path
-  ).then((m) => m.default)
-
-  if (!isApplicationHostDefinition(hostDefinition)) {
-    throw new Error(`Invalid application host definition: ${name}`)
-  }
-
-  // Create runtime
-  const runtime = new ApplicationWorkerRuntime(
-    serverConfig,
-    { name, path, transports: transportsData },
-    hostDefinition,
-  )
-
-  // Set up HMR with supersede logic
-  setupApplicationHMR(runtime)
-
-  return runtime
-}
-
-/**
- * Set up HMR acceptance for application host definition changes with supersede logic.
- *
- * When a reload is in progress and another HMR event arrives, the pending
- * reload is superseded - only the most recent config is applied.
- */
-function setupApplicationHMR(runtime: ApplicationWorkerRuntime) {
-  const logger = runtime.logger.child({ component: 'HMR' })
-
-  // Track active reload
-  let activeReload: Promise<void> | null = null
-
-  // Track pending reload (supersedes previous pending)
-  let pendingConfig: unknown | null = null
-  let pendingResolve: (() => void) | null = null
-  let pendingReject: ((e: Error) => void) | null = null
-
-  /**
-   * Execute a reload with the given config.
-   */
-  const executeReload = async (config: any): Promise<void> => {
-    activeReload = doReload(config)
-
-    try {
-      await activeReload
-    } finally {
-      activeReload = null
-
-      // If there's a pending reload, execute it now
-      if (pendingConfig !== null) {
-        const config = pendingConfig
-        const resolve = pendingResolve!
-        const reject = pendingReject!
-
-        pendingConfig = null
-        pendingResolve = null
-        pendingReject = null
-
-        executeReload(config).then(resolve, reject)
-      }
-    }
-  }
-
-  /**
-   * Perform the actual reload.
-   */
-  const doReload = async (config: any): Promise<void> => {
-    try {
-      logger.debug('Reloading application...')
-      await runtime.reload(config)
-      logger.info('Application reloaded successfully')
-    } catch (error) {
-      // Log error but keep worker alive for next HMR update
-      logger.error(new Error('Error during HMR reload', { cause: error }))
-    }
-  }
-
-  /**
-   * Schedule a reload. If reload is in progress, supersedes any pending.
-   */
-  const scheduleReload = (config: any): Promise<void> => {
-    // If no active reload, execute immediately
-    if (!activeReload) {
-      return executeReload(config)
-    }
-
-    logger.debug('Reload in progress, queuing update...')
-    // Supersede any existing pending reload
-    if (pendingResolve) {
-      logger.debug('Superseding previous pending reload')
-      pendingResolve() // Resolve old pending (it's superseded)
-    }
-
-    // Create new pending
-    return new Promise((resolve, reject) => {
-      pendingConfig = config
-      pendingResolve = resolve
-      pendingReject = reject
-    })
-  }
-
-  // Register global hot accept handler
-  globalThis._hotAccept = async (module: any) => {
-    logger.debug('Received HMR update')
-    if (!module) return
-
-    if (!isApplicationHostDefinition(module.default)) {
-      logger.error(
-        new Error('Invalid application host definition during HMR reload'),
-      )
-      return
-    }
-
-    await scheduleReload(module.default)
-  }
-}
-
-/**
- * Initialize a job worker.
- */
-async function initializeJobWorker(
-  options: Extract<RunWorkerOptions['runtime'], { type: 'jobs' }>,
-  serverConfig: ServerConfig,
-) {
-  const { jobWorkerPool } = options
-  const runtime = new JobWorkerRuntime(serverConfig, {
-    poolName: jobWorkerPool,
-    port: workerData.port,
-  })
-  return runtime
-}

package/src/resolver.ts

@@ -1,7 +0,0 @@
-import { ResolverFactory } from 'oxc-resolver'
-
-export const resolver = new ResolverFactory({
-  tsconfig: 'auto',
-  extensions: ['.ts', '.js', '.mjs', '.mts', '.json', '.node', '.wasm'],
-  mainFields: ['module', 'main'],
-})