ditox 2.0.0 → 2.1.0

package/src/index.ts

@@ -9,14 +9,22 @@ export type {
 } from './ditox';
 
 export {
+  isToken,
   bindMultiValue,
-  getValues,
+  tryResolveValue,
+  tryResolveValues,
+  resolveValue,
   resolveValues,
   injectable,
+  injectableClass,
+} from './utils';
+
+export {
+  getValues,
   getProps,
   resolveProps,
   injectableProps,
-} from './utils';
+} from './utils-deprecated';
 
 export {
   bindModule,

package/src/utils-deprecated.test.ts

@@ -0,0 +1,286 @@
+import {createContainer, optional, ResolverError, token} from './ditox';
+import {bindMultiValue, injectable, resolveValues} from './utils';
+import {
+  getProps,
+  getValues,
+  injectableProps,
+  resolveProps,
+} from './utils-deprecated';
+
+const NUMBER = token<number>('number');
+const STRING = token<string>('string');
+
+describe('bindMultiValue', () => {
+  const NUMBERS = token<Array<number>>('numbers');
+
+  it('should append a value to an array declared by a token', () => {
+    const container = createContainer();
+
+    bindMultiValue(container, NUMBERS, 1);
+    bindMultiValue(container, NUMBERS, 2);
+
+    const values: Array<number> = container.resolve(NUMBERS);
+    expect(values).toEqual([1, 2]);
+  });
+
+  it('should append new values to an array declared by a token', () => {
+    const container = createContainer();
+
+    bindMultiValue(container, NUMBERS, 1);
+    bindMultiValue(container, NUMBERS, 2);
+    expect(container.resolve(NUMBERS)).toEqual([1, 2]);
+
+    bindMultiValue(container, NUMBERS, 3);
+    bindMultiValue(container, NUMBERS, 4);
+    expect(container.resolve(NUMBERS)).toEqual([1, 2, 3, 4]);
+  });
+
+  it('should add new values to a copy of array from the parent container', () => {
+    const parent = createContainer();
+    parent.bindValue(NUMBERS, [1, 2]);
+    const container = createContainer(parent);
+
+    bindMultiValue(container, NUMBERS, 3);
+    bindMultiValue(container, NUMBERS, 4);
+    expect(parent.resolve(NUMBERS)).toEqual([1, 2]);
+    expect(container.resolve(NUMBERS)).toEqual([1, 2, 3, 4]);
+
+    container.remove(NUMBERS);
+    expect(parent.resolve(NUMBERS)).toEqual([1, 2]);
+    expect(container.resolve(NUMBERS)).toEqual([1, 2]);
+  });
+});
+
+describe('getValues', () => {
+  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);
+    expect(values).toEqual([1, 'abc']);
+  });
+
+  it('should return "undefined" item in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const values = getValues(container, NUMBER, STRING);
+    expect(values).toEqual([1, 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 values = getValues(container, NUMBER, STRING, OPTIONAL_STRING);
+    expect(values).toEqual([1, undefined, 'value']);
+  });
+
+  it('should works with a big arity', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const values = getValues(
+      container,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+      NUMBER,
+    );
+    expect(values).toEqual([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+  });
+});
+
+describe('resolveValues', () => {
+  it('should resolve tokens from the container', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, 'abc');
+
+    const values: [number, string] = resolveValues(container, NUMBER, STRING);
+    expect(values).toEqual([1, 'abc']);
+  });
+
+  it('should throw an error in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    expect(() => {
+      resolveValues(container, NUMBER, 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 values = getValues(container, NUMBER, optional(STRING, 'value'));
+    expect(values).toEqual([1, 'value']);
+  });
+});
+
+describe('injectable()', () => {
+  it('should inject values from Container as arguments of the factory', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, '2');
+
+    const decoratedFactory = injectable(
+      (a: number, b: string) => a + b,
+      NUMBER,
+      STRING,
+    );
+
+    expect(decoratedFactory(container)).toBe('12');
+  });
+
+  it('should throw ResolverError error in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const decoratedFactory = injectable(
+      (a: number, b: string) => a + b,
+      NUMBER,
+      STRING,
+    );
+
+    expect(() => decoratedFactory(container)).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
+  });
+
+  it('should inject values of optional tokens in case values are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const decoratedFactory = injectable(
+      (a, b) => a + b,
+      NUMBER,
+      optional(STRING, 'value'),
+    );
+
+    expect(decoratedFactory(container)).toBe('1value');
+  });
+});
+
+describe('getProps', () => {
+  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} = getProps(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 = getProps(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 = getProps(container, {
+      a: NUMBER,
+      b: STRING,
+      c: OPTIONAL_STRING,
+    });
+    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+  });
+});
+
+describe('resolveProps', () => {
+  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} = resolveProps(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(() => {
+      resolveProps(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 = resolveProps(container, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+    expect(props).toEqual({a: 1, b: 'value'});
+  });
+});
+
+describe('injectableProps()', () => {
+  function join({a, b}: {a: number; b: string}): string {
+    return `${a}/${b}`;
+  }
+
+  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, '2');
+
+    const decoratedFactory = injectableProps(join, {a: NUMBER, b: STRING});
+
+    expect(decoratedFactory(container)).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});
+
+    expect(() => decoratedFactory(container)).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
+  });
+
+  it('should inject values of optional tokens in case values are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const decoratedFactory = injectableProps(join, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+
+    expect(decoratedFactory(container)).toBe('1/value');
+  });
+});

package/src/utils-deprecated.ts

@@ -0,0 +1,87 @@
+import type {Container, Token} from './ditox';
+import {
+  injectable,
+  resolveValue,
+  tryResolveValue,
+  tryResolveValues,
+} from './utils';
+
+type ValuesProps = {[key: string]: unknown};
+type TokenProps<Props extends ValuesProps> = {
+  [K in keyof Props]: Token<Props[K]>;
+};
+
+/**
+ * Returns an array of resolved values by the specified token.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValues()` function.
+ */
+export function getValues<
+  Tokens extends Token<unknown>[],
+  Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+  },
+>(container: Container, ...tokens: Tokens): Values {
+  return tryResolveValues(container, ...tokens);
+}
+
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValue()` function.
+ *
+ * @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> {
+  return tryResolveValue(container, tokens) as Partial<Props>;
+}
+
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @deprecated Use `resolveValue()` function.
+ *
+ * @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 {
+  return resolveValue(container, tokens) as Props;
+}
+
+/**
+ * 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.
+ *
+ * @deprecated Use `injectable()` function.
+ *
+ * @example
+ * ```ts
+ * const factory = ({a, b}: {a: number, b: number}) => a + b;
+ * const decoratedFactory = injectableProps(factory, {a: tokenA, b: tokenB});
+ * const result = decoratedFactory(container);
+ * ```
+ */
+export function injectableProps<Props extends ValuesProps, Result>(
+  factory: (props: Props) => Result,
+  tokens: TokenProps<Props>,
+): (container: Container) => Result {
+  return injectable(factory as any, tokens);
+}