nmtjs 0.16.0 → 0.17.0-beta.1

package/src/runtime/server/config.ts

@@ -1,199 +0,0 @@
-import type {
-  ApplicationHost,
-  ApplicationHostDefinition,
-  TransportOptionsOf,
-} from '@nmtjs/application'
-import type { LoggingOptions } from '@nmtjs/core'
-import type { ApplicationOptions } from '@nmtjs/proxy'
-import type { Applications } from 'nmtjs/runtime/types'
-
-import type { StoreType } from '../enums.ts'
-import type { AnyJob } from '../jobs/job.ts'
-import type { JobsSchedulerOptions } from '../scheduler/index.ts'
-import type { SubscriptionAdapterType } from '../subscription/manager.ts'
-import type { StoreTypeOptions } from '../types.ts'
-import { kServerConfig } from '../constants.ts'
-
-export type ServerPoolOptions = {
-  /**
-   * Number of worker threads
-   */
-  threads: number
-  /**
-   * Max number of jobs per worker
-   */
-  jobs: number
-}
-
-export type ServerStoreConfig =
-  | { type: StoreType.Redis; options: StoreTypeOptions[StoreType.Redis] }
-  | { type: StoreType.Valkey; options: StoreTypeOptions[StoreType.Valkey] }
-
-export type ServerApplicationConfig<T = ApplicationHostDefinition> =
-  T extends ApplicationHostDefinition<any, infer Transports>
-    ? {
-        threads: {
-          [K in keyof Transports]: TransportOptionsOf<Transports[K]>
-        }[]
-      }
-    : T extends ApplicationHost<infer Transports>
-      ? {
-          threads: {
-            [K in keyof Transports]: TransportOptionsOf<Transports[K]>
-          }[]
-        }
-      : any
-
-export type ServerJobsConfig = {
-  pools: Record<string, ServerPoolOptions>
-  jobs?: AnyJob[]
-  /**
-   * @deprecated Scheduler is currently being refactored and is not available.
-   * Using this option will throw an error at startup.
-   */
-  scheduler?: JobsSchedulerOptions
-}
-
-type ServerApplicationDefinitionConfig<T> = T extends {
-  type: 'neemata'
-  definition: infer Definition
-}
-  ? ServerApplicationConfig<Definition>
-  : ServerApplicationConfig<any>
-
-export interface ServerConfigInit {
-  logger: LoggingOptions
-  applications: {
-    [K in keyof Applications]: ServerApplicationDefinitionConfig<
-      Applications[K]
-    >
-  }
-  store?: ServerStoreConfig
-  /**
-   * Proxy configuration. Enabling this will start a reverse proxy server that handles TLS, routing,
-   * load balancing, and health checks for your applications.
-   *
-   * The applications will be accessible via `<hostname>:<port>/<application-name>/**`
-   *
-   * Requires adding `@nmtjs/proxy` package to your dependencies
-   * and [`cargo`](https://doc.rust-lang.org/cargo/getting-started/installation.html) alongside with
-   * [`rustc`](https://www.rust-lang.org/tools/install) to be available globally for building native modules.
-   */
-  proxy?: {
-    port: number
-    hostname: string
-    applications: {
-      [K in keyof Applications]?: Omit<ApplicationOptions, 'name'>
-    }
-    threads?: number
-    healthChecks?: { interval?: number }
-    tls?: { key: string; cert: string }
-  }
-  jobs?: ServerJobsConfig
-  commands?: {}
-  subscription?: { adapter: SubscriptionAdapterType }
-  deploymentId?: string
-  metrics?: {
-    /**
-     * @default '/metrics'
-     */
-    path?: string
-    /**
-     * @default 9187
-     */
-    port?: number
-    /**
-     * @default 0.0.0.0
-     */
-    host?: string
-
-    push?: {
-      /**
-       * Pushgateway URL (including protocol and port)
-       *
-       * @default http://127.0.0.1:9091
-       */
-      url?: string
-      /**
-       * Job name for the pushgateway
-       */
-      name: string
-      /**
-       * Push interval in milliseconds
-       */
-      interval: number
-    }
-  }
-}
-
-export interface ServerConfig {
-  [kServerConfig]: true
-  logger: ServerConfigInit['logger']
-  applications: ServerConfigInit['applications']
-  store: ServerConfigInit['store']
-  /**
-   * Proxy configuration. Enabling this will start a reverse proxy server that handles TLS, routing,
-   * load balancing, and health checks for your applications.
-   *
-   * The applications will be accessible via `<hostname>:<port>/<application-name>/**`
-   *
-   * Requires adding `@nmtjs/proxy` package to your dependencies
-   */
-  proxy: ServerConfigInit['proxy']
-  jobs?: {
-    pools: ServerJobsConfig['pools']
-    jobs: Map<string, AnyJob>
-    /**
-     * @deprecated Scheduler is currently being refactored and is not available.
-     * Using this option will throw an error at startup.
-     */
-    scheduler?: JobsSchedulerOptions
-  }
-  commands?: {}
-  subscription: ServerConfigInit['subscription']
-  deploymentId: ServerConfigInit['deploymentId']
-  metrics?: ServerConfigInit['metrics']
-}
-
-export function defineServer(options: ServerConfigInit): ServerConfig {
-  const {
-    deploymentId,
-    logger,
-    commands,
-    proxy,
-    store,
-    applications,
-    subscription,
-    metrics,
-  } = options
-
-  let jobs: ServerConfig['jobs'] | undefined
-  if (options.jobs) {
-    const map = new Map<string, AnyJob>()
-    for (const job of options.jobs.jobs ?? []) map.set(job.name, job)
-    for (const { job } of options.jobs.scheduler?.entries ?? [])
-      map.set(job.name, job)
-    jobs = {
-      pools: options.jobs.pools,
-      jobs: map,
-      scheduler: options.jobs.scheduler,
-    }
-  }
-
-  return Object.freeze({
-    [kServerConfig]: true,
-    deploymentId,
-    logger,
-    commands,
-    proxy,
-    store,
-    applications,
-    subscription,
-    jobs,
-    metrics,
-  } as const)
-}
-
-export function isServerConfig(value: any): value is ServerConfig {
-  return Boolean(value?.[kServerConfig])
-}

package/src/runtime/server/environment.ts

@@ -1,71 +0,0 @@
-import type { ViteDevServer } from 'vite'
-
-import type { ErrorPolicy } from './error-policy.ts'
-import type { HMRCoordinator } from './hmr-coordinator.ts'
-import { getErrorPolicy } from './error-policy.ts'
-
-/**
- * Encapsulates everything that differs between Dev and Prod environments.
- * This provides a clean abstraction over environment-specific behavior.
- */
-export interface RuntimeEnvironment {
-  readonly mode: 'development' | 'production'
-  readonly errorPolicy: ErrorPolicy
-  readonly hmr: HMRCoordinator | null // null in prod
-  readonly vite: ViteDevServer | null // null in prod
-}
-
-/**
- * Options for creating a development environment.
- */
-export interface DevEnvironmentOptions {
-  vite?: ViteDevServer
-  hmr?: HMRCoordinator
-}
-
-/**
- * Creates a RuntimeEnvironment for the given mode.
- *
- * @param mode - 'development' or 'production'
- * @param options - Optional configuration (vite server for dev mode)
- */
-export function createRuntimeEnvironment(
-  mode: 'development' | 'production',
-  options?: DevEnvironmentOptions,
-): RuntimeEnvironment {
-  const errorPolicy = getErrorPolicy(mode)
-
-  if (mode === 'development') {
-    return {
-      mode,
-      errorPolicy,
-      hmr: options?.hmr ?? null,
-      vite: options?.vite ?? null,
-    }
-  }
-
-  // Production mode - no HMR or Vite
-  return { mode, errorPolicy, hmr: null, vite: null }
-}
-
-/**
- * Type guard to check if environment is development mode.
- */
-export function isDevEnvironment(
-  env: RuntimeEnvironment,
-): env is RuntimeEnvironment & {
-  mode: 'development'
-  hmr: HMRCoordinator | null
-  vite: ViteDevServer | null
-} {
-  return env.mode === 'development'
-}
-
-/**
- * Type guard to check if environment is production mode.
- */
-export function isProdEnvironment(
-  env: RuntimeEnvironment,
-): env is RuntimeEnvironment & { mode: 'production'; hmr: null; vite: null } {
-  return env.mode === 'production'
-}

package/src/runtime/server/error-policy.ts

@@ -1,132 +0,0 @@
-import type { WorkerType } from '../enums.ts'
-
-/**
- * Context provided to error policy decisions about worker failures.
- */
-export interface WorkerErrorContext {
-  workerId: string
-  workerType: WorkerType
-  consecutiveFailures: number
-  totalFailures: number
-  lastStableTime: number | null
-}
-
-/**
- * Actions that can be taken in response to errors.
- */
-export type ErrorAction =
-  | { type: 'exit'; code: number }
-  | { type: 'restart'; delay: number }
-  | { type: 'wait' } // Dev only: wait for HMR fix
-  | { type: 'ignore' }
-
-/**
- * Interface defining error handling behavior for different environments.
- * Dev and Prod modes have different requirements and this interface makes those explicit.
- */
-export interface ErrorPolicy {
-  /** How to handle server startup failure */
-  onStartupError(error: Error): ErrorAction
-
-  /** How to handle worker crash */
-  onWorkerError(error: Error, context: WorkerErrorContext): ErrorAction
-
-  /** Delay before restarting a failed worker */
-  getRestartDelay(consecutiveFailures: number): number
-
-  /** Whether to continue if some workers are down */
-  readonly allowDegradedMode: boolean
-}
-
-/**
- * Calculates exponential backoff delay with a cap.
- * @param failures - Number of consecutive failures
- * @param base - Base delay in ms (default: 100)
- * @param maxDelay - Maximum delay in ms (default: 5000)
- */
-function exponentialBackoff(
-  failures: number,
-  base = 100,
-  maxDelay = 5000,
-): number {
-  return Math.min(base * 2 ** Math.max(0, failures - 1), maxDelay)
-}
-
-/**
- * Time window in ms after which a worker is considered "stable".
- * If stable, consecutive failure count is reset on next error.
- */
-const STABILITY_WINDOW_MS = 30_000
-
-/**
- * Maximum retries before giving up in dev mode.
- */
-const DEV_MAX_RETRIES = 1
-
-/**
- * Maximum retries before exiting in prod mode.
- */
-const PROD_MAX_RETRIES = 3
-
-/**
- * Development Error Policy
- *
- * - Startup errors: Wait for HMR fix (don't exit)
- * - Worker errors: Restart with exponential backoff
- * - After 10 consecutive failures: Stop retrying, wait for HMR fix
- * - Stability window: Reset failure count if worker was stable for 30s+
- * - Degraded mode: Allowed (keep serving with partial workers)
- */
-export const DevErrorPolicy: ErrorPolicy = {
-  onStartupError: () => ({ type: 'wait' }),
-
-  onWorkerError: (_error, ctx) => {
-    // Check if worker was stable before this failure
-    const wasStable =
-      ctx.lastStableTime !== null &&
-      Date.now() - ctx.lastStableTime > STABILITY_WINDOW_MS
-
-    // Reset failure count if was stable
-    const effectiveFailures = wasStable ? 1 : ctx.consecutiveFailures
-
-    if (effectiveFailures >= DEV_MAX_RETRIES) {
-      return { type: 'wait' } // Stop trying, wait for HMR fix
-    }
-
-    return { type: 'restart', delay: exponentialBackoff(effectiveFailures) }
-  },
-
-  getRestartDelay: (n) => exponentialBackoff(n),
-  allowDegradedMode: true,
-}
-
-/**
- * Production Error Policy
- *
- * - Startup errors: Exit immediately with code 1
- * - Worker errors: Restart up to 3 times, then exit
- * - No stability window consideration (each failure counts)
- * - Degraded mode: Not allowed (all workers must be healthy)
- */
-export const ProdErrorPolicy: ErrorPolicy = {
-  onStartupError: () => ({ type: 'exit', code: 1 }),
-
-  onWorkerError: (_error, ctx) => {
-    if (ctx.consecutiveFailures >= PROD_MAX_RETRIES) {
-      return { type: 'exit', code: 1 }
-    }
-    return { type: 'restart', delay: 1000 }
-  },
-
-  getRestartDelay: () => 1000,
-  allowDegradedMode: false,
-}
-
-/**
- * Get the appropriate error policy for the given mode.
- */
-export function getErrorPolicy(
-  mode: 'development' | 'production',
-): ErrorPolicy {
-  return mode === 'development' ? DevErrorPolicy : ProdErrorPolicy
-}

package/src/runtime/server/hmr-coordinator.ts

@@ -1,116 +0,0 @@
-import type { Logger } from '@nmtjs/core'
-
-import type { ServerLifecycle } from './lifecycle.ts'
-
-/**
- * HMRCoordinator handles HMR (Hot Module Replacement) with proper supersede logic.
- *
- * When a reload is in progress and another HMR event arrives, the pending reload
- * is superseded by the latest - only the most recent config is applied.
- *
- * This component is only used in development mode.
- */
-export class HMRCoordinator {
-  /** Currently executing reload, if any */
-  private active: Promise<void> | null = null
-
-  /** Pending reload - only the latest request is kept */
-  private pendingResolvers: {
-    resolve: () => void
-    reject: (e: Error) => void
-  } | null = null
-
-  /** Whether a reload is pending after the current one completes */
-  private hasPending = false
-
-  private logger: Logger
-
-  constructor(
-    private readonly lifecycle: ServerLifecycle,
-    logger: Logger,
-  ) {
-    this.logger = logger.child({ component: 'HMRCoordinator' })
-  }
-
-  /**
-   * Schedule a reload. If a reload is already in progress, supersedes any pending reload.
-   *
-   * @returns Promise that resolves when this reload completes (or is superseded)
-   */
-  async scheduleReload(): Promise<void> {
-    // If no active reload, execute immediately
-    if (!this.active) {
-      return this.executeReload()
-    }
-
-    // Supersede any existing pending reload - resolve previous waiter
-    if (this.pendingResolvers) {
-      this.logger.debug('Superseding pending reload with new request')
-      this.pendingResolvers.resolve()
-    }
-
-    // Mark that we have a pending reload
-    this.hasPending = true
-
-    // Create new pending promise for this caller
-    return new Promise((resolve, reject) => {
-      this.pendingResolvers = { resolve, reject }
-    })
-  }
-
-  /**
-   * Execute a reload, handling the pending queue.
-   */
-  private async executeReload(): Promise<void> {
-    this.logger.debug('HMR reload starting')
-
-    this.active = this.doReload()
-
-    try {
-      await this.active
-      this.logger.debug('HMR reload complete')
-    } finally {
-      this.active = null
-
-      // If there's a pending reload, execute it now
-      if (this.hasPending && this.pendingResolvers) {
-        const { resolve, reject } = this.pendingResolvers
-        this.pendingResolvers = null
-        this.hasPending = false
-        this.executeReload().then(resolve, reject)
-      }
-    }
-  }
-
-  /**
-   * Perform the actual reload via the lifecycle.
-   */
-  private async doReload(): Promise<void> {
-    // Check if lifecycle can reload
-    if (this.lifecycle.canReload) {
-      await this.lifecycle.reload()
-    } else if (this.lifecycle.canStart) {
-      // If in failed/idle state, try to start
-      await this.lifecycle.start()
-    } else {
-      this.logger.warn(
-        { state: this.lifecycle.currentState },
-        'Cannot reload in current state',
-      )
-    }
-  }
-
-  /**
-   * Check if a reload is currently in progress.
-   */
-  get isReloading(): boolean {
-    return this.active !== null
-  }
-
-  /**
-   * Check if there's a pending reload waiting.
-   */
-  get isPending(): boolean {
-    return this.hasPending
-  }
-}