V6 binding abstractions

src/bindings/binding.ts

@@ -1,40 +1,20 @@
-import { BindingScopeEnum, BindingTypeEnum } from "../constants/literal_types";
 import { interfaces } from "../interfaces/interfaces";
 import { id } from "../utils/id";
+import { NotConfiguredScope } from "../scope/not-configured-scope";
+import { NotConfiguredValueProvider } from "./not-configured-value-provider";
 
 class Binding<TActivated> implements interfaces.Binding<TActivated> {
 
     public id: number;
     public moduleId: interfaces.ContainerModuleBase["id"];
 
-    // Determines weather the bindings has been already activated
-    // The activation action takes place when an instance is resolved
-    // If the scope is singleton it only happens once
-    public activated: boolean;
-
     // A runtime identifier because at runtime we don't have interfaces
     public serviceIdentifier: interfaces.ServiceIdentifier<TActivated>;
 
-    // constructor from binding to or toConstructor
-    public implementationType: interfaces.Newable<TActivated> | TActivated | null;
-
-    // Cache used to allow singleton scope and BindingType.ConstantValue bindings
-    public cache: TActivated | Promise<TActivated> | null;
-
-    // Cache used to allow BindingType.DynamicValue bindings
-    public dynamicValue: interfaces.DynamicValue<TActivated> | null;
-
-    // The scope mode to be used
-    public scope: interfaces.BindingScope;
+    // Scope
+    public scope: interfaces.ResolveScope<TActivated>;
 
-    // The kind of binding
-    public type: interfaces.BindingType;
-
-    // A factory method used in BindingType.Factory bindings
-    public factory: interfaces.FactoryCreator<unknown> | null;
-
-    // An async factory method used in BindingType.Provider bindings
-    public provider: interfaces.ProviderCreator<unknown> | null;
+    public valueProvider:interfaces.ValueProviderType<TActivated>;
 
     // A constraint used to limit the contexts in which this binding is applicable
     public constraint: (request: interfaces.Request) => boolean;
@@ -45,35 +25,24 @@ class Binding<TActivated> implements interfaces.Binding<TActivated> {
     // On deactivation handler (invoked just before an instance is unbinded and removed from container)
     public onDeactivation: interfaces.BindingDeactivation<TActivated> | null;
 
-    public constructor(serviceIdentifier: interfaces.ServiceIdentifier<TActivated>, scope: interfaces.BindingScope) {
+    public constructor(serviceIdentifier: interfaces.ServiceIdentifier<TActivated>) {
         this.id = id();
-        this.activated = false;
         this.serviceIdentifier = serviceIdentifier;
-        this.scope = scope;
-        this.type = BindingTypeEnum.Invalid;
+        this.scope = new NotConfiguredScope(serviceIdentifier);
+        this.valueProvider = new NotConfiguredValueProvider(serviceIdentifier);
         this.constraint = (request: interfaces.Request) => true;
-        this.implementationType = null;
-        this.cache = null;
-        this.factory = null;
-        this.provider = null;
         this.onActivation = null;
         this.onDeactivation = null;
-        this.dynamicValue = null;
     }
 
     public clone(): interfaces.Binding<TActivated> {
-        const clone = new Binding(this.serviceIdentifier, this.scope);
-        clone.activated = (clone.scope === BindingScopeEnum.Singleton) ? this.activated : false;
-        clone.implementationType = this.implementationType;
-        clone.dynamicValue = this.dynamicValue;
-        clone.scope = this.scope;
-        clone.type = this.type;
-        clone.factory = this.factory;
-        clone.provider = this.provider;
+        const clone = new Binding(this.serviceIdentifier);
+        clone.valueProvider = this.valueProvider.clone() as interfaces.ValueProviderType<TActivated>;
+        clone.scope = this.scope.clone();
         clone.constraint = this.constraint;
         clone.onActivation = this.onActivation;
         clone.onDeactivation = this.onDeactivation;
-        clone.cache = this.cache;
+
         return clone;
     }
 

src/bindings/constant-value-provider.ts

@@ -0,0 +1,12 @@
+import { interfaces } from "../interfaces/interfaces";
+import { ValueFromProvider } from "./value-from-provider";
+
+export class ConstantValueProvider<TActivated> extends ValueFromProvider<TActivated>
+implements interfaces.ConstantValueProvider<TActivated>{
+  type: "ConstantValue" = "ConstantValue"
+  clone(){
+    const clone = new ConstantValueProvider<TActivated>();
+    clone.valueFrom = this.valueFrom;
+    return clone;
+  }
+}

src/bindings/constructor-value-provider.ts

@@ -0,0 +1,11 @@
+import { ValueFromProvider } from "./value-from-provider";
+import { interfaces } from "../interfaces/interfaces";
+export class ConstructorValueProvider<TActivated> extends ValueFromProvider<TActivated>
+  implements interfaces.ConstructorValueProvider<TActivated>{
+    type: "Constructor" = "Constructor"
+    clone(){
+      const clone = new ConstructorValueProvider<TActivated>();
+      clone.valueFrom = this.valueFrom;
+      return clone;
+    }
+  }

src/bindings/dynamic-value-provider.ts

@@ -0,0 +1,14 @@
+import { interfaces } from "../interfaces/interfaces";
+export class DynamicValueProvider<TActivated> implements interfaces.DynamicValueProvider<TActivated>{
+  type: "DynamicValue" = "DynamicValue"
+  factoryType:"toDynamicValue" = "toDynamicValue"
+  valueFrom: interfaces.DynamicValue<TActivated>;
+  provideValue(context:interfaces.Context, _:interfaces.Request[]): TActivated|Promise<TActivated>{
+    return this.valueFrom(context);
+  }
+  clone(){
+    const clone = new DynamicValueProvider<TActivated>();
+    clone.valueFrom = this.valueFrom;
+    return clone;
+  }
+}

src/bindings/factory-value-provider-base.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces";
+
+export abstract class FactoryValueProviderBase<TActivated>
+  implements interfaces.ValueProvider<TActivated, (context:interfaces.Context) => TActivated>{
+  valueFrom:  (context:interfaces.Context) => TActivated
+  provideValue(context:interfaces.Context, _:interfaces.Request[]): TActivated | Promise<TActivated> {
+    return this.valueFrom(context);
+  }
+  abstract clone():FactoryValueProviderBase<TActivated>
+}

src/bindings/factory-value-provider.ts

@@ -0,0 +1,13 @@
+import { interfaces } from "../interfaces/interfaces";
+import { FactoryValueProviderBase } from "./factory-value-provider-base";
+
+export class FactoryValueProvider<TActivated> extends FactoryValueProviderBase<TActivated>
+  implements interfaces.FactoryValueProvider<TActivated>{
+    type: "Factory" = "Factory"
+    factoryType:"toFactory"= "toFactory";
+    clone(){
+      const clone = new FactoryValueProvider<TActivated>();
+      clone.valueFrom = this.valueFrom;
+      return clone;
+    }
+}

src/bindings/instance-value-provider.ts

@@ -0,0 +1,20 @@
+import { interfaces } from "../interfaces/interfaces";
+import { resolveInstance } from "../resolution/instantiation";
+
+export class InstanceValueProvider<TActivated> implements interfaces.InstanceValueProvider<TActivated>{
+  type: "Instance" = "Instance";
+  valueFrom: interfaces.Newable<TActivated>;
+  provideValue(context:interfaces.Context, childRequests:interfaces.Request[]): TActivated {
+    const binding = context.currentRequest.bindings[0];
+      return resolveInstance(
+        binding,
+        binding.valueProvider!.valueFrom as interfaces.Newable<TActivated>,
+        childRequests,
+    );
+  }
+  clone(){
+    const clone = new InstanceValueProvider<TActivated>();
+    clone.valueFrom = this.valueFrom;
+    return clone;
+  }
+}

src/bindings/not-configured-value-provider.ts

@@ -0,0 +1,9 @@
+import { interfaces } from "../interfaces/interfaces";
+import { NotConfigured } from "../utils/binding_utils";
+
+export class NotConfiguredValueProvider extends NotConfigured implements interfaces.NotConfiguredValueProvider{
+  valueFrom:never;
+  provideValue():never{
+    this._throwAccessedUnconfigured();
+  }
+}

src/bindings/provider-value-provider.ts

@@ -0,0 +1,13 @@
+import { interfaces } from "../interfaces/interfaces";
+import { FactoryValueProviderBase } from "./factory-value-provider-base";
+
+export class ProviderValueProvider<TActivated> extends FactoryValueProviderBase<TActivated>
+  implements interfaces.ProviderValueProvider<TActivated>{
+    type:"Provider" = "Provider"
+    factoryType:"toProvider" = "toProvider"
+    clone(){
+      const clone = new ProviderValueProvider<TActivated>();
+      clone.valueFrom = this.valueFrom;
+      return clone;
+    }
+}

src/bindings/value-from-provider.ts

@@ -0,0 +1,9 @@
+import { interfaces } from "../interfaces/interfaces";
+
+export abstract class ValueFromProvider<TActivated> implements interfaces.ValueProvider<TActivated,TActivated>{
+  valueFrom: TActivated;
+  provideValue(): TActivated|Promise<TActivated>{
+      return this.valueFrom;
+  }
+  abstract clone():ValueFromProvider<TActivated>
+}

src/bindings/value-provider-factory-interface.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces";
+
+export interface ValueProviderFactory<T>{
+  toInstance():interfaces.InstanceValueProvider<T>
+  toConstantValue():interfaces.ConstantValueProvider<T>
+  toDynamicValue():interfaces.DynamicValueProvider<T>
+  toConstructor():interfaces.ConstructorValueProvider<T>
+  toFactory(): interfaces.FactoryValueProvider<T>
+  toProvider(): interfaces.ProviderValueProvider<T>
+}

src/bindings/value-provider-factory.ts

@@ -0,0 +1,31 @@
+import { interfaces } from "../interfaces/interfaces";
+import { ConstantValueProvider } from "./constant-value-provider";
+import { ConstructorValueProvider } from "./constructor-value-provider";
+import { DynamicValueProvider } from "./dynamic-value-provider";
+import { FactoryValueProvider } from "./factory-value-provider";
+import { InstanceValueProvider } from "./instance-value-provider";
+import { ProviderValueProvider } from "./provider-value-provider";
+import { ValueProviderFactory as ValueProviderFactoryInterface } from "./value-provider-factory-interface"
+
+export class ValueProviderFactory<T> implements ValueProviderFactoryInterface<T>{
+  toInstance(): interfaces.InstanceValueProvider<T> {
+      return new InstanceValueProvider<T>();
+  }
+  toConstantValue(): interfaces.ConstantValueProvider<T> {
+      return new ConstantValueProvider();
+  }
+  toDynamicValue(): interfaces.DynamicValueProvider<T> {
+      return new DynamicValueProvider();
+  }
+  toConstructor(): interfaces.ConstructorValueProvider<T> {
+      return new ConstructorValueProvider();
+  }
+  toFactory(): interfaces.FactoryValueProvider<T> {
+      return new FactoryValueProvider<T>();
+  }
+
+  toProvider(): interfaces.ProviderValueProvider<T> {
+      return new ProviderValueProvider<T>();
+  }
+
+}

src/constants/literal_types.ts

@@ -1,20 +1,33 @@
 import { interfaces } from "../interfaces/interfaces";
 
+const ContextHierarchyOptionEnum: interfaces.ContextHierarchyOptionEnum = {
+    Disallow: "Disallow",
+    Allow: "Allow",
+    IfBindedInCustomOrRootRequestScope: "IfBindedInCustomOrRootRequestScope"
+}
+
 const BindingScopeEnum: interfaces.BindingScopeEnum = {
     Request: "Request",
     Singleton: "Singleton",
-    Transient: "Transient"
+    Transient: "Transient",
+    RootRequest: "RootRequest",
+    Custom: "Custom",
+    NotConfigured: "NotConfigured"
+};
+
+const ConfigurableBindingScopeEnum: interfaces.ConfigurableBindingScopeEnum = {
+    ...BindingScopeEnum,
+    Custom:"Custom"
 };
 
 const BindingTypeEnum: interfaces.BindingTypeEnum = {
     ConstantValue: "ConstantValue",
     Constructor: "Constructor",
     DynamicValue: "DynamicValue",
     Factory: "Factory",
-    Function: "Function",
     Instance: "Instance",
-    Invalid: "Invalid",
-    Provider: "Provider"
+    Provider: "Provider",
+    NotConfigured: "NotConfigured"
 };
 
 const TargetTypeEnum: interfaces.TargetTypeEnum = {
@@ -23,4 +36,4 @@ const TargetTypeEnum: interfaces.TargetTypeEnum = {
     Variable: "Variable"
 };
 
-export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum };
+export { BindingScopeEnum, ConfigurableBindingScopeEnum, BindingTypeEnum, TargetTypeEnum, ContextHierarchyOptionEnum };