nmtjs 0.16.1 → 0.17.0-beta.2

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

@@ -1,275 +0,0 @@
-import EventEmitter from 'node:events'
-
-import type { Logger } from '@nmtjs/core'
-
-import type { WorkerType } from '../enums.ts'
-import type { JobTaskResult, WorkerJobTask } from '../types.ts'
-import type { ErrorPolicy } from './error-policy.ts'
-import type {
-  ManagedWorker,
-  ManagedWorkerConfig,
-  WorkerState,
-} from './managed-worker.ts'
-import type { WorkerRegistration } from './types.ts'
-
-/**
- * Health states for a worker pool.
- */
-export type PoolHealth = 'healthy' | 'degraded' | 'unhealthy'
-
-/**
- * Report on pool health status.
- */
-export interface PoolHealthReport {
-  poolName: string
-  overall: PoolHealth
-  healthy: number
-  total: number
-  workers: Array<{
-    id: string
-    state: WorkerState
-    consecutiveFailures: number
-    totalFailures: number
-  }>
-}
-
-/**
- * Configuration for creating a worker pool.
- */
-export interface WorkerPoolConfig {
-  name: string
-  workerType: WorkerType
-  path: string
-  workerData?: any
-  onWorker?: (registration: WorkerRegistration) => void
-}
-
-/**
- * Events emitted by WorkerPool.
- */
-export interface WorkerPoolEvents {
-  'health-change': [health: PoolHealth]
-}
-
-/**
- * Factory function for creating ManagedWorker instances.
- * This allows for dependency injection and testing.
- */
-export type ManagedWorkerFactory = (
-  config: ManagedWorkerConfig,
-  policy: ErrorPolicy,
-  logger: Logger,
-) => ManagedWorker
-
-/**
- * Factory function for creating WorkerPool instances.
- * This allows for dependency injection and testing.
- */
-export type WorkerPoolFactory = (
-  config: WorkerPoolConfig,
-  policy: ErrorPolicy,
-  workerFactory: ManagedWorkerFactory,
-  logger: Logger,
-) => WorkerPool
-
-/**
- * WorkerPool manages a collection of workers for a single application or job pool.
- *
- * Features:
- * - Health tracking with three states: healthy, degraded, unhealthy
- * - Integration with ErrorPolicy for degraded mode decisions
- * - Worker lifecycle management (start, stop)
- * - Health reports for debugging and monitoring
- *
- * Each application gets its own WorkerPool for isolated failure domains.
- */
-export class WorkerPool extends EventEmitter<WorkerPoolEvents> {
-  private workers: ManagedWorker[] = []
-  private health: PoolHealth = 'healthy'
-  private logger: Logger
-
-  constructor(
-    readonly config: WorkerPoolConfig,
-    private readonly policy: ErrorPolicy,
-    private readonly workerFactory: ManagedWorkerFactory,
-    logger: Logger,
-  ) {
-    super()
-    this.logger = logger.child({ component: 'WorkerPool', pool: config.name })
-  }
-
-  /** Current pool health */
-  get currentHealth(): PoolHealth {
-    return this.health
-  }
-
-  /** Total number of workers in the pool */
-  get workerCount(): number {
-    return this.workers.length
-  }
-
-  /** Number of healthy (ready) workers */
-  get healthyCount(): number {
-    return this.workers.filter((w) => w.isHealthy).length
-  }
-
-  /** Get all workers in this pool */
-  getWorkers(): readonly ManagedWorker[] {
-    return this.workers
-  }
-
-  /**
-   * Add a worker to the pool.
-   *
-   * @param workerData - Additional data to pass to the worker
-   * @param index - Worker index (used for naming)
-   * @returns The created ManagedWorker
-   */
-  add(workerData: any, index: number): ManagedWorker {
-    const { config } = this
-
-    const workerConfig: ManagedWorkerConfig = {
-      id: `${config.name}-${index + 1}`,
-      name: config.name,
-      index,
-      workerType: config.workerType,
-      path: config.path,
-      workerData: { ...config.workerData, ...workerData },
-      onWorker: config.onWorker,
-    }
-
-    const worker = this.workerFactory(workerConfig, this.policy, this.logger)
-
-    worker.on('state-change', () => this.updateHealth())
-
-    this.workers.push(worker)
-    return worker
-  }
-
-  /**
-   * Start all workers in the pool.
-   */
-  async startAll(): Promise<void> {
-    this.logger.debug({ count: this.workers.length }, 'Starting all workers')
-    await Promise.all(this.workers.map((w) => w.start()))
-    this.logger.debug({ count: this.workers.length }, 'All workers started')
-  }
-
-  /**
-   * Restart workers that are in error state.
-   * Called when HMR update comes in and there are failed workers.
-   * @returns Number of workers that were restarted
-   */
-  async restartFailedWorkers(): Promise<number> {
-    const failedWorkers = this.workers.filter((w) => w.currentState === 'error')
-    if (failedWorkers.length === 0) return 0
-
-    this.logger.debug(
-      { count: failedWorkers.length },
-      'Restarting failed workers after HMR update',
-    )
-
-    // Reset failure counts before restarting
-    for (const worker of failedWorkers) {
-      worker.resetFailureCount()
-    }
-
-    await Promise.all(failedWorkers.map((w) => w.start()))
-    return failedWorkers.length
-  }
-
-  /**
-   * Stop all workers in the pool and clean up.
-   */
-  async stopAll(): Promise<void> {
-    this.logger.debug({ count: this.workers.length }, 'Stopping all workers')
-
-    // Remove all event listeners from workers before stopping
-    for (const worker of this.workers) {
-      worker.removeAllListeners()
-    }
-
-    await Promise.all(this.workers.map((w) => w.stop()))
-
-    // Clear workers array
-    this.workers = []
-
-    // Remove all listeners from the pool itself
-    this.removeAllListeners()
-
-    this.logger.debug('All workers stopped and cleaned up')
-  }
-
-  /**
-   * Get a health report for this pool.
-   */
-  getHealthReport(): PoolHealthReport {
-    return {
-      poolName: this.config.name,
-      overall: this.health,
-      healthy: this.healthyCount,
-      total: this.workerCount,
-      workers: this.workers.map((w) => ({
-        id: w.config.id,
-        state: w.currentState,
-        consecutiveFailures: w.context.consecutiveFailures,
-        totalFailures: w.context.totalFailures,
-      })),
-    }
-  }
-
-  /**
-   * Update pool health based on worker states.
-   */
-  private updateHealth(): void {
-    const readyCount = this.healthyCount
-    const total = this.workerCount
-
-    let newHealth: PoolHealth
-    if (readyCount === total) {
-      newHealth = 'healthy'
-    } else if (readyCount > 0 && this.policy.allowDegradedMode) {
-      newHealth = 'degraded'
-    } else {
-      newHealth = 'unhealthy'
-    }
-
-    if (newHealth !== this.health) {
-      const oldHealth = this.health
-      this.health = newHealth
-      this.logger.trace(
-        { from: oldHealth, to: newHealth, ready: readyCount, total },
-        'Pool health changed',
-      )
-      this.emit('health-change', newHealth)
-    }
-  }
-}
-
-/**
- * JobRunnersPool extends WorkerPool with round-robin task execution.
- * Used for job worker pools where tasks need to be distributed across workers.
- */
-export class JobRunnersPool extends WorkerPool {
-  private runIndex = 0
-
-  /**
-   * Run a task on the next available worker (round-robin).
-   */
-  async run(task: WorkerJobTask): Promise<JobTaskResult> {
-    const workers = this.getWorkers()
-    const healthyWorkers = workers.filter((w) => w.isHealthy)
-
-    if (healthyWorkers.length === 0) {
-      throw new Error('No healthy job runner threads available')
-    }
-
-    if (this.runIndex >= healthyWorkers.length) {
-      this.runIndex = 0
-    }
-
-    const worker = healthyWorkers[this.runIndex]!
-    this.runIndex++
-    return await worker.run(task)
-  }
-}

package/src/runtime/store/index.ts

@@ -1,30 +0,0 @@
-import type { ServerStoreConfig } from '../server/config.ts'
-import type { StoreTypes } from '../types.ts'
-import { StoreType } from '../enums.ts'
-
-export async function createStoreClient<T extends ServerStoreConfig>(
-  config: T,
-): Promise<StoreTypes[T['type']]> {
-  if (config.type === StoreType.Redis) {
-    const { Redis } = await import('ioredis').catch(() => {
-      throw new Error(
-        'ioredis package is not installed. Please install it to use Redis store.',
-      )
-    })
-    return new Redis({
-      ...config.options,
-      lazyConnect: true,
-    }) as StoreTypes[T['type']]
-  } else if (config.type === StoreType.Valkey) {
-    const { Redis } = await import('iovalkey').catch(() => {
-      throw new Error(
-        'iovalkey package is not installed. Please install it to use Valkey store.',
-      )
-    })
-    return new Redis({
-      ...config.options,
-      lazyConnect: true,
-    }) as StoreTypes[T['type']]
-  }
-  throw new Error('Unsupported store')
-}

package/src/runtime/subscription/manager.ts

@@ -1,307 +0,0 @@
-import assert from 'node:assert'
-import { createHash } from 'node:crypto'
-import { PassThrough, Readable } from 'node:stream'
-
-import type {
-  SubcriptionOptions,
-  TAnyEventContract,
-  TAnySubscriptionContract,
-} from '@nmtjs/contract'
-import type { Logger } from '@nmtjs/core'
-import type { t } from '@nmtjs/type'
-import { isAbortError } from '@nmtjs/common'
-
-export type SubscriptionAdapterEvent = { channel: string; payload: any }
-
-export interface SubscriptionAdapterType {
-  publish(channel: string, payload: any): Promise<boolean>
-  subscribe(
-    channel: string,
-    signal?: AbortSignal,
-  ): AsyncGenerator<SubscriptionAdapterEvent>
-  initialize(): Promise<void>
-  dispose(): Promise<void>
-}
-
-export type SubscriptionChannel = {
-  stream: Readable
-  subscription: TAnySubscriptionContract
-  event: TAnyEventContract
-}
-
-export type SubscribeFn = <
-  Contract extends TAnySubscriptionContract,
-  Events extends {
-    [K in keyof Contract['events']]?: true
-  },
->(
-  subscription: Contract,
-  events: Events,
-  options: Contract['options'],
-  signal?: AbortSignal,
-) => Promise<
-  Omit<Readable, typeof Symbol.asyncIterator> & {
-    [Symbol.asyncIterator]: () => AsyncIterator<
-      {} extends Events
-        ? {
-            [K in keyof Contract['events']]: {
-              event: K
-              data: t.infer.decode.output<Contract['events'][K]['payload']>
-            }
-          }[keyof Contract['events']]
-        : {
-            [K in keyof Events]: K extends keyof Contract['events']
-              ? {
-                  event: K
-                  data: t.infer.decode.output<Contract['events'][K]['payload']>
-                }
-              : never
-          }[keyof Events]
-    >
-  }
->
-
-export type PublishFn = <
-  S extends TAnySubscriptionContract,
-  E extends S['events'][keyof S['events']],
->(
-  event: E,
-  options: S['options'],
-  data: t.infer.decode.input<E['payload']>,
-) => Promise<boolean>
-
-export type SubscriptionManagerOptions = {
-  logger: Logger
-  adapter: SubscriptionAdapterType
-}
-
-export class SubscriptionManager {
-  readonly subscriptions = new Map<string, SubscriptionChannel>()
-  protected readonly logger: Logger
-
-  constructor(protected readonly options: SubscriptionManagerOptions) {
-    this.logger = options.logger.child({ component: SubscriptionManager.name })
-  }
-
-  subscribe: SubscribeFn = async (subscription, events, options, signal) => {
-    const eventKeys =
-      Object.keys(events).length === 0
-        ? Object.keys(subscription.events)
-        : Object.keys(events)
-
-    this.logger.debug(
-      { subscription: subscription.name, eventCount: eventKeys.length },
-      'Opening subscription',
-    )
-
-    const streams = Array(eventKeys.length)
-
-    for (const index in eventKeys) {
-      const event = subscription.events[eventKeys[index]]
-      const channel = getChannelName(event, options)
-      if (this.subscriptions.has(channel)) {
-        streams[index] = this.subscriptions.get(channel)!.stream
-        this.logger.trace(
-          {
-            channel,
-            event: event.name,
-            activeChannels: this.subscriptions.size,
-          },
-          'Reusing pubsub channel stream',
-        )
-      } else {
-        const iterable = this.options.adapter.subscribe(channel, signal)
-        const stream = this.createEventStream(iterable)
-        stream.on('close', () => {
-          this.subscriptions.delete(channel)
-          this.logger.debug(
-            {
-              channel,
-              event: event.name,
-              activeChannels: this.subscriptions.size,
-            },
-            'Pubsub channel stream closed',
-          )
-        })
-        stream.on('error', (error) => {
-          this.logger.warn(
-            { channel, event: event.name, error },
-            'Pubsub channel stream failed',
-          )
-        })
-        streams[index] = stream
-        this.subscriptions.set(channel, { subscription, event, stream })
-        this.logger.debug(
-          {
-            channel,
-            event: event.name,
-            activeChannels: this.subscriptions.size,
-          },
-          'Creating channel stream',
-        )
-      }
-    }
-
-    const mergedStream = mergeEventStreams(streams, signal)
-
-    mergedStream.once('close', () => {
-      this.logger.debug(
-        { subscription: subscription.name, eventCount: eventKeys.length },
-        'Pubsub subscription stream closed',
-      )
-    })
-    mergedStream.once('error', (error) => {
-      this.logger.warn(
-        {
-          subscription: subscription.name,
-          eventCount: eventKeys.length,
-          error,
-        },
-        'Pubsub subscription stream failed',
-      )
-    })
-
-    return mergedStream
-  }
-
-  publish: PublishFn = async (event, options, data) => {
-    const channel = getChannelName(event, options)
-
-    this.logger.trace({ channel, event: event.name }, 'Publishing pubsub event')
-
-    try {
-      const payload = event.payload.encode(data)
-      const published = await this.options.adapter.publish(channel, payload)
-
-      if (published) {
-        this.logger.trace(
-          { channel, event: event.name },
-          'Published pubsub event',
-        )
-      } else {
-        this.logger.warn(
-          { channel, event: event.name },
-          'Pubsub adapter reported publish failure',
-        )
-      }
-
-      return published
-    } catch (error: any) {
-      this.logger.error(
-        { channel, event: event.name, error },
-        'Failed to publish pubsub event',
-      )
-      throw error
-    }
-  }
-
-  async dispose(): Promise<void> {
-    for (const { stream } of this.subscriptions.values()) {
-      stream.destroy()
-    }
-    this.subscriptions.clear()
-  }
-
-  private createEventStream(
-    iterable: AsyncGenerator<SubscriptionAdapterEvent>,
-  ): Readable {
-    const { subscriptions } = this
-    const logger = this.logger
-
-    return new Readable({
-      objectMode: true,
-      read() {
-        iterable.next().then(
-          ({ value, done }) => {
-            if (done) {
-              logger.trace('Pubsub adapter stream ended')
-              this.push(null)
-            } else {
-              const subscription = subscriptions.get(value.channel)
-              if (subscription) {
-                const { event } = subscription
-                try {
-                  const data = event.payload.decode(value.payload)
-                  logger.trace(
-                    { channel: value.channel, event: event.name },
-                    'Received event',
-                  )
-                  this.push({ event: event.name, data })
-                } catch (error: any) {
-                  logger.warn(
-                    { channel: value.channel, event: event.name, error },
-                    'Failed to decode pubsub event payload',
-                  )
-                  this.destroy(error)
-                }
-              } else {
-                logger.trace(
-                  { channel: value.channel },
-                  'Dropped pubsub event for inactive channel',
-                )
-              }
-            }
-          },
-          (error) => {
-            if (isAbortError(error)) {
-              logger.trace('Pubsub adapter stream aborted')
-              this.push(null)
-            } else {
-              logger.warn({ error }, 'Pubsub adapter stream failed')
-              this.destroy(error)
-            }
-          },
-        )
-      },
-    })
-  }
-}
-
-function concat(...args: any) {
-  return args.filter(Boolean).join('/')
-}
-
-function getChannelName<T extends TAnyEventContract>(
-  contract: T,
-  options: T['options'],
-) {
-  const key = options ? serializerOptions(options) : ''
-  assert(contract.name, 'Event contract must have a name')
-  return concat(contract.name, key)
-}
-
-function serializerOptions(options: Exclude<SubcriptionOptions, null>): string {
-  const hash = createHash('sha1')
-  const serialized = Object.entries(options)
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([key, value]) => `${key}=${value}`)
-    .join(';')
-  hash.update(serialized)
-  return hash.digest('base64url')
-}
-
-function mergeEventStreams(
-  streams: Readable[],
-  signal?: AbortSignal,
-): Readable {
-  const destination = new PassThrough({
-    signal,
-    objectMode: true,
-    readableObjectMode: true,
-    writableObjectMode: true,
-  })
-
-  let ended = 0
-
-  for (const source of streams) {
-    source.pipe(destination, { end: false })
-    source.once('end', () => {
-      ended++
-      if (ended === streams.length) {
-        destination.end()
-      }
-    })
-  }
-
-  return destination
-}