@nmtjs/core 0.12.6 → 0.12.8

package/package.json

@@ -11,23 +11,22 @@
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.12.6",
-    "@nmtjs/type": "0.12.6"
+    "@nmtjs/common": "0.12.8",
+    "@nmtjs/type": "0.12.8"
   },
   "devDependencies": {
     "@types/node": "^20",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.12.6",
-    "@nmtjs/type": "0.12.6"
+    "@nmtjs/common": "0.12.8",
+    "@nmtjs/type": "0.12.8"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.8",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/constants.ts

@@ -1,41 +0,0 @@
-export const kOptionalDependency: unique symbol = Symbol.for(
-  'neemata:OptionalDependencyKey',
-)
-export type kOptionalDependency = typeof kOptionalDependency
-
-export const kInjectable: unique symbol = Symbol.for('neemata:InjectableKey')
-export type kInjectable = typeof kInjectable
-
-export const kLazyInjectable: unique symbol = Symbol.for(
-  'neemata:LazyInjectableKey',
-)
-export type kLazyInjectable = typeof kLazyInjectable
-
-export const kValueInjectable: unique symbol = Symbol.for(
-  'neemata:ValueInjectableKey',
-)
-export type kValueInjectable = typeof kValueInjectable
-
-export const kFactoryInjectable: unique symbol = Symbol.for(
-  'neemata:FactoryInjectableKey',
-)
-export type kFactoryInjectable = typeof kFactoryInjectable
-
-export const kClassInjectable: unique symbol = Symbol.for(
-  'neemata:ClassInjectableKey',
-)
-export type kClassInjectable = typeof kClassInjectable
-
-export const kProvider: unique symbol = Symbol.for('neemata:ProviderKey')
-export type kProvider = typeof kProvider
-
-export const kHookCollection: unique symbol = Symbol.for(
-  'neemata:HookCollectionKey',
-)
-export type kHookCollection = typeof kHookCollection
-
-export const kPlugin: unique symbol = Symbol.for('neemata:PluginKey')
-export type kPlugin = typeof kPlugin
-
-export const kMetadata: unique symbol = Symbol.for('neemata:MetadataKey')
-export type kMetadata = typeof kMetadata

package/src/container.ts

@@ -1,440 +0,0 @@
-import assert from 'node:assert'
-import { tryCaptureStackTrace } from '@nmtjs/common'
-import { Scope } from './enums.ts'
-import {
-  type AnyInjectable,
-  CoreInjectables,
-  compareScope,
-  createExtendableClassInjectable,
-  createValueInjectable,
-  type Dependencies,
-  type DependencyContext,
-  getDepedencencyInjectable,
-  isClassInjectable,
-  isFactoryInjectable,
-  isInjectable,
-  isLazyInjectable,
-  isOptionalInjectable,
-  isValueInjectable,
-  type ResolveInjectableType,
-} from './injectables.ts'
-import type { Logger } from './logger.ts'
-import type { Registry } from './registry.ts'
-
-type InstanceWrapper = { private: any; public: any; context: any }
-
-type ContainerOptions = {
-  registry: Registry
-  logger: Logger
-}
-
-export class Container {
-  readonly instances = new Map<AnyInjectable, InstanceWrapper[]>()
-  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()
-  private readonly injectables = new Set<AnyInjectable>()
-  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()
-  // private readonly transients = new Map<any, any>()
-  private disposing = false
-
-  constructor(
-    private readonly application: ContainerOptions,
-    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,
-    private readonly parent?: Container,
-  ) {
-    if ((scope as any) === Scope.Transient) {
-      throw new Error('Invalid scope')
-    }
-    this.provide(CoreInjectables.inject, this.createInjectFunction())
-    this.provide(CoreInjectables.dispose, this.createDisposeFunction())
-    this.provide(CoreInjectables.registry, application.registry)
-  }
-
-  async load() {
-    const traverse = (dependencies: Dependencies) => {
-      for (const key in dependencies) {
-        const dependency = dependencies[key]
-        const injectable = getDepedencencyInjectable(dependency)
-        this.injectables.add(injectable)
-        traverse(injectable.dependencies)
-      }
-    }
-
-    for (const dependant of this.application.registry.getDependants()) {
-      traverse(dependant.dependencies)
-    }
-
-    const injectables = Array.from(this.findCurrentScopeInjectables())
-    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))
-  }
-
-  fork(scope: Exclude<Scope, Scope.Transient>) {
-    return new Container(this.application, scope, this)
-  }
-
-  async dispose() {
-    this.application.logger.trace('Disposing [%s] scope context...', this.scope)
-
-    // Prevent new resolutions during disposal
-    this.disposing = true
-
-    // Get proper disposal order using topological sort
-    const disposalOrder = this.getDisposalOrder()
-
-    // Dispose in the correct order
-    for (const injectable of disposalOrder) {
-      if (this.instances.has(injectable)) {
-        await this.disposeInjectableInstances(injectable)
-      }
-    }
-
-    this.instances.clear()
-    this.injectables.clear()
-    this.resolvers.clear()
-    this.dependants.clear()
-
-    this.disposing = false
-  }
-
-  containsWithinSelf(injectable: AnyInjectable) {
-    return this.instances.has(injectable) || this.resolvers.has(injectable)
-  }
-
-  contains(injectable: AnyInjectable): boolean {
-    return (
-      this.containsWithinSelf(injectable) ||
-      (this.parent?.contains(injectable) ?? false)
-    )
-  }
-
-  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {
-    if (injectable.scope === Scope.Transient) {
-      throw new Error('Cannot get transient injectable directly')
-    }
-
-    if (this.instances.has(injectable)) {
-      return this.instances.get(injectable)!.at(0)!.public
-    }
-
-    if (this.parent?.contains(injectable)) {
-      return this.parent.get(injectable)
-    }
-
-    throw new Error('No instance found')
-  }
-
-  resolve<T extends AnyInjectable>(injectable: T) {
-    return this.resolveInjectable(injectable)
-  }
-
-  async createContext<T extends Dependencies>(dependencies: T) {
-    return this.createInjectableContext(dependencies)
-  }
-
-  private async createInjectableContext<T extends Dependencies>(
-    dependencies: T,
-    dependant?: AnyInjectable,
-  ) {
-    const injections: Record<string, any> = {}
-    const deps = Object.entries(dependencies)
-    const resolvers: Promise<any>[] = Array(deps.length)
-    for (let i = 0; i < deps.length; i++) {
-      const [key, dependency] = deps[i]
-      const injectable = getDepedencencyInjectable(dependency)
-      const resolver = this.resolveInjectable(injectable, dependant)
-      resolvers[i] = resolver.then((value) => (injections[key] = value))
-    }
-    await Promise.all(resolvers)
-    return Object.freeze(injections) as DependencyContext<T>
-  }
-
-  async provide<T extends AnyInjectable>(
-    injectable: T,
-    instance: ResolveInjectableType<T>,
-  ) {
-    if (compareScope(injectable.scope, '>', this.scope)) {
-      throw new Error('Invalid scope') // TODO: more informative error
-    }
-
-    this.instances.set(injectable, [
-      {
-        private: instance,
-        public: instance,
-        context: undefined,
-      },
-    ])
-  }
-
-  satisfies(injectable: AnyInjectable) {
-    return compareScope(injectable.scope, '<=', this.scope)
-  }
-
-  private *findCurrentScopeInjectables() {
-    for (const injectable of this.injectables) {
-      if (injectable.scope === this.scope) {
-        yield injectable
-      }
-    }
-  }
-
-  private resolveInjectable<T extends AnyInjectable>(
-    injectable: T,
-    dependant?: AnyInjectable,
-  ): Promise<ResolveInjectableType<T>> {
-    if (this.disposing) {
-      return Promise.reject(new Error('Cannot resolve during disposal'))
-    }
-
-    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
-      // TODO: more informative error
-      return Promise.reject(
-        new Error('Invalid scope: dependant is looser than injectable'),
-      )
-    }
-
-    if (isValueInjectable(injectable)) {
-      return Promise.resolve(injectable.value)
-    } else if (
-      this.parent?.contains(injectable) ||
-      (this.parent?.satisfies(injectable) &&
-        compareScope(this.parent.scope, '<', this.scope))
-    ) {
-      return this.parent.resolveInjectable(injectable, dependant)
-    } else {
-      const { stack, label } = injectable
-
-      if (dependant) {
-        let dependants = this.dependants.get(injectable)
-        if (!dependants) {
-          this.dependants.set(injectable, (dependants = new Set()))
-        }
-        dependants.add(dependant)
-      }
-
-      const isTransient = injectable.scope === Scope.Transient
-
-      if (!isTransient && this.instances.has(injectable)) {
-        return Promise.resolve(this.instances.get(injectable)!.at(0)!.public)
-      } else if (!isTransient && this.resolvers.has(injectable)) {
-        return this.resolvers.get(injectable)!
-      } else {
-        const isLazy = isLazyInjectable(injectable)
-
-        if (isLazy) {
-          const isOptional = isOptionalInjectable(injectable)
-          if (isOptional) return Promise.resolve(undefined as any)
-          return Promise.reject(
-            new Error(
-              `No instance provided for ${label || 'an'} injectable:\n${stack}`,
-            ),
-          )
-        } else {
-          const resolution = this.createResolution(injectable).finally(() => {
-            this.resolvers.delete(injectable)
-          })
-          if (injectable.scope !== Scope.Transient) {
-            this.resolvers.set(injectable, resolution)
-          }
-          return resolution
-        }
-      }
-    }
-  }
-
-  private async createResolution<T extends AnyInjectable>(
-    injectable: T,
-  ): Promise<ResolveInjectableType<T>> {
-    const { dependencies } = injectable
-    const context = await this.createInjectableContext(dependencies, injectable)
-    const wrapper = {
-      private: null as any,
-      public: null as ResolveInjectableType<T>,
-      context,
-    }
-    if (isFactoryInjectable(injectable)) {
-      wrapper.private = await Promise.resolve(
-        injectable.factory(wrapper.context),
-      )
-      wrapper.public = injectable.pick(wrapper.private)
-    } else if (isClassInjectable(injectable)) {
-      wrapper.private = new injectable(context)
-      wrapper.public = wrapper.private
-      await wrapper.private.$onCreate()
-    } else {
-      throw new Error('Invalid injectable type')
-    }
-
-    let instances = this.instances.get(injectable)
-
-    if (!instances) {
-      instances = []
-      this.instances.set(injectable, instances)
-    }
-    instances.push(wrapper)
-
-    return wrapper.public
-  }
-
-  private createInjectFunction() {
-    const inject = <T extends AnyInjectable>(
-      injectable: T,
-      context: InlineInjectionDependencies<T>,
-    ) => {
-      const dependencies: Dependencies = {
-        ...injectable.dependencies,
-      }
-
-      for (const key in context) {
-        const dep = context[key]
-        if (isInjectable(dep) || isOptionalInjectable(dep)) {
-          dependencies[key] = dep
-        } else {
-          dependencies[key] = createValueInjectable(dep)
-        }
-      }
-
-      const newInjectable = isClassInjectable(injectable)
-        ? createExtendableClassInjectable(
-            injectable,
-            dependencies,
-            Scope.Transient,
-            1,
-          )
-        : {
-            ...injectable,
-            dependencies,
-            scope: Scope.Transient,
-            stack: tryCaptureStackTrace(1),
-          }
-
-      return this.resolve(newInjectable) as Promise<ResolveInjectableType<T>>
-    }
-
-    const explicit = async <T extends AnyInjectable>(
-      injectable: T,
-      context: InlineInjectionDependencies<T>,
-    ) => {
-      if ('asyncDispose' in Symbol === false) {
-        throw new Error(
-          'Symbol.asyncDispose is not supported in this environment',
-        )
-      }
-      const instance = await inject(injectable, context)
-      const dispose = this.createDisposeFunction()
-      return Object.assign(instance, {
-        [Symbol.asyncDispose]: async () => {
-          await dispose(injectable, instance)
-        },
-      })
-    }
-
-    return Object.assign(inject, { explicit })
-  }
-
-  private createDisposeFunction() {
-    return async <T extends AnyInjectable>(injectable: T, instance?: any) => {
-      if (injectable.scope === Scope.Transient) {
-        assert(
-          instance,
-          'Instance is required for transient injectable disposal',
-        )
-        const wrappers = this.instances.get(injectable)
-        if (wrappers) {
-          for (const wrapper of wrappers) {
-            if (wrapper.public === instance) {
-              await this.disposeInjectableInstance(
-                injectable,
-                wrapper.private,
-                wrapper.context,
-              )
-              const index = wrappers.indexOf(wrapper)
-              wrappers.splice(index, 1)
-            }
-          }
-
-          if (wrappers.length === 0) {
-            this.instances.delete(injectable)
-          }
-        }
-      } else {
-        await this.disposeInjectableInstances(injectable)
-      }
-    }
-  }
-
-  private getDisposalOrder(): AnyInjectable[] {
-    const visited = new Set<AnyInjectable>()
-    const result: AnyInjectable[] = []
-
-    const visit = (injectable: AnyInjectable) => {
-      if (visited.has(injectable)) return
-      visited.add(injectable)
-
-      const dependants = this.dependants.get(injectable)
-      if (dependants) {
-        for (const dependant of dependants) {
-          if (this.instances.has(dependant)) {
-            visit(dependant)
-          }
-        }
-      }
-
-      // Only add to result if this container owns the instance
-      if (this.instances.has(injectable)) {
-        result.push(injectable)
-      }
-    }
-
-    for (const injectable of this.instances.keys()) {
-      visit(injectable)
-    }
-
-    return result
-  }
-
-  private async disposeInjectableInstances(injectable: AnyInjectable) {
-    try {
-      if (this.instances.has(injectable)) {
-        const wrappers = this.instances.get(injectable)!
-        await Promise.all(
-          wrappers.map((wrapper) =>
-            this.disposeInjectableInstance(
-              injectable,
-              wrapper.private,
-              wrapper.context,
-            ),
-          ),
-        )
-      }
-    } catch (cause) {
-      const error = new Error(
-        'Injectable disposal error. Potential memory leak',
-        { cause },
-      )
-      this.application.logger.error(error)
-    } finally {
-      this.instances.delete(injectable)
-    }
-  }
-
-  private async disposeInjectableInstance(
-    injectable: AnyInjectable,
-    instance: any,
-    context: any,
-  ) {
-    if (isFactoryInjectable(injectable)) {
-      const { dispose } = injectable
-      if (dispose) await dispose(instance, context)
-    } else if (isClassInjectable(injectable)) {
-      await instance.$onDispose()
-    }
-  }
-}
-
-type InlineInjectionDependencies<T extends AnyInjectable> = {
-  [K in keyof T['dependencies']]?:
-    | ResolveInjectableType<T['dependencies'][K]>
-    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>
-}
-
-export type InjectFn = ReturnType<Container['createInjectFunction']>
-export type DisposeFn = ReturnType<Container['createDisposeFunction']>

package/src/enums.ts

@@ -1,19 +0,0 @@
-export enum Scope {
-  Global = 'Global',
-  Connection = 'Connection',
-  Call = 'Call',
-  Transient = 'Transient',
-}
-
-export enum Hook {
-  BeforeInitialize = 'BeforeInitialize',
-  AfterInitialize = 'AfterInitialize',
-  BeforeStart = 'BeforeStart',
-  AfterStart = 'AfterStart',
-  BeforeStop = 'BeforeStop',
-  AfterStop = 'AfterStop',
-  BeforeTerminate = 'BeforeTerminate',
-  AfterTerminate = 'AfterTerminate',
-  OnConnect = 'OnConnect',
-  OnDisconnect = 'OnDisconnect',
-}

package/src/hooks.ts

@@ -1,69 +0,0 @@
-import type { Callback } from '@nmtjs/common'
-import { kHookCollection } from './constants.ts'
-import type { Hook } from './enums.ts'
-
-export interface HookType {
-  [key: string]: (...args: any[]) => any
-  // [Hook.AfterInitialize]: () => any
-  // [Hook.BeforeStart]: () => any
-  // [Hook.AfterStart]: () => any
-  // [Hook.BeforeStop]: () => any
-  // [Hook.AfterStop]: () => any
-  // [Hook.BeforeTerminate]: () => any
-  // [Hook.AfterTerminate]: () => any
-  // [Hook.OnConnect]: (...args: any[]) => any
-  // [Hook.OnDisconnect]: (...args: any[]) => any
-}
-
-export type CallHook<T extends string> = (
-  hook: T,
-  ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]
-) => Promise<void>
-
-export class Hooks {
-  static merge(from: Hooks, to: Hooks) {
-    for (const [name, callbacks] of from[kHookCollection]) {
-      for (const callback of callbacks) {
-        to.add(name, callback)
-      }
-    }
-  }
-
-  [kHookCollection] = new Map<string, Set<Callback>>()
-
-  add(name: string, callback: Callback) {
-    let hooks = this[kHookCollection].get(name)
-    if (!hooks) this[kHookCollection].set(name, (hooks = new Set()))
-    hooks.add(callback)
-    return () => this.remove(name, callback)
-  }
-
-  remove(name: string, callback: Callback) {
-    const hooks = this[kHookCollection].get(name)
-    if (hooks) hooks.delete(callback)
-  }
-
-  async call<T extends string | Hook>(
-    name: T,
-    options: { concurrent?: boolean; reverse?: boolean } | undefined,
-    ...args: T extends Hook ? Parameters<HookType[T]> : any[]
-  ) {
-    const { concurrent = true, reverse = false } = options ?? {}
-    const hooks = this[kHookCollection].get(name)
-    if (!hooks) return
-    const hooksArr = Array.from(hooks)
-    if (concurrent) {
-      await Promise.all(hooksArr.map((hook) => hook(...args)))
-    } else {
-      if (reverse) hooksArr.reverse()
-      for (const hook of hooksArr) await hook(...args)
-    }
-  }
-
-  clear() {
-    this[kHookCollection].clear()
-  }
-}
-
-export const createErrForHook = (hook: Hook | (object & string)) =>
-  `Error during [${hook}] hook`

package/src/index.ts

@@ -1,15 +0,0 @@
-// biome-ignore lint/correctness/noUnusedImports: TSC wants it
-// biome-ignore assist/source/organizeImports: TSC wants it
-import {} from 'pino'
-
-export * from './constants.ts'
-export * from './container.ts'
-export * from './enums.ts'
-export * from './hooks.ts'
-export * from './injectables.ts'
-export * from './logger.ts'
-export * from './metadata.ts'
-export * from './plugin.ts'
-export * from './registry.ts'
-export * from './types.ts'
-export * from './utils/index.ts'