@sima-land/isomorph 11.0.0-alpha.4 → 11.0.0-alpha.41

package/src/di/__test__/application.test.ts

@@ -0,0 +1,258 @@
+import { createApplication, CURRENT_APP } from '../application';
+import { AlreadyBoundError, CircularDependencyError } from '../errors';
+import { createPreset } from '../preset';
+import { createToken } from '../token';
+
+describe('Application', () => {
+  it('should throw exception properly when component not found', () => {
+    const TOKEN = {
+      config: createToken<any>('config'),
+      server: createToken<any>('server'),
+      client: createToken<any>('client'),
+      logger: createToken<any>('logger'),
+    } as const;
+
+    const app = createApplication();
+    const spy = jest.fn();
+
+    app.bind(TOKEN.config).toProvider(() => {
+      spy();
+      return { type: 'config' };
+    });
+
+    app.bind(TOKEN.logger).toProvider(resolve => {
+      const config = resolve(TOKEN.config);
+      return { type: 'logger', config };
+    });
+
+    app.bind(TOKEN.client).toProvider(resolve => {
+      const logger = resolve(TOKEN.logger);
+      return { type: 'client', logger };
+    });
+
+    expect(() => {
+      app.get(TOKEN.server);
+    }).toThrow('Nothing bound to Token(server)');
+  });
+
+  it('should bound itself to known token', () => {
+    const app = createApplication();
+
+    expect(app.get(CURRENT_APP)).toBe(app);
+  });
+
+  it('bind() should return binding with .toValue() method', () => {
+    const token = createToken<any>('foo');
+    const app = createApplication();
+    const component = { count: 10 };
+
+    app.bind(token).toValue(component);
+
+    expect(app.get(token)).toBe(component);
+  });
+
+  it('should prevent second binding to same token', () => {
+    const token = createToken<number>('age');
+    const app = createApplication();
+
+    expect(() => {
+      app.bind(token).toValue(23);
+    }).not.toThrow();
+
+    expect(() => {
+      app.bind(token).toValue(34);
+    }).toThrow(new AlreadyBoundError(token, 'Application'));
+  });
+
+  it('should handle presets', () => {
+    const TOKEN = {
+      admin: createToken<{ role: 'admin'; rule: { for: string } }>('rules'),
+      rules: createToken<Array<{ for: string }>>('admin'),
+    };
+
+    const adminPreset = createPreset([
+      [
+        TOKEN.admin,
+        resolve => {
+          const rules = resolve(TOKEN.rules);
+
+          return {
+            role: 'admin',
+            rule: rules.find(r => r.for === 'admin'),
+          };
+        },
+      ],
+    ]);
+
+    const rulesPreset = createPreset([
+      [TOKEN.rules, () => [{ for: 'admin' }, { for: 'user' }, { for: 'guest' }]],
+    ]);
+
+    const app = createApplication();
+
+    app.preset(adminPreset);
+    app.preset(rulesPreset);
+
+    expect(app.get(TOKEN.admin)).toEqual({
+      role: 'admin',
+      rule: { for: 'admin' },
+    });
+  });
+
+  it('should handle parent app attach', () => {
+    const TOKEN = {
+      config: createToken<{ port: number }>('config'),
+      server: createToken<{ start: VoidFunction }>('server'),
+    };
+
+    const parentApp = createApplication();
+    const childApp = createApplication();
+    const spy = jest.fn();
+
+    childApp.attach(parentApp);
+
+    childApp.bind(TOKEN.server).toProvider(resolve => {
+      const config = resolve(TOKEN.config);
+
+      return {
+        start() {
+          spy(config.port);
+        },
+      };
+    });
+
+    parentApp.bind(TOKEN.config).toValue({ port: 1200 });
+
+    const server = childApp.get(TOKEN.server);
+
+    expect(spy).toBeCalledTimes(0);
+    server.start();
+    expect(spy).toBeCalledTimes(1);
+    expect(spy).toBeCalledWith(1200);
+  });
+
+  it('should prevent reattach', () => {
+    const parentApp = createApplication();
+    const childApp = createApplication();
+    const otherApp = createApplication();
+
+    childApp.attach(parentApp);
+
+    // other app reattach
+    expect(() => {
+      childApp.attach(otherApp);
+    }).toThrow(Error('Cannot reattach application'));
+
+    // same app reattach
+    expect(() => {
+      childApp.attach(parentApp);
+    }).toThrow(Error('Cannot reattach application'));
+  });
+
+  it('invoke() should works properly', () => {
+    const TOKEN = {
+      sword: createToken<{ sharpness: number }>('sword'),
+      knight: createToken<{ power: number; attack: () => number }>('knight'),
+    } as const;
+
+    const app = createApplication();
+
+    app.bind(TOKEN.knight).toProvider(resolve => {
+      const weapon = resolve(TOKEN.sword);
+
+      return {
+        power: 12,
+
+        attack() {
+          return weapon.sharpness + this.power;
+        },
+      };
+    });
+
+    app.bind(TOKEN.sword).toValue({ sharpness: 5 });
+
+    const spy = jest.fn();
+
+    app.invoke([TOKEN.knight], knight => {
+      spy(knight.attack());
+    });
+
+    expect(spy).toBeCalledTimes(1);
+    expect(spy).toBeCalledWith(17);
+  });
+
+  it('should properly handle circular dependencies', () => {
+    const TOKEN = {
+      config: createToken<any>('config'),
+      logger: createToken<any>('logger'),
+    } as const;
+
+    const app = createApplication();
+
+    app.bind(TOKEN.config).toProvider(resolve => {
+      const logger = resolve(TOKEN.logger);
+
+      logger.info('Config created');
+
+      return {
+        appName: 'test app',
+      };
+    });
+
+    app.bind(TOKEN.logger).toProvider(resolve => {
+      const config = resolve(TOKEN.config);
+
+      return {
+        info(message: any) {
+          // eslint-disable-next-line no-console
+          console.log(config.appName, message);
+        },
+      };
+    });
+
+    expect(() => app.get(TOKEN.config)).toThrow(
+      new CircularDependencyError([TOKEN.config, TOKEN.logger, TOKEN.config], 'Application'),
+    );
+  });
+
+  it('should throw exception properly when component not found in parent app too', () => {
+    const TOKEN = {
+      config: createToken<any>('config'),
+      client: createToken<any>('client'),
+      logger: createToken<any>('logger'),
+    } as const;
+
+    const parent = createApplication();
+    const child = createApplication();
+    child.attach(parent);
+
+    child.bind(TOKEN.logger).toProvider(resolve => {
+      const config = resolve(TOKEN.config);
+      return { type: 'logger', config };
+    });
+
+    child.bind(TOKEN.client).toProvider(resolve => {
+      const logger = resolve(TOKEN.logger);
+      return { type: 'client', logger };
+    });
+
+    expect(() => {
+      child.get(TOKEN.client);
+    }).toThrow('Nothing bound to Token(config)');
+  });
+
+  it('should get component from cache', () => {
+    const app = createApplication();
+    const token = createToken<{ id: number }>('foo');
+
+    const value = { id: 123 };
+    app.bind(token).toValue(value);
+
+    const first = app.get(token);
+    const second = app.get(token);
+
+    expect(Object.is(value, first)).toBe(true);
+    expect(Object.is(value, second)).toBe(true);
+    expect(Object.is(first, second)).toBe(true);
+  });
+});

package/src/di/__test__/container.test.ts

@@ -0,0 +1,103 @@
+import { createContainer } from '../container';
+import { AlreadyBoundError, CircularDependencyError, NothingBoundError } from '../errors';
+import { createToken } from '../token';
+
+describe('Container', () => {
+  it('should prevent second binding to same token', () => {
+    const token = createToken<number>('age');
+    const container = createContainer();
+
+    expect(() => {
+      container.set(token, () => 23);
+    }).not.toThrow(new AlreadyBoundError(token));
+
+    expect(() => {
+      container.set(token, () => 23);
+    }).toThrow(new AlreadyBoundError(token));
+  });
+
+  it('should throw type error when provider is not a function', () => {
+    const token = createToken<number>('answer');
+    const container = createContainer();
+
+    container.set(token, 42 as any);
+
+    expect(() => {
+      container.get(token);
+    }).toThrow(new Error('Provider is not a function'));
+  });
+
+  it('should properly get component from cache', () => {
+    const token = createToken<{ id: number; name: string }>('user');
+    const container = createContainer();
+
+    container.set(token, () => ({
+      id: 1,
+      name: 'John',
+    }));
+
+    const user1 = container.get(token);
+    const user2 = container.get(token);
+
+    expect(user1).toBe(user2);
+  });
+
+  it('should provide resolve', () => {
+    const TOKEN = {
+      foo: createToken<number>('foo'),
+      bar: createToken<string>('bar'),
+    } as const;
+
+    const container = createContainer();
+
+    container.set(TOKEN.foo, () => 123.45);
+
+    container.set(TOKEN.bar, resolve => {
+      const foo = resolve(TOKEN.foo);
+      return foo.toString();
+    });
+
+    expect(container.get(TOKEN.bar)).toBe('123.45');
+  });
+
+  it('should handle circular dependencies', () => {
+    const TOKEN = {
+      foo: createToken<number>('foo'),
+      bar: createToken<string>('bar'),
+      baz: createToken<boolean>('baz'),
+    } as const;
+
+    const container = createContainer();
+
+    container.set(TOKEN.foo, resolve => {
+      const baz = resolve(TOKEN.baz);
+
+      return Number(baz);
+    });
+
+    container.set(TOKEN.bar, resolve => {
+      const foo = resolve(TOKEN.foo);
+
+      return String(foo + 11);
+    });
+
+    container.set(TOKEN.baz, resolve => {
+      const bar = resolve(TOKEN.bar);
+
+      return bar.length > 1;
+    });
+
+    expect(() => {
+      container.get(TOKEN.bar);
+    }).toThrow(new CircularDependencyError([TOKEN.bar, TOKEN.foo, TOKEN.baz, TOKEN.bar]));
+  });
+
+  it('should throw error when nothing boud to token', () => {
+    const container = createContainer();
+    const token = createToken('test');
+
+    expect(() => {
+      container.get(token);
+    }).toThrow(new NothingBoundError(token));
+  });
+});

package/src/di/__test__/errors.test.ts

@@ -0,0 +1,56 @@
+import { AlreadyBoundError, CircularDependencyError, NothingBoundError } from '../errors';
+import { createToken } from '../token';
+
+describe('NothingBoundError', () => {
+  const token = createToken('something');
+
+  it('should show message properly', () => {
+    const error = new NothingBoundError(token);
+
+    expect(error.message).toBe('Nothing bound to Token(something) in [unknown container]');
+  });
+
+  it('should handle name', () => {
+    const error = new NothingBoundError(token, 'MyContainer');
+
+    expect(error.message).toBe('Nothing bound to Token(something) in MyContainer');
+  });
+});
+
+describe('AlreadyBoundError', () => {
+  const token = createToken('hello');
+
+  it('should show message properly', () => {
+    const error = new AlreadyBoundError(token);
+
+    expect(error.message).toBe(
+      'Cannot rebind token in [unknown container], already bound: Token(hello)',
+    );
+  });
+
+  it('should handle name', () => {
+    const error = new AlreadyBoundError(token, 'ServerApp');
+
+    expect(error.message).toBe('Cannot rebind token in ServerApp, already bound: Token(hello)');
+  });
+});
+
+describe('CircularDependencyError', () => {
+  const trace = [createToken('A'), createToken('B'), createToken('A')];
+
+  it('should show message properly', () => {
+    const error = new CircularDependencyError(trace);
+
+    expect(error.message).toBe(
+      'Circular dependency found in [unknown container], trace: Token(A) >> Token(B) >> Token(A)',
+    );
+  });
+
+  it('should handle name', () => {
+    const error = new CircularDependencyError(trace, 'BrowserApp');
+
+    expect(error.message).toBe(
+      'Circular dependency found in BrowserApp, trace: Token(A) >> Token(B) >> Token(A)',
+    );
+  });
+});

package/src/di/__test__/preset.test.ts

@@ -0,0 +1,23 @@
+import { createApplication } from '../application';
+import { createPreset } from '../preset';
+import { createToken } from '../token';
+
+describe('Preset', () => {
+  it('set() and override() should add providers', () => {
+    const preset = createPreset([]);
+
+    const TOKEN = {
+      hello: createToken<string>('hello'),
+      world: createToken<string>('world'),
+    } as const;
+
+    preset.set(TOKEN.hello, () => 'hello');
+    preset.set(TOKEN.world, () => 'world');
+
+    const app = createApplication();
+    app.preset(preset);
+
+    expect(app.get(TOKEN.hello)).toBe('hello');
+    expect(app.get(TOKEN.world)).toBe('world');
+  });
+});

package/src/di/__test__/token.test.ts

@@ -0,0 +1,25 @@
+import { createToken } from '../token';
+
+describe('Token implementation', () => {
+  it('_resolve() should works properly', () => {
+    const token = createToken();
+    const registry = new Map<symbol, any>();
+    const component = { type: 'some component' };
+
+    registry.set(token._key, component);
+
+    expect(token._resolve(registry)).toBe(component);
+  });
+
+  it('toString() should works properly', () => {
+    const token = createToken('hello');
+
+    expect(String(token)).toBe('Token(hello)');
+  });
+
+  it('toString() should works properly for unnamed token', () => {
+    const token = createToken();
+
+    expect(String(token)).toBe('Token(unknown)');
+  });
+});

package/src/di/application.ts

@@ -0,0 +1,126 @@
+/* eslint-disable require-jsdoc, jsdoc/require-jsdoc */
+import type { Application, Provider, Token, Binding, ExtractType, Preset } from './types';
+import { AlreadyBoundError, CircularDependencyError, NothingBoundError } from './errors';
+import { createToken } from './token';
+
+/**
+ * Токен, с помощью которого можно достать из приложения само приложение.
+ */
+export const CURRENT_APP = createToken<Application>('application/self');
+
+/**
+ * Реализация Application.
+ */
+class ApplicationImplementation implements Application {
+  /** Родительское приложение. */
+  private parent?: ApplicationImplementation;
+
+  /** Зарегистрированные пресеты. */
+  private presets: Preset[];
+
+  /** Зарегистрированные провайдеры. */
+  private providers: Map<symbol, Provider<unknown>>;
+
+  /** Инициализированные компоненты (синглтоны). */
+  private components: Map<symbol, unknown>;
+
+  /** Инициализировано ли приложение.  */
+  private initialized: boolean;
+
+  constructor() {
+    this.providers = new Map();
+    this.components = new Map();
+    this.presets = [];
+    this.initialized = false;
+  }
+
+  toString() {
+    return 'Application';
+  }
+
+  bind<T>(token: Token<T>): Binding<T> {
+    if (this.providers.has(token._key)) {
+      throw new AlreadyBoundError(token, this.toString());
+    }
+
+    return {
+      toValue: value => {
+        this.providers.set(token._key, () => value);
+      },
+      toProvider: provider => {
+        this.providers.set(token._key, provider);
+      },
+    };
+  }
+
+  get<T>(token: Token<T>): T {
+    if (!this.initialized) {
+      this.bind(CURRENT_APP).toValue(this);
+
+      for (const preset of this.presets) {
+        preset.apply(this);
+      }
+
+      this.initialized = true;
+    }
+
+    return this.resolve(token, []);
+  }
+
+  protected resolve<T>(token: Token<T>, chain: Token<any>[]): T {
+    const nextChain = () => [...chain, token];
+
+    if (chain.includes(token)) {
+      throw new CircularDependencyError(nextChain(), this.toString());
+    }
+
+    if (this.components.has(token._key)) {
+      return this.components.get(token._key) as T;
+    }
+
+    if (this.providers.has(token._key)) {
+      const provider = this.providers.get(token._key) as Provider<T>;
+
+      const component = provider(otherToken => this.resolve(otherToken, nextChain()));
+
+      // ВАЖНО: всегда как singleton
+      this.components.set(token._key, component);
+
+      return component as T;
+    }
+
+    if (this.parent) {
+      // ВАЖНО: передаём именно chain а не nextChain()
+      return this.parent.resolve(token, chain);
+    }
+
+    throw new NothingBoundError(token, this.toString());
+  }
+
+  attach(parent: ApplicationImplementation): void {
+    if (this.parent) {
+      throw new Error('Cannot reattach application');
+    }
+
+    this.parent = parent;
+  }
+
+  preset(preset: Preset): void {
+    this.presets.push(preset);
+  }
+
+  invoke<Tokens extends readonly Token<any>[]>(
+    tokens: [...Tokens],
+    fn: (...args: ExtractType<Tokens>) => void,
+  ): void {
+    fn(...(tokens.map(token => this.get(token)) as any));
+  }
+}
+
+/**
+ * Возвращает новое DI-приложение.
+ * @return DI-приложение.
+ */
+export function createApplication(): Application {
+  return new ApplicationImplementation();
+}

package/src/di/container.ts

@@ -0,0 +1,60 @@
+/* eslint-disable require-jsdoc, jsdoc/require-jsdoc */
+import type { Container, Provider, Token } from './types';
+import { AlreadyBoundError, CircularDependencyError, NothingBoundError } from './errors';
+
+class ContainerImplementation implements Container {
+  cache: Map<symbol, any>;
+  registry: Map<symbol, Provider<any>>;
+
+  constructor() {
+    this.cache = new Map<symbol, any>();
+    this.registry = new Map<symbol, Provider<any>>();
+  }
+
+  set<T>(token: Token<T>, provider: Provider<T>): void {
+    if (this.registry.has(token._key)) {
+      throw new AlreadyBoundError(token);
+    }
+
+    this.registry.set(token._key, provider);
+  }
+
+  get<T>(token: Token<T>): T {
+    return this.resolve(token, []);
+  }
+
+  private resolve<T>(token: Token<T>, chain: Token<any>[]): T {
+    if (chain.includes(token)) {
+      throw new CircularDependencyError([...chain, token]);
+    } else {
+      chain.push(token);
+    }
+
+    if (this.cache.has(token._key)) {
+      return this.cache.get(token._key);
+    } else if (this.registry.has(token._key)) {
+      const provider = this.registry.get(token._key);
+
+      if (typeof provider !== 'function') {
+        throw new Error('Provider is not a function');
+      }
+
+      const value = provider(otherToken => this.resolve(otherToken, chain));
+
+      // всегда как singleton
+      this.cache.set(token._key, value);
+
+      return value;
+    } else {
+      throw new NothingBoundError(token);
+    }
+  }
+}
+
+/**
+ * Возвращает новый DI-контейнер.
+ * @return DI-контейнер.
+ */
+export function createContainer(): Container {
+  return new ContainerImplementation();
+}