nmtjs 0.16.0-beta.9 → 0.16.0

package/src/runtime/jobs/router.ts

@@ -1,26 +1,23 @@
+import type {
+  AnyGuard,
+  AnyMiddleware,
+  AnyProcedure,
+  AnyRouter,
+  AnyRouterMetaBinding,
+  ProcedureMetaBinding,
+  Router,
+} from '@nmtjs/application'
 import type { MaybePromise } from '@nmtjs/common'
 import type { TProcedureContract, TRouterContract } from '@nmtjs/contract'
 import type { Dependencies, DependencyContext } from '@nmtjs/core'
 import type { NullableType, OptionalType } from '@nmtjs/type'
 import type { NeverType } from '@nmtjs/type/never'
+import { createProcedure, createRouter } from '@nmtjs/application'
 import { CoreInjectables } from '@nmtjs/core'
 import { t } from '@nmtjs/type'
 
-import type { AnyGuard } from '../application/api/guards.ts'
-import type { AnyMiddleware } from '../application/api/middlewares.ts'
-import type {
-  AnyProcedure,
-  ProcedureMetaBinding,
-} from '../application/api/procedure.ts'
-import type {
-  AnyRouter,
-  AnyRouterMetaBinding,
-  Router,
-} from '../application/api/router.ts'
 import type { AnyJob } from './job.ts'
 import type { JobStatus } from './types.ts'
-import { createProcedure } from '../application/api/procedure.ts'
-import { createRouter } from '../application/api/router.ts'
 import { jobManager } from '../injectables.ts'
 
 // ============================================================================
@@ -196,7 +193,7 @@ type JobItemSchemaType<T extends AnyJob> = t.ObjectType<{
   startedAt: OptionalType<t.NumberType>
   completedAt: OptionalType<t.NumberType>
   error: OptionalType<t.StringType>
-  stacktrace: OptionalType<t.ArrayType<t.StringType>>
+  stacktrace: NullableType<t.ArrayType<t.StringType>>
 }>
 
 /** Type-level representation of createListOutputSchema output */
@@ -326,7 +323,7 @@ function createJobItemSchema<T extends AnyJob>(job: T): JobItemSchemaType<T> {
     startedAt: t.number().optional(),
     completedAt: t.number().optional(),
     error: t.string().optional(),
-    stacktrace: t.array(t.string()).optional(),
+    stacktrace: t.array(t.string()).nullable(),
   })
 }
 

package/src/runtime/jobs/runner.ts

@@ -1,10 +1,11 @@
+import type { LifecycleHooks } from '@nmtjs/application'
 import type { Container, Logger, LoggingOptions } from '@nmtjs/core'
 import type { Job } from 'bullmq'
+import { LifecycleHook } from '@nmtjs/application'
 import { anyAbortSignal } from '@nmtjs/common'
 import { Scope } from '@nmtjs/core'
 import { UnrecoverableError } from 'bullmq'
 
-import type { LifecycleHooks } from '../hooks.ts'
 import type { AnyJob } from './job.ts'
 import type { AnyJobStep } from './step.ts'
 import type {
@@ -12,7 +13,6 @@ import type {
   JobProgressCheckpoint,
   StepResultEntry,
 } from './types.ts'
-import { LifecycleHook } from '../enums.ts'
 import {
   currentJobInfo,
   jobAbortSignal,

package/src/runtime/jobs/types.ts

@@ -105,7 +105,7 @@ export interface JobItem<TInput = unknown, TOutput = unknown> {
   /** Error message if job failed */
   error?: string
   /** Stack trace if job failed */
-  stacktrace?: string[]
+  stacktrace: string[] | null
 }
 
 // ============================================================================

package/src/runtime/metrics/metric.ts

@@ -1,6 +1,6 @@
 import type { ClassConstructorArgs } from '@nmtjs/common'
-import type { Metric, MetricConfiguration } from 'prom-client'
-import { Counter, Gauge, Histogram, Summary } from 'prom-client'
+import type { Metric, MetricConfiguration } from '@nmtjs/prom-client'
+import { Counter, Gauge, Histogram, Summary } from '@nmtjs/prom-client'
 
 import { registry } from './registry.ts'
 

package/src/runtime/metrics/registry.ts

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

package/src/runtime/metrics/server.ts

@@ -1,7 +1,7 @@
 import { createServer } from 'node:http'
 
 import type { Logger } from '@nmtjs/core'
-import { Pushgateway } from 'prom-client'
+import { Pushgateway } from '@nmtjs/prom-client'
 
 import type { ServerConfig } from '../server/config.ts'
 

package/src/runtime/plugin.ts

@@ -1,13 +1,2 @@
-import type { Provision } from '@nmtjs/core'
-
-import type { LifecycleHooks } from './hooks.ts'
-
-export interface RuntimePlugin {
-  name: string
-  hooks?: LifecycleHooks['_']['config']
-  injections?: Provision[]
-}
-
-export function createPlugin<T extends RuntimePlugin>(plugin: T): T {
-  return plugin
-}
+export type { RuntimePlugin } from '@nmtjs/application'
+export { createPlugin } from '@nmtjs/application'

package/src/runtime/runtime.ts

@@ -1,9 +1,11 @@
+import type { RuntimePlugin } from '@nmtjs/application'
 import type {
   AnyInjectable,
   Dependant,
   Logger,
   LoggingOptions,
 } from '@nmtjs/core'
+import { LifecycleHook, LifecycleHooks } from '@nmtjs/application'
 import {
   Container,
   createLogger,
@@ -11,10 +13,6 @@ import {
   Scope,
 } from '@nmtjs/core'
 
-import type { RuntimePlugin } from './plugin.ts'
-import { LifecycleHook } from './enums.ts'
-import { LifecycleHooks } from './hooks.ts'
-
 export type BaseRuntimeOptions = {
   logger?: LoggingOptions
   container?: Container

package/src/runtime/server/applications.ts

@@ -120,6 +120,12 @@ export class ApplicationServerApplications extends EventEmitter<{
 
       // 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',

package/src/runtime/server/config.ts

@@ -1,10 +1,13 @@
+import type {
+  ApplicationHost,
+  ApplicationHostDefinition,
+  TransportOptionsOf,
+} from '@nmtjs/application'
 import type { LoggingOptions } from '@nmtjs/core'
-import type { Transport } from '@nmtjs/gateway'
 import type { ApplicationOptions } 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 { 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'
@@ -26,25 +29,23 @@ 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>
+export type ServerApplicationConfig<T = ApplicationHostDefinition> =
+  T extends ApplicationHostDefinition<any, infer Transports>
     ? {
         threads: {
-          [K in keyof Transports]: Transports[K] extends Transport<
-            any,
-            infer Options
-          >
-            ? Options
-            : never
+          [K in keyof Transports]: TransportOptionsOf<Transports[K]>
         }[]
       }
-    : any
+    : T extends ApplicationHost<infer Transports>
+      ? {
+          threads: {
+            [K in keyof Transports]: TransportOptionsOf<Transports[K]>
+          }[]
+        }
+      : any
 
 export type ServerJobsConfig = {
-  pools: {
-    [JobWorkerPool.Io]: ServerPoolOptions
-    [JobWorkerPool.Compute]: ServerPoolOptions
-  }
+  pools: Record<string, ServerPoolOptions>
   jobs?: AnyJob[]
   /**
    * @deprecated Scheduler is currently being refactored and is not available.
@@ -53,14 +54,19 @@ export type ServerJobsConfig = {
   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]: Applications[K]['type'] extends 'neemata'
-      ? ServerApplicationConfig<
-          (Applications[K] & { type: 'neemata' })['definition']
-        >
-      : ServerApplicationConfig<any>
+    [K in keyof Applications]: ServerApplicationDefinitionConfig<
+      Applications[K]
+    >
   }
   store?: ServerStoreConfig
   /**

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/redis.ts

@@ -1,10 +1,10 @@
 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 type { RuntimePlugin } from '../plugin.ts'
 import type { Store } from '../types.ts'
 import type {
   SubscriptionAdapterEvent,

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