Skip to content
Permalink
Browse files

feat(core): Adds DI support for `providedIn: 'platform'|'any'` (#32154)

Extend the vocabulary of the `providedIn` to also include  `'platform'` and `'any'`` scope.
```
@Injectable({
  providedId: 'platform', // tree shakable injector for platform injector
})
class MyService {...}
```

PR Close #32154
  • Loading branch information...
mhevery committed Aug 23, 2019
1 parent 8a47b48 commit 77c382ccbabf74c7b1d2cb9e3d18b8574abb91fc
@@ -15,7 +15,7 @@ export {ChangeDetectorStatus as ɵChangeDetectorStatus, isDefaultChangeDetection
export {Console as ɵConsole} from './console';
export {inject, setCurrentInjector as ɵsetCurrentInjector, ɵɵinject} from './di/injector_compatibility';
export {getInjectableDef as ɵgetInjectableDef, ɵɵInjectableDef, ɵɵInjectorDef} from './di/interface/defs';
export {APP_ROOT as ɵAPP_ROOT} from './di/scope';
export {INJECTOR_SCOPE as ɵINJECTOR_SCOPE} from './di/scope';
export {DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID} from './i18n/localization';
export {ivyEnabled as ɵivyEnabled} from './ivy_switch';
export {ComponentFactory as ɵComponentFactory} from './linker/component_factory';
@@ -50,9 +50,11 @@ export interface InjectableDecorator {
*
*/
(): TypeDecorator;
(options?: {providedIn: Type<any>| 'root' | null}&InjectableProvider): TypeDecorator;
(options?: {providedIn: Type<any>| 'root' | 'platform' | 'any' | null}&
InjectableProvider): TypeDecorator;
new (): Injectable;
new (options?: {providedIn: Type<any>| 'root' | null}&InjectableProvider): Injectable;
new (options?: {providedIn: Type<any>| 'root' | 'platform' | 'any' | null}&
InjectableProvider): Injectable;
}

/**
@@ -64,10 +66,14 @@ export interface Injectable {
/**
* Determines which injectors will provide the injectable,
* by either associating it with an @NgModule or other `InjectorType`,
* or by specifying that this injectable should be provided in the
* 'root' injector, which will be the application-level injector in most apps.
* or by specifying that this injectable should be provided in the:
* - 'root' injector, which will be the application-level injector in most apps.
* - 'platform' injector, which would be the special singleton platform injector shared by all
* applications on the page.
* - 'any` injector, which would be the injector which receives the resolution. (Note this only
* works on NgModule Injectors and not on Element Injector)
*/
providedIn?: Type<any>|'root'|null;
providedIn?: Type<any>|'root'|'platform'|'any'|null;
}

/**
@@ -90,9 +96,9 @@ export interface InjectableType<T> extends Type<T> { ngInjectableDef: ɵɵInject
/**
* Supports @Injectable() in JIT mode for Render2.
*/
function render2CompileInjectable(
injectableType: Type<any>,
options?: {providedIn?: Type<any>| 'root' | null} & InjectableProvider): void {
function render2CompileInjectable(injectableType: Type<any>, options?: {
providedIn?: Type<any>| 'root' | 'platform' | 'any' | null
} & InjectableProvider): void {
if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {
(injectableType as InjectableType<any>).ngInjectableDef = ɵɵdefineInjectable({
token: injectableType,
@@ -57,7 +57,7 @@ export class InjectionToken<T> {
readonly ngInjectableDef: never|undefined;

constructor(protected _desc: string, options?: {
providedIn?: Type<any>| 'root' | null,
providedIn?: Type<any>| 'root' | 'platform' | 'any' | null,
factory: () => T
}) {
this.ngInjectableDef = undefined;
@@ -11,12 +11,13 @@ import {stringify} from '../util/stringify';

import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, formatError, ɵɵinject} from './injector_compatibility';
import {ɵɵdefineInjectable} from './interface/defs';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, formatError, setCurrentInjector, ɵɵinject} from './injector_compatibility';
import {getInjectableDef, ɵɵdefineInjectable} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, ValueProvider} from './interface/provider';
import {Inject, Optional, Self, SkipSelf} from './metadata';
import {createInjector} from './r3_injector';
import {INJECTOR_SCOPE} from './scope';

export function INJECTOR_IMPL__PRE_R3__(
providers: StaticProvider[], parent: Injector | undefined, name: string) {
@@ -124,8 +125,9 @@ const NO_NEW_LINE = 'ɵ';
export class StaticInjector implements Injector {
readonly parent: Injector;
readonly source: string|null;
readonly scope: string|null;

private _records: Map<any, Record>;
private _records: Map<any, Record|null>;

constructor(
providers: StaticProvider[], parent: Injector = Injector.NULL, source: string|null = null) {
@@ -136,17 +138,37 @@ export class StaticInjector implements Injector {
Injector, <Record>{token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false});
records.set(
INJECTOR, <Record>{token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false});
recursivelyProcessProviders(records, providers);
this.scope = recursivelyProcessProviders(records, providers);
}

get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
get(token: any, notFoundValue?: any): any;
get(token: any, notFoundValue?: any, flags: InjectFlags = InjectFlags.Default): any {
const record = this._records.get(token);
const records = this._records;
let record = records.get(token);
if (record === undefined) {
// This means we have never seen this record, see if it is tree shakable provider.
const injectableDef = getInjectableDef(token);
if (injectableDef) {
const providedIn = injectableDef && injectableDef.providedIn;
if (providedIn === 'any' || providedIn != null && providedIn === this.scope) {
records.set(
token, record = resolveProvider(
{provide: token, useFactory: injectableDef.factory, deps: EMPTY}));
}
}
if (record === undefined) {
// Set record to null to make sure that we don't go through expensive lookup above again.
records.set(token, null);
}
}
let lastInjector = setCurrentInjector(this);
try {
return tryResolveToken(token, record, this._records, this.parent, notFoundValue, flags);
return tryResolveToken(token, record, records, this.parent, notFoundValue, flags);
} catch (e) {
return catchInjectorError(e, token, 'StaticInjectorError', this.source);
} finally {
setCurrentInjector(lastInjector);
}
}

@@ -203,13 +225,15 @@ function multiProviderMixError(token: any) {
return staticError('Cannot mix multi providers and regular providers', token);
}

function recursivelyProcessProviders(records: Map<any, Record>, provider: StaticProvider) {
function recursivelyProcessProviders(records: Map<any, Record>, provider: StaticProvider): string|
null {
let scope: string|null = null;
if (provider) {
provider = resolveForwardRef(provider);
if (provider instanceof Array) {
// if we have an array recurse into the array
for (let i = 0; i < provider.length; i++) {
recursivelyProcessProviders(records, provider[i]);
scope = recursivelyProcessProviders(records, provider[i]) || scope;
}
} else if (typeof provider === 'function') {
// Functions were supported in ReflectiveInjector, but are not here. For safety give useful
@@ -244,15 +268,19 @@ function recursivelyProcessProviders(records: Map<any, Record>, provider: Static
if (record && record.fn == MULTI_PROVIDER_FN) {
throw multiProviderMixError(token);
}
if (token === INJECTOR_SCOPE) {
scope = resolvedProvider.value;
}
records.set(token, resolvedProvider);
} else {
throw staticError('Unexpected provider', provider);
}
}
return scope;
}

function tryResolveToken(
token: any, record: Record | undefined, records: Map<any, Record>, parent: Injector,
token: any, record: Record | undefined | null, records: Map<any, Record|null>, parent: Injector,
notFoundValue: any, flags: InjectFlags): any {
try {
return resolveToken(token, record, records, parent, notFoundValue, flags);
@@ -272,7 +300,7 @@ function tryResolveToken(
}

function resolveToken(
token: any, record: Record | undefined, records: Map<any, Record>, parent: Injector,
token: any, record: Record | undefined | null, records: Map<any, Record|null>, parent: Injector,
notFoundValue: any, flags: InjectFlags): any {
let value;
if (record && !(flags & InjectFlags.SkipSelf)) {
@@ -35,7 +35,7 @@ export interface ɵɵInjectableDef<T> {
* - `null`, does not belong to any injector. Must be explicitly listed in the injector
* `providers`.
*/
providedIn: InjectorType<any>|'root'|'any'|null;
providedIn: InjectorType<any>|'root'|'platform'|'any'|null;

/**
* The token to which this definition belongs.
@@ -140,7 +140,7 @@ export interface InjectorTypeWithProviders<T> {
*/
export function ɵɵdefineInjectable<T>(opts: {
token: unknown,
providedIn?: Type<any>| 'root' | 'any' | null,
providedIn?: Type<any>| 'root' | 'platform' | 'any' | null,
factory: () => T,
}): never {
return ({
@@ -21,7 +21,7 @@ import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALU
import {InjectorType, InjectorTypeWithProviders, getInheritedInjectableDef, getInjectableDef, getInjectorDef, ɵɵInjectableDef} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider} from './interface/provider';
import {APP_ROOT} from './scope';
import {INJECTOR_SCOPE} from './scope';



@@ -84,8 +84,10 @@ export function createInjector(
export class R3Injector {
/**
* Map of tokens to records which contain the instances of those tokens.
* - `null` value implies that we don't have the record. Used by tree-shakable injectors
* to prevent further searches.
*/
private records = new Map<Type<any>|InjectionToken<any>, Record<any>>();
private records = new Map<Type<any>|InjectionToken<any>, Record<any>|null>();

/**
* The transitive set of `InjectorType`s which define this injector.
@@ -101,7 +103,7 @@ export class R3Injector {
* Flag indicating this injector provides the APP_ROOT_SCOPE token, and thus counts as the
* root scope.
*/
private readonly isRootInjector: boolean;
private readonly scope: 'root'|'platform'|null;

readonly source: string|null;

@@ -129,7 +131,8 @@ export class R3Injector {

// Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide
// any injectable scoped to APP_ROOT_SCOPE.
this.isRootInjector = this.records.has(APP_ROOT);
const record = this.records.get(INJECTOR_SCOPE);
this.scope = record != null ? record.value : null;

// Eagerly instantiate the InjectorType classes themselves.
this.injectorDefTypes.forEach(defType => this.get(defType));
@@ -170,7 +173,7 @@ export class R3Injector {
// Check for the SkipSelf flag.
if (!(flags & InjectFlags.SkipSelf)) {
// SkipSelf isn't set, check if the record belongs to this injector.
let record: Record<T>|undefined = this.records.get(token);
let record: Record<T>|undefined|null = this.records.get(token);
if (record === undefined) {
// No record, but maybe the token is scoped to this injector. Look for an ngInjectableDef
// with a scope matching this injector.
@@ -179,11 +182,13 @@ export class R3Injector {
// Found an ngInjectableDef and it's scoped to this injector. Pretend as if it was here
// all along.
record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
this.records.set(token, record);
} else {
record = null;
}
this.records.set(token, record);
}
// If a record was found, get the instance for it and return it.
if (record !== undefined) {
if (record != null /* NOT null || undefined */) {
return this.hydrate(token, record);
}
}
@@ -389,7 +394,7 @@ export class R3Injector {
if (!def.providedIn) {
return false;
} else if (typeof def.providedIn === 'string') {
return def.providedIn === 'any' || (def.providedIn === 'root' && this.isRootInjector);
return def.providedIn === 'any' || (def.providedIn === this.scope);
} else {
return this.injectorDefTypes.has(def.providedIn);
}
@@ -14,5 +14,4 @@ import {InjectionToken} from './injection_token';
* as a root scoped injector when processing requests for unknown tokens which may indicate
* they are provided in the root scope.
*/
export const APP_ROOT = new InjectionToken<boolean>(
'The presence of this token marks an injector as being the root injector.');
export const INJECTOR_SCOPE = new InjectionToken<'root'|'platform'|null>('Set Injector scope.');
@@ -48,7 +48,7 @@ function cloneNgModuleDefinition(def: NgModuleDefinition): NgModuleDefinition {

return {
factory: def.factory,
isRoot: def.isRoot, providers, modules, providersByKey,
scope: def.scope, providers, modules, providersByKey,
};
}

@@ -10,7 +10,7 @@ import {resolveForwardRef} from '../di/forward_ref';
import {Injector} from '../di/injector';
import {INJECTOR, setCurrentInjector} from '../di/injector_compatibility';
import {getInjectableDef, ɵɵInjectableDef} from '../di/interface/defs';
import {APP_ROOT} from '../di/scope';
import {INJECTOR_SCOPE} from '../di/scope';
import {NgModuleRef} from '../linker/ng_module_factory';
import {newArray} from '../util/array_utils';
import {stringify} from '../util/stringify';
@@ -42,11 +42,11 @@ export function moduleProvideDef(
export function moduleDef(providers: NgModuleProviderDef[]): NgModuleDefinition {
const providersByKey: {[key: string]: NgModuleProviderDef} = {};
const modules = [];
let isRoot: boolean = false;
let scope: 'root'|'platform'|null = null;
for (let i = 0; i < providers.length; i++) {
const provider = providers[i];
if (provider.token === APP_ROOT && provider.value === true) {
isRoot = true;
if (provider.token === INJECTOR_SCOPE) {
scope = provider.value;
}
if (provider.flags & NodeFlags.TypeNgModule) {
modules.push(provider.token);
@@ -60,7 +60,7 @@ export function moduleDef(providers: NgModuleProviderDef[]): NgModuleDefinition
providersByKey,
providers,
modules,
isRoot,
scope: scope,
};
}

@@ -134,8 +134,9 @@ function moduleTransitivelyPresent(ngModule: NgModuleData, scope: any): boolean
}

function targetsModule(ngModule: NgModuleData, def: ɵɵInjectableDef<any>): boolean {
return def.providedIn != null && (moduleTransitivelyPresent(ngModule, def.providedIn) ||
def.providedIn === 'root' && ngModule._def.isRoot);
const providedIn = def.providedIn;
return providedIn != null && (providedIn === 'any' || providedIn === ngModule._def.scope ||
moduleTransitivelyPresent(ngModule, providedIn));
}

function _createProviderInstance(ngModule: NgModuleData, providerDef: NgModuleProviderDef): any {
@@ -45,7 +45,7 @@ export interface NgModuleDefinition extends Definition<NgModuleDefinitionFactory
providers: NgModuleProviderDef[];
providersByKey: {[tokenKey: string]: NgModuleProviderDef};
modules: any[];
isRoot: boolean;
scope: 'root'|'platform'|null;
}

export interface NgModuleDefinitionFactory extends DefinitionFactory<NgModuleDefinition> {}
@@ -8,6 +8,7 @@

import {CommonModule} from '@angular/common';
import {Attribute, ChangeDetectorRef, Component, Directive, ElementRef, EventEmitter, Host, HostBinding, INJECTOR, Inject, Injectable, InjectionToken, Injector, Input, LOCALE_ID, ModuleWithProviders, NgModule, Optional, Output, Pipe, PipeTransform, Self, SkipSelf, TemplateRef, ViewChild, ViewContainerRef, forwardRef, ɵDEFAULT_LOCALE_ID as DEFAULT_LOCALE_ID} from '@angular/core';
importINJECTOR_SCOPE} from '@angular/core/src/core';
import {ViewRef} from '@angular/core/src/render3/view_ref';
import {TestBed} from '@angular/core/testing';
import {ivyEnabled, onlyInIvy} from '@angular/private/testing';
@@ -866,6 +867,37 @@ describe('di', () => {
});
});

describe('Tree shakable injectors', () => {
it('should support tree shakable injectors scopes', () => {
@Injectable({providedIn: 'any'})
class AnyService {
constructor(public injector: Injector) {}
}

@Injectable({providedIn: 'root'})
class RootService {
constructor(public injector: Injector) {}
}

@Injectable({providedIn: 'platform'})
class PlatformService {
constructor(public injector: Injector) {}
}

const testBedInjector: Injector = TestBed.get(Injector);
const childInjector = Injector.create([], testBedInjector);

const anyService = childInjector.get(AnyService);
expect(anyService.injector).toBe(childInjector);

const rootService = childInjector.get(RootService);
expect(rootService.injector.getINJECTOR_SCOPE)).toBe('root');

const platformService = childInjector.get(PlatformService);
expect(platformService.injector.getINJECTOR_SCOPE)).toBe('platform');
});
});

describe('service injection', () => {

it('should create instance even when no injector present', () => {
@@ -1,6 +1,6 @@
[
{
"name": "APP_ROOT"
"name": "INJECTOR_SCOPE"
},
{
"name": "CIRCULAR"

0 comments on commit 77c382c

Please sign in to comment.
You can’t perform that action at this time.