Fix circular dependencies in migrator

src/di/ContainerBlueprint.ts

@@ -1,9 +1,19 @@
-import {DependencyKey, Instantiable} from './types'
+import {DependencyKey, Instantiable, StaticClass, TypedDependencyKey} from './types'
 import NamedFactory from './factory/NamedFactory'
 import {AbstractFactory} from './factory/AbstractFactory'
 import {Factory} from './factory/Factory'
 import {ClosureFactory} from './factory/ClosureFactory'
 
+/** Simple type alias for a callback to a container's onResolve method. */
+export type ContainerResolutionCallback<T> = (() => unknown) | ((t: T) => unknown)
+
+/**
+ * Blueprint for newly-created containers.
+ *
+ * This is used to allow global helpers like `@Singleton()`
+ * or `@CLIDirective()` while still supporting multiple
+ * global Container instances at once.
+ */
 export class ContainerBlueprint {
     private static instance?: ContainerBlueprint
 
@@ -17,6 +27,19 @@ export class ContainerBlueprint {
 
     protected factories: (() => AbstractFactory<any>)[] = []
 
+    protected constructableFactories: StaticClass<AbstractFactory<any>, any>[] = []
+
+    protected resolutionCallbacks: ({key: TypedDependencyKey<any>, callback: ContainerResolutionCallback<any>})[] = []
+
+    /**
+     * Register some factory class with the container. Should take no construction params.
+     * @param factory
+     */
+    registerFactory(factory: StaticClass<AbstractFactory<any>, any>): this {
+        this.constructableFactories.push(factory)
+        return this
+    }
+
     /**
      * Register a basic instantiable class as a standard Factory with this container,
      * identified by a string name rather than static class.
@@ -47,7 +70,38 @@ export class ContainerBlueprint {
         return this
     }
 
+    /**
+     * Get an array of factory instances in the blueprint.
+     */
     resolve(): AbstractFactory<any>[] {
         return this.factories.map(x => x())
     }
+
+    /**
+     * Register an onResolve callback to be added to all newly-created containers.
+     * @param key
+     * @param callback
+     */
+    onResolve<T>(key: TypedDependencyKey<T>, callback: ContainerResolutionCallback<T>): this {
+        this.resolutionCallbacks.push({
+            key,
+            callback,
+        })
+        return this
+    }
+
+    /**
+     * Get an array of static Factory classes that need to be instantiated by
+     * the container itself.
+     */
+    resolveConstructable(): StaticClass<AbstractFactory<any>, any> {
+        return [...this.constructableFactories]
+    }
+
+    /**
+     * Get an array of DependencyKey-callback pairs to register with new containers.
+     */
+    resolveResolutionCallbacks(): ({key: TypedDependencyKey<any>, callback: ContainerResolutionCallback<any>})[] {
+        return [...this.resolutionCallbacks]
+    }
 }