@nmtjs/core 0.7.3 → 0.7.5

package/src/container.ts

@@ -1,122 +1,27 @@
-import { type Async, tryCaptureStackTrace } from '@nmtjs/common'
-import {
-  kFactoryInjectable,
-  kInjectable,
-  kLazyInjectable,
-  kOptionalDependency,
-  kValueInjectable,
-} from './constants.ts'
 import { Scope } from './enums.ts'
+import {
+  type AnyInjectable,
+  CoreInjectables,
+  compareScope,
+  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'
 
-const ScopeStrictness = {
-  [Scope.Global]: 0,
-  [Scope.Connection]: 1,
-  [Scope.Call]: 2,
-  [Scope.Transient]: 3,
-}
-
-export type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {
-  [kOptionalDependency]: any
-  injectable: T
-}
-
-export type Depedency = DependencyOptional | AnyInjectable
-
-export type Dependencies = Record<string, Depedency>
-
-export type ResolveInjectableType<T extends AnyInjectable> =
-  T extends Injectable<infer Type, any, any> ? Type : never
-
-export interface Dependant<Deps extends Dependencies = Dependencies> {
-  dependencies: Deps
-  label?: string
-  stack?: string
-}
-
-export type DependencyInjectable<T extends Depedency> = T extends AnyInjectable
-  ? T
-  : T extends DependencyOptional
-    ? T['injectable']
-    : never
-
-export type DependencyContext<Deps extends Dependencies> = {
-  readonly [K in keyof Deps as Deps[K] extends AnyInjectable
-    ? K
-    : never]: Deps[K] extends AnyInjectable
-    ? ResolveInjectableType<Deps[K]>
-    : never
-} & {
-  readonly [K in keyof Deps as Deps[K] extends DependencyOptional
-    ? K
-    : never]?: Deps[K] extends DependencyOptional
-    ? ResolveInjectableType<Deps[K]['injectable']>
-    : never
-}
-
-export type InjectableFactoryType<
-  InjectableType,
-  InjectableDeps extends Dependencies,
-> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>
-
-export type InjectablePickType<Input, Output> = (injectable: Input) => Output
-
-export type InjectableDisposeType<
-  InjectableType,
-  InjectableDeps extends Dependencies,
-> = (
-  instance: InjectableType,
-  context: DependencyContext<InjectableDeps>,
-) => any
-
-export interface LazyInjectable<T, S extends Scope = Scope.Global>
-  extends Dependant<{}> {
-  scope: S
-  [kInjectable]: any
-  [kLazyInjectable]: T
-}
-
-export interface ValueInjectable<T> extends Dependant<{}> {
-  scope: Scope.Global
-  value: T
-  [kInjectable]: any
-  [kValueInjectable]: any
-}
-
-export interface FactoryInjectable<
-  T,
-  D extends Dependencies = {},
-  S extends Scope = Scope.Global,
-  P = T,
-> extends Dependant<D> {
-  scope: S
-  factory: InjectableFactoryType<P, D>
-  pick: InjectablePickType<P, T>
-  dispose?: InjectableDisposeType<P, D>
-  [kInjectable]: any
-  [kFactoryInjectable]: any
-}
-
-export type Injectable<
-  InjectableValue = any,
-  InjectableDeps extends Dependencies = {},
-  InjectableScope extends Scope = Scope,
-> =
-  | LazyInjectable<InjectableValue, InjectableScope>
-  | ValueInjectable<InjectableValue>
-  | FactoryInjectable<InjectableValue, InjectableDeps, InjectableScope, any>
-
-export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<
-  T,
-  any,
-  S
->
-
 export class Container {
   readonly instances = new Map<
     AnyInjectable,
-    { instance: any; picked: any; context: any }
+    { instance: any; picked?: any; context?: any }
   >()
   private readonly resolvers = new Map<AnyInjectable, Promise<any>>()
   private readonly injectables = new Set<AnyInjectable>()
@@ -133,6 +38,7 @@ export class Container {
     if ((scope as any) === Scope.Transient) {
       throw new Error('Invalid scope')
     }
+    this.provide(CoreInjectables.inject, createInjectFunction(this))
   }
 
   async load() {
@@ -267,7 +173,7 @@ export class Container {
       throw new Error('Invalid scope: dependant is looser than injectable')
     }
 
-    if (checkIsValueInjectable(injectable)) {
+    if (isValueInjectable(injectable)) {
       return Promise.resolve(injectable.value)
     } else if (
       this.parent?.contains(injectable) ||
@@ -291,52 +197,78 @@ export class Container {
       } else if (this.resolvers.has(injectable)) {
         return this.resolvers.get(injectable)!
       } else {
-        const isLazy = checkIsLazyInjectable(injectable)
+        const isLazy = isLazyInjectable(injectable)
 
         if (isLazy) {
-          const isOptional = checkIsOptional(injectable)
+          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 if (!checkIsFactoryInjectable(injectable)) {
-          throw new Error('Invalid injectable')
-        }
-
-        const resolution = this.createInjectableContext(
-          dependencies,
-          injectable,
-        )
-          .then((context) =>
-            Promise.resolve(injectable.factory(context)).then((instance) => ({
-              instance,
-              context,
-            })),
+        } else if (isFactoryInjectable(injectable)) {
+          const resolution = this.createInjectableContext(
+            dependencies,
+            injectable,
+          )
+            .then((context) =>
+              Promise.resolve(injectable.factory(context)).then((instance) => ({
+                instance,
+                context,
+              })),
+            )
+            .then(({ instance, context }) => {
+              const picked = injectable.pick(instance)
+              if (compareScope(this.scope, '>=', scope))
+                this.instances.set(injectable, { instance, picked, context })
+              if (scope !== Scope.Transient) this.resolvers.delete(injectable)
+              return picked
+            })
+          if (scope !== Scope.Transient)
+            this.resolvers.set(injectable, resolution)
+          return resolution
+        } else if (isClassInjectable(injectable)) {
+          const resolution = this.createInjectableContext(
+            dependencies,
+            injectable,
           )
-          .then(({ instance, context }) => {
-            const picked = injectable.pick(instance)
-            if (compareScope(this.scope, '>=', scope))
-              this.instances.set(injectable, { instance, picked, context })
-            if (scope !== Scope.Transient) this.resolvers.delete(injectable)
-            return picked
-          })
-        if (scope !== Scope.Transient)
-          this.resolvers.set(injectable, resolution)
-        return resolution
+            .then((context) => {
+              const instance = new injectable(context)
+              return instance.$onCreate().then(() => instance)
+            })
+            .then((instance) => {
+              // const picked = injectable.pick(instance)
+              if (compareScope(this.scope, '>=', scope))
+                this.instances.set(injectable, {
+                  instance,
+                  picked: undefined,
+                  context: undefined,
+                })
+              if (scope !== Scope.Transient) this.resolvers.delete(injectable)
+              return instance
+            })
+          if (scope !== Scope.Transient)
+            this.resolvers.set(injectable, resolution)
+          return resolution
+        } else {
+          throw new Error('Invalid injectable type')
+        }
       }
     }
   }
 
   private async disposeInjectable(injectable: AnyInjectable) {
     try {
-      if (kFactoryInjectable in injectable) {
+      if (isFactoryInjectable(injectable)) {
         const { dispose } = injectable
         if (dispose) {
           const { instance, context } = this.instances.get(injectable)!
           await dispose(instance, context)
         }
+      } else if (isClassInjectable(injectable)) {
+        const { instance } = this.instances.get(injectable)!
+        await instance.$onDispose()
       }
     } catch (cause) {
       const error = new Error(
@@ -350,146 +282,36 @@ export class Container {
   }
 }
 
-function compareScope(
-  left: Scope,
-  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',
-  right: Scope,
-) {
-  const leftScope = ScopeStrictness[left]
-  const rightScope = ScopeStrictness[right]
-  switch (operator) {
-    case '=':
-      return leftScope === rightScope
-    case '!=':
-      return leftScope !== rightScope
-    case '>':
-      return leftScope > rightScope
-    case '<':
-      return leftScope < rightScope
-    case '>=':
-      return leftScope >= rightScope
-    case '<=':
-      return leftScope <= rightScope
-    default:
-      throw new Error('Invalid operator')
-  }
-}
+export function createInjectFunction(container: Container) {
+  return <T extends AnyInjectable>(
+    injectable: T,
+    context: InlineInjectionDependencies<T>,
+  ) => {
+    const dependencies: Dependencies = {}
+
+    for (const key in context) {
+      const dep = context[key]
+      if (isInjectable(dep) || isOptionalInjectable(dep)) {
+        dependencies[key] = dep
+      } else {
+        dependencies[key] = createValueInjectable(dep)
+      }
+    }
 
-export const checkIsLazyInjectable = (
-  injectable: any,
-): injectable is LazyInjectable<any> => kLazyInjectable in injectable
-export const checkIsFactoryInjectable = (
-  injectable: any,
-): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable
-export const checkIsValueInjectable = (
-  injectable: any,
-): injectable is ValueInjectable<any> => kValueInjectable in injectable
-export const checkIsInjectable = (
-  injectable: any,
-): injectable is AnyInjectable<any> => kInjectable in injectable
-export const checkIsOptional = (
-  injectable: any,
-): injectable is DependencyOptional<any> => kOptionalDependency in injectable
-
-export function getInjectableScope(injectable: AnyInjectable) {
-  let scope = injectable.scope
-  const deps = Object.values(injectable.dependencies as Dependencies)
-  for (const dependency of deps) {
-    const injectable = getDepedencencyInjectable(dependency)
-    const dependencyScope = getInjectableScope(injectable)
-    if (compareScope(dependencyScope, '>', scope)) {
-      scope = dependencyScope
+    const newInjectable = {
+      ...injectable,
+      dependencies,
+      scope: Scope.Transient,
     }
-  }
-  return scope
-}
 
-export function getDepedencencyInjectable(
-  dependency: Depedency,
-): AnyInjectable {
-  if (kOptionalDependency in dependency) {
-    return dependency.injectable
+    return container.resolve(newInjectable)
   }
-  return dependency
-}
-
-export function createOptionalInjectable<T extends AnyInjectable>(
-  injectable: T,
-) {
-  return {
-    [kOptionalDependency]: true,
-    injectable,
-  } as DependencyOptional<T>
-}
-
-export function createLazyInjectable<T, S extends Scope = Scope.Global>(
-  scope = Scope.Global as S,
-  label?: string,
-): LazyInjectable<T, S> {
-  return Object.freeze({
-    scope,
-    dependencies: {},
-    label,
-    stack: tryCaptureStackTrace(),
-    [kInjectable]: true,
-    [kLazyInjectable]: true as unknown as T,
-  })
 }
 
-export function createValueInjectable<T>(
-  value: T,
-  label?: string,
-): ValueInjectable<T> {
-  return Object.freeze({
-    value,
-    scope: Scope.Global,
-    dependencies: {},
-    label,
-    stack: tryCaptureStackTrace(),
-    [kInjectable]: true,
-    [kValueInjectable]: true,
-  })
+type InlineInjectionDependencies<T extends AnyInjectable> = {
+  [K in keyof T['dependencies']]:
+    | ResolveInjectableType<T['dependencies'][K]>
+    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>
 }
 
-export function createFactoryInjectable<
-  T,
-  D extends Dependencies = {},
-  S extends Scope = Scope.Global,
-  P = T,
->(
-  paramsOrFactory:
-    | {
-        dependencies?: D
-        scope?: S
-        pick?: InjectablePickType<P, T>
-        factory: InjectableFactoryType<P, D>
-        dispose?: InjectableDisposeType<P, D>
-      }
-    | InjectableFactoryType<P, D>,
-  label?: string,
-): FactoryInjectable<null extends T ? P : T, D, S, P> {
-  const isFactory = typeof paramsOrFactory === 'function'
-  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory
-  const injectable = {
-    dependencies: (params.dependencies ?? {}) as D,
-    scope: (params.scope ?? Scope.Global) as S,
-    factory: params.factory,
-    dispose: params.dispose,
-    pick: params.pick ?? ((instance: P) => instance as unknown as T),
-    label,
-    stack: tryCaptureStackTrace(),
-    [kInjectable]: true,
-    [kFactoryInjectable]: true,
-  }
-  const actualScope = getInjectableScope(injectable)
-  if (
-    !isFactory &&
-    params.scope &&
-    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]
-  )
-    throw new Error(
-      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,
-    )
-  injectable.scope = actualScope as unknown as S
-  return Object.freeze(injectable) as any
-}
+export type InjectFn = ReturnType<typeof createInjectFunction>