Circuit

examples/circuit.ts

@@ -0,0 +1,45 @@
+import { circuit } from '../lib';
+
+class Service {
+
+  private executionIndex = 0;
+
+  @circuit(2, 1000)
+  public get() {
+    if (this.executionIndex < 2) {
+      this.executionIndex += 1;
+      throw new Error('Something went wrong');
+    }
+
+    return 42;
+  }
+
+}
+
+async function main() {
+  const service = new Service();
+
+  try {
+    service.get();
+  } catch (error) {
+    console.log(error.message); // function throws error
+  }
+  try {
+    service.get();
+  } catch (error) {
+    console.log(error.message); // function throws error
+  }
+  try {
+    service.get();
+  } catch (error) {
+    console.log(error.message); // decorator throws error
+  }
+
+  await new Promise(resolve => setTimeout(
+    () => resolve(),
+    1000,
+  ));
+  console.log(service.get()); // prints: 42
+}
+
+main();

lib/circuit.ts → lib/circuit/CircuitOptions.ts

@@ -41,17 +41,10 @@ export type CircuitOptions = {
   errorFilter?: (err: Error) => boolean,
 };
 
-/**
- * A circuit breaker.
- * After the method fails `threshold` count it enters the closed state and
- * throws a `Circuit closed.` error. Once in closed state, the circuit fails
- * for the provided `timeout` milliseconds. After the `timeout` interval expires
- * the circuit transitions to half-opened state and allows next execution.
- * If the execution succeeds then circuit transitions back to open state and resets
- * the number of counted errors to zero.
- * @param threshold the max number of failures until the circuit gets closed.
- * @param timeout timeout in milliseconds to keep the circuit in closed state.
- */
-export function circuit(threshold: number, timeout: number, options?: CircuitOptions) {
-  throw new Error('Not implemented.');
-}
+export const DEFAULT_OPTIONS: Readonly<CircuitOptions> = {
+  interval: undefined,
+  policy: 'errors',
+  onError: 'throw',
+  scope: 'class',
+  errorFilter: () => true,
+};

lib/circuit/CircuitState/CircuitState.ts

@@ -0,0 +1,74 @@
+import { Policy } from '../Policy/Policy';
+
+export class CircuitState {
+
+  private state: 'open' | 'close' | 'half-open' = 'open';
+  private timers: number[] = [];
+
+  constructor(
+    private readonly timeout: number,
+    private readonly interval: number,
+    private readonly errorsFilter: (error: Error) => boolean,
+    private readonly policy: Policy,
+  ) { }
+
+  public allowExecution(): boolean {
+    return this.state !== 'close';
+  }
+
+  public register(error?: Error): this {
+    const isError = error && this.errorsFilter(error);
+    const type = isError ? 'error' : 'success';
+
+    if (this.state === 'half-open') {
+      if (isError) {
+        this.close();
+      } else {
+        this.open();
+      }
+    }
+
+    this.policy.addExecution(type);
+    this.removeExecution(type);
+
+    if (!this.policy.allowExecution()) {
+      this.close();
+    }
+
+    return this;
+  }
+
+  private removeExecution(type: 'success' | 'error'): void {
+    if (typeof this.interval !== 'number') {
+      return;
+    }
+
+    const timer = setTimeout(
+      () => {
+        this.policy.removeExecution(type);
+
+        if (this.state === 'open' && !this.policy.allowExecution()) {
+          this.close();
+        }
+      },
+      this.interval,
+    );
+
+    this.timers.push(timer as any);
+  }
+
+  private open() {
+    this.state = 'open';
+    this.policy.reset();
+
+    this.timers.forEach(timer => clearTimeout(timer as any));
+    this.timers = [];
+  }
+
+  private close() {
+    this.state = 'close';
+
+    setTimeout(() => this.state = 'half-open', this.timeout);
+  }
+
+}

lib/circuit/CircuitState/factory.ts

@@ -0,0 +1,21 @@
+import { Factory } from '../../interfaces/factory';
+import { PolicyFactory } from '../Policy/factory';
+import { CircuitState } from './CircuitState';
+
+export class CircuitStateFactory implements Factory<CircuitState> {
+
+
+  constructor(
+    private readonly timeout: number,
+    private readonly interval: number,
+    private readonly errorFilter: (error: Error) => boolean,
+    private readonly policyFactory: PolicyFactory,
+  ) { }
+
+  public create(): CircuitState {
+    const policy = this.policyFactory.create();
+
+    return new CircuitState(this.timeout, this.interval, this.errorFilter, policy);
+  }
+
+}

lib/circuit/CircuitStateStorage/ArgumentsCircuitStateStorage.ts

@@ -0,0 +1,22 @@
+import * as hash from 'object-hash';
+
+import { CircuitState } from '../CircuitState/CircuitState';
+import { CircuitStateFactory } from '../CircuitState/factory';
+import { CircuitStateStorage } from './CircuitStateStorage';
+
+export class ArgumentsCircuitStateStorage implements CircuitStateStorage {
+
+  private readonly argumentsStorage = new Map<string, CircuitState>();
+
+  constructor(private readonly circuitStateFactory: CircuitStateFactory) { }
+
+  public get(args: any[]): CircuitState {
+    const key = hash(args);
+    if (!this.argumentsStorage.has(key)) {
+      this.argumentsStorage.set(key, this.circuitStateFactory.create());
+    }
+
+    return this.argumentsStorage.get(key);
+  }
+
+}

lib/circuit/CircuitStateStorage/CircuitStateStorage.ts

@@ -0,0 +1,6 @@
+import { ClassType } from '../../interfaces/class';
+import { CircuitState } from '../CircuitState/CircuitState';
+
+export interface CircuitStateStorage {
+  get(args: any[], instance: ClassType): CircuitState;
+}

lib/circuit/CircuitStateStorage/ClassCircuitStateStorage.ts

@@ -0,0 +1,19 @@
+import { CircuitState } from '../CircuitState/CircuitState';
+import { CircuitStateFactory } from '../CircuitState/factory';
+import { CircuitStateStorage } from './CircuitStateStorage';
+
+export class ClassCircuitStateStorage implements CircuitStateStorage {
+
+  private circuitState: CircuitState = null;
+
+  constructor(private readonly circuitStateFactory: CircuitStateFactory) { }
+
+  public get(): CircuitState {
+    if (!this.circuitState) {
+      this.circuitState = this.circuitStateFactory.create();
+    }
+
+    return this.circuitState;
+  }
+
+}

lib/circuit/CircuitStateStorage/InstanceCircuitStateStorage.ts

@@ -0,0 +1,21 @@
+import { ClassType } from '../../interfaces/class';
+import { CircuitState } from '../CircuitState/CircuitState';
+import { CircuitStateFactory } from '../CircuitState/factory';
+import { CircuitStateStorage } from './CircuitStateStorage';
+
+export class InstanceCircuitStateStorage implements CircuitStateStorage {
+
+  private readonly instancesStorage = new WeakMap<ClassType, CircuitState>();
+
+  constructor(private readonly circuitStateFactory: CircuitStateFactory) { }
+
+  public get(_: any[], instance: ClassType): CircuitState {
+    const hasState = this.instancesStorage.has(instance);
+    if (!hasState) {
+      this.instancesStorage.set(instance, this.circuitStateFactory.create());
+    }
+
+    return this.instancesStorage.get(instance);
+  }
+
+}

lib/circuit/CircuitStateStorage/factory.ts

@@ -0,0 +1,43 @@
+import { Factory } from '../../interfaces/factory';
+import { CircuitStateFactory } from '../CircuitState/factory';
+import { CircuitStateStorage } from './CircuitStateStorage';
+import { ArgumentsCircuitStateStorage } from './ArgumentsCircuitStateStorage';
+import { ClassCircuitStateStorage } from './ClassCircuitStateStorage';
+import { InstanceCircuitStateStorage } from './InstanceCircuitStateStorage';
+
+export class CircuitStateStorageFactory implements Factory<CircuitStateStorage> {
+
+  constructor(
+    private readonly scope: 'args-hash' | 'class' | 'instance',
+    private readonly circuitStateFactory: CircuitStateFactory,
+  ) { }
+
+  public create(): CircuitStateStorage {
+    switch (this.scope) {
+      case 'args-hash':
+        return this.argumentsCircuitStateStorage();
+
+      case 'class':
+        return this.classCircuitStateStorage();
+
+      case 'instance':
+        return this.instanceCircuitStateStorage();
+
+      default:
+        throw new Error(`@circuit unsuported scope option: ${this.scope}`);
+    }
+  }
+
+  private argumentsCircuitStateStorage(): ArgumentsCircuitStateStorage {
+    return new ArgumentsCircuitStateStorage(this.circuitStateFactory);
+  }
+
+  private classCircuitStateStorage(): ClassCircuitStateStorage {
+    return new ClassCircuitStateStorage(this.circuitStateFactory);
+  }
+
+  private instanceCircuitStateStorage(): InstanceCircuitStateStorage {
+    return new InstanceCircuitStateStorage(this.circuitStateFactory);
+  }
+
+}

lib/circuit/Policy/ErrorsPolicy.ts

@@ -0,0 +1,33 @@
+import { Policy } from './Policy';
+
+export class ErrorsPolicy implements Policy {
+
+  private errors: number = 0;
+
+  constructor(
+    private readonly threshold: number,
+  ) { }
+
+  public addExecution(type: 'success' | 'error'): this {
+    this.errors += type === 'error' ? 1 : 0;
+
+    return this;
+  }
+
+  public removeExecution(type: 'success' | 'error'): this {
+    this.errors -= type === 'error' ? 1 : 0;
+
+    return this;
+  }
+
+  public reset(): this {
+    this.errors = 0;
+
+    return this;
+  }
+
+  public allowExecution(): boolean {
+    return this.errors < this.threshold;
+  }
+
+}

lib/circuit/Policy/Policy.ts

@@ -0,0 +1,6 @@
+export interface Policy {
+  addExecution(type: 'success' | 'error'): this;
+  removeExecution(type: 'success' | 'error'): this;
+  reset(): this;
+  allowExecution(): boolean;
+}

lib/circuit/Policy/RatePolicy.ts

@@ -0,0 +1,40 @@
+import { Policy } from './Policy';
+
+export class RatePolicy implements Policy {
+
+  private errors = 0;
+  private totalCalls = 0;
+
+  constructor(
+    private readonly threshold: number,
+  ) { }
+
+  public addExecution(type: 'success' | 'error'): this {
+    this.errors += type === 'error' ? 1 : 0;
+    this.totalCalls += 1;
+
+    return this;
+  }
+
+  public removeExecution(type: 'success' | 'error'): this {
+    this.errors -= type === 'error' ? 1 : 0;
+    this.totalCalls -= 1;
+
+    return this;
+  }
+
+  public reset(): this {
+    this.errors = this.totalCalls = 0;
+
+    return this;
+  }
+
+  public allowExecution(): boolean {
+    return this.rate() < this.threshold;
+  }
+
+  private rate(): number {
+    return this.totalCalls === 0 ? 0 : this.errors / this.totalCalls;
+  }
+
+}