ts-ioc-container 33.5.0 → 34.0.0

package/README.md

@@ -97,7 +97,7 @@ describe('Basic usage', function () {
       constructor(@inject(by.key('ILogger')) public logger: Logger) {}
     }
 
-    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger).to('ILogger'));
+    const container = new Container(new MetadataInjector()).add(R.toClass(Logger).fromKey('ILogger'));
 
     expect(container.resolve(App).logger.name).toBe('Logger');
   });
@@ -108,8 +108,8 @@ describe('Basic usage', function () {
     }
 
     const container = new Container(new MetadataInjector())
-      .add(R.fromClass(Logger).to('ILogger1'))
-      .add(R.fromClass(Logger).to('ILogger2'));
+      .add(R.toClass(Logger).fromKey('ILogger1'))
+      .add(R.toClass(Logger).fromKey('ILogger2'));
 
     expect(container.resolve(App).loggers).toHaveLength(2);
   });
@@ -160,7 +160,7 @@ class Logger {}
 
 describe('Scopes', function () {
   it('should resolve dependencies from scope', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger));
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.toClass(Logger));
     const child = root.createScope('child');
 
     expect(child.resolve('ILogger')).toBe(child.resolve('ILogger'));
@@ -214,7 +214,7 @@ describe('Instances', function () {
   class Logger {}
 
   it('should return injected instances', () => {
-    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger));
+    const container = new Container(new MetadataInjector()).add(R.toClass(Logger));
     const scope = container.createScope();
 
     const logger1 = container.resolve('ILogger');
@@ -231,7 +231,7 @@ describe('Instances', function () {
       constructor(@inject(by.instances(isLogger)) public loggers: Logger[]) {}
     }
 
-    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger));
+    const container = new Container(new MetadataInjector()).add(R.toClass(Logger));
 
     const logger0 = container.resolve('ILogger');
     const logger1 = container.resolve('ILogger');
@@ -260,7 +260,7 @@ class Logger {}
 
 describe('Disposing', function () {
   it('should container and make it unavailable for the further usage', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger).to('ILogger'));
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.toClass(Logger).fromKey('ILogger'));
     const child = root.createScope('child');
 
     const logger = child.resolve('ILogger');
@@ -312,7 +312,7 @@ describe('lazy provider', () => {
 
   function createContainer() {
     const container = new Container(new MetadataInjector());
-    container.add(R.fromClass(Flag)).add(R.fromClass(Service));
+    container.add(R.toClass(Flag)).add(R.toClass(Service));
     return container;
   }
 
@@ -403,7 +403,7 @@ class App {
 
 describe('Reflection Injector', function () {
   it('should inject dependencies by @inject decorator', function () {
-    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger).to('ILogger'));
+    const container = new Container(new MetadataInjector()).add(R.toClass(Logger).fromKey('ILogger'));
 
     const app = container.resolve(App);
 
@@ -426,7 +426,7 @@ describe('SimpleInjector', function () {
       constructor(public container: IContainer) {}
     }
 
-    const container = new Container(new SimpleInjector()).add(R.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).add(R.toClass(App).fromKey('App'));
     const app = container.resolve<App>('App');
 
     expect(app.container).toBeInstanceOf(Container);
@@ -440,7 +440,7 @@ describe('SimpleInjector', function () {
       ) {}
     }
 
-    const container = new Container(new SimpleInjector()).add(R.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).add(R.toClass(App).fromKey('App'));
     const app = container.resolve<App>('App', { args: ['Hello world'] });
 
     expect(app.greeting).toBe('Hello world');
@@ -468,7 +468,7 @@ describe('ProxyInjector', function () {
       }
     }
 
-    const container = new Container(new ProxyInjector()).add(R.fromClass(Logger).to('logger'));
+    const container = new Container(new ProxyInjector()).add(R.toClass(Logger).fromKey('logger'));
 
     const app = container.resolve(App);
     expect(app.logger).toBeInstanceOf(Logger);
@@ -498,8 +498,8 @@ describe('ProxyInjector', function () {
     const greetingTemplate = (name: string) => `Hello ${name}`;
 
     const container = new Container(new ProxyInjector())
-      .add(R.fromClass(App).to('App').pipe(args({ greetingTemplate })))
-      .add(R.fromClass(Logger).to('logger'));
+      .add(R.toClass(App).fromKey('App').pipe(args({ greetingTemplate })))
+      .add(R.toClass(Logger).fromKey('logger'));
 
     const app = container.resolve<App>('App', { args: [{ name: `world` }] });
     expect(app.greeting).toBe('Hello world');
@@ -573,20 +573,20 @@ describe('Singleton', function () {
   }
 
   it('should resolve the same container per every request', function () {
-    const container = createContainer().add(R.fromClass(Logger));
+    const container = createContainer().add(R.toClass(Logger));
 
     expect(container.resolve('logger')).toBe(container.resolve('logger'));
   });
 
   it('should resolve different dependency per scope', function () {
-    const container = createContainer().add(R.fromClass(Logger));
+    const container = createContainer().add(R.toClass(Logger));
     const child = container.createScope();
 
     expect(container.resolve('logger')).not.toBe(child.resolve('logger'));
   });
 
   it('should resolve the same dependency for scope', function () {
-    const container = createContainer().add(R.fromClass(Logger));
+    const container = createContainer().add(R.toClass(Logger));
     const child = container.createScope();
 
     expect(child.resolve('logger')).toBe(child.resolve('logger'));
@@ -633,21 +633,21 @@ describe('ArgsProvider', function () {
   }
 
   it('can assign argument function to provider', function () {
-    const root = createContainer().add(R.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
+    const root = createContainer().add(R.toClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
 
     const logger = root.createScope().resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('can assign argument to provider', function () {
-    const root = createContainer().add(R.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().add(R.toClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('should set provider arguments with highest priority in compare to resolve arguments', function () {
-    const root = createContainer().add(R.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().add(R.toClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger', { args: ['file'] });
 
@@ -684,9 +684,9 @@ describe('ArgsProvider', function () {
     }
 
     const root = createContainer()
-      .add(R.fromClass(EntityManager))
-      .add(R.fromClass(UserRepository))
-      .add(R.fromClass(TodoRepository));
+      .add(R.toClass(EntityManager))
+      .add(R.toClass(UserRepository))
+      .add(R.toClass(TodoRepository));
     const main = root.resolve(Main);
 
     expect(main.userEntities.repository).toBeInstanceOf(UserRepository);
@@ -725,9 +725,9 @@ describe('ArgsProvider', function () {
     }
 
     const root = createContainer()
-      .add(R.fromClass(EntityManager))
-      .add(R.fromClass(UserRepository))
-      .add(R.fromClass(TodoRepository));
+      .add(R.toClass(EntityManager))
+      .add(R.toClass(UserRepository))
+      .add(R.toClass(TodoRepository));
     const main = root.resolve(Main);
 
     const userRepository = root.resolve<EntityManager>('EntityManager', { args: ['UserRepository'] }).repository;
@@ -768,7 +768,7 @@ describe('Visibility', function () {
     @provider(singleton(), visible(({ isParent }) => isParent))
     class FileLogger {}
 
-    const parent = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(FileLogger));
+    const parent = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.toClass(FileLogger));
 
     const child = parent.createScope('child');
 
@@ -857,8 +857,8 @@ describe('alias', () => {
     }
 
     const container = new Container(new MetadataInjector())
-      .add(R.fromClass(LoggerMiddleware))
-      .add(R.fromClass(ErrorHandlerMiddleware));
+      .add(R.toClass(LoggerMiddleware))
+      .add(R.toClass(ErrorHandlerMiddleware));
 
     const app = container.resolve(App);
     app.run();
@@ -871,7 +871,7 @@ describe('alias', () => {
     @provider(alias('ILogger'))
     class FileLogger {}
 
-    const container = new Container(new MetadataInjector()).add(R.fromClass(FileLogger));
+    const container = new Container(new MetadataInjector()).add(R.toClass(FileLogger));
 
     expect(byAlias((aliases) => aliases.has('ILogger'))(container)).toBeInstanceOf(FileLogger);
     expect(() => byAlias((aliases) => aliases.has('logger'))(container)).toThrowError(DependencyNotFoundError);
@@ -888,8 +888,8 @@ describe('alias', () => {
 
     const container = new Container(new MetadataInjector(), { tags: ['root'] })
       .register(IMemoKey, Provider.fromValue<IMemo>(new Map()))
-      .add(R.fromClass(FileLogger))
-      .add(R.fromClass(DbLogger));
+      .add(R.toClass(FileLogger))
+      .add(R.toClass(DbLogger));
 
     const result1 = byAlias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(container);
     const child = container.createScope('child');
@@ -919,10 +919,10 @@ describe('alias', () => {
 
     const container = new Container(new MetadataInjector())
       .register(IMemoKey, Provider.fromValue<IMemo>(new Map()))
-      .add(R.fromClass(FileLogger));
+      .add(R.toClass(FileLogger));
 
     const loggers = container.resolve(App).loggers;
-    container.add(R.fromClass(DbLogger));
+    container.add(R.toClass(DbLogger));
     const loggers2 = container.resolve(App).loggers;
 
     expect(loggers).toEqual(loggers2);
@@ -1006,7 +1006,7 @@ describe('lazy provider', () => {
 
   function createContainer() {
     const container = new Container(new MetadataInjector());
-    container.add(R.fromClass(TodoRepository)).add(R.fromClass(Logger));
+    container.add(R.toClass(TodoRepository)).add(R.toClass(Logger));
     return container;
   }
 
@@ -1053,33 +1053,33 @@ describe('Registration module', function () {
     @provider(singleton())
     class Logger {}
 
-    const root = createContainer().add(R.fromClass(Logger));
+    const root = createContainer().add(R.toClass(Logger));
 
     expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
   });
 
   it('should register value', function () {
-    const root = createContainer().add(R.fromValue('smth').to('ISmth'));
+    const root = createContainer().add(R.toValue('smth').fromKey('ISmth'));
 
     expect(root.resolve('ISmth')).toBe('smth');
   });
 
   it('should register fn', function () {
-    const root = createContainer().add(R.fromFn(() => 'smth').to('ISmth'));
+    const root = createContainer().add(R.toFn(() => 'smth').fromKey('ISmth'));
 
     expect(root.resolve('ISmth')).toBe('smth');
   });
 
   it('should raise an error if key is not provider', () => {
     expect(() => {
-      createContainer().add(R.fromValue('smth'));
+      createContainer().add(R.toValue('smth'));
     }).toThrowError(DependencyMissingKeyError);
   });
 
   it('should register dependency by class name if @key is not provided', function () {
     class FileLogger {}
 
-    const root = createContainer().add(R.fromClass(FileLogger));
+    const root = createContainer().add(R.toClass(FileLogger));
 
     expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
   });
@@ -1089,7 +1089,7 @@ describe('Registration module', function () {
     @provider(singleton())
     class Logger {}
 
-    const root = createContainer().add(R.fromClass(Logger));
+    const root = createContainer().add(R.toClass(Logger));
 
     expect(root.resolve('Logger')).toBeInstanceOf(Logger);
     expect(root.resolve('Logger')).toBe(root.resolve('ILogger'));
@@ -1112,7 +1112,7 @@ import { singleton, Container, key, provider, MetadataInjector, Registration as
 class Logger {}
 describe('ScopeProvider', function () {
   it('should return the same instance', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger));
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.toClass(Logger));
     const child = root.createScope();
     expect(root.resolve('ILogger')).toBe(child.resolve('ILogger'));
   });
@@ -1135,13 +1135,13 @@ class TestLogger {}
 
 class Production implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.add(R.fromClass(Logger));
+    container.add(R.toClass(Logger));
   }
 }
 
 class Development implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.add(R.fromClass(TestLogger));
+    container.add(R.toClass(TestLogger));
   }
 }
 
@@ -1213,7 +1213,7 @@ class Logger {
 
 describe('onConstruct', function () {
   it('should make logger be ready on resolve', function () {
-    const container = new Container(new MyInjector()).add(R.fromClass(Logger));
+    const container = new Container(new MyInjector()).add(R.toClass(Logger));
 
     const logger = container.resolve<Logger>('logger');
 
@@ -1278,7 +1278,7 @@ class Logger {
 
 describe('onDispose', function () {
   it('should invoke hooks on all instances', async function () {
-    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger)).add(R.fromClass(LogsRepo));
+    const container = new Container(new MetadataInjector()).add(R.toClass(Logger)).add(R.toClass(LogsRepo));
 
     const logger = container.resolve<Logger>('logger');
     logger.log('Hello');
@@ -1306,7 +1306,7 @@ describe('inject property', () => {
     }
     const expected = 'Hello world!';
 
-    const container = new Container(new MetadataInjector()).add(Registration.fromValue(expected).to('greeting'));
+    const container = new Container(new MetadataInjector()).add(Registration.toValue(expected).fromKey('greeting'));
     const app = container.resolve(App);
     runHooks(app as object, 'onInit', { scope: container });
 

package/cjm/by.js

@@ -54,7 +54,7 @@ const depKey = (key = (0, utils_1.generateUUID)()) => {
     return {
         key,
         assignTo: (registration) => {
-            let reg = registration.pipe(...mappers).to(key);
+            let reg = registration.pipe(...mappers).fromKey(key);
             if (isValidWhen) {
                 reg = registration.when(isValidWhen);
             }

package/cjm/provider/Provider.js

@@ -12,6 +12,9 @@ class Provider {
         const mappers = (0, utils_1.isConstructor)(value) ? (0, IProvider_1.getTransformers)(value) ?? [] : [];
         return new Provider(() => value).pipe(...mappers);
     }
+    static fromKey(key) {
+        return new Provider((c) => c.resolve(key));
+    }
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
         this.aliases = new Set();

package/cjm/registration/IRegistration.js

@@ -4,16 +4,10 @@ exports.register = exports.getTransformers = exports.scope = exports.redirectFro
 const metadata_1 = require("../metadata");
 const key = (...keys) => (r) => {
     const [originalKey, ...redirectKeys] = keys;
-    let registration = r.to(originalKey);
-    for (const key of redirectKeys) {
-        registration = registration.redirectFrom(key);
-    }
-    return registration;
+    return r.fromKey(originalKey).redirectFrom(...redirectKeys);
 };
 exports.key = key;
-const redirectFrom = (redirectKey) => (r) => {
-    return r.redirectFrom(redirectKey);
-};
+const redirectFrom = (...keys) => (r) => r.redirectFrom(...keys);
 exports.redirectFrom = redirectFrom;
 const scope = (predicate) => (r) => r.when(predicate);
 exports.scope = scope;

package/cjm/registration/Registration.js

@@ -6,20 +6,23 @@ const Provider_1 = require("../provider/Provider");
 const DependencyMissingKeyError_1 = require("../errors/DependencyMissingKeyError");
 const IRegistration_1 = require("./IRegistration");
 class Registration {
-    static fromClass(Target) {
+    static toClass(Target) {
         const transform = (0, utils_1.pipe)(...(0, IRegistration_1.getTransformers)(Target));
         return transform(new Registration(() => Provider_1.Provider.fromClass(Target), Target.name));
     }
-    static fromValue(value) {
+    static toValue(value) {
         if ((0, utils_1.isConstructor)(value)) {
             const transform = (0, utils_1.pipe)(...(0, IRegistration_1.getTransformers)(value));
             return transform(new Registration(() => Provider_1.Provider.fromValue(value), value.name));
         }
         return new Registration(() => Provider_1.Provider.fromValue(value));
     }
-    static fromFn(fn) {
+    static toFn(fn) {
         return new Registration(() => new Provider_1.Provider(fn));
     }
+    static toKey(key) {
+        return new Registration(() => Provider_1.Provider.fromKey(key));
+    }
     constructor(createProvider, key, matchScope = () => true) {
         this.createProvider = createProvider;
         this.key = key;
@@ -27,12 +30,14 @@ class Registration {
         this.redirectKeys = new Set();
         this.mappers = [];
     }
-    to(key) {
+    fromKey(key) {
         this.key = key;
         return this;
     }
-    redirectFrom(key) {
-        this.redirectKeys.add(key);
+    redirectFrom(...keys) {
+        for (const key of keys) {
+            this.redirectKeys.add(key);
+        }
         return this;
     }
     pipe(...mappers) {

package/esm/by.js

@@ -48,7 +48,7 @@ export const depKey = (key = generateUUID()) => {
     return {
         key,
         assignTo: (registration) => {
-            let reg = registration.pipe(...mappers).to(key);
+            let reg = registration.pipe(...mappers).fromKey(key);
             if (isValidWhen) {
                 reg = registration.when(isValidWhen);
             }

package/esm/provider/Provider.js

@@ -9,6 +9,9 @@ export class Provider {
         const mappers = isConstructor(value) ? getTransformers(value) ?? [] : [];
         return new Provider(() => value).pipe(...mappers);
     }
+    static fromKey(key) {
+        return new Provider((c) => c.resolve(key));
+    }
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
         this.aliases = new Set();

package/esm/registration/IRegistration.js

@@ -1,15 +1,9 @@
 import { getMetadata, setMetadata } from '../metadata';
 export const key = (...keys) => (r) => {
     const [originalKey, ...redirectKeys] = keys;
-    let registration = r.to(originalKey);
-    for (const key of redirectKeys) {
-        registration = registration.redirectFrom(key);
-    }
-    return registration;
-};
-export const redirectFrom = (redirectKey) => (r) => {
-    return r.redirectFrom(redirectKey);
+    return r.fromKey(originalKey).redirectFrom(...redirectKeys);
 };
+export const redirectFrom = (...keys) => (r) => r.redirectFrom(...keys);
 export const scope = (predicate) => (r) => r.when(predicate);
 const METADATA_KEY = 'registration';
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];

package/esm/registration/Registration.js

@@ -3,20 +3,23 @@ import { Provider } from '../provider/Provider';
 import { DependencyMissingKeyError } from '../errors/DependencyMissingKeyError';
 import { getTransformers } from './IRegistration';
 export class Registration {
-    static fromClass(Target) {
+    static toClass(Target) {
         const transform = pipe(...getTransformers(Target));
         return transform(new Registration(() => Provider.fromClass(Target), Target.name));
     }
-    static fromValue(value) {
+    static toValue(value) {
         if (isConstructor(value)) {
             const transform = pipe(...getTransformers(value));
             return transform(new Registration(() => Provider.fromValue(value), value.name));
         }
         return new Registration(() => Provider.fromValue(value));
     }
-    static fromFn(fn) {
+    static toFn(fn) {
         return new Registration(() => new Provider(fn));
     }
+    static toKey(key) {
+        return new Registration(() => Provider.fromKey(key));
+    }
     constructor(createProvider, key, matchScope = () => true) {
         this.createProvider = createProvider;
         this.key = key;
@@ -24,12 +27,14 @@ export class Registration {
         this.redirectKeys = new Set();
         this.mappers = [];
     }
-    to(key) {
+    fromKey(key) {
         this.key = key;
         return this;
     }
-    redirectFrom(key) {
-        this.redirectKeys.add(key);
+    redirectFrom(...keys) {
+        for (const key of keys) {
+            this.redirectKeys.add(key);
+        }
         return this;
     }
     pipe(...mappers) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "33.5.0",
+  "version": "34.0.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "554d11b827eeaea495cc7024ade9b1e7fd6c8649"
+  "gitHead": "54c0f0048be52409045c3336677f900275baf425"
 }

package/typings/provider/Provider.d.ts

@@ -5,6 +5,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
     static fromClass<T>(Target: constructor<T>): IProvider<T>;
     static fromValue<T>(value: T): IProvider<T>;
+    static fromKey<T>(key: DependencyKey): Provider<T>;
     key?: DependencyKey;
     private readonly aliases;
     private argsFn;

package/typings/registration/IRegistration.d.ts

@@ -4,13 +4,13 @@ import { IProvider } from '../provider/IProvider';
 export type ScopePredicate = (s: IContainer) => boolean;
 export interface IRegistration<T = any> extends IContainerModule {
     when(isValidWhen: ScopePredicate): this;
-    to(key: DependencyKey): this;
+    fromKey(key: DependencyKey): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
-    redirectFrom(key: DependencyKey): this;
+    redirectFrom(...keys: DependencyKey[]): this;
 }
 export type ReturnTypeOfRegistration<T> = T extends IRegistration<infer R> ? R : never;
 export declare const key: (...keys: DependencyKey[]) => MapFn<IRegistration>;
-export declare const redirectFrom: (redirectKey: DependencyKey) => MapFn<IRegistration>;
+export declare const redirectFrom: (...keys: DependencyKey[]) => MapFn<IRegistration>;
 export declare const scope: (predicate: ScopePredicate) => MapFn<IRegistration>;
 export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<any>>[];
 export declare const register: (...mappers: MapFn<IRegistration>[]) => ClassDecorator;

package/typings/registration/Registration.d.ts

@@ -7,13 +7,14 @@ export declare class Registration<T = any> implements IRegistration<T> {
     private key?;
     private matchScope;
     private redirectKeys;
-    static fromClass<T>(Target: constructor<T>): IRegistration<any>;
-    static fromValue<T>(value: T): IRegistration<any>;
-    static fromFn<T>(fn: ResolveDependency<T>): Registration<T>;
+    static toClass<T>(Target: constructor<T>): IRegistration<any>;
+    static toValue<T>(value: T): IRegistration<any>;
+    static toFn<T>(fn: ResolveDependency<T>): Registration<T>;
+    static toKey<T>(key: DependencyKey): Registration<T>;
     private mappers;
     constructor(createProvider: (key: DependencyKey) => IProvider<T>, key?: DependencyKey | undefined, matchScope?: ScopePredicate);
-    to(key: DependencyKey): this;
-    redirectFrom(key: DependencyKey): this;
+    fromKey(key: DependencyKey): this;
+    redirectFrom(...keys: DependencyKey[]): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
     when(isValidWhen: ScopePredicate): this;
     applyTo(container: IContainer): void;