@quantform/core 0.6.4 → 0.6.6

package/src/domain/{candle-operator.ts → ohlc-operator.ts}

@@ -12,11 +12,11 @@ import {
 } from 'rxjs';
 
 import { decimal } from '../shared';
-import { Candle } from './candle';
+import { Ohlc } from './ohlc';
 import { tf } from './timeframe';
 
 function aggregate(
-  candle: Candle | undefined,
+  candle: Ohlc | undefined,
   timeframe: number,
   value: decimal,
   timestamp: number
@@ -24,23 +24,23 @@ function aggregate(
   const frame = tf(timestamp, timeframe);
 
   if (!candle) {
-    return new Candle(frame, value, value, value, value);
+    return new Ohlc(frame, value, value, value, value);
   }
 
   if (candle.timestamp === frame) {
     candle.apply(value);
     return undefined;
   } else {
-    return new Candle(frame, candle.close, value, value, value);
+    return new Ohlc(frame, candle.close, value, value, value);
   }
 }
 
-export function candle<T extends { timestamp: number }>(
+export function ohlc<T extends { timestamp: number }>(
   timeframe: number,
   fn: (x: T) => decimal,
-  candleToStartWith?: Candle
+  candleToStartWith?: Ohlc
 ) {
-  return function (source: Observable<T>): Observable<Candle> {
+  return function (source: Observable<T>): Observable<Ohlc> {
     let candle = candleToStartWith;
 
     return source.pipe(
@@ -77,18 +77,18 @@ export function candle<T extends { timestamp: number }>(
   };
 }
 
-export function mergeCandle<T extends { timestamp: number }>(
+export function mergeOhlc<T extends { timestamp: number }>(
   timeframe: number,
   fn: (x: T) => decimal,
-  history$: Observable<Candle>
+  history$: Observable<Ohlc>
 ) {
-  return function (source$: Observable<T>): Observable<Candle> {
+  return function (source$: Observable<T>): Observable<Ohlc> {
     return concat(
       history$.pipe(skipLast(1)),
       history$.pipe(
         last(),
         switchMap(lastHistoricalCandle =>
-          source$.pipe(candle(timeframe, fn, lastHistoricalCandle))
+          source$.pipe(ohlc(timeframe, fn, lastHistoricalCandle))
         ),
         share()
       )
@@ -96,10 +96,10 @@ export function mergeCandle<T extends { timestamp: number }>(
   };
 }
 
-export function candleCompleted(): (source: Observable<Candle>) => Observable<Candle> {
-  let currCandle: Candle;
+export function ohlcCompleted(): (source: Observable<Ohlc>) => Observable<Ohlc> {
+  let currCandle: Ohlc;
 
-  return (source: Observable<Candle>) =>
+  return (source: Observable<Ohlc>) =>
     source.pipe(
       map(it => {
         if (!currCandle) {
@@ -117,7 +117,7 @@ export function candleCompleted(): (source: Observable<Candle>) => Observable<Ca
           return undefined;
         }
       }),
-      filter(it => it !== undefined) as OperatorFunction<Candle | undefined, Candle>,
+      filter(it => it !== undefined) as OperatorFunction<Ohlc | undefined, Ohlc>,
       share()
     );
 }

package/src/domain/{candle.spec.ts → ohlc.spec.ts}

@@ -1,11 +1,11 @@
 import { d, now } from '../shared';
-import { Candle } from './candle';
+import { Ohlc } from './ohlc';
 
-describe('Candle', () => {
-  test('should construct a candle', () => {
+describe('Ohlc', () => {
+  test('should construct a ohlc', () => {
     const timestamp = now();
 
-    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
+    const sut = new Ohlc(timestamp, d(2), d(4), d(1), d(3));
 
     expect(sut.timestamp).toEqual(timestamp);
     expect(sut.open).toEqual(d(2));
@@ -14,10 +14,10 @@ describe('Candle', () => {
     expect(sut.close).toEqual(d(3));
   });
 
-  test('should modify a candle', () => {
+  test('should modify a ohlc', () => {
     const timestamp = now();
 
-    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
+    const sut = new Ohlc(timestamp, d(2), d(4), d(1), d(3));
 
     sut.apply(d(10));
 

package/src/domain/{candle.ts → ohlc.ts}

@@ -1,6 +1,6 @@
 import { decimal, timestamp } from '../shared';
 
-export class Candle {
+export class Ohlc {
   constructor(
     public timestamp: timestamp,
     public open: decimal,
@@ -8,7 +8,7 @@ export class Candle {
     public low: decimal,
     public close: decimal,
     public volume?: decimal
-  ) {}
+  ) { }
 
   apply(value: decimal) {
     this.high = decimal.max(this.high, value);

package/src/domain/order.ts

@@ -13,7 +13,6 @@ export type OrderState =
   | 'REJECTED';
 
 export class Order implements Component {
-  readonly kind = 'order';
   state: OrderState = 'NEW';
   quantityExecuted = d.Zero;
   averageExecutionRate?: decimal;
@@ -37,10 +36,6 @@ export class Order implements Component {
     }
   }
 
-  toString() {
-    return this.id;
-  }
-
   calculateBalanceToLock(
     base: Balance,
     quote: Balance

package/src/domain/orderbook.ts

@@ -18,7 +18,6 @@ export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decima
  */
 export class Orderbook implements Component {
   readonly id: string;
-  readonly kind = 'orderbook';
 
   constructor(
     public timestamp: number,
@@ -28,8 +27,4 @@ export class Orderbook implements Component {
   ) {
     this.id = instrument.id;
   }
-
-  toString() {
-    return this.instrument.toString();
-  }
 }

package/src/domain/position.ts

@@ -5,7 +5,6 @@ import { Component } from './component';
 export type PositionMode = 'CROSS' | 'ISOLATED';
 
 export class Position implements Component {
-  readonly kind = 'position';
   estimatedUnrealizedPnL?: decimal;
 
   get margin(): decimal {
@@ -29,8 +28,4 @@ export class Position implements Component {
 
     return this.estimatedUnrealizedPnL;
   }
-
-  toString() {
-    return this.id;
-  }
 }

package/src/domain/session-builder.ts

@@ -27,9 +27,9 @@ export function deposit(selector: AssetSelector, amount: decimal): SessionFeatur
   };
 }
 
-export function period(from: Date, to: Date): SessionFeature {
+export function period(from: Date, to?: Date): SessionFeature {
   return (builder: SessionBuilder) => {
-    builder.usePeriod(from.getTime(), to.getTime());
+    builder.usePeriod(from.getTime(), to?.getTime() ?? now());
   };
 }
 
@@ -76,7 +76,7 @@ export class SessionBuilder {
   }
 
   useBalance(selector: AssetSelector, amount: decimal): SessionBuilder {
-    this.balance[selector.toString()] = amount;
+    this.balance[selector.id] = amount;
 
     return this;
   }

package/src/domain/session.ts

@@ -20,10 +20,10 @@ import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
   Balance,
-  Candle,
   Instrument,
   InstrumentSelector,
   invalidInstrumentSelectorError,
+  Ohlc,
   Order,
   Orderbook,
   Position,
@@ -53,7 +53,7 @@ export class Session {
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
     readonly measurement: Measurement | undefined
-  ) { }
+  ) {}
 
   async awake(): Promise<void> {
     if (this.initialized) {
@@ -203,7 +203,7 @@ export class Session {
     selector: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Observable<Readonly<Candle>> {
+  ): Observable<Readonly<Ohlc>> {
     return this.store.changes$.pipe(
       startWith(this.store.snapshot.universe.instrument.get(selector.id)),
       filter(it => it instanceof Instrument && it.id == selector.id),

package/src/domain/trade.ts

@@ -8,7 +8,6 @@ import { Component } from './component';
  */
 export class Trade implements Component {
   readonly id: string;
-  readonly kind = 'trade';
 
   constructor(
     public timestamp: number,
@@ -18,8 +17,4 @@ export class Trade implements Component {
   ) {
     this.id = instrument.id;
   }
-
-  toString() {
-    return this.instrument.toString();
-  }
 }

package/src/index.ts

@@ -1,6 +1,80 @@
+import chalk from 'chalk';
+import { finalize, forkJoin, Observable, of, switchMap } from 'rxjs';
+
+import { Session, SessionBuilder, SessionFeature } from './domain';
 export * from './adapter';
 export * from './domain';
 export * from './shared';
 export * from './storage';
 export * from './store';
-export * from './strategy';
+
+import { Logger } from './shared';
+
+const registry: Record<string, () => Array<SessionFeature>> = {};
+
+export type SessionHook = (session: Session) => Observable<any>;
+
+/**
+ * Describes a single strategy logic
+ */
+export let rule: (name: string | undefined, describe: SessionHook) => void;
+
+/**
+ *
+ */
+export let beforeAll: (describe: SessionHook) => void;
+
+/**
+ *
+ * @param name
+ * @param describe
+ */
+export function describe(name: string, describe: () => Array<SessionFeature>) {
+  registry[name] = describe;
+}
+
+/**
+ *
+ * @param name
+ * @param builder
+ * @returns
+ */
+export async function spawn(name: string, builder: SessionBuilder) {
+  const describe = registry[name];
+  if (!describe) {
+    throw new Error(`missing strategy: ${name}`);
+  }
+
+  const ruleHooks = new Array<SessionHook>();
+  const beforeAllHooks = new Array<SessionHook>();
+
+  beforeAll = (describe: SessionHook) => {
+    beforeAllHooks.push(describe);
+  };
+
+  rule = (ruleName: string | undefined, describe: SessionHook) => {
+    if (ruleName) {
+      Logger.info(name, `${chalk.italic(ruleName)} rule found`);
+    }
+
+    ruleHooks.push(describe);
+  };
+
+  for (const feature of describe()) {
+    feature(builder);
+  }
+
+  return (session: Session) => {
+    const beforeAll$ = beforeAllHooks.map(it => it(session));
+    const rule$ = ruleHooks.map(it => it(session));
+
+    if (!beforeAll$.length) {
+      beforeAll$.push(of(true));
+    }
+
+    return forkJoin(beforeAll$).pipe(
+      switchMap(() => forkJoin(rule$)),
+      finalize(() => session.dispose())
+    );
+  };
+}

package/src/shared/logger.ts

@@ -17,13 +17,13 @@ const time = () => chalk.gray(new Date(now()).toISOString());
 
 export class Logger {
   public static info = (context: string, message: string) =>
-    console.info(`${time()} ${colorize(context)}: ${message}`);
+    console.info(`${this.prefix(context)}: ${message}`);
 
   public static debug = (context: string, message: string) =>
-    console.debug(`${time()} ${colorize(context)}: ${message}`);
+    console.debug(`${this.prefix(context)}: ${message}`);
 
   public static warn = (context: string, message: string) =>
-    console.warn(`${time()} ${colorize(context)}: ${message}`);
+    console.warn(`${this.prefix(context)}: ${message}`);
 
   public static error = (context: string, error: unknown) => {
     let message = 'Unknown Error';
@@ -32,6 +32,8 @@ export class Logger {
       message = error.message;
     }
 
-    console.error(`${time()} ${colorize(context)}: ${message}`);
+    console.error(`${this.prefix(context)}: ${message}`);
   };
+
+  public static prefix = (context: string) => `${time()} ${colorize(context)}`;
 }

package/dist/domain/candle-operator.d.ts

@@ -1,11 +0,0 @@
-import { Observable } from 'rxjs';
-import { decimal } from '../shared';
-import { Candle } from './candle';
-export declare function candle<T extends {
-    timestamp: number;
-}>(timeframe: number, fn: (x: T) => decimal, candleToStartWith?: Candle): (source: Observable<T>) => Observable<Candle>;
-export declare function mergeCandle<T extends {
-    timestamp: number;
-}>(timeframe: number, fn: (x: T) => decimal, history$: Observable<Candle>): (source$: Observable<T>) => Observable<Candle>;
-export declare function candleCompleted(): (source: Observable<Candle>) => Observable<Candle>;
-//# sourceMappingURL=candle-operator.d.ts.map

package/dist/domain/candle-operator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"candle-operator.d.ts","sourceRoot":"","sources":["../../src/domain/candle-operator.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,UAAU,EAKX,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAuBlC,wBAAgB,MAAM,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EACpD,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EACrB,iBAAiB,CAAC,EAAE,MAAM,YAED,WAAW,CAAC,CAAC,KAAG,WAAW,MAAM,CAAC,CAmC5D;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EACzD,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EACrB,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,aAEF,WAAW,CAAC,CAAC,KAAG,WAAW,MAAM,CAAC,CAY7D;AAED,wBAAgB,eAAe,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,KAAK,UAAU,CAAC,MAAM,CAAC,CAwBpF"}

package/dist/domain/candle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"candle.d.ts","sourceRoot":"","sources":["../../src/domain/candle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE/C,qBAAa,MAAM;IAER,SAAS,EAAE,SAAS;IACpB,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,OAAO;IACb,GAAG,EAAE,OAAO;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,CAAC;gBALP,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,qBAAS;IAGzB,KAAK,CAAC,KAAK,EAAE,OAAO;CAKrB"}

package/dist/strategy.d.ts

@@ -1,8 +0,0 @@
-import { Observable } from 'rxjs';
-import { Session, SessionBuilder, SessionFeature } from './domain';
-export declare type SessionAction = (session: Session) => Observable<any>;
-export declare let rule: (name: string | undefined, describe: SessionAction) => void;
-export declare let beforeAll: (describe: SessionAction) => void;
-export declare function describe(name: string, describe: () => Array<SessionFeature>): void;
-export declare function prepare(name: string, builder: SessionBuilder): Promise<(session: Session) => Observable<any[]>>;
-//# sourceMappingURL=strategy.d.ts.map

package/dist/strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAa,MAAM,MAAM,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAKnE,oBAAY,aAAa,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC;AAElE,eAAO,IAAI,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;AAC7E,eAAO,IAAI,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;AAExD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC,cAAc,CAAC,QAE3E;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,qBAqBhD,OAAO,wBASzB"}

package/dist/strategy.js

@@ -1,44 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepare = exports.describe = exports.beforeAll = exports.rule = void 0;
-const rxjs_1 = require("rxjs");
-const shared_1 = require("./shared");
-const registry = {};
-function describe(name, describe) {
-    registry[name] = describe;
-}
-exports.describe = describe;
-function prepare(name, builder) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const describe = registry[name];
-        const rules = new Array();
-        const beforeAlls = new Array();
-        exports.beforeAll = (describe) => {
-            beforeAlls.push(describe);
-        };
-        exports.rule = (ruleName, describe) => {
-            if (ruleName) {
-                shared_1.Logger.info(name, ruleName);
-            }
-            rules.push(describe);
-        };
-        for (const plugin of describe()) {
-            plugin(builder);
-        }
-        return (session) => {
-            const toBeforeAll = beforeAlls.map(it => it(session));
-            const toRules = rules.map(it => it(session));
-            return (0, rxjs_1.forkJoin)(toBeforeAll).pipe((0, rxjs_1.switchMap)(() => (0, rxjs_1.forkJoin)(toRules)), (0, rxjs_1.finalize)(() => session.dispose()));
-        };
-    });
-}
-exports.prepare = prepare;

package/src/domain/candle-operator.spec.ts

@@ -1,126 +0,0 @@
-import { from } from 'rxjs';
-
-import { d } from '../shared';
-import { Candle } from './candle';
-import { candle, candleCompleted, mergeCandle } from './candle-operator';
-
-describe('candle', () => {
-  test('should aggregate and pipe candle updates', done => {
-    const input$ = from([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d.Zero },
-      { timestamp: 5, rate: d(7) },
-      { timestamp: 6, rate: d(8) }
-    ]);
-
-    const output = [
-      new Candle(0, d(1), d(1), d(1), d(1)),
-      new Candle(0, d(1), d(2), d(1), d(2)),
-      new Candle(0, d(1), d(3), d(1), d(3)),
-      new Candle(0, d(1), d(3), d.Zero, d.Zero),
-      new Candle(5, d.Zero, d(7), d(7), d(7)),
-      new Candle(5, d.Zero, d(8), d(7), d(8))
-    ].reverse();
-
-    input$.pipe(candle(5, it => it.rate)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-});
-
-describe('candleCompleted', () => {
-  test('should aggregate and pipe distinct completed candles', done => {
-    const input$ = from([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d.Zero },
-      { timestamp: 5, rate: d(7) },
-      { timestamp: 6, rate: d(8) }
-    ]);
-
-    input$
-      .pipe(
-        candle(5, it => it.rate),
-        candleCompleted()
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual(new Candle(0, d(1), d(3), d.Zero, d.Zero));
-          done();
-        }
-      });
-  });
-});
-
-describe('mergeCandle', () => {
-  test('should pipe and merge candle from history', done => {
-    const history$ = from([
-      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
-      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
-      new Candle(3, d(3), d(3.5), d(2.5), d(4))
-    ]);
-
-    const input$ = from([
-      { timestamp: 3, rate: d(5) },
-      { timestamp: 4, rate: d(3) },
-      { timestamp: 5, rate: d(4) }
-    ]);
-
-    const output = [
-      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
-      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
-      new Candle(3, d(3), d(5), d(2.5), d(5)),
-      new Candle(4, d(5), d(3), d(3), d(3)),
-      new Candle(5, d(3), d(4), d(4), d(4))
-    ].reverse();
-
-    input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-
-  test('should pipe and not merge candle from history', done => {
-    const history$ = from([
-      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
-      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
-      new Candle(3, d(3), d(3.5), d(2.5), d(4))
-    ]);
-
-    const input$ = from([
-      { timestamp: 4, rate: d(5) },
-      { timestamp: 5, rate: d(3) },
-      { timestamp: 6, rate: d(4) }
-    ]);
-
-    const output = [
-      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
-      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
-      new Candle(3, d(3), d(3.5), d(2.5), d(4)),
-      new Candle(4, d(4), d(5), d(5), d(5)),
-      new Candle(5, d(5), d(3), d(3), d(3)),
-      new Candle(6, d(3), d(4), d(4), d(4))
-    ].reverse();
-
-    input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-});

package/src/strategy.ts

@@ -1,47 +0,0 @@
-import { finalize, forkJoin, Observable, switchMap } from 'rxjs';
-
-import { Session, SessionBuilder, SessionFeature } from './domain';
-import { Logger } from './shared';
-
-const registry: Record<string, () => Array<SessionFeature>> = {};
-
-export type SessionAction = (session: Session) => Observable<any>;
-
-export let rule: (name: string | undefined, describe: SessionAction) => void;
-export let beforeAll: (describe: SessionAction) => void;
-
-export function describe(name: string, describe: () => Array<SessionFeature>) {
-  registry[name] = describe;
-}
-
-export async function prepare(name: string, builder: SessionBuilder) {
-  const describe = registry[name];
-  const rules = new Array<SessionAction>();
-  const beforeAlls = new Array<SessionAction>();
-
-  beforeAll = (describe: SessionAction) => {
-    beforeAlls.push(describe);
-  };
-
-  rule = (ruleName: string | undefined, describe: SessionAction) => {
-    if (ruleName) {
-      Logger.info(name, ruleName);
-    }
-
-    rules.push(describe);
-  };
-
-  for (const plugin of describe()) {
-    plugin(builder);
-  }
-
-  return (session: Session) => {
-    const toBeforeAll = beforeAlls.map(it => it(session));
-    const toRules = rules.map(it => it(session));
-
-    return forkJoin(toBeforeAll).pipe(
-      switchMap(() => forkJoin(toRules)),
-      finalize(() => session.dispose())
-    );
-  };
-}