Merge pull request #102 from denis-ilchishin/optional_deps

feat(application): add optional dependencies

Author: denny-il

packages/application/lib/api.spec.ts

@@ -179,7 +179,7 @@ describe.sequential('Api', () => {
 
   const call = (
     options: Pick<ProcedureCallOptions, 'procedure'> &
-      Partial<ProcedureCallOptions>,
+      Partial<Omit<ProcedureCallOptions, 'procedure'>>,
   ) =>
     api.call({
       container,

packages/application/lib/container.spec.ts

@@ -42,15 +42,6 @@ describe.sequential('Provider', () => {
     expect(newProvider).not.toBe(provider)
   })
 
-  it('should clone with a options', () => {
-    let newProvider = provider.withOptions({ some: 'option' })
-    expect(newProvider.options).to.deep.eq({ some: 'option' })
-    expect(newProvider).not.toBe(provider)
-    newProvider = provider.withOptions({ some: 'option', other: 'option' })
-    expect(newProvider.options).to.deep.eq({ some: 'option', other: 'option' })
-    expect(newProvider.scope).not.toBe(Scope.Transient)
-  })
-
   it('should clone with a dependencies', () => {
     const dep1 = new Provider().withValue('dep1')
     const dep2 = new Provider().withValue('dep2')
@@ -70,11 +61,6 @@ describe.sequential('Provider', () => {
     expect(newProvider.description).toBe('description')
     expect(newProvider).not.toBe(provider)
   })
-
-  it('should clone with options type', () => {
-    const newProvider = provider.withOptionsType<number>().withOptions(1)
-    expect(newProvider).not.toBe(provider)
-  })
 })
 
 describe.sequential('Container', () => {
@@ -118,16 +104,16 @@ describe.sequential('Container', () => {
     const dep1 = new Provider().withValue('dep1')
     const dep2 = new Provider()
       .withDependencies({ dep1 })
-      .withFactory(({ dep1 }) => ({ dep1 }))
+      .withFactory((deps) => deps)
     const dep3 = new Provider().withFactory(() => 'dep3')
     const provider = new Provider()
-      .withDependencies({ dep2, dep3 })
-      .withFactory(({ ...deps }) => deps)
+      .withDependencies({ dep2, dep3, dep4: dep3.optional() })
+      .withFactory((deps) => deps)
     const deps = await container.resolve(provider)
     expect(deps).toHaveProperty('dep2')
     expect(deps).toHaveProperty('dep3')
-    expect(deps).toHaveProperty('dep2.dep1')
-    expect(deps.dep2.dep1).toBe('dep1')
+    expect(deps).toHaveProperty('dep4', deps.dep3)
+    expect(deps).toHaveProperty('dep2.dep1', 'dep1')
   })
 
   it('should dispose', async () => {
@@ -140,12 +126,6 @@ describe.sequential('Container', () => {
     expect(spy).toHaveBeenCalledOnce()
   })
 
-  it('should provide with options', async () => {
-    const options = {}
-    const provider = new Provider().withFactory((ctx, options) => options)
-    expect(await container.resolve(provider.withOptions(options))).toBe(options)
-  })
-
   it('should be cached', async () => {
     const provider = new Provider().withFactory(() => ({}))
     const val = await container.resolve(provider)

packages/application/lib/container.ts

@@ -29,7 +29,10 @@ export function getProviderScope(provider: AnyProvider) {
   return scope
 }
 
-export type Dependencies = Record<string, AnyProvider>
+export type Dependencies = Record<
+  string,
+  AnyProvider | { isOptional: true; provider: AnyProvider }
+>
 
 export type ResolveProviderType<T extends Provider> = Awaited<T['value']>
 
@@ -38,31 +41,38 @@ export interface Depender<Deps extends Dependencies = {}> {
 }
 
 export type DependencyContext<Deps extends Dependencies> = {
-  [K in keyof Deps]: ResolveProviderType<Deps[K]>
+  [K in keyof Deps as Deps[K] extends AnyProvider
+    ? K
+    : never]: Deps[K] extends AnyProvider ? ResolveProviderType<Deps[K]> : never
+} & {
+  [K in keyof Deps as Deps[K] extends {
+    isOptional: true
+    provider: AnyProvider
+  }
+    ? K
+    : never]?: Deps[K] extends {
+    isOptional: true
+    provider: AnyProvider
+  }
+    ? ResolveProviderType<Deps[K]['provider']>
+    : never
 }
 
 export type ProviderFactoryType<
   ProviderType,
-  ProviderOptions,
   ProviderDeps extends Dependencies,
-> = (
-  injections: DependencyContext<ProviderDeps>,
-  options: ProviderOptions,
-) => ProviderType
+> = (injections: DependencyContext<ProviderDeps>) => ProviderType
 
 export type ProviderDisposeType<
   ProviderType,
-  ProviderOptions,
   ProviderDeps extends Dependencies,
 > = (
   instance: Awaited<ProviderType>,
   ctx: DependencyContext<ProviderDeps>,
-  options: ProviderOptions,
 ) => any
 
 export class Provider<
   ProviderValue = any,
-  ProviderOptions = unknown,
   ProviderDeps extends Dependencies = {},
 > implements Depender<ProviderDeps>
 {
@@ -79,56 +89,34 @@ export class Provider<
   readonly value!: ProviderValue
   readonly dependencies: ProviderDeps = {} as ProviderDeps
   readonly scope: Scope = Scope.Global
-  readonly factory!: ProviderFactoryType<
-    ProviderValue,
-    ProviderOptions,
-    ProviderDeps
-  >
-  readonly dispose?: ProviderDisposeType<
-    ProviderValue,
-    ProviderOptions,
-    ProviderDeps
-  >
-  readonly options!: ProviderOptions
+  readonly factory!: ProviderFactoryType<ProviderValue, ProviderDeps>
+  readonly dispose?: ProviderDisposeType<ProviderValue, ProviderDeps>
   readonly description!: string
 
   withDependencies<Deps extends Dependencies>(dependencies: Deps) {
-    const provider = new Provider<
-      ProviderValue,
-      ProviderOptions,
-      Merge<ProviderDeps, Deps>
-    >()
+    const provider = new Provider<ProviderValue, Merge<ProviderDeps, Deps>>()
     return Provider.override(provider, this, {
       dependencies: merge(this.dependencies, dependencies),
     })
   }
 
   withScope<S extends Scope>(scope: S) {
-    const provider = new Provider<
-      ProviderValue,
-      ProviderOptions,
-      ProviderDeps
-    >()
+    const provider = new Provider<ProviderValue, ProviderDeps>()
     return Provider.override(provider, this, { scope })
   }
 
-  withOptionsType<Options>() {
-    const provider = new Provider<ProviderValue, Options, ProviderDeps>()
-    return Provider.override(provider, this)
-  }
-
   withFactory<
-    F extends ProviderFactoryType<ProviderValue, ProviderOptions, ProviderDeps>,
+    F extends ProviderFactoryType<ProviderValue, ProviderDeps>,
     T extends Awaited<ReturnType<F>>,
   >(factory: F) {
-    const provider = new Provider<T, ProviderOptions, ProviderDeps>()
+    const provider = new Provider<T, ProviderDeps>()
     return Provider.override(provider, this, { factory, value: undefined })
   }
 
   withValue<T extends ProviderValue extends never ? any : ProviderValue>(
     value: T,
   ) {
-    const provider = new Provider<T, ProviderOptions, ProviderDeps>()
+    const provider = new Provider<T, ProviderDeps>()
     return Provider.override(provider, this, {
       value,
       factory: undefined,
@@ -137,31 +125,31 @@ export class Provider<
   }
 
   withDisposal(dispose: this['dispose']) {
-    const provider = new Provider<
-      ProviderValue,
-      ProviderOptions,
-      ProviderDeps
-    >()
+    const provider = new Provider<ProviderValue, ProviderDeps>()
     return Provider.override(provider, this, { dispose })
   }
 
-  withOptions(options: ProviderOptions) {
-    const provider = new Provider<
-      ProviderValue,
-      ProviderOptions,
-      ProviderDeps
-    >()
-    return Provider.override(provider, this, { options })
-  }
-
   withDescription(description: string) {
-    const provider = new Provider<
-      ProviderValue,
-      ProviderOptions,
-      ProviderDeps
-    >()
+    const provider = new Provider<ProviderValue, ProviderDeps>()
     return Provider.override(provider, this, { description })
   }
+
+  optional() {
+    return {
+      isOptional: true as const,
+      provider: this as Provider<ProviderValue, ProviderDeps>,
+    }
+  }
+
+  async resolve(
+    ...args: keyof ProviderDeps extends never
+      ? []
+      : [DependencyContext<ProviderDeps>]
+  ) {
+    if (this.value) return this.value
+    const [ctx = {}] = args
+    return await this.factory(ctx as any)
+  }
 }
 
 export class Container {
@@ -182,8 +170,10 @@ export class Container {
     const traverse = (dependencies: Dependencies) => {
       for (const key in dependencies) {
         const depender = dependencies[key]
-        this.providers.add(depender)
-        traverse(depender.dependencies)
+        const provider =
+          depender instanceof Provider ? depender : depender.provider
+        this.providers.add(provider)
+        traverse(provider.dependencies)
       }
     }
 
@@ -204,11 +194,11 @@ export class Container {
     // to prevent first disposal of a provider
     // that other disposing provider depends on
     this.application.logger.trace('Disposing [%s] scope context...', this.scope)
-    for (const [{ dispose, options, dependencies }, value] of this.instances) {
+    for (const [{ dispose, dependencies }, value] of this.instances) {
       if (dispose) {
         try {
           const ctx = await this.createContext(dependencies)
-          await dispose(value, ctx, options)
+          await dispose(value, ctx)
         } catch (cause) {
           this.application.logger.error(
             new Error('Context disposal error. Potential memory leak', {
@@ -237,13 +227,12 @@ export class Container {
     } else if (this.resolvers.has(provider)) {
       return this.resolvers.get(provider)!
     } else {
-      const { value, factory, scope, dependencies, options } = provider
+      const { value, factory, scope, dependencies } = provider
       if (typeof value !== 'undefined') return Promise.resolve(value)
       if (this.parent?.isResolved(provider))
         return this.parent.resolve(provider)
-      // if (typeof factory !== 'function') console.log(provider)
       const resolution = this.createContext(dependencies)
-        .then((ctx) => factory(ctx, options))
+        .then((ctx) => factory(ctx))
         .then((instance) => {
           if (ScopeStrictness[this.scope] >= ScopeStrictness[scope])
             this.instances.set(provider, instance)
@@ -271,7 +260,9 @@ export class Container {
     const injections: any = {}
     const resolvers: Promise<any>[] = []
     for (const [key, dependency] of Object.entries(dependencies)) {
-      const resolver = this.resolve(dependency)
+      const provider =
+        dependency instanceof Provider ? dependency : dependency.provider
+      const resolver = this.resolve(provider)
       resolvers.push(resolver.then((value) => (injections[key] = value)))
     }
     await Promise.all(resolvers)

packages/application/lib/types.ts

@@ -80,8 +80,8 @@ export type ConnectionProvider<T, C> = Provider<ConnectionFn<T, C>>
 
 export type AnyApplication = Application<any, any, any, any>
 
-export type AnyProvider = Provider<any, any, any>
-export type AnyProcedure = Procedure<any, any, any, any>
+export type AnyProvider = Provider<any, any>
+export type AnyProcedure = Procedure<any, any, any, any, any>
 export type AnyTask = Task<any, any, any>
 export type AnyEvent = Event<any, any, any>