nmtjs 0.16.0-beta.9 → 0.16.1

package/src/runtime/server/jobs.ts

@@ -14,10 +14,12 @@ import type {
   WorkerPoolConfig,
   WorkerPoolFactory,
 } from './worker-pool.ts'
-import { JobWorkerPool, WorkerType } from '../enums.ts'
+import { WorkerType } from '../enums.ts'
 import { getJobQueueName } from '../jobs/manager.ts'
 import { JobRunnersPool } from './worker-pool.ts'
 
+type JobsPoolConfig = Exclude<ServerConfig['jobs'], undefined>['pools']
+
 function enrichBullMqErrorStack(error: unknown): Error {
   const normalized =
     error instanceof Error
@@ -31,6 +33,38 @@ function enrichBullMqErrorStack(error: unknown): Error {
   return normalized
 }
 
+function getJobsByPool(jobs: Iterable<AnyJob>): Map<string, AnyJob[]> {
+  const jobsByPool = new Map<string, AnyJob[]>()
+
+  for (const job of jobs) {
+    const poolJobs = jobsByPool.get(job.options.pool)
+    if (poolJobs) {
+      poolJobs.push(job)
+    } else {
+      jobsByPool.set(job.options.pool, [job])
+    }
+  }
+
+  return jobsByPool
+}
+
+function assertActiveJobPoolsConfigured(
+  jobsByPool: Map<string, AnyJob[]>,
+  pools: JobsPoolConfig,
+) {
+  const missingPoolMessages = [...jobsByPool]
+    .filter(([poolName]) => !pools[poolName])
+    .flatMap(([poolName, jobs]) =>
+      jobs.map((job) => `${job.name} -> ${poolName}`),
+    )
+
+  if (missingPoolMessages.length > 0) {
+    throw new Error(
+      `Invalid jobs pool configuration: missing pool config for jobs: ${missingPoolMessages.join(', ')}`,
+    )
+  }
+}
+
 /**
  * ApplicationServerJobs manages job worker pools and BullMQ queue workers.
  *
@@ -38,7 +72,7 @@ function enrichBullMqErrorStack(error: unknown): Error {
  * - Uses JobRunnersPool (extends WorkerPool) for worker management
  * - Uses ManagedWorker for restart logic and state tracking
  * - Integrates with ErrorPolicy for restart decisions
- * - Proper health tracking per job pool type
+ * - Proper health tracking per job pool
  */
 export class ApplicationServerJobs {
   /**
@@ -49,10 +83,10 @@ export class ApplicationServerJobs {
   jobs: Map<string, AnyJob>
 
   /**
-   * Shared resource pools by pool type (Io, Compute).
-   * All jobs of a given pool type share the same pool for resource management.
+   * Shared resource pools by configured pool name.
+   * All jobs using the same pool name share the same pool for resource management.
    */
-  protected pools = new Map<JobWorkerPool, JobRunnersPool>()
+  protected pools = new Map<string, JobRunnersPool>()
 
   constructor(
     readonly params: {
@@ -86,16 +120,16 @@ export class ApplicationServerJobs {
       return
     }
 
-    // Step 1: Initialize shared resource pools (Io, Compute)
-    const poolTypes = Object.values(JobWorkerPool)
+    const jobsByPool = getJobsByPool(this.jobs.values())
+    assertActiveJobPoolsConfigured(jobsByPool, jobsConfig.pools)
 
-    for (const poolType of poolTypes) {
-      const poolConfig = jobsConfig.pools[poolType]
-      if (!poolConfig) continue
+    // Step 1: Initialize shared resource pools used by active jobs
+    for (const poolName of jobsByPool.keys()) {
+      const poolConfig = jobsConfig.pools[poolName]!
 
-      // Create a JobRunnersPool for this pool type
+      // Create a JobRunnersPool for this pool
       const config: WorkerPoolConfig = {
-        name: `job-pool-${poolType}`,
+        name: `job-pool-${poolName}`,
         workerType: WorkerType.Job,
         path: workerConfig.path,
         workerData: { ...workerConfig.workerData },
@@ -111,15 +145,15 @@ export class ApplicationServerJobs {
 
       // Add workers to the pool
       for (let i = 0; i < poolConfig.threads; i++) {
-        pool.add({ runtime: { type: 'jobs', jobWorkerPool: poolType } }, i)
+        pool.add({ runtime: { type: 'jobs', jobWorkerPool: poolName } }, i)
       }
 
       await pool.startAll()
-      this.pools.set(poolType, pool)
+      this.pools.set(poolName, pool)
 
       logger.info(
         {
-          pool: poolType,
+          pool: poolName,
           threads: poolConfig.threads,
           jobsPerThread: poolConfig.jobs,
         },
@@ -129,28 +163,18 @@ export class ApplicationServerJobs {
 
     // Step 2: Create a dedicated BullMQ Worker for each job
     // Calculate how many jobs use each pool for fair concurrency distribution
-    const jobsPerPool = new Map<JobWorkerPool, number>()
-    for (const job of this.jobs.values()) {
-      const count = jobsPerPool.get(job.options.pool) ?? 0
-      jobsPerPool.set(job.options.pool, count + 1)
-    }
-
     for (const job of this.jobs.values()) {
       const queueName = getJobQueueName(job)
-      const poolType = job.options.pool
-      const pool = this.pools.get(poolType)
+      const poolName = job.options.pool
+      const pool = this.pools.get(poolName)
 
       if (!pool) {
-        logger.warn(
-          { job: job.name, pool: poolType },
-          'No pool configured for job, skipping worker creation',
-        )
-        continue
+        throw new Error(`Job "${job.name}" pool "${poolName}" is not started`)
       }
 
-      const poolConfig = jobsConfig.pools[poolType]
+      const poolConfig = jobsConfig.pools[poolName]!
       const poolCapacity = poolConfig.threads * poolConfig.jobs
-      const jobCountInPool = jobsPerPool.get(poolType) ?? 1
+      const jobCountInPool = jobsByPool.get(poolName)?.length ?? 1
       // Use job-specific concurrency if provided, otherwise distribute pool capacity evenly
       const defaultConcurrency = Math.max(
         1,
@@ -192,7 +216,7 @@ export class ApplicationServerJobs {
 
       this.queueWorkers.add(queueWorker)
       logger.info(
-        { job: job.name, queue: queueName, pool: poolType, concurrency },
+        { job: job.name, queue: queueName, pool: poolName, concurrency },
         'Job queue worker started',
       )
     }
@@ -234,9 +258,9 @@ export class ApplicationServerJobs {
   }
 
   /**
-   * Get a job pool by type.
+   * Get a job pool by name.
    */
-  getPool(poolType: JobWorkerPool): JobRunnersPool | undefined {
-    return this.pools.get(poolType)
+  getPool(poolName: string): JobRunnersPool | undefined {
+    return this.pools.get(poolName)
   }
 }

package/src/runtime/subscription/manager.ts

@@ -7,12 +7,10 @@ import type {
   TAnyEventContract,
   TAnySubscriptionContract,
 } from '@nmtjs/contract'
-import type { Container, Logger } from '@nmtjs/core'
+import type { Logger } from '@nmtjs/core'
 import type { t } from '@nmtjs/type'
 import { isAbortError } from '@nmtjs/common'
 
-import { subscriptionAdapter } from '../injectables.ts'
-
 export type SubscriptionAdapterEvent = { channel: string; payload: any }
 
 export interface SubscriptionAdapterType {
@@ -74,7 +72,7 @@ export type PublishFn = <
 
 export type SubscriptionManagerOptions = {
   logger: Logger
-  container: Container
+  adapter: SubscriptionAdapterType
 }
 
 export class SubscriptionManager {
@@ -85,13 +83,7 @@ export class SubscriptionManager {
     this.logger = options.logger.child({ component: SubscriptionManager.name })
   }
 
-  protected get adapter() {
-    return this.options.container.resolve(subscriptionAdapter)
-  }
-
   subscribe: SubscribeFn = async (subscription, events, options, signal) => {
-    const adapter = await this.adapter
-
     const eventKeys =
       Object.keys(events).length === 0
         ? Object.keys(subscription.events)
@@ -118,7 +110,7 @@ export class SubscriptionManager {
           'Reusing pubsub channel stream',
         )
       } else {
-        const iterable = adapter.subscribe(channel, signal)
+        const iterable = this.options.adapter.subscribe(channel, signal)
         const stream = this.createEventStream(iterable)
         stream.on('close', () => {
           this.subscriptions.delete(channel)
@@ -173,15 +165,13 @@ export class SubscriptionManager {
   }
 
   publish: PublishFn = async (event, options, data) => {
-    const adapter = await this.adapter
-
     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 adapter.publish(channel, payload)
+      const published = await this.options.adapter.publish(channel, payload)
 
       if (published) {
         this.logger.trace(
@@ -205,6 +195,13 @@ export class SubscriptionManager {
     }
   }
 
+  async dispose(): Promise<void> {
+    for (const { stream } of this.subscriptions.values()) {
+      stream.destroy()
+    }
+    this.subscriptions.clear()
+  }
+
   private createEventStream(
     iterable: AsyncGenerator<SubscriptionAdapterEvent>,
   ): Readable {

package/src/runtime/subscription/redis.ts

@@ -1,10 +1,14 @@
 import EventEmitter, { on } from 'node:events'
 
+import type { RuntimePlugin } from '@nmtjs/application'
 import type { Logger } from '@nmtjs/core'
 import { isAbortError } from '@nmtjs/common'
-import { createFactoryInjectable } from '@nmtjs/core'
+import {
+  CoreInjectables,
+  createFactoryInjectable,
+  provision,
+} from '@nmtjs/core'
 
-import type { RuntimePlugin } from '../plugin.ts'
 import type { Store } from '../types.ts'
 import type {
   SubscriptionAdapterEvent,
@@ -130,28 +134,26 @@ export class RedisSubscriptionAdapter implements SubscriptionAdapterType {
 }
 
 export const RedisSubscriptionAdapterPlugin = (): RuntimePlugin => {
-  return {
-    name: 'redis-subscription-adapter',
-    hooks: {
-      'lifecycle:beforeInitialize': async (ctx) => {
-        const adapter = await ctx.container.resolve(
-          createFactoryInjectable({
-            dependencies: { config: storeConfig },
-            factory: async ({ config }) => {
-              const connection = await createStoreClient(config)
-              const adapter = new RedisSubscriptionAdapter(
-                connection,
-                ctx.logger,
-              )
-              await adapter.initialize()
-              return { adapter, connection }
-            },
-            pick: ({ adapter }) => adapter,
-            dispose: ({ connection }) => connection.quit(),
-          }),
-        )
-        ctx.container.provide(subscriptionAdapter, adapter)
+  const adapterFactory = createFactoryInjectable(
+    {
+      dependencies: { config: storeConfig, logger: CoreInjectables.logger },
+      factory: async ({ config, logger }) => {
+        const connection = await createStoreClient(config)
+        const adapter = new RedisSubscriptionAdapter(connection, logger)
+        await adapter.initialize()
+        return { adapter, connection }
+      },
+      pick: ({ adapter }) => adapter,
+      dispose: async ({ adapter, connection }) => {
+        await adapter.dispose()
+        await connection.quit()
       },
     },
+    'RedisSubscriptionAdapter',
+  )
+
+  return {
+    name: 'redis-subscription-adapter',
+    injections: [provision(subscriptionAdapter, adapterFactory)],
   }
 }

package/src/runtime/types.ts

@@ -1,11 +1,9 @@
-import type { HookTypes } from '@nmtjs/core'
+import type { ApplicationHostDefinition } from '@nmtjs/application'
 import type { ProxyableTransportType } from '@nmtjs/gateway'
 import type { Redis, RedisOptions } from 'ioredis'
 import type { Redis as Valkey, RedisOptions as ValkeyOptions } from 'iovalkey'
 
-import type { ApplicationConfig } from './application/config.ts'
-import type { LifecycleHook, StoreType } from './enums.ts'
-import type { BaseRuntime } from './runtime.ts'
+import type { StoreType } from './enums.ts'
 
 export type WorkerThreadErrorOrigin = 'bootstrap' | 'start' | 'runtime'
 
@@ -66,15 +64,8 @@ export type JobTaskResultTypes = {
   queue_job_not_found: {}
 }
 
-export interface LifecycleHookTypes extends HookTypes {
-  [LifecycleHook.BeforeInitialize]: (runtime: BaseRuntime) => any
-  [LifecycleHook.AfterInitialize]: (runtime: BaseRuntime) => any
-  [LifecycleHook.BeforeDispose]: (runtime: BaseRuntime) => any
-  [LifecycleHook.AfterDispose]: (runtime: BaseRuntime) => any
-}
-
 export type ApplicationDefinitionType =
-  | { type: 'neemata'; definition: ApplicationConfig<any, any> }
+  | { type: 'neemata'; definition: ApplicationHostDefinition }
   | { type: 'custom'; definition: any }
 
 export interface Applications

package/src/runtime/workers/application.ts

@@ -1,217 +1,133 @@
-import type { Dependant } from '@nmtjs/core'
-import type { GatewayOptions, Transport } from '@nmtjs/gateway'
-import { Gateway } from '@nmtjs/gateway'
+import type {
+  ApplicationHost,
+  ApplicationHostDefinition,
+  ApplicationHostOptions,
+  ApplicationResolvedProcedure,
+  ApplicationTransport,
+  NeemataApplication,
+  TransportOptionsOf,
+} from '@nmtjs/application'
+import type { Gateway, GatewayOptions } from '@nmtjs/gateway'
+import { createApplicationHost, LifecycleHook } from '@nmtjs/application'
 import { JsonFormat } from '@nmtjs/json-format/server'
 import { MsgpackFormat } from '@nmtjs/msgpack-format/server'
 import { ProtocolFormats } from '@nmtjs/protocol/server'
 
-import type { ApplicationConfig } from '../application/config.ts'
-import type {
-  AnyFilter,
-  AnyGuard,
-  AnyMiddleware,
-  AnyProcedure,
-  AnyRouter,
-  kDefaultProcedure as kDefaultProcedureKey,
-} from '../application/index.ts'
-import type { ServerConfig } from '../server/config.ts'
-import { ApplicationApi } from '../application/api/api.ts'
-import { ApplicationHooks } from '../application/hooks.ts'
-import {
-  isProcedure,
-  isRootRouter,
-  isRouter,
-  kDefaultProcedure,
-  kRootRouter,
-} from '../application/index.ts'
-import { LifecycleHook, WorkerType } from '../enums.ts'
+import type { ServerApplicationConfig, ServerConfig } from '../server/config.ts'
+import { WorkerType } from '../enums.ts'
 import { BaseWorkerRuntime } from './base.ts'
 
 export interface ApplicationWorkerRuntimeOptions {
   name: string
   path: string
-  transports: { [key: string]: any }
+  transports: ServerApplicationConfig['threads'][number]
 }
 
 export class ApplicationWorkerRuntime extends BaseWorkerRuntime {
-  api!: ApplicationApi
-  applicationHooks!: ApplicationHooks
-  gateway!: Gateway
-  transports!: GatewayOptions['transports']
-
-  routers = new Map<string | kRootRouter, AnyRouter>()
-  procedures = new Map<
-    string | kDefaultProcedureKey,
-    { procedure: AnyProcedure; path: AnyRouter[] }
-  >()
-  filters = new Set<AnyFilter>()
-  middlewares = new Set<AnyMiddleware>()
-  guards = new Set<AnyGuard>()
+  host!: ApplicationHost
 
   constructor(
     readonly config: ServerConfig,
     readonly runtimeOptions: ApplicationWorkerRuntimeOptions,
-    protected appConfig: ApplicationConfig,
+    protected hostDefinition: ApplicationHostDefinition,
   ) {
     super(
       config,
       {
         logger: config.logger,
         name: `Worker ${runtimeOptions.name}`,
-        plugins: appConfig.plugins,
+        plugins: [],
       },
       WorkerType.Application,
     )
+  }
 
-    this.applicationHooks = new ApplicationHooks()
+  get application(): NeemataApplication {
+    return this.host.application
+  }
 
-    this.api = new ApplicationApi({
-      timeout: this.appConfig.api.timeout,
-      container: this.container,
-      logger: this.logger,
-      meta: this.appConfig.meta,
-      filters: this.filters,
-      middlewares: this.middlewares,
-      guards: this.guards,
-      procedures: this.procedures,
-    })
+  get api() {
+    return this.application.api
   }
 
-  async start() {
-    await this.initialize()
+  get applicationHooks() {
+    return this.application.applicationHooks
+  }
 
-    this.transports = {}
+  get gateway(): Gateway<ApplicationResolvedProcedure> {
+    return this.host.gateway
+  }
 
-    for (const key in this.runtimeOptions.transports) {
-      const options = this.runtimeOptions.transports[key]
-      const { factory, proxyable } = this.appConfig.transports[key] as Transport
-      this.transports[key] = { transport: await factory(options), proxyable }
-    }
+  get transports(): GatewayOptions<ApplicationResolvedProcedure>['transports'] {
+    return this.host.transports
+  }
 
-    this.gateway = new Gateway({
-      ...this.appConfig.gateway,
+  async start() {
+    await this.initialize()
+    this.host = createApplicationHost(this.hostDefinition.application, {
+      name: this.runtimeOptions.name,
       logger: this.logger,
       container: this.container,
-      hooks: this.lifecycleHooks,
       formats: new ProtocolFormats([new JsonFormat(), new MsgpackFormat()]),
-      transports: this.transports,
-      api: this.api,
-      identity: this.appConfig.identity,
-    })
-
-    return await this.gateway.start().finally(async () => {
-      await this.lifecycleHooks.callHook(LifecycleHook.Start)
+      ...this.resolveHostOptions(),
     })
+    return this.host.start()
   }
 
   async stop() {
-    await this.gateway.stop()
+    await this.host.stop()
     await this.dispose()
     await this.lifecycleHooks.callHook(LifecycleHook.Stop)
   }
 
-  async reload(appConfig: ApplicationConfig): Promise<void> {
-    await this.dispose()
-    this.appConfig = appConfig
-    this.plugins = appConfig.plugins
-    await this.initialize()
-    this.gateway.options.identity =
-      this.appConfig.identity ?? this.gateway.options.identity
-    await this.gateway.reload()
+  async reload(hostDefinition: ApplicationHostDefinition): Promise<void> {
+    this.hostDefinition = hostDefinition
+    await this.host.reloadApplication(hostDefinition.application)
   }
 
-  async initialize(): Promise<void> {
-    this.registerApi()
-    this.lifecycleHooks.addHooks(this.appConfig.lifecycleHooks)
-    await super.initialize()
-  }
+  protected *_dependents() {}
 
-  protected async _initialize(): Promise<void> {
-    await super._initialize()
+  protected resolveHostOptions(): Pick<
+    ApplicationHostOptions,
+    'transports' | 'gateway' | 'identity'
+  > {
+    const config = this.config.applications[
+      this.runtimeOptions.name
+    ] as ServerApplicationConfig
 
-    for (const hook of this.appConfig.hooks) {
-      this.applicationHooks.hook(hook.name, async (...args: any[]) => {
-        const ctx = await this.container.createContext(hook.dependencies)
-        await hook.handler(ctx, ...args)
-      })
+    if (!config) {
+      throw new Error(
+        `Missing server application config: ${this.runtimeOptions.name}`,
+      )
     }
-  }
 
-  protected async _dispose(): Promise<void> {
-    this.applicationHooks.removeAllHooks()
-    await super._dispose()
-    this.lifecycleHooks.removeHooks(this.appConfig.lifecycleHooks)
-    this.filters.clear()
-    this.middlewares.clear()
-    this.guards.clear()
-    this.routers.clear()
-    this.procedures.clear()
-  }
-
-  protected *_dependents(): Generator<Dependant> {
-    yield* this.appConfig.filters
-    yield* this.appConfig.guards
-    yield* this.appConfig.middlewares
-    yield* this.appConfig.meta
-    yield* this.appConfig.hooks
-    for (const router of this.routers.values()) {
-      yield* router.meta
-    }
-    for (const { procedure } of this.procedures.values()) {
-      yield procedure
-      yield* procedure.meta
-      yield* procedure.guards
-      yield* procedure.middlewares
+    return {
+      transports: createHostTransportConfig(
+        this.hostDefinition.transports,
+        this.runtimeOptions.transports,
+      ),
+      gateway: this.hostDefinition.gateway,
+      identity: this.hostDefinition.identity,
     }
   }
+}
 
-  protected registerApi() {
-    const { router, filters, guards, middlewares } = this.appConfig
-
-    if (this.routers.has(kRootRouter)) {
-      throw new Error('Root router already registered')
-    }
-
-    if (!isRootRouter(router)) {
-      throw new Error('Root router must be a root router')
-    }
-
-    this.routers.set(kRootRouter, router)
-    this.registerRouter(router, [])
-
-    if (router.default) {
-      if (!isProcedure(router.default)) {
-        throw new Error('Root router default must be a procedure')
-      }
-      this.procedures.set(kDefaultProcedure, {
-        procedure: router.default,
-        path: [router],
-      })
+function createHostTransportConfig<
+  Transports extends Record<string, ApplicationTransport>,
+>(
+  transports: Transports,
+  options: { [K in keyof Transports]: TransportOptionsOf<Transports[K]> },
+) {
+  const config = {} as {
+    [K in keyof Transports]: {
+      transport: Transports[K]
+      options: TransportOptionsOf<Transports[K]>
     }
-
-    for (const filter of filters) this.filters.add(filter)
-    for (const middleware of middlewares) this.middlewares.add(middleware)
-    for (const guard of guards) this.guards.add(guard)
   }
 
-  protected registerRouter(router: AnyRouter, path: AnyRouter[] = []) {
-    for (const route of Object.values(router.routes)) {
-      if (isRouter(route)) {
-        const name = route.contract.name
-        if (!name) throw new Error('Nested routers must have a name')
-        if (this.routers.has(name)) {
-          throw new Error(`Router ${String(name)} already registered`)
-        }
-        this.routers.set(name, route)
-        this.registerRouter(route, [...path, router])
-      } else if (isProcedure(route)) {
-        const name = route.contract.name
-        if (!name) throw new Error('Procedures must have a name')
-        if (this.procedures.has(name)) {
-          throw new Error(`Procedure ${name} already registered`)
-        }
-        this.procedures.set(name, { procedure: route, path: [...path, router] })
-      }
-    }
+  for (const key in transports) {
+    config[key] = { transport: transports[key], options: options[key] }
   }
+
+  return config
 }