V6 binding abstractions #1336

tonyhallett · 2021-05-05T17:10:32Z

Description

As per #1327.

Binding no longer has properties for each "to" syntax call and activated and cache have also been removed.
Binding now has a value provider that provides what is to be resolved.
Binding now has the scope property of type Scope, one of the 5 different scopes that include the new inRootRequestScope and inCustomScope.

inRootRequestScope()
This works similarly to request scope but applies to all container.get calls that occur during the 'root' container.get. This allows scope to be shared across toDynamicValue/toFactory

container.bind<Weapon>(TYPE.DynamicWeapon).toDynamicValue((context) => {
    return context.container.get<Weapon>(TYPE.Weapon);
});

This is facilitated by Context.parentContext, which is managed by Container._planAndResolve, and the new RootRequestScope that stores in the rootRequestScope of the root Request object.

Related Issue

#1143

Motivation and Context

As soon as you use toDynamicValue/toFactory you cannot resolve a previously resolved value unless it is singleton scoped. With this code change there is now the concept of a root request which can be scoped to.

How Has This Been Tested?

Thoroughly.

Types of changes

Updated docs / Refactor code / Added a tests case (non-breaking change)
Bug fix (non-breaking change which fixes an issue)
[] New feature (non-breaking change which adds functionality)
Breaking change (fix or feature that would cause existing functionality to change)

Checklist:

My code follows the code style of this project.
My change requires a change to the documentation.
I have updated the documentation accordingly.
I have read the CONTRIBUTING document.
I have added tests to cover my changes.
All new and existing tests passed.
I have updated the changelog.

@notaphplover
I will review this pull request tomorrow as I would like to discuss some aspects of it.

tonyhallett

The workflow file is set up for the master branch only.

tonyhallett · 2021-05-07T11:05:49Z

src/interfaces/interfaces.ts

-        Constructor: interfaces.BindingType;
-        DynamicValue: interfaces.BindingType;
-        Factory: interfaces.BindingType;
-        Function: interfaces.BindingType;


Determined that Factory BindingTypeEnum is unnecessary. Opinions please.

tonyhallett · 2021-05-07T11:08:06Z

src/interfaces/interfaces.ts

+    }
+
+    export interface NotConfiguredScope extends Scope<never>,Clonable<NotConfiguredScope>{
+        type:"NotConfigured",


NotConfiguredScope and NotConfiguredValueProvider could be renamed InvalidScope/InvalidValueProvider with type Invalid to adhere to previous BindingType/Enum

tonyhallett · 2021-05-07T11:11:56Z

src/syntax/binding_in_syntax.ts

@@ -1,30 +1,44 @@
 import { BindingScopeEnum } from "../constants/literal_types";
 import { interfaces } from "../interfaces/interfaces";
 import { BindingWhenOnSyntax } from "./binding_when_on_syntax";
+import { BindingScopeScopeFactory as BindingScopeScopeFactoryInterface } from "../scope/binding-scope-scope-factory-interface";


Ok to change to IBindingScopeScopeFactory ? Did not want to add to interfaces.ts internal interfaces.

tonyhallett · 2021-05-07T11:12:39Z

src/syntax/binding_in_syntax.ts


 class BindingInSyntax<T> implements interfaces.BindingInSyntax<T> {

    private _binding: interfaces.Binding<T>;

+    public bindingScopeScopeFactoryInterface:BindingScopeScopeFactoryInterface<T> = new BindingScopeScopeFactory<T>()


Assume ok for public properties that can use for testing, given that is not on the interface ?

tonyhallett · 2021-05-07T11:14:15Z

src/syntax/binding_to_syntax.ts

+            scope = BindingScopeEnum.Singleton;
+        }
+        this._binding.scope = this.bindingScopeScopeFactory.get(scope);
+        return new BindingInWhenOnSyntax<T>(this._binding);


Assume ok to return this for methods that return interfaces.BindingWhenOnSyntax

tonyhallett · 2021-05-07T11:28:21Z

src/interfaces/interfaces.ts

        serviceIdentifier: ServiceIdentifier<TActivated>;
        constraint: ConstraintFunction;
-        dynamicValue: DynamicValue<TActivated> | null;


dyamicValue, implementationType, factory, provider, cache ( in terms of constant value ) are now valueFrom on the ValueProvider

As per activated and cache do we want utility functions ?

tonyhallett · 2021-05-07T11:28:52Z

src/interfaces/interfaces.ts

        serviceIdentifier: ServiceIdentifier<TActivated>;
        constraint: ConstraintFunction;
-        dynamicValue: DynamicValue<TActivated> | null;
-        scope: BindingScope;


scope now Scope which has type BindingScope

tonyhallett · 2021-05-07T11:29:25Z

src/interfaces/interfaces.ts

        serviceIdentifier: ServiceIdentifier<TActivated>;
        constraint: ConstraintFunction;
-        dynamicValue: DynamicValue<TActivated> | null;
-        scope: BindingScope;
-        type: BindingType;


type is ValueProvider.type with the omission of Function

tonyhallett · 2021-05-07T11:33:31Z

src/container/container.ts

@@ -106,7 +110,8 @@ class Container implements interfaces.Container {
        this._deactivations = new Lookup<interfaces.BindingDeactivation<any>>();
        this.parent = null;
        this._metadataReader = new MetadataReader();
-        this._moduleActivationStore = new ModuleActivationStore()
+        this._moduleActivationStore = new ModuleActivationStore();
+        this._contextStack = new ContextStack(this)


The ContextStack provides the context hierarchy in conjunction with planAndResolve.
What I have not done is deal with snapshot and restore. The ContextStack uses the Container.options to stay current.
We currently do not snapshot and restore container options which seems incorerct to me.

Thoughts ?

It also has not been tested as a unit.

tonyhallett · 2021-05-07T11:36:38Z

src/container/context-stack.ts

+  }
+
+  private _determineRequiresContextHierarchy(): void {
+    let requiresContextHierarchyOption: interfaces.ContextHierarchyOption = ContextHierarchyOptionEnum.Allow;


Defaults to Allow. I wanted it to be IfBindedInCustomOrRootRequestScope but the performance test
it("Should be able to register 10K bindings in less than 1 ms", () =>
failed as went to 3s.

Thoughts on default ?

tonyhallett · 2021-05-07T13:21:53Z

src/resolution/instantiation.ts

@@ -116,7 +115,7 @@ function _postConstruct<T>(constr: interfaces.Newable<T>, instance: T): void | P
 }

 function _validateInstanceResolution(binding: interfaces.Binding<unknown>, constr: interfaces.Newable<unknown>): void {
-    if (binding.scope === "Transient") {
+    if (binding.scope.type === ConfigurableBindingScopeEnum.Transient) {


This will be changed to Singleton #1335

tonyhallett · 2021-05-07T13:23:26Z

src/syntax/binding_to_syntax.ts

-        this._binding.implementationType = constructor as any;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax<T>(this._binding);
+        //tbd change generics


//tbd change generics
Mentioned in #1319 (comment)

tonyhallett · 2021-05-07T13:25:30Z

test/syntax/binding_to_syntax.test.ts

+            expect(bindingInWhenOn).to.be.instanceOf(BindingInWhenOnSyntax);
+            expect(bindingInWhenOn._binding === binding).to.equal(true);
+        }
+        expectBindingInWhenOnSyntax(bindingToSyntax.to(Sid));


This test was absent from original code. Other "to" methods can be added....

tonyhallett · 2021-05-07T13:26:55Z

src/scope/root-request-scope.ts

+    return resolved;
+  }
+  _getRootContextRootRequestStore(context:interfaces.Context):interfaces.RequestScope {
+    while(context.parentContext !== undefined){


Could add this code as helper methods to Context ?

tonyhallett · 2021-05-14T11:13:59Z

@inversify/maintainers
Thoughts on this v6 change please

PodaruDragos · 2021-05-19T15:56:01Z

@tonyhallett I'm not against this. I do think the code looks better this way, but maybe users like .to().blabla syntax.
From my point of view this change is ok, but I do want to know the opinion of @dcavanagh and @notaphplover.

PodaruDragos · 2021-05-19T16:00:25Z

src/scope/root-request-scope.ts

+import { interfaces } from "../interfaces/interfaces";
+
+export class RootRequestScope<T> implements interfaces.RootRequestScope<T>{
+  type: "RootRequest" = "RootRequest";


can we maybe get this from an Enum ? same for the others ?

PodaruDragos · 2021-05-19T16:01:56Z

src/interfaces/interfaces.ts

+        type:"Instance";
+    }
+
+    export interface DynamicValueProvider<TActivated> extends


same here. idk having strings like this is scary

I don't understand your position.

From before.
The BindingType is a union of strings.
The BindingTypeEnum interface has been written so that it is possible for the literal to provide the same BindingType for all members

//interfaces export type BindingType = "ConstantValue" | "Constructor" | "DynamicValue" | "Factory" | "Function" | "Instance" | "Invalid" | "Provider"; export interface BindingTypeEnum { ConstantValue: interfaces.BindingType; Constructor: interfaces.BindingType; DynamicValue: interfaces.BindingType; Factory: interfaces.BindingType; Function: interfaces.BindingType; Instance: interfaces.BindingType; Invalid: interfaces.BindingType; Provider: interfaces.BindingType; } //literal-types const BindingTypeEnum: interfaces.BindingTypeEnum = { ConstantValue: "ConstantValue", Constructor: "Constructor", DynamicValue: "DynamicValue", Factory: "Factory", Function: "Function", Instance: "Instance", Invalid: "Invalid", Provider: "Provider" };

There was nothing preventing

//literal-types const BindingTypeEnum: interfaces.BindingTypeEnum = { ConstantValue: "ConstantValue", Constructor: "ConstantValue", DynamicValue: "ConstantValue", Factory: "ConstantValue", Function: "ConstantValue", Instance: "ConstantValue", Invalid: "ConstantValue", Provider: "ConstantValue" };

Now we have the concept of a ValueProvider where each of the derivations have a type that can be used for discriminated unions. ( Although it is highly unlikely, imo, we could add another one later. ).
The BindingType is a union of these types - so no change to before, it is a union of strings.
I have typed the BindingTypeEnum interface such that the class has to follow.

//interfaces export type ValueProviderType<TActivated> = ConstantValueProvider<TActivated> | InstanceValueProvider<TActivated> | DynamicValueProvider<TActivated> | ConstructorValueProvider<TActivated> | FactoryValueProvider<TActivated> | ProviderValueProvider<TActivated> | NotConfiguredValueProvider export type BindingType = ValueProviderType<unknown>["type"]; export interface BindingTypeEnum { ConstantValue: ConstantValueProvider<unknown>["type"]; Constructor: ConstructorValueProvider<unknown>["type"]; DynamicValue: DynamicValueProvider<unknown>["type"]; Factory: FactoryValueProvider<unknown>["type"]; Instance: InstanceValueProvider<unknown>["type"]; Provider: ProviderValueProvider<unknown>["type"]; NotConfigured: NotConfiguredValueProvider["type"]; } //literal-types const BindingTypeEnum: interfaces.BindingTypeEnum = { ConstantValue: "ConstantValue", Constructor: "Constructor", DynamicValue: "DynamicValue", Factory: "Factory", Instance: "Instance", Provider: "Provider", NotConfigured: "NotConfigured" };

Please can you explain your concern.

PodaruDragos · 2021-05-19T16:04:16Z

src/container/stack.ts

+      return this._stack.pop();
+  }
+
+  peek(): T | undefined {


Can we maybe change this function name ?
I don't think peek implies getting last element in an array

Array is the implementation detail. Peek is what you would have got from pop without removing it ?

PodaruDragos · 2021-05-19T16:07:37Z

left some comments, I'll review this thoroughly if we agree to make this change

tonyhallett · 2021-05-19T16:41:56Z

@PodaruDragos
Thanks for the review.

but maybe users like .to().blabla syntax.

The to syntax has not changed. Are your referring to the properties from the Binding interface ?

    export interface Binding<TActivated> extends Clonable<Binding<TActivated>> {
        dynamicValue: DynamicValue<TActivated> | null;
        //type: BindingType;
        implementationType: Newable<TActivated> | TActivated | null;
        factory: FactoryCreator<unknown> | null;
        provider: ProviderCreator<unknown> | null;
        cache: null | TActivated | Promise<TActivated>;
    }

We could provide setters and getters.

PodaruDragos · 2021-05-19T17:05:24Z

The to syntax has not changed. Are your referring to the properties from the Binding interface ?

maybe I didn't carefully read that. Is it still possible to do container.bind('bla').to('bla').inSingletonScope() ?

tonyhallett · 2021-05-19T17:07:54Z

The to syntax has not changed. Are your referring to the properties from the Binding interface ?

maybe I didn't carefully read that. Is it still possible to do container.bind('bla').to('bla').inSingletonScope() ?

Syntax has not changed at all.
The difference is that Binding has a ValueProvider and a Scope.

PodaruDragos · 2021-05-19T17:10:43Z

Syntax has not changed at all.

then I am really ok with this. thanks for clearing that out.

tonyhallett · 2021-05-19T17:45:18Z

@PodaruDragos

I did not consider errors thrown during resolution so I think that an error handler is necessary to ensure the context stack is cleared up.
current code

    private _planAndResolve<T>(): (args: interfaces.NextArgs<T>) => interfaces.ContainerResolution<T> {
        return (args: interfaces.NextArgs<T>) => {

            // create a plan
            let context = plan(
                this._metadataReader,
                this,
                args.isMultiInject,
                args.targetType,
                args.serviceIdentifier,
                args.key,
                args.value,
                args.avoidConstraints
            );

            this._contextStack.planCompleted(context);

            // apply context interceptor 
            //**************************************************************
            context = args.contextInterceptor(context);

            // resolve plan
            const result = resolve<T>(context); 
            //**********************************************************
            this._contextStack.resolved(); 

            return result;

        };
    }

PodaruDragos · 2021-08-23T20:20:04Z

@tonyhallett @notaphplover did we plan to not do this update ?
Seems like this could be a good way forward.

I do want to first maybe land this PR first to not deal with a lot of conflicts.

@tonyhallett @notaphplover what do you think ?

tonyhallett · 2021-08-23T21:18:53Z

I'd certainly would like it to be discussed further. It adds a new scope that resolves an outstanding issue and in my opinion improves upon the current design. I may have missed something so it needs a review from a couple of people.

Re the linked draft. Apologies I have not looked at it yet. I have some open source code that I need to finish but I will have a look soon

PodaruDragos · 2021-10-21T08:43:23Z

@tonyhallett hello
now that #1311 has been merged. I think it's time to go over this again.
I'll take a look again on this. I do think that merging master into this branch is gonna be a big hassle.

tonyhallett · 2021-10-21T17:05:36Z

I do think that merging master into this branch is gonna be a big hassle

Most definitely

I have a couple of outstanding tasks that will probably keep me busy for a couple of weeks. After that I will be able to join in.

PodaruDragos · 2022-01-27T13:51:43Z

hey @tonyhallett @notaphplover should be start going over this again ?

tonyhallett · 2022-01-28T22:13:03Z

Unfortunately I am busy with other things. I would love to participate but it will not be possible for a while.

tonyhallett added 30 commits May 4, 2021 11:05

binding provideValue method

be130d8

create and assign value providers in bindingtosyntax

de71cf8

correct signatures

b492db3

FactoryTypeValueProvider

8f477a2

clone value provider

046e520

do not reset the binding scope when clone

f232d52

remove non caching properties from Binding

7f1e6e6

Scope type

158b66a

remove cache and activated from binding

1a9e2e9

use InstanceValueProvider

145b113

give singleton scope clone same behaviours w.r.t rejecting promises

0216d37

remove scope responsibility from value provider

caf5f0f

ScopeManager

4d8de8d

rename files to adhere to naming convention

007c75b

refactor planner - sub requests required as not instantiated

3b9205b

make valueproviderfactory public, hidden by interface

c33a919

remaining value provider tests

c60ad71

tests for 100% coverage

1b5504b

scope to return undefined instead of null

b463a07

move scope tests from features to scope folder

8472480

RootRequestScope ( and custom scope )

a23684e

move non public interfaces from interfaces

6cc4aa4

rename test file to test file name

5e59e82

value provider discriminated union

20e8bc4

scope discriminated union and improve binding enums

2b3f649

remove null as possible type of binding.valueProvider

42cc523

remove BindingScopeScope from interfaces

0361ee0

type tidy

fcd4a8d

NotConfiguredScope

9d2f7bb

reorder methods

166b59e

NotConfiguredValueProvider and correction of value provider cloning

b7a8bc9

PodaruDragos requested a review from dcavanagh May 7, 2021 08:08

tonyhallett added 4 commits May 7, 2021 11:16

delete commented code

cd534ba

correct parameter type

a8a4c30

context hierarchy options

f772ebe

add missing enum values

9777284

tonyhallett commented May 7, 2021

View reviewed changes

tonyhallett mentioned this pull request May 7, 2021

Fix constant value deactivation #1331

Merged

tonyhallett commented May 7, 2021

View reviewed changes

correction to binding scope enums

2d0be7e

tonyhallett commented May 7, 2021

View reviewed changes

PodaruDragos reviewed May 19, 2021

View reviewed changes

V6 binding abstractions #1336

Are you sure you want to change the base?

V6 binding abstractions #1336

Conversation

tonyhallett commented May 5, 2021 • edited Loading

Description

Related Issue

Motivation and Context

How Has This Been Tested?

Types of changes

Checklist:

tonyhallett left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tonyhallett May 7, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tonyhallett May 7, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tonyhallett May 7, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tonyhallett May 7, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tonyhallett commented May 14, 2021

PodaruDragos commented May 19, 2021

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

PodaruDragos commented May 19, 2021

tonyhallett commented May 19, 2021

PodaruDragos commented May 19, 2021

tonyhallett commented May 19, 2021

PodaruDragos commented May 19, 2021

tonyhallett commented May 19, 2021

PodaruDragos commented Aug 23, 2021

tonyhallett commented Aug 23, 2021

PodaruDragos commented Oct 21, 2021

tonyhallett commented Oct 21, 2021

PodaruDragos commented Jan 27, 2022

tonyhallett commented Jan 28, 2022

tonyhallett commented May 5, 2021 •

edited

Loading

tonyhallett May 7, 2021 •

edited

Loading

tonyhallett May 7, 2021 •

edited

Loading

tonyhallett May 7, 2021 •

edited

Loading

tonyhallett May 7, 2021 •

edited

Loading