nmtjs 0.15.0-beta.2 → 0.15.0-beta.20

package/src/runtime/pubsub/redis.ts

@@ -0,0 +1,108 @@
+import EventEmitter, { on } from 'node:events'
+
+import { isAbortError } from '@nmtjs/common'
+import { createFactoryInjectable, provide } from '@nmtjs/core'
+
+import type { RuntimePlugin } from '../core/plugin.ts'
+import type { Store } from '../types.ts'
+import type { PubSubAdapterEvent, PubSubAdapterType } from './manager.ts'
+import { pubSubAdapter, storeConfig } from '../injectables.ts'
+import { createStoreClient } from '../store/index.ts'
+
+export class RedisPubSubAdapter implements PubSubAdapterType {
+  protected readonly events = new EventEmitter()
+  protected readonly listeners = new Map<string, number>()
+  protected subscriberClient?: Store
+
+  constructor(protected readonly client: Store) {}
+
+  async initialize() {
+    // Create a dedicated subscriber client (Redis requires separate clients for pub/sub)
+    this.subscriberClient = this.client.duplicate()
+
+    // Set up message handler
+    this.subscriberClient.on('message', (channel: string, message: string) => {
+      try {
+        const parsed = JSON.parse(message)
+        this.events.emit(channel, parsed)
+      } catch {}
+    })
+  }
+
+  async dispose() {
+    if (this.subscriberClient) {
+      await this.subscriberClient.quit()
+      this.subscriberClient = undefined
+    }
+  }
+
+  async publish(channel: string, payload: any): Promise<boolean> {
+    try {
+      await this.client.publish(channel, JSON.stringify(payload))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async *subscribe(
+    channel: string,
+    signal?: AbortSignal,
+  ): AsyncGenerator<PubSubAdapterEvent> {
+    if (!this.subscriberClient) {
+      throw new Error('RedisPubSubAdapter not initialized')
+    }
+
+    if (!this.listeners.has(channel)) {
+      await this.subscriberClient.subscribe(channel)
+      this.listeners.set(channel, 1)
+    } else {
+      this.listeners.set(channel, this.listeners.get(channel)! + 1)
+    }
+
+    try {
+      signal?.throwIfAborted()
+      for await (const [payload] of on(this.events, channel, { signal })) {
+        yield { channel, payload }
+      }
+    } catch (error: any) {
+      if (isAbortError(error)) throw error
+    } finally {
+      const count = this.listeners.get(channel)
+      if (count !== undefined) {
+        if (count > 1) {
+          this.listeners.set(channel, count - 1)
+        } else {
+          await this.subscriberClient?.unsubscribe(channel)
+          this.listeners.delete(channel)
+        }
+      }
+    }
+  }
+}
+
+export const RedisPubSubAdapterPlugin = (): RuntimePlugin => {
+  return {
+    name: 'pubsub-redis-adapter',
+    hooks: {
+      'lifecycle:afterInitialize': async (ctx) => {
+        await ctx.container.provide([
+          provide(
+            pubSubAdapter,
+            createFactoryInjectable({
+              dependencies: { config: storeConfig },
+              factory: async ({ config }) => {
+                const connection = await createStoreClient(config)
+                const adapter = new RedisPubSubAdapter(connection)
+                await adapter.initialize()
+                return { adapter, connection }
+              },
+              pick: ({ adapter }) => adapter,
+              dispose: ({ connection }) => connection.quit(),
+            }),
+          ),
+        ])
+      },
+    },
+  }
+}

package/src/runtime/scheduler/index.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,210 @@
+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 { Thread } from './pool.ts'
+import type {
+  ApplicationServerWorkerConfig,
+  ApplicationWorkerErrorEvent,
+  ApplicationWorkerReadyEvent,
+} from './server.ts'
+import { Pool } from './pool.ts'
+
+export type ApplicationProxyUpstream = {
+  type: ProxyableTransportType
+  url: string
+}
+
+export class ApplicationServerApplications extends EventEmitter<{
+  add: [application: string, upstream: ApplicationProxyUpstream]
+  remove: [application: string, upstream: ApplicationProxyUpstream]
+}> {
+  pool: Pool
+
+  protected readonly upstreams = new Map<
+    string,
+    Map<string, { upstream: ApplicationProxyUpstream; count: number }>
+  >()
+  protected readonly upstreamsByThread = new WeakMap<
+    Thread,
+    Array<{ application: string; key: string }>
+  >()
+
+  constructor(
+    readonly params: {
+      logger: Logger
+      applications: string[]
+      workerConfig: ApplicationServerWorkerConfig
+      applicationsConfig: Record<
+        string,
+        { type: 'neemata' | 'custom'; specifier: string }
+      >
+      serverConfig: ServerConfig
+    },
+  ) {
+    super()
+    this.pool = new Pool({
+      path: this.params.workerConfig.path,
+      worker: this.params.workerConfig.worker,
+      workerData: { ...this.params.workerConfig.workerData },
+    })
+  }
+
+  get appsNames() {
+    return this.params.applications
+  }
+
+  async start() {
+    const { logger, applications, applicationsConfig, serverConfig } =
+      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.info(
+        `Spinning [${threadsConfig.length}] workers for [${applicationName}] application...`,
+      )
+
+      for (let i = 0; i < threadsConfig.length; i++) {
+        const thread = this.pool.add({
+          index: i,
+          name: `application-${applicationName}`,
+          workerData: {
+            runtime: {
+              type: 'application',
+              name: applicationName,
+              path: applicationPath.specifier,
+              transportsData: threadsConfig[i],
+            },
+          },
+        })
+
+        thread.on('ready', ({ hosts }) => {
+          this.removeThreadUpstreams(thread)
+
+          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.upstreamsByThread.set(thread, keys)
+
+          this.emitWorkerReady({
+            application: applicationName,
+            threadId: thread.worker.threadId,
+            hosts: sanitizedHosts.length ? sanitizedHosts : undefined,
+          })
+        })
+
+        thread.on('error', (error: WorkerThreadError) => {
+          this.emitWorkerError({
+            application: applicationName,
+            threadId: thread.worker.threadId,
+            error,
+          })
+          this.removeThreadUpstreams(thread)
+        })
+
+        thread.worker.once('exit', () => {
+          this.removeThreadUpstreams(thread)
+        })
+      }
+    }
+
+    await this.pool.start()
+  }
+
+  async stop() {
+    await this.pool.stop()
+  }
+
+  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++
+  }
+
+  protected removeThreadUpstreams(thread: Thread) {
+    const keys = this.upstreamsByThread.get(thread)
+    if (!keys) return
+    this.upstreamsByThread.delete(thread)
+
+    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)
+      }
+    }
+  }
+
+  protected emitWorkerReady(event: ApplicationWorkerReadyEvent) {
+    this.params.workerConfig.events?.emit('worker-ready', event)
+  }
+
+  protected emitWorkerError(event: ApplicationWorkerErrorEvent) {
+    this.params.logger.error(
+      new Error(
+        `Worker [${event.application}] thread ${event.threadId} error`,
+        { cause: event.error },
+      ),
+    )
+    this.params.workerConfig.events?.emit('worker-error', event)
+  }
+}

package/src/runtime/server/config.ts

@@ -0,0 +1,158 @@
+import type { TSError } from '@nmtjs/common'
+import type { LoggingOptions } from '@nmtjs/core'
+import type { Transport } from '@nmtjs/gateway'
+import type { ApplicationOptions, PortUpstreamOptions } from '@nmtjs/proxy'
+import type { Applications } from 'nmtjs/runtime/types'
+
+import type { ApplicationConfig } from '../application/config.ts'
+import type { JobWorkerPool, StoreType } from '../enums.ts'
+import type { AnyJob } from '../jobs/job.ts'
+import type { PubSubAdapterType } from '../pubsub/manager.ts'
+import type { JobsSchedulerOptions } from '../scheduler/index.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 = ApplicationConfig> =
+  T extends ApplicationConfig<any, infer Transports>
+    ? {
+        threads: {
+          [K in keyof Transports]: Transports[K] extends Transport<
+            any,
+            infer Options
+          >
+            ? Options
+            : never
+        }[]
+      }
+    : any
+
+export type ServerJobsConfig = {
+  pools: {
+    [JobWorkerPool.Io]: ServerPoolOptions
+    [JobWorkerPool.Compute]: ServerPoolOptions
+  }
+  jobs?: AnyJob[]
+  /**
+   * @deprecated Scheduler is currently being refactored and is not available.
+   * Using this option will throw an error at startup.
+   */
+  scheduler?: JobsSchedulerOptions
+  ui?: { hostname?: string; port?: number }
+}
+
+export interface ServerConfigInit {
+  logger: LoggingOptions
+  applications: {
+    [K in keyof Applications]: Applications[K]['type'] extends 'neemata'
+      ? ServerApplicationConfig<
+          (Applications[K] & { type: 'neemata' })['definition']
+        >
+      : ServerApplicationConfig<any>
+  }
+  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?: {}
+  pubsub?: { adapter: PubSubAdapterType }
+  deploymentId?: string
+}
+
+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
+   * 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: 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
+    ui?: ServerJobsConfig['ui']
+  }
+  commands?: {}
+  pubsub: ServerConfigInit['pubsub']
+  deploymentId: ServerConfigInit['deploymentId']
+}
+
+export function defineServer(options: ServerConfigInit): ServerConfig {
+  const { deploymentId, logger, commands, proxy, store, applications, pubsub } =
+    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,
+      ui: options.jobs.ui,
+    }
+  }
+
+  return Object.freeze({
+    [kServerConfig]: true,
+    deploymentId,
+    logger,
+    commands,
+    proxy,
+    store,
+    applications,
+    pubsub,
+    jobs,
+  } as const)
+}
+
+export function isServerConfig(value: any): value is ServerConfig {
+  return Boolean(value?.[kServerConfig])
+}