nmtjs 0.15.0-beta.2 → 0.15.0-beta.21

package/src/runtime/core/plugin.ts

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

package/src/runtime/core/runtime.ts

@@ -0,0 +1,109 @@
+import type {
+  AnyInjectable,
+  Dependant,
+  Logger,
+  LoggingOptions,
+} from '@nmtjs/core'
+import {
+  Container,
+  createLogger,
+  getDepedencencyInjectable,
+  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
+  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) {
+        for (const injection of injections) {
+          await this.container.provide(injection.token, injection.value)
+        }
+      }
+      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/enums.ts

@@ -0,0 +1,24 @@
+export enum StoreType {
+  Redis = 'Redis',
+  Valkey = 'Valkey',
+}
+
+export enum JobWorkerPool {
+  Io = 'Io',
+  Compute = 'Compute',
+}
+
+export enum LifecycleHook {
+  BeforeInitialize = 'lifecycle:beforeInitialize',
+  AfterInitialize = 'lifecycle:afterInitialize',
+  BeforeDispose = 'lifecycle:beforeDispose',
+  AfterDispose = 'lifecycle:afterDispose',
+  Stop = 'lifecycle:stop',
+  Start = 'lifecycle:start',
+}
+
+export enum WorkerType {
+  Application = 'Application',
+  Job = 'Job',
+  Command = 'Command',
+}

package/src/runtime/index.ts

@@ -0,0 +1,21 @@
+export * from './application/index.ts'
+export * from './constants.ts'
+export * from './core/hooks.ts'
+export * from './core/plugin.ts'
+export * from './core/runtime.ts'
+export * from './enums.ts'
+export * from './injectables.ts'
+export * from './jobs/job.ts'
+export * from './jobs/manager.ts'
+export * from './jobs/router.ts'
+export * from './jobs/step.ts'
+export * from './pubsub/manager.ts'
+export * from './pubsub/redis.ts'
+export * from './scheduler/index.ts'
+export * from './server/config.ts'
+export * from './server/server.ts'
+export * from './store/index.ts'
+export * from './types.ts'
+export * from './workers/application.ts'
+export * from './workers/base.ts'
+export * from './workers/job.ts'

package/src/runtime/injectables.ts

@@ -0,0 +1,61 @@
+import { createLazyInjectable, Scope } from '@nmtjs/core'
+
+import type { JobWorkerPool, WorkerType } from './enums.ts'
+import type { JobManagerInstance } from './jobs/manager.ts'
+import type {
+  PubSubAdapterType,
+  PubSubPublish,
+  PubSubSubscribe,
+} from './pubsub/manager.ts'
+import type { ServerStoreConfig } from './server/config.ts'
+
+export const pubSubAdapter = createLazyInjectable<PubSubAdapterType>(
+  Scope.Global,
+  'PubSubAdapter',
+)
+
+export const pubSubPublish = createLazyInjectable<PubSubPublish>(
+  Scope.Global,
+  'PubSubPublish',
+)
+
+export const pubSubSubscribe = createLazyInjectable<PubSubSubscribe>(
+  Scope.Global,
+  'PubSubSubscribe',
+)
+
+export const jobManager = createLazyInjectable<JobManagerInstance>(
+  Scope.Global,
+  'JobManager',
+)
+
+export const storeConfig = createLazyInjectable<ServerStoreConfig>(
+  Scope.Global,
+  'StoreConfig',
+)
+
+export const workerType = createLazyInjectable<WorkerType>(
+  Scope.Global,
+  'WorkerType',
+)
+
+export const jobWorkerPool = createLazyInjectable<JobWorkerPool>(
+  Scope.Global,
+  'JobWorkerPool',
+)
+
+export const jobAbortSignal = createLazyInjectable<AbortSignal>(
+  Scope.Global,
+  'JobAbortSignal',
+)
+
+export const RuntimeInjectables = {
+  pubSubAdapter,
+  pubSubPublish,
+  pubSubSubscribe,
+  jobManager,
+  storeConfig,
+  workerType,
+  jobWorkerPool,
+  jobAbortSignal,
+}

package/src/runtime/jobs/job.ts

@@ -0,0 +1,370 @@
+import type { MaybePromise, TSError } from '@nmtjs/common'
+import type { Dependencies, DependencyContext } from '@nmtjs/core'
+import type { t } from '@nmtjs/type'
+import type { AnyObjectLikeType, ObjectType } from '@nmtjs/type/object'
+import { tryCaptureStackTrace } from '@nmtjs/common'
+
+import type { JobWorkerPool } from '../enums.ts'
+import type { AnyJobStep, JobStep } from './step.ts'
+import { kJobKey } from '../constants.ts'
+import { isJobStep } from './step.ts'
+
+type DefaultObjectType = ObjectType<{}>
+
+type DefaultResultType = Record<string, any>
+
+export type AnyJobOptions = JobOptions<string, any, any, any, any, any>
+
+export interface AnyJob {
+  _: { data: any; result: any; input: any; output: any; progress: any }
+  [kJobKey]: true
+  options: AnyJobOptions
+  steps: readonly AnyJobStep[]
+  conditions: Map<number, JobCondition<any, any, any, any>>
+  name: string
+  dependencies: Dependencies
+  input: AnyObjectLikeType
+  output: AnyObjectLikeType
+  progress: AnyObjectLikeType
+  afterEachHandler?: JobAfterEachHandler<any, any, any, any, any>
+  beforeEachHandler?: JobBeforeEachHandler<any, any, any, any, any>
+  onErrorHandler?: JobOnErrorHandler<any, any, any, any, any>
+  returnHandler?: JobReturnHandler<any, any, any, any, any, any>
+}
+
+export type JobBackoffOptions = {
+  type: 'fixed' | 'exponential'
+  delay: number
+  jitter?: number
+}
+
+export type JobCondition<
+  Deps extends Dependencies = {},
+  Result extends DefaultResultType = {},
+  Data = any,
+  Input extends AnyObjectLikeType = AnyObjectLikeType,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (params: {
+  context: DependencyContext<Deps>
+  data: Data
+  input: t.infer.decode.output<Input>
+  result: Result
+  progress: t.infer.decode.output<Progress>
+}) => MaybePromise<boolean>
+
+export type JobReturnHandler<
+  Deps extends Dependencies,
+  Result extends DefaultResultType,
+  Input extends AnyObjectLikeType,
+  Output extends AnyObjectLikeType,
+  Data,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (params: {
+  context: DependencyContext<Deps>
+  data: Data
+  input: t.infer.decode.output<Input>
+  result: Result
+  progress: t.infer.decode.output<Progress>
+}) => MaybePromise<t.infer.encode.input<Output>>
+
+export type JobDataHandler<
+  Deps extends Dependencies,
+  Input extends AnyObjectLikeType,
+  Data,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (
+  ctx: DependencyContext<Deps>,
+  input: t.infer.decode.output<Input>,
+  progress: t.infer.decode.output<Progress>,
+) => MaybePromise<Data>
+
+export type JobAfterEachHandler<
+  Deps extends Dependencies,
+  Result extends DefaultResultType,
+  Input extends AnyObjectLikeType,
+  Data,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (params: {
+  context: DependencyContext<Deps>
+  data: Data
+  input: t.infer.decode.output<Input>
+  result: Result
+  progress: t.infer.decode.output<Progress>
+  step: AnyJobStep
+  stepIndex: number
+}) => MaybePromise<void>
+
+export type JobBeforeEachHandler<
+  Deps extends Dependencies,
+  Result extends DefaultResultType,
+  Input extends AnyObjectLikeType,
+  Data,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (params: {
+  context: DependencyContext<Deps>
+  data: Data
+  input: t.infer.decode.output<Input>
+  result: Result
+  progress: t.infer.decode.output<Progress>
+  step: AnyJobStep
+  stepIndex: number
+}) => MaybePromise<void>
+
+export type JobOnErrorHandler<
+  Deps extends Dependencies,
+  Result extends DefaultResultType,
+  Input extends AnyObjectLikeType,
+  Data,
+  Progress extends AnyObjectLikeType = AnyObjectLikeType,
+> = (params: {
+  context: DependencyContext<Deps>
+  data: Data
+  input: t.infer.decode.output<Input>
+  result: Result
+  progress: t.infer.decode.output<Progress>
+  step: AnyJobStep
+  stepIndex: number
+  error: unknown
+}) => MaybePromise<
+  | boolean
+  // biome-ignore lint/suspicious/noConfusingVoidType: its ok
+  | void
+>
+
+export interface JobOptions<
+  Name extends string = string,
+  Input extends AnyObjectLikeType = AnyObjectLikeType,
+  Output extends AnyObjectLikeType = AnyObjectLikeType,
+  Progress extends AnyObjectLikeType = DefaultObjectType,
+  Deps extends Dependencies = {},
+  Data = any,
+> {
+  name: Name
+  pool: JobWorkerPool
+  input: Input
+  output: Output
+  progress?: Progress
+  concurrency?: number
+  timeout?: number
+  dependencies?: Deps
+  data?: JobDataHandler<Deps, Input, Data, Progress>
+  attempts?: number
+  backoff?: JobBackoffOptions
+  oneoff?: boolean
+}
+
+export class Job<
+  in out Name extends string = string,
+  in out Deps extends Dependencies = {},
+  in out Data = any,
+  in out Input extends AnyObjectLikeType = DefaultObjectType,
+  in out Output extends AnyObjectLikeType = DefaultObjectType,
+  in out Progress extends AnyObjectLikeType = DefaultObjectType,
+  out Steps extends [...AnyJobStep[]] = [],
+  in out Result extends DefaultResultType = {},
+  out Return extends boolean = false,
+> implements AnyJob
+{
+  _!: {
+    data: Data
+    result: Result & t.infer.decode.output<Input>
+    input: t.infer.decode.output<Input>
+    output: t.infer.decode.output<Output>
+    progress: t.infer.decode.output<Progress>
+  };
+  [kJobKey] = true as const
+  steps: Steps = [] as unknown as Steps
+  conditions: Map<number, JobCondition<any, any, any, any, any>> = new Map()
+  returnHandler?: JobReturnHandler<
+    Deps,
+    this['_']['result'],
+    Input,
+    Output,
+    Data,
+    Progress
+  >
+  afterEachHandler?: JobAfterEachHandler<
+    Deps,
+    this['_']['result'],
+    Input,
+    Data,
+    Progress
+  >
+  beforeEachHandler?: JobBeforeEachHandler<
+    Deps,
+    this['_']['result'],
+    Input,
+    Data,
+    Progress
+  >
+  onErrorHandler?: JobOnErrorHandler<
+    Deps,
+    this['_']['result'],
+    Input,
+    Data,
+    Progress
+  >
+
+  constructor(
+    public options: JobOptions<Name, Input, Output, Progress, Deps, Data>,
+    public stack?: string,
+  ) {}
+
+  get name(): Name {
+    return this.options.name
+  }
+
+  get dependencies(): Deps {
+    return this.options.dependencies ?? ({} as Deps)
+  }
+
+  get input(): Input {
+    return this.options.input as Input
+  }
+
+  get output(): Output {
+    return this.options.output as Output
+  }
+
+  get progress(): Progress {
+    return this.options.progress as Progress
+  }
+
+  step<
+    StepInput extends AnyObjectLikeType,
+    StepOutput extends AnyObjectLikeType,
+    StepDeps extends Dependencies,
+    StepResult,
+    Condition extends
+      | JobCondition<Deps, Result, this['_']['data'], Input>
+      | undefined,
+  >(
+    ...[step, condition]: Return extends false
+      ? [
+          step: JobStep<
+            StepInput,
+            StepOutput,
+            StepDeps,
+            this['_']['result'] extends t.infer.decode.output<StepInput>
+              ? t.infer.decode.output<StepOutput>
+              : TSError<
+                  'Accumulated job result does not satisfy current step input:',
+                  this['_']['result']
+                >,
+            this['_']['data']
+          >,
+          condition?: Condition,
+        ]
+      : [TSError<'Job has already has return statement'>]
+  ) {
+    if (!isJobStep(step)) throw new Error('Invalid job step object')
+
+    const length = this.steps.push(step)
+    if (condition) this.conditions.set(length - 1, condition)
+
+    return this as unknown as Job<
+      Name,
+      Deps,
+      Data,
+      Input,
+      Output,
+      Progress,
+      [...Steps, JobStep<StepInput, StepOutput, StepDeps, StepResult, any>],
+      Result &
+        (undefined extends Condition
+          ? t.infer.decode.output<
+              StepOutput extends undefined ? DefaultObjectType : StepOutput
+            >
+          : Partial<
+              t.infer.decode.output<
+                StepOutput extends undefined ? DefaultObjectType : StepOutput
+              >
+            >)
+    >
+  }
+
+  return(
+    ...[handler]: Return extends false
+      ? Result extends t.infer.encode.input<Output>
+        ? [
+            JobReturnHandler<
+              Deps,
+              this['_']['result'],
+              Input,
+              Output,
+              Data,
+              Progress
+            >?,
+          ]
+        : [
+            JobReturnHandler<
+              Deps,
+              this['_']['result'],
+              Input,
+              Output,
+              Data,
+              Progress
+            >,
+          ]
+      : [TSError<'Job already has a return statement'>]
+  ) {
+    if (typeof handler === 'function') {
+      this.returnHandler = handler
+    } else {
+      this.returnHandler = (result) => result as any
+    }
+    return this as unknown as Job<
+      Name,
+      Deps,
+      Data,
+      Input,
+      Output,
+      Progress,
+      Steps,
+      Result,
+      true
+    >
+  }
+
+  afterEach(
+    handler: Return extends true
+      ? JobAfterEachHandler<Deps, this['_']['result'], Input, Data, Progress>
+      : TSError<'Job must have a return statement to use afterEach'>,
+  ) {
+    this.afterEachHandler = handler as any
+    return this
+  }
+
+  beforeEach(
+    handler: Return extends true
+      ? JobBeforeEachHandler<Deps, this['_']['result'], Input, Data, Progress>
+      : TSError<'Job must have a return statement to use beforeEach'>,
+  ) {
+    this.beforeEachHandler = handler as any
+    return this
+  }
+
+  onError(
+    handler: Return extends true
+      ? JobOnErrorHandler<Deps, this['_']['result'], Input, Data, Progress>
+      : TSError<'Job must have a return statement to use onError'>,
+  ) {
+    this.onErrorHandler = handler as any
+    return this
+  }
+}
+
+export function createJob<
+  Name extends string,
+  Input extends AnyObjectLikeType,
+  Output extends AnyObjectLikeType,
+  Deps extends Dependencies = {},
+  Data = any,
+  Progress extends AnyObjectLikeType = DefaultObjectType,
+>(options: JobOptions<Name, Input, Output, Progress, Deps, Data>) {
+  const stack = tryCaptureStackTrace()
+  return new Job<Name, Deps, Data, Input, Output, Progress>(
+    { dependencies: {} as Deps, ...options },
+    stack,
+  )
+}