ditox 2.0.0 → 2.1.0

package/src/utils.test.ts

@@ -1,18 +1,18 @@
 import {createContainer, optional, ResolverError, token} from './ditox';
 import {
   bindMultiValue,
-  getProps,
-  getValues,
   injectable,
-  injectableProps,
-  resolveProps,
+  injectableClass,
+  resolveValue,
   resolveValues,
+  tryResolveValue,
+  tryResolveValues,
 } from './utils';
 
 const NUMBER = token<number>('number');
 const STRING = token<string>('string');
 
-describe('bindMultiValue', () => {
+describe('bindMultiValue()', () => {
   const NUMBERS = token<Array<number>>('numbers');
 
   it('should append a value to an array declared by a token', () => {
@@ -53,13 +53,53 @@ describe('bindMultiValue', () => {
   });
 });
 
-describe('getValues', () => {
+describe('tryResolveValue()', () => {
+  it('should return an object with values by the tokens', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, 'abc');
+
+    const props: {a: number; b: string} = tryResolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+    });
+    expect(props).toEqual({a: 1, b: 'abc'});
+  });
+
+  it('should return "undefined" item in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const props = tryResolveValue(container, {a: NUMBER, b: STRING});
+    expect(props).toEqual({a: 1, b: undefined});
+  });
+
+  it('should return values of optional tokens in case they are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const OPTIONAL_STRING = optional(STRING, 'value');
+
+    const props = tryResolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+      c: OPTIONAL_STRING,
+    });
+    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+  });
+});
+
+describe('tryResolveValues()', () => {
   it('should return values for the tokens', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, 'abc');
 
-    const values: [number, string] = getValues(container, NUMBER, STRING);
+    const values: [number, string] = tryResolveValues(
+      container,
+      NUMBER,
+      STRING,
+    );
     expect(values).toEqual([1, 'abc']);
   });
 
@@ -67,7 +107,7 @@ describe('getValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(container, NUMBER, STRING);
+    const values = tryResolveValues(container, NUMBER, STRING);
     expect(values).toEqual([1, undefined]);
   });
 
@@ -77,7 +117,7 @@ describe('getValues', () => {
 
     const OPTIONAL_STRING = optional(STRING, 'value');
 
-    const values = getValues(container, NUMBER, STRING, OPTIONAL_STRING);
+    const values = tryResolveValues(container, NUMBER, STRING, OPTIONAL_STRING);
     expect(values).toEqual([1, undefined, 'value']);
   });
 
@@ -85,7 +125,7 @@ describe('getValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(
+    const values = tryResolveValues(
       container,
       NUMBER,
       NUMBER,
@@ -102,7 +142,43 @@ describe('getValues', () => {
   });
 });
 
-describe('resolveValues', () => {
+describe('resolveValue()', () => {
+  it('should an object with resolved values from the container for the specified token props', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, 'abc');
+
+    const props: {a: number; b: string} = resolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+    });
+    expect(props).toEqual({a: 1, b: 'abc'});
+  });
+
+  it('should throw an error in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    expect(() => {
+      resolveValue(container, {a: NUMBER, b: STRING});
+    }).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
+  });
+
+  it('should resolve values of optional tokens in case they are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const props = resolveValue(container, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+    expect(props).toEqual({a: 1, b: 'value'});
+  });
+});
+
+describe('resolveValues()', () => {
   it('should resolve tokens from the container', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
@@ -127,12 +203,30 @@ describe('resolveValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(container, NUMBER, optional(STRING, 'value'));
+    const values = resolveValues(container, NUMBER, optional(STRING, 'value'));
     expect(values).toEqual([1, 'value']);
   });
+
+  it('should resolve a dictionary of tokens', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const values = resolveValue(container, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+    expect(values).toEqual({
+      a: 1,
+      b: 'value',
+    });
+  });
 });
 
 describe('injectable()', () => {
+  function join({a, b}: {a: number; b: string}): string {
+    return `${a}/${b}`;
+  }
+
   it('should inject values from Container as arguments of the factory', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
@@ -174,83 +268,104 @@ describe('injectable()', () => {
 
     expect(decoratedFactory(container)).toBe('1value');
   });
-});
 
-describe('getProps', () => {
-  it('should return an object with values by the tokens', () => {
+  it('should inject values from Container as an object for the first argument of the factory', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
-    container.bindValue(STRING, 'abc');
+    container.bindValue(STRING, '2');
 
-    const props: {a?: number; b?: string} = getProps(container, {
-      a: NUMBER,
-      b: STRING,
-    });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+
+    expect(decoratedFactory(container)).toBe('1/2');
   });
 
-  it('should return "undefined" item in case a value is not provided', () => {
+  it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const props = getProps(container, {a: NUMBER, b: STRING});
-    expect(props).toEqual({a: 1, b: undefined});
+    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+
+    expect(() => decoratedFactory(container)).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
   });
 
-  it('should return values of optional tokens in case they are not provided', () => {
+  it('should inject values of optional tokens in case values are not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const OPTIONAL_STRING = optional(STRING, 'value');
-
-    const props = getProps(container, {
+    const decoratedFactory = injectable(join, {
       a: NUMBER,
-      b: STRING,
-      c: OPTIONAL_STRING,
+      b: optional(STRING, 'value'),
     });
-    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+
+    expect(decoratedFactory(container)).toBe('1/value');
   });
 });
 
-describe('resolveProps', () => {
-  it('should an object with resolved values from the container for the specified token props', () => {
+describe('injectableClass()', () => {
+  class TestClass {
+    a: number;
+    b: string;
+
+    constructor(a: number, b: string) {
+      this.a = a;
+      this.b = b;
+    }
+
+    concat(): string {
+      return this.a + this.b;
+    }
+  }
+
+  it('should inject values from Container as arguments of the constructor', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
-    container.bindValue(STRING, 'abc');
+    container.bindValue(STRING, '2');
 
-    const props: {a: number; b: string} = resolveProps(container, {
-      a: NUMBER,
-      b: STRING,
-    });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    const factory = injectableClass(TestClass, NUMBER, STRING);
+
+    expect(factory(container).concat()).toBe('12');
   });
 
-  it('should throw an error in case a value is not provided', () => {
+  it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    expect(() => {
-      resolveProps(container, {a: NUMBER, b: STRING});
-    }).toThrowError(
+    const factory = injectableClass(TestClass, NUMBER, STRING);
+
+    expect(() => factory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
     );
   });
 
-  it('should resolve values of optional tokens in case they are not provided', () => {
+  it('should inject values of optional tokens in case values are not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const props = resolveProps(container, {
-      a: NUMBER,
-      b: optional(STRING, 'value'),
-    });
-    expect(props).toEqual({a: 1, b: 'value'});
+    const factory = injectableClass(
+      TestClass,
+      NUMBER,
+      optional(STRING, 'value'),
+    );
+
+    expect(factory(container).concat()).toBe('1value');
   });
 });
 
-describe('injectableProps()', () => {
-  function join({a, b}: {a: number; b: string}): string {
-    return `${a}/${b}`;
+describe('injectableClass()', () => {
+  class TestClass {
+    a: number;
+    b: string;
+
+    constructor(props: {a: number; b: string}) {
+      this.a = props.a;
+      this.b = props.b;
+    }
+
+    join(): string {
+      return `${this.a}/${this.b}`;
+    }
   }
 
   it('should inject values from Container as an object for the first argument of the factory', () => {
@@ -258,18 +373,18 @@ describe('injectableProps()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, '2');
 
-    const decoratedFactory = injectableProps(join, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
 
-    expect(decoratedFactory(container)).toBe('1/2');
+    expect(factory(container).join()).toBe('1/2');
   });
 
   it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const decoratedFactory = injectableProps(join, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
 
-    expect(() => decoratedFactory(container)).toThrowError(
+    expect(() => factory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
     );
   });
@@ -278,11 +393,11 @@ describe('injectableProps()', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const decoratedFactory = injectableProps(join, {
+    const factory = injectableClass(TestClass, {
       a: NUMBER,
       b: optional(STRING, 'value'),
     });
 
-    expect(decoratedFactory(container)).toBe('1/value');
+    expect(factory(container).join()).toBe('1/value');
   });
 });

package/src/utils.ts

@@ -5,6 +5,19 @@ type TokenProps<Props extends ValuesProps> = {
   [K in keyof Props]: Token<Props[K]>;
 };
 
+/**
+ * Checks if a value is the token
+ */
+export function isToken<T>(value: unknown): value is Token<T> {
+  return (
+    value !== undefined &&
+    value !== null &&
+    typeof value === 'object' &&
+    'symbol' in value &&
+    typeof (value as any).symbol === 'symbol'
+  );
+}
+
 /**
  * Rebinds the array by the token with added new value.
  * @param container - Dependency container.
@@ -22,41 +35,154 @@ export function bindMultiValue<T>(
 }
 
 /**
- * Returns an array of resolved values by the specified token.
+ * Tries to resolve a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
  * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const value = tryResolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = tryResolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
  */
-export function getValues<
-  Tokens extends Token<unknown>[],
+export function tryResolveValue<
+  Tokens extends Token<unknown> | {[key: string]: Token<unknown>},
+  Values extends Tokens extends Token<infer V>
+    ? V | undefined
+    : Tokens extends TokenProps<infer Props>
+    ? Partial<Props>
+    : never,
+>(container: Container, token: Tokens): Values {
+  if (isToken(token)) {
+    return container.get(token) as Values;
+  }
+
+  const obj: any = {};
+  Object.keys(token).forEach((key) => (obj[key] = container.get(token[key])));
+  return obj;
+}
+
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const items1 = tryResolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = tryResolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
+ */
+export function tryResolveValues<
+  Tokens extends (Token<unknown> | {[key: string]: Token<unknown>})[],
   Values extends {
-    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V>
+      ? V | undefined
+      : Tokens[K] extends TokenProps<infer Props>
+      ? Partial<Props>
+      : never;
   },
 >(container: Container, ...tokens: Tokens): Values {
-  return tokens.map(container.get) as Values;
+  return tokens.map((item) => tryResolveValue(container, item)) as Values;
 }
 
 /**
- * Returns an array of resolved values by the specified token.
+ * Resolves a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a value is not found by the token, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const value = resolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = resolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+export function resolveValue<
+  Tokens extends Token<unknown> | {[key: string]: Token<unknown>},
+  Values extends Tokens extends Token<infer V>
+    ? V
+    : Tokens extends TokenProps<infer Props>
+    ? Props
+    : never,
+>(container: Container, token: Tokens): Values {
+  if (isToken(token)) {
+    return container.resolve(token) as Values;
+  }
+
+  const obj: any = {};
+  Object.keys(token).forEach(
+    (key) => (obj[key] = container.resolve(token[key])),
+  );
+  return obj;
+}
+
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
  * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const items1 = resolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = resolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
  */
 export function resolveValues<
-  Tokens extends Token<unknown>[],
+  Tokens extends (Token<unknown> | {[key: string]: Token<unknown>})[],
   Values extends {
-    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V>
+      ? V
+      : Tokens[K] extends TokenProps<infer Props>
+      ? Props
+      : never;
   },
 >(container: Container, ...tokens: Tokens): Values {
-  return tokens.map(container.resolve) as Values;
+  return tokens.map((item) => resolveValue(container, item)) as Values;
 }
 
 /**
- * Decorates a factory by passing resolved tokens as factory arguments.
+ * Decorates a factory by passing resolved values as factory arguments.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+ *
  * @param factory - A factory.
  * @param tokens - Tokens which correspond to factory arguments.
+ *
  * @return Decorated factory which takes a dependency container as a single argument.
  */
 export function injectable<
-  Tokens extends Token<unknown>[],
+  Tokens extends (Token<unknown> | {[key: string]: Token<unknown>})[],
   Values extends {
-    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V>
+      ? V
+      : Tokens[K] extends TokenProps<infer Props>
+      ? Props
+      : never;
   },
   Result,
 >(
@@ -71,62 +197,34 @@ export function injectable<
 }
 
 /**
- * Returns an object with resolved properties which are specified by token properties.
- * If a token is not found, then `undefined` value is used.
+ * Decorates a class by passing resolved values as arguments to its constructor.
  *
- * @example
- * ```ts
- * const props = getProps(container, {a: tokenA, b: tokenB});
- * console.log(props); // {a: 1, b: 2}
- * ```
- */
-export function getProps<Props extends ValuesProps>(
-  container: Container,
-  tokens: TokenProps<Props>,
-): Partial<Props> {
-  const obj: any = {...tokens};
-  Object.keys(obj).forEach((key) => (obj[key] = container.get(obj[key])));
-  return obj;
-}
-
-/**
- * Returns an object with resolved properties which are specified by token properties.
- * If a token is not found, then `ResolverError` is thrown.
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
  *
- * @example
- * ```ts
- * const props = resolveProps(container, {a: tokenA, b: tokenB});
- * console.log(props); // {a: 1, b: 2}
- * ```
- */
-export function resolveProps<Props extends ValuesProps>(
-  container: Container,
-  tokens: TokenProps<Props>,
-): Props {
-  const obj: any = {...tokens};
-  Object.keys(obj).forEach((key) => (obj[key] = container.resolve(obj[key])));
-  return obj;
-}
-
-/**
- * Decorates a factory by passing a resolved object with tokens as the first argument.
- * @param factory - A factory.
- * @param tokens - Object with tokens.
- * @return Decorated factory which takes a dependency container as a single argument.
+ * @param constructor - Constructor of a class
+ * @param tokens - Tokens which correspond to constructor arguments
  *
- * @example
- * ```ts
- * const factory = ({a, b}: {a: number, b: number}) => a + b;
- * const decoratedFactory = injectableProps(factory, {a: tokenA, b: tokenB});
- * const result = decoratedFactory(container);
- * ```
+ * @return A factory function which takes a dependency container as a single argument
+ * and returns a new created class.
  */
-export function injectableProps<Props extends ValuesProps, Result>(
-  factory: (props: Props) => Result,
-  tokens: TokenProps<Props>,
+export function injectableClass<
+  Tokens extends (Token<unknown> | {[key: string]: Token<unknown>})[],
+  Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V>
+      ? V
+      : Tokens[K] extends TokenProps<infer Props>
+      ? Props
+      : never;
+  },
+  Result,
+>(
+  this: unknown,
+  constructor: new (...params: Values) => Result,
+  ...tokens: Tokens
 ): (container: Container) => Result {
-  return (container) => {
-    const values: Props = resolveProps(container, tokens);
-    return factory(values);
-  };
+  return injectable<Tokens, Values, Result>(
+    (...values) => new constructor(...values),
+    ...tokens,
+  );
 }