fix(@gabliam/core): change middleware by activation hook.

middlewares aren't called for all bean (typically for request with childRequest)

packages/core/src/container/create-container.ts

@@ -1,13 +1,34 @@
 import { makeLoggerMiddleware } from 'inversify-logger-middleware';
-import { makeValueMiddleware } from './value-middleware';
+import { makeActivationValue } from './value-activation';
 import { Container } from './container';
-import { makeInjectMiddleware } from './inject-container-middleware';
+import { makeActivationInject } from './inject-container-activation';
+import * as _ from 'lodash';
+import { ContainerActivationHook } from './interfaces';
 
 /**
  * Create the inversify container
  */
-export function createContainer(): Container {
+export function createContainer(
+  ...activationHooks: ContainerActivationHook[]
+): Container {
   const container = new Container();
+  activationHooks.unshift(
+    makeActivationInject(container),
+    makeActivationValue(container)
+  );
+
+  // add custom onActivation hooks
+  container.bind = <any>_.wrap(
+    container.bind,
+    (originalBind, ...rest: any[]) => {
+      const binding = originalBind.apply(container, rest);
+      binding._binding.onActivation = (context: any, instance: any) => {
+        const wires = _.flow(activationHooks);
+        return wires(instance);
+      };
+      return binding;
+    }
+  );
 
   const middlewares = [];
 
@@ -17,8 +38,6 @@ export function createContainer(): Container {
     middlewares.push(logger);
   }
 
-  middlewares.push(makeValueMiddleware(container));
-  middlewares.push(makeInjectMiddleware(container));
   container.applyMiddleware(...middlewares);
   return container;
 }

packages/core/src/container/index.ts

@@ -1,2 +1,3 @@
 export * from './container';
+export * from './interfaces';
 export * from './create-container';

packages/core/src/container/inject-container-activation.ts

@@ -0,0 +1,27 @@
+import { METADATA_KEY, INJECT_CONTAINER_KEY } from '../constants';
+import { Container } from './container';
+import { ContainerActivationHook } from './interfaces';
+
+/**
+ * make the injector activation
+ *  Intercept all creation, if the class as a InjectContainerMetadata then inject the container
+ */
+export function makeActivationInject(
+  container: Container
+): ContainerActivationHook {
+  return (instance: any) => {
+    if (instance && instance.constructor) {
+      const injectContainer = Reflect.hasMetadata(
+        METADATA_KEY.injectContainer,
+        instance.constructor
+      );
+
+      if (injectContainer) {
+        Object.defineProperty(instance, INJECT_CONTAINER_KEY, {
+          value: container
+        });
+      }
+    }
+    return instance;
+  };
+}

packages/core/src/container/interfaces.ts

@@ -0,0 +1 @@
+export type ContainerActivationHook = (instance: any) => any;

packages/core/src/container/value-activation.ts

@@ -0,0 +1,32 @@
+import { METADATA_KEY } from '../constants';
+import { ValueMetadata } from '../interfaces';
+import { configureValueExtractor } from '../utils';
+import { Container } from './container';
+import { ContainerActivationHook } from './interfaces';
+
+/**
+ *  Make  the value activation
+ *  Intercept all creation, if the class as a Value decorator then inject the value
+ */
+export function makeActivationValue(
+  container: Container
+): ContainerActivationHook {
+  const valueExtractor = configureValueExtractor(container);
+
+  return (instance: any) => {
+    if (instance && instance.constructor) {
+      const valueMetadata: ValueMetadata[] = Reflect.getMetadata(
+        METADATA_KEY.value,
+        instance.constructor
+      );
+
+      if (valueMetadata) {
+        valueMetadata.forEach(({ key, path, validator }) => {
+          const defaultValue = instance[key];
+          instance[key] = valueExtractor(path, defaultValue, validator);
+        });
+      }
+    }
+    return instance;
+  };
+}