nmtjs 0.16.1 → 0.17.0-beta.2

package/src/runtime/jobs/types.ts

@@ -1,116 +0,0 @@
-// ============================================================================
-// Job Definition Types (metadata about job structure)
-// ============================================================================
-
-/** Metadata about a job step in a job definition */
-export interface JobStepInfo {
-  /** Optional human-readable label for the step */
-  label?: string
-  /** Whether this step has a condition that may skip it */
-  conditional: boolean
-  /** Whether this step executes in a parallel group */
-  parallel: boolean
-}
-
-/** Metadata about a job definition (not a running job instance) */
-export interface JobDefinitionInfo {
-  /** Job name from definition */
-  name: string
-  /** Information about each step in the job */
-  steps: JobStepInfo[]
-}
-
-// ============================================================================
-// Job Execution Types (runtime state of a running job)
-// ============================================================================
-
-/** Result of a single step execution */
-export interface StepResultEntry {
-  /** Output data produced by the step, or null if skipped */
-  data: Record<string, unknown> | null
-  /** Timestamp when step started (ms since epoch) */
-  startedAt: number
-  /** Timestamp when step completed (ms since epoch) */
-  completedAt: number
-  /** Duration in milliseconds (completedAt - startedAt) */
-  duration: number
-}
-
-/** Checkpoint data persisted for job resume support */
-export interface JobProgressCheckpoint {
-  /** Index of the next step to execute (0 = not started, length = completed) */
-  stepIndex: number
-  /** Label of the next step to execute, if labeled */
-  stepLabel?: string
-  /** Accumulated result from all completed steps */
-  result: Record<string, unknown>
-  /** Results of each individual step */
-  stepResults: StepResultEntry[]
-  /** User-defined progress state */
-  progress: Record<string, unknown>
-}
-
-/** Information about the currently executing job, available via injectable */
-export interface JobExecutionContext {
-  /** Job definition name */
-  name: string
-  /** Queue job ID */
-  id?: string
-  /** Queue name */
-  queue?: string
-  /** Number of attempts made so far */
-  attempts?: number
-  /** Current step index being executed */
-  stepIndex?: number
-}
-
-// ============================================================================
-// Job Item Types (job instances from queue)
-// ============================================================================
-
-/** Vendor-agnostic job status */
-export type JobStatus =
-  | 'pending' // Queued, waiting to be picked up
-  | 'active' // Currently executing
-  | 'completed' // Successfully finished
-  | 'failed' // Failed (may retry)
-  | 'delayed' // Scheduled for future
-  | 'cancelled' // Manually cancelled
-  | 'unknown' // State cannot be determined
-
-/** A job instance retrieved from the queue */
-export interface JobItem<TInput = unknown, TOutput = unknown> {
-  /** Unique job instance ID */
-  id: string
-  /** Job definition name */
-  name: string
-  /** Queue name this job belongs to */
-  queue: string
-  /** Input data passed to the job */
-  data: TInput
-  /** Output produced by the job (if completed) */
-  output?: TOutput | null
-  /** Current job status */
-  status: JobStatus
-  /** Job priority (lower = higher priority) */
-  priority?: number
-  /** Job progress checkpoint (includes step state and user progress) */
-  progress?: JobProgressCheckpoint
-  /** Number of execution attempts */
-  attempts: number
-  /** Timestamp when job started processing (ms) */
-  startedAt?: number
-  /** Timestamp when job completed (ms) */
-  completedAt?: number
-  /** Error message if job failed */
-  error?: string
-  /** Stack trace if job failed */
-  stacktrace: string[] | null
-}
-
-// ============================================================================
-// Injectable Types
-// ============================================================================
-
-/** Function to manually trigger saving job progress state */
-export type SaveJobProgress = () => Promise<void>

package/src/runtime/metrics/metric.ts

@@ -1,18 +0,0 @@
-import type { ClassConstructorArgs } from '@nmtjs/common'
-import type { Metric, MetricConfiguration } from '@nmtjs/prom-client'
-import { Counter, Gauge, Histogram, Summary } from '@nmtjs/prom-client'
-
-import { registry } from './registry.ts'
-
-export const createMetric =
-  <T extends Metric>(contructor: new (config: MetricConfiguration<any>) => T) =>
-  (config: ClassConstructorArgs<T>[0]): T =>
-    new contructor({
-      ...config,
-      registers: [...(config.registers ?? []), registry],
-    })
-
-export const createCounterMetric = createMetric(Counter)
-export const createGaugeMetric = createMetric(Gauge)
-export const createHistogramMetric = createMetric(Histogram)
-export const createSummaryMetric = createMetric(Summary)

package/src/runtime/metrics/registry.ts

@@ -1,11 +0,0 @@
-import {
-  collectDefaultMetrics,
-  register,
-  WorkerRegistry,
-} from '@nmtjs/prom-client'
-
-export const workerRegistry = new WorkerRegistry()
-
-export const registry = register
-
-collectDefaultMetrics()

package/src/runtime/metrics/server.ts

@@ -1,69 +0,0 @@
-import { createServer } from 'node:http'
-
-import type { Logger } from '@nmtjs/core'
-import { Pushgateway } from '@nmtjs/prom-client'
-
-import type { ServerConfig } from '../server/config.ts'
-
-export async function createMetricsServer(
-  logger: Logger,
-  config: Exclude<ServerConfig['metrics'], undefined>,
-) {
-  const { workerRegistry: registry } = await import('./registry.ts')
-  const { host = '0.0.0.0', port = 9187, path = '/metrics', push } = config
-
-  let intervalRef: any
-
-  if (push) {
-    const { url = 'http://127.0.0.1:9091', interval, name: jobName } = push
-    const gateway = new Pushgateway(url, {}, registry)
-    intervalRef = setInterval(() => {
-      gateway
-        .pushAdd({ jobName })
-        .catch((cause) =>
-          logger.error(new Error('Metrics push error', { cause })),
-        )
-    }, interval)
-  }
-
-  const server = createServer((req, res) => {
-    const url = new URL(`http://${req.headers.host || 'localhost'}${req.url}`)
-    if (url.pathname === path) {
-      res.setHeader('Content-Type', registry.contentType)
-      registry
-        .workerMetrics()
-        .then((metrics) => {
-          res.writeHead(200)
-          res.end(metrics)
-        })
-        .catch((cause) => {
-          logger.error(new Error('Metrics collection error', { cause }))
-          res.writeHead(500)
-          res.end('Internal Server Error')
-        })
-    } else {
-      res.writeHead(404)
-      res.end('Not Found')
-    }
-  })
-
-  return {
-    start: () =>
-      new Promise<void>((resolve) =>
-        server.listen({ host: host, port: port }, resolve),
-      ),
-    stop: () =>
-      new Promise<void>((resolve, reject) => {
-        if (intervalRef) clearInterval(intervalRef)
-        server.close((err) => {
-          if (err) {
-            reject(err)
-          } else {
-            resolve()
-          }
-        })
-      }),
-  }
-}
-
-export type MetricsServer = Awaited<ReturnType<typeof createMetricsServer>>

package/src/runtime/plugin.ts

@@ -1,2 +0,0 @@
-export type { RuntimePlugin } from '@nmtjs/application'
-export { createPlugin } from '@nmtjs/application'

package/src/runtime/runtime.ts

@@ -1,103 +0,0 @@
-import type { RuntimePlugin } from '@nmtjs/application'
-import type {
-  AnyInjectable,
-  Dependant,
-  Logger,
-  LoggingOptions,
-} from '@nmtjs/core'
-import { LifecycleHook, LifecycleHooks } from '@nmtjs/application'
-import {
-  Container,
-  createLogger,
-  getDepedencencyInjectable,
-  Scope,
-} from '@nmtjs/core'
-
-export type BaseRuntimeOptions = {
-  logger?: LoggingOptions
-  container?: Container
-  plugins?: RuntimePlugin[]
-  name?: string
-}
-
-export abstract class BaseRuntime {
-  logger: Logger
-  container: Container
-  lifecycleHooks: LifecycleHooks
-  plugins: RuntimePlugin[]
-
-  constructor(options: BaseRuntimeOptions = {}) {
-    this.logger = createLogger(options.logger, options.name || 'Runtime')
-    this.container = options.container
-      ? options.container.fork(Scope.Global)
-      : new Container({ logger: this.logger })
-    this.lifecycleHooks = new LifecycleHooks()
-    this.plugins = options.plugins || []
-  }
-
-  protected abstract _initialize(): Promise<void>
-  protected abstract _dispose(): Promise<void>
-  protected abstract _dependents(): Generator<Dependant>
-
-  async reload(...args: any[]): Promise<void> {
-    await this._dispose()
-    await this._initialize()
-  }
-
-  async initialize() {
-    this.logger.debug('Initializing a runtime...')
-    await this._initializePlugins()
-    await this._initializeContainer()
-    await this.lifecycleHooks.callHook(LifecycleHook.BeforeInitialize, this)
-    await this._initialize()
-    await this.lifecycleHooks.callHook(LifecycleHook.AfterInitialize, this)
-    this.logger.debug('Runtime initialized')
-  }
-
-  async dispose() {
-    this.logger.debug('Disposing a runtime...')
-    await this.lifecycleHooks.callHook(LifecycleHook.BeforeDispose, this)
-    await this._dispose()
-    await this.lifecycleHooks.callHook(LifecycleHook.AfterDispose, this)
-    await this._disposeContainer()
-    await this._disposePlugins()
-    this.logger.debug('Runtime disposed')
-  }
-
-  protected async _initializePlugins() {
-    if (!this.plugins?.length) return
-    for (const { name, hooks, injections } of this.plugins) {
-      this.logger.debug(`Initializing plugin [${name}]...`)
-      if (injections) this.container.provide(injections)
-      if (hooks) this.lifecycleHooks.addHooks(hooks)
-    }
-  }
-
-  protected async _disposePlugins() {
-    if (!this.plugins?.length) return
-    for (const { name, hooks, injections } of this.plugins) {
-      this.logger.debug(`Disposing plugin [${name}]...`)
-      if (hooks) this.lifecycleHooks.removeHooks(hooks)
-      if (injections) {
-        for (const injection of injections) {
-          await this.container.disposeInjectableInstances(injection.token)
-        }
-      }
-    }
-  }
-
-  protected async _initializeContainer() {
-    const dependents = this._dependents()
-    const dependencies = new Set<AnyInjectable>()
-    for (const dependant of dependents) {
-      for (const dependency of Object.values(dependant.dependencies)) {
-        dependencies.add(getDepedencencyInjectable(dependency))
-      }
-    }
-    await this.container.initialize(dependencies)
-  }
-
-  protected async _disposeContainer() {
-    await this.container.dispose()
-  }
-}

package/src/runtime/scheduler/index.ts

@@ -1,39 +0,0 @@
-import type { AnyJob } from '../jobs/job.ts'
-
-export interface JobsSchedulerEntry<T extends AnyJob = AnyJob> {
-  job: T
-  data: T['_']['input']
-  cron: string
-}
-
-export type JobsSchedulerOptions = { entries: JobsSchedulerEntry[] }
-
-/**
- * @deprecated Job scheduler is currently being refactored and is not available.
- * This will throw an error if instantiated.
- */
-export class JobsScheduler {
-  constructor() {
-    throw new Error(
-      'JobsScheduler is currently a work in progress and not available. ' +
-        'Scheduled jobs will be supported in a future release.',
-    )
-  }
-
-  async initialize() {}
-  async stop() {}
-}
-
-/**
- * @deprecated Job scheduler is currently being refactored and is not available.
- */
-export function createSchedulerJobEntry<T extends AnyJob>(
-  job: T,
-  data: T['_']['input'],
-  cron: string,
-): JobsSchedulerEntry<T> {
-  throw new Error(
-    'createSchedulerJobEntry is currently a work in progress and not available. ' +
-      'Scheduled jobs will be supported in a future release.',
-  )
-}

package/src/runtime/server/applications.ts

@@ -1,264 +0,0 @@
-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 { ErrorPolicy } from './error-policy.ts'
-import type { ManagedWorker } from './managed-worker.ts'
-import type { ApplicationServerWorkerConfig } from './types.ts'
-import type {
-  ManagedWorkerFactory,
-  WorkerPool,
-  WorkerPoolConfig,
-  WorkerPoolFactory,
-} from './worker-pool.ts'
-import { WorkerType } from '../enums.ts'
-
-export type ApplicationProxyUpstream = {
-  type: ProxyableTransportType
-  url: string
-}
-
-/**
- * ApplicationServerApplications manages all application worker pools.
- *
- * Changes from the old Pool-based implementation:
- * - Uses WorkerPool for each application (isolated failure domains)
- * - Uses ManagedWorker for restart logic and state tracking
- * - Integrates with ErrorPolicy for restart decisions
- * - Proper health tracking per application
- */
-export class ApplicationServerApplications extends EventEmitter<{
-  add: [application: string, upstream: ApplicationProxyUpstream]
-  remove: [application: string, upstream: ApplicationProxyUpstream]
-}> {
-  /** Worker pools per application */
-  private pools = new Map<string, WorkerPool>()
-
-  /** Upstreams for proxy routing */
-  protected readonly upstreams = new Map<
-    string,
-    Map<string, { upstream: ApplicationProxyUpstream; count: number }>
-  >()
-
-  /** Track upstreams by worker for cleanup */
-  protected readonly upstreamsByWorker = new WeakMap<
-    ManagedWorker,
-    Array<{ application: string; key: string }>
-  >()
-
-  constructor(
-    readonly params: {
-      logger: Logger
-      applications: string[]
-      workerConfig: ApplicationServerWorkerConfig
-      applicationsConfig: Record<
-        string,
-        { type: 'neemata' | 'custom'; specifier: string }
-      >
-      serverConfig: ServerConfig
-      errorPolicy: ErrorPolicy
-      workerFactory: ManagedWorkerFactory
-      poolFactory: WorkerPoolFactory
-    },
-  ) {
-    super()
-  }
-
-  get appsNames() {
-    return this.params.applications
-  }
-
-  /**
-   * Start all application workers.
-   */
-  async start() {
-    const {
-      logger,
-      applications,
-      applicationsConfig,
-      serverConfig,
-      workerConfig,
-      errorPolicy,
-      workerFactory,
-      poolFactory,
-    } = this.params
-
-    for (const applicationName of applications) {
-      const applicationPath = applicationsConfig[applicationName]
-      if (!applicationPath) {
-        logger.warn(
-          `Application [${applicationName}] not found in applicationsConfig, skipping...`,
-        )
-        continue
-      }
-
-      const applicationConfig = serverConfig.applications[
-        applicationName
-      ] as ServerApplicationConfig
-
-      const threadsConfig = Array.isArray(applicationConfig.threads)
-        ? applicationConfig.threads
-        : new Array(applicationConfig.threads).fill(undefined)
-
-      logger.debug(
-        `Spinning [${threadsConfig.length}] workers for [${applicationName}] application...`,
-      )
-
-      // Create a WorkerPool for this application
-      const poolConfig: WorkerPoolConfig = {
-        name: `application-${applicationName}`,
-        workerType: WorkerType.Application,
-        path: workerConfig.path,
-        workerData: { ...workerConfig.workerData },
-        onWorker: workerConfig.worker,
-      }
-
-      const pool = poolFactory(poolConfig, errorPolicy, workerFactory, logger)
-
-      // Add workers to the pool
-      for (let i = 0; i < threadsConfig.length; i++) {
-        if (applicationPath.type !== 'neemata') {
-          throw new Error(
-            `Unsupported custom application worker: ${applicationName}`,
-          )
-        }
-
-        const workerData = {
-          runtime: {
-            type: 'application',
-            name: applicationName,
-            path: applicationPath.specifier,
-            transportsData: threadsConfig[i],
-          },
-        }
-
-        const worker = pool.add(workerData, i)
-
-        // Handle worker ready - update upstreams
-        worker.on('ready', (hosts) => {
-          this.removeWorkerUpstreams(worker)
-
-          const keys: Array<{ application: string; key: string }> = []
-          const sanitizedHosts: ThreadPortMessageTypes['ready']['hosts'] = []
-
-          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 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)
-            }
-          }
-
-          this.upstreamsByWorker.set(worker, keys)
-        })
-
-        // Handle worker error - clean up upstreams
-        worker.on('error', (_error: WorkerThreadError) => {
-          this.removeWorkerUpstreams(worker)
-        })
-
-        // Handle worker state changes for upstream cleanup
-        worker.on('state-change', (from, to) => {
-          if (to === 'stopping' || to === 'stopped' || to === 'error') {
-            this.removeWorkerUpstreams(worker)
-          }
-        })
-      }
-
-      this.pools.set(applicationName, pool)
-    }
-
-    // Start all pools
-    await Promise.all([...this.pools.values()].map((p) => p.startAll()))
-  }
-
-  /**
-   * Stop all application workers.
-   */
-  async stop() {
-    await Promise.all([...this.pools.values()].map((p) => p.stopAll()))
-    this.pools.clear()
-  }
-
-  /**
-   * 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> {
-    let total = 0
-    for (const pool of this.pools.values()) {
-      total += await pool.restartFailedWorkers()
-    }
-    return total
-  }
-
-  /**
-   * Get pool for an application.
-   */
-  getPool(applicationName: string): WorkerPool | undefined {
-    return this.pools.get(applicationName)
-  }
-
-  /**
-   * Add an upstream for proxy routing.
-   */
-  protected addUpstream(
-    application: string,
-    key: string,
-    upstream: ApplicationProxyUpstream,
-  ) {
-    let appUpstreams = this.upstreams.get(application)
-    if (!appUpstreams) {
-      appUpstreams = new Map()
-      this.upstreams.set(application, appUpstreams)
-    }
-
-    const current = appUpstreams.get(key)
-    if (!current) {
-      appUpstreams.set(key, { upstream, count: 1 })
-      this.emit('add', application, upstream)
-      return
-    }
-
-    current.count++
-  }
-
-  /**
-   * Remove upstreams associated with a worker.
-   */
-  protected removeWorkerUpstreams(worker: ManagedWorker) {
-    const keys = this.upstreamsByWorker.get(worker)
-    if (!keys) return
-    this.upstreamsByWorker.delete(worker)
-
-    for (const { application, key } of keys) {
-      const appUpstreams = this.upstreams.get(application)
-      const current = appUpstreams?.get(key)
-      if (!current) continue
-
-      current.count--
-      if (current.count <= 0) {
-        appUpstreams?.delete(key)
-        this.emit('remove', application, current.upstream)
-      }
-      if (appUpstreams && appUpstreams.size === 0) {
-        this.upstreams.delete(application)
-      }
-    }
-  }
-}