nmtjs 0.16.1 → 0.17.0-beta.2

package/src/runtime/server/pool-manager.ts

@@ -1,187 +0,0 @@
-import EventEmitter from 'node:events'
-
-import type { Logger } from '@nmtjs/core'
-
-import type { ErrorPolicy } from './error-policy.ts'
-import type {
-  ManagedWorkerFactory,
-  PoolHealth,
-  PoolHealthReport,
-  WorkerPool,
-  WorkerPoolConfig,
-  WorkerPoolFactory,
-} from './worker-pool.ts'
-
-/**
- * Overall server health state.
- */
-export type ServerHealth = 'healthy' | 'degraded' | 'unhealthy'
-
-/**
- * Report on overall server health including all pools.
- */
-export interface ServerHealthReport {
-  overall: ServerHealth
-  pools: PoolHealthReport[]
-}
-
-/**
- * Events emitted by PoolManager.
- */
-export interface PoolManagerEvents {
-  'health-change': [health: ServerHealth]
-  'pool-health-change': [poolName: string, health: PoolHealth]
-}
-
-/**
- * PoolManager manages multiple application pools with aggregate health tracking.
- *
- * Features:
- * - Creates and manages WorkerPools for each application/job type
- * - Aggregates health across all pools
- * - Provides server-level health reports
- *
- * Each application gets its own pool for isolated failure domains.
- * For example, if "api" is degraded but "admin" is healthy, they're tracked independently.
- */
-export class PoolManager extends EventEmitter<PoolManagerEvents> {
-  private pools = new Map<string, WorkerPool>()
-  private health: ServerHealth = 'healthy'
-  private logger: Logger
-
-  constructor(
-    private readonly policy: ErrorPolicy,
-    private readonly workerFactory: ManagedWorkerFactory,
-    private readonly poolFactory: WorkerPoolFactory,
-    logger: Logger,
-  ) {
-    super()
-    this.logger = logger.child({ component: 'PoolManager' })
-  }
-
-  /** Current overall server health */
-  get currentHealth(): ServerHealth {
-    return this.health
-  }
-
-  /** Number of pools managed */
-  get poolCount(): number {
-    return this.pools.size
-  }
-
-  /**
-   * Create a new pool for an application or job type.
-   *
-   * @param config - Pool configuration
-   * @returns The created WorkerPool
-   * @throws If a pool with this name already exists
-   */
-  createPool(config: WorkerPoolConfig): WorkerPool {
-    if (this.pools.has(config.name)) {
-      throw new Error(`Pool for "${config.name}" already exists`)
-    }
-
-    const pool = this.poolFactory(
-      config,
-      this.policy,
-      this.workerFactory,
-      this.logger,
-    )
-
-    pool.on('health-change', (health) => {
-      this.emit('pool-health-change', config.name, health)
-      this.updateHealth()
-    })
-
-    this.pools.set(config.name, pool)
-    this.logger.debug({ pool: config.name }, 'Pool created')
-
-    return pool
-  }
-
-  /**
-   * Get a pool by name.
-   */
-  getPool(name: string): WorkerPool | undefined {
-    return this.pools.get(name)
-  }
-
-  /**
-   * Get all pools.
-   */
-  getAllPools(): Map<string, WorkerPool> {
-    return new Map(this.pools)
-  }
-
-  /**
-   * Start all pools.
-   */
-  async startAll(): Promise<void> {
-    this.logger.debug({ count: this.pools.size }, 'Starting all pools')
-    await Promise.all([...this.pools.values()].map((p) => p.startAll()))
-    this.logger.debug({ count: this.pools.size }, 'All pools started')
-  }
-
-  /**
-   * Stop all pools.
-   */
-  async stopAll(): Promise<void> {
-    this.logger.debug({ count: this.pools.size }, 'Stopping all pools')
-    await Promise.all([...this.pools.values()].map((p) => p.stopAll()))
-    this.pools.clear()
-    this.logger.debug('All pools stopped')
-  }
-
-  /**
-   * Get a health report for all pools.
-   * This is for internal debugging/logging only.
-   * External health checks should use application-level procedures
-   * or external monitoring (k8s probes, process monitors).
-   */
-  getHealthReport(): ServerHealthReport {
-    const poolReports = [...this.pools.values()].map((p) => p.getHealthReport())
-    return { overall: this.health, pools: poolReports }
-  }
-
-  /**
-   * Update overall server health based on pool states.
-   */
-  private updateHealth(): void {
-    const poolHealths = [...this.pools.values()].map((p) => p.currentHealth)
-
-    // No pools = healthy
-    if (poolHealths.length === 0) {
-      this.setHealth('healthy')
-      return
-    }
-
-    let newHealth: ServerHealth
-    if (poolHealths.every((h) => h === 'healthy')) {
-      newHealth = 'healthy'
-    } else if (
-      poolHealths.some((h) => h !== 'unhealthy') &&
-      this.policy.allowDegradedMode
-    ) {
-      newHealth = 'degraded'
-    } else {
-      newHealth = 'unhealthy'
-    }
-
-    this.setHealth(newHealth)
-  }
-
-  /**
-   * Set the health state, emitting event if changed.
-   */
-  private setHealth(newHealth: ServerHealth): void {
-    if (newHealth !== this.health) {
-      const oldHealth = this.health
-      this.health = newHealth
-      this.logger.info(
-        { from: oldHealth, to: newHealth },
-        'Server health changed',
-      )
-      this.emit('health-change', newHealth)
-    }
-  }
-}

package/src/runtime/server/proxy.ts

@@ -1,119 +0,0 @@
-import type { Logger } from '@nmtjs/core'
-import { Proxy as NeemataProxy } from '@nmtjs/proxy'
-
-import type {
-  ApplicationProxyUpstream,
-  ApplicationServerApplications,
-} from './applications.ts'
-import type { ServerConfig } from './config.ts'
-
-/**
- * Transform ApplicationProxyUpstream to the format expected by Rust proxy.
- */
-function toProxyUpstream(upstream: ApplicationProxyUpstream) {
-  const url = new URL(upstream.url)
-  const secure = url.protocol === 'https:' || url.protocol === 'wss:'
-  const port = url.port ? Number.parseInt(url.port, 10) : secure ? 443 : 80
-
-  return {
-    type: 'port' as const,
-    transport: upstream.type,
-    secure,
-    hostname: url.hostname,
-    port,
-  }
-}
-
-export class ApplicationServerProxy {
-  proxyServer: NeemataProxy
-
-  protected readonly onAdd: (
-    application: string,
-    upstream: ApplicationProxyUpstream,
-  ) => void
-  protected readonly onRemove: (
-    application: string,
-    upstream: ApplicationProxyUpstream,
-  ) => void
-
-  constructor(
-    readonly params: {
-      logger: Logger
-      config: ServerConfig['proxy']
-      applications: ApplicationServerApplications
-    },
-  ) {
-    const { config } = params
-    if (!config) {
-      throw new Error('Proxy config is required')
-    }
-    this.proxyServer = new NeemataProxy({
-      listen: `${config.hostname}:${config.port}`,
-      tls: config.tls
-        ? { keyPath: config.tls.key, certPath: config.tls.cert }
-        : undefined,
-      applications: Object.entries(config.applications)
-        .filter(([_, options]) => options !== undefined)
-        .map(([app, options]) => ({
-          name: app,
-          routing: options!.routing,
-          sni: options!.sni,
-        })),
-    })
-
-    this.onAdd = (application, upstream) => {
-      const proxyUpstream = toProxyUpstream(upstream)
-      this.params.logger.debug(
-        { application, upstream: proxyUpstream },
-        'Adding upstream to proxy',
-      )
-      this.proxyServer
-        .addUpstream(application, proxyUpstream)
-        .catch((error) => {
-          this.params.logger.warn(
-            { error, application, upstream: proxyUpstream },
-            'Failed to add upstream to proxy',
-          )
-        })
-    }
-
-    this.onRemove = (application, upstream) => {
-      const proxyUpstream = toProxyUpstream(upstream)
-      this.params.logger.debug(
-        { application, upstream: proxyUpstream },
-        'Removing upstream from proxy',
-      )
-
-      this.proxyServer
-        .removeUpstream(application, proxyUpstream)
-        .catch((error) => {
-          this.params.logger.warn(
-            { error, application, upstream: proxyUpstream },
-            'Failed to remove upstream from proxy',
-          )
-        })
-    }
-
-    params.applications.on('add', this.onAdd)
-    params.applications.on('remove', this.onRemove)
-  }
-
-  async start() {
-    const { config } = this.params
-    if (!config) {
-      throw new Error('Proxy config is required')
-    }
-    this.params.logger.info(
-      { hostname: config.hostname, port: config.port, threads: config.threads },
-      'Proxy configuration',
-    )
-    await this.proxyServer.start()
-  }
-
-  async stop() {
-    this.params.applications.off('add', this.onAdd)
-    this.params.applications.off('remove', this.onRemove)
-
-    await this.proxyServer.stop()
-  }
-}

package/src/runtime/server/server.ts

@@ -1,218 +0,0 @@
-import type { Logger } from '@nmtjs/core'
-import { createLogger } from '@nmtjs/core'
-
-import type { MetricsServer } from '../metrics/server.ts'
-import type { Store } from '../types.ts'
-import type { ServerConfig } from './config.ts'
-import type { ErrorPolicy } from './error-policy.ts'
-import type { ManagedWorkerConfig } from './managed-worker.ts'
-import type {
-  ApplicationServerRunOptions,
-  ApplicationServerWorkerConfig,
-} from './types.ts'
-import type {
-  ManagedWorkerFactory,
-  WorkerPoolConfig,
-  WorkerPoolFactory,
-} from './worker-pool.ts'
-import { createMetricsServer } from '../metrics/server.ts'
-import { createStoreClient } from '../store/index.ts'
-import { ApplicationServerApplications } from './applications.ts'
-import { DevErrorPolicy } from './error-policy.ts'
-import { ApplicationServerJobs } from './jobs.ts'
-import { ManagedWorker } from './managed-worker.ts'
-import { ApplicationServerProxy } from './proxy.ts'
-import { WorkerPool } from './worker-pool.ts'
-
-/**
- * Default factory for creating ManagedWorker instances.
- */
-export const defaultWorkerFactory: ManagedWorkerFactory = (
-  config: ManagedWorkerConfig,
-  policy: ErrorPolicy,
-  logger: Logger,
-) => new ManagedWorker(config, policy, logger)
-
-/**
- * Default factory for creating WorkerPool instances.
- */
-export const defaultPoolFactory: WorkerPoolFactory = (
-  config: WorkerPoolConfig,
-  policy: ErrorPolicy,
-  workerFactory: ManagedWorkerFactory,
-  logger: Logger,
-) => new WorkerPool(config, policy, workerFactory, logger)
-
-/**
- * ApplicationServer is the main server orchestrator.
- *
- * It manages:
- * - Application worker pools
- * - Job runner pools
- * - Reverse proxy
- * - Store connections
- *
- * The server integrates with ErrorPolicy for proper error handling
- * and uses ManagedWorker for worker lifecycle management.
- */
-export class ApplicationServer {
-  logger: Logger
-
-  applications?: ApplicationServerApplications
-  jobRunners?: ApplicationServerJobs
-
-  proxy?: ApplicationServerProxy
-  store?: Store
-  metrics?: MetricsServer
-
-  constructor(
-    readonly config: ServerConfig,
-    readonly applicationsConfig: Record<
-      string,
-      { type: 'neemata' | 'custom'; specifier: string }
-    >,
-    readonly workerConfig: ApplicationServerWorkerConfig,
-    readonly runOptions: ApplicationServerRunOptions = {
-      applications: Object.keys(config.applications),
-      scheduler: false,
-      jobs: Boolean(config.jobs?.jobs.size),
-    },
-    readonly errorPolicy: ErrorPolicy = DevErrorPolicy,
-    readonly workerFactory: ManagedWorkerFactory = defaultWorkerFactory,
-    readonly poolFactory: WorkerPoolFactory = defaultPoolFactory,
-  ) {
-    this.logger = createLogger(config.logger, 'Server')
-    this.logger.trace(
-      { applications: applicationsConfig, workerConfig, runOptions },
-      'ApplicationServer initialized',
-    )
-  }
-
-  async start() {
-    const { config, logger, errorPolicy, workerFactory, poolFactory } = this
-    logger.info('Starting application server...')
-
-    if (config.metrics) {
-      logger.info('Starting metrics server...')
-      this.metrics = await createMetricsServer(this.logger, config.metrics)
-      await this.metrics.start()
-      logger.debug('Metrics server started')
-    }
-
-    if (config.store) {
-      logger.info('Connecting to store...')
-      this.store = await createStoreClient(config.store)
-      await this.store.connect()
-      logger.debug('Store connected')
-    }
-
-    this.applications = new ApplicationServerApplications({
-      logger: this.logger,
-      workerConfig: this.workerConfig,
-      serverConfig: this.config,
-      applicationsConfig: this.applicationsConfig,
-      applications: this.runOptions.applications,
-      errorPolicy,
-      workerFactory,
-      poolFactory,
-    })
-
-    if (this.runOptions.jobs) {
-      if (!this.store) {
-        throw new Error(
-          'Jobs feature requires a store configuration. ' +
-            'Please configure `store` in your server config or disable jobs.',
-        )
-      }
-      this.jobRunners = new ApplicationServerJobs({
-        logger: this.logger,
-        workerConfig: this.workerConfig,
-        serverConfig: this.config,
-        store: this.store,
-        errorPolicy,
-        workerFactory,
-        poolFactory,
-      })
-    }
-
-    if (this.config.proxy) {
-      this.logger.debug(
-        'Proxy configuration detected, creating a proxy server...',
-      )
-      this.proxy = new ApplicationServerProxy({
-        logger: this.logger,
-        config: this.config.proxy,
-        applications: this.applications,
-      })
-    }
-
-    await this.applications.start()
-
-    if (this.runOptions.jobs) {
-      await this.jobRunners?.start()
-    }
-
-    if (this.runOptions.scheduler && config.jobs?.scheduler) {
-      throw new Error(
-        'JobsScheduler is currently a work in progress and not available. ' +
-          'Scheduled jobs will be supported in a future release.',
-      )
-    }
-
-    if (this.proxy) {
-      logger.info('Starting proxy server...')
-      await this.proxy.start()
-      logger.debug('Proxy server started')
-    }
-
-    logger.info('Application server started')
-  }
-
-  async stop() {
-    this.logger.info('Stopping application server...')
-
-    // Stop proxy + stop accepting new jobs first
-    if (this.proxy) {
-      this.logger.info('Stopping proxy server...')
-      await this.proxy.stop()
-      this.logger.debug('Proxy server stopped')
-    }
-
-    if (this.jobRunners) {
-      this.logger.info('Stopping job runners...')
-      await this.jobRunners.stop()
-      this.logger.debug('Job runners stopped')
-    }
-
-    // Stop applications
-    if (this.applications) {
-      this.logger.info('Stopping applications...')
-      await this.applications.stop()
-      this.logger.debug('Applications stopped')
-    }
-
-    // Close store connection
-    if (this.store) {
-      this.logger.info('Closing store...')
-      this.store.disconnect(false)
-      this.logger.debug('Store disconnected')
-    }
-
-    if (this.metrics) {
-      this.logger.info('Stopping metrics server...')
-      await this.metrics.stop()
-      this.logger.debug('Metrics server stopped')
-    }
-
-    this.logger.info('Application server gracefully stopped')
-  }
-
-  /**
-   * Restart failed workers across all pools.
-   * Called when HMR update comes in and workers may have failed.
-   * @returns Number of workers that were restarted
-   */
-  async restartFailedWorkers(): Promise<number> {
-    return (await this.applications?.restartFailedWorkers()) ?? 0
-  }
-}

package/src/runtime/server/types.ts

@@ -1,32 +0,0 @@
-import type EventEmitter from 'node:events'
-import type { MessagePort, Worker } from 'node:worker_threads'
-
-/**
- * Run options for the ApplicationServer.
- */
-export type ApplicationServerRunOptions = {
-  applications: string[]
-  scheduler: boolean
-  jobs: boolean
-}
-
-export type WorkerRegistration = { worker: Worker; vitePort?: MessagePort }
-
-/**
- * Minimal event map required for worker management.
- * The events emitter may have additional events (like 'hmr-update').
- */
-export type WorkerEventMap = {
-  worker: [registration: WorkerRegistration]
-  [key: string]: any[]
-}
-
-/**
- * Configuration for worker management in ApplicationServer.
- */
-export type ApplicationServerWorkerConfig = {
-  path: string
-  workerData?: any
-  worker?: (registration: WorkerRegistration) => any
-  events?: EventEmitter<WorkerEventMap>
-}