@quantform/core 0.7.12 → 0.7.17

package/lib/backtest/index.d.ts

@@ -0,0 +1,7 @@
+export * from './use-backtest';
+export * from './use-backtest-options';
+export * from './use-backtest-scheduler';
+export * from './use-backtest-storage';
+export * from './use-backtest-sync';
+export * from './when-backtest-finished';
+//# sourceMappingURL=index.d.ts.map

package/lib/backtest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/backtest/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC"}

package/lib/backtest/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-backtest"), exports);
+__exportStar(require("./use-backtest-options"), exports);
+__exportStar(require("./use-backtest-scheduler"), exports);
+__exportStar(require("./use-backtest-storage"), exports);
+__exportStar(require("./use-backtest-sync"), exports);
+__exportStar(require("./when-backtest-finished"), exports);

package/lib/backtest/use-backtest-options.d.ts

@@ -0,0 +1,15 @@
+import { Dependency } from '../module';
+type BacktestOptions = {
+    from: number;
+    to: number;
+};
+/**
+ *
+ */
+export declare function backtestOptions(options: BacktestOptions): Dependency;
+/**
+ * Will return current backtest execution options.
+ */
+export declare const useBacktestOptions: () => BacktestOptions;
+export {};
+//# sourceMappingURL=use-backtest-options.d.ts.map

package/lib/backtest/use-backtest-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-options.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AAIrD,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,UAAU,CAKpE;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,uBAAoD,CAAC"}

package/lib/backtest/use-backtest-options.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBacktestOptions = exports.backtestOptions = void 0;
+const module_1 = require("../module");
+const injectionToken = Symbol('backtest-options');
+/**
+ *
+ */
+function backtestOptions(options) {
+    return {
+        provide: injectionToken,
+        useValue: options
+    };
+}
+exports.backtestOptions = backtestOptions;
+/**
+ * Will return current backtest execution options.
+ */
+const useBacktestOptions = () => (0, module_1.useContext)(injectionToken);
+exports.useBacktestOptions = useBacktestOptions;

package/lib/backtest/use-backtest-query-buffer.d.ts

@@ -0,0 +1,15 @@
+import { BacktestStorage } from './use-backtest';
+export declare const useBacktestQueryBuffer: <T>(storage: BacktestStorage<T>) => {
+    size(): number;
+    peek(): {
+        timestamp: number;
+        payload: T;
+    };
+    dequeue(): {
+        timestamp: number;
+        payload: T;
+    };
+    completed(): boolean;
+    fetchNextPage(): Promise<void>;
+};
+//# sourceMappingURL=use-backtest-query-buffer.d.ts.map

package/lib/backtest/use-backtest-query-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-query-buffer.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-query-buffer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;mBAGJ,MAAM;;;;mBAAN,MAAM;;;;;CAwCnC,CAAC"}

package/lib/backtest/use-backtest-query-buffer.js

@@ -0,0 +1,52 @@
+"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.useBacktestQueryBuffer = void 0;
+const replay_1 = require("../replay");
+const storage_1 = require("../storage");
+const with_memo_1 = require("../with-memo");
+exports.useBacktestQueryBuffer = (0, with_memo_1.withMemo)((storage) => {
+    const { from, to } = (0, replay_1.useReplayOptions)();
+    let page = [];
+    let index = 0;
+    let completed = false;
+    let count = 0;
+    return {
+        size() {
+            return page.length - index;
+        },
+        peek() {
+            return page[index];
+        },
+        dequeue() {
+            return page[index++];
+        },
+        completed() {
+            return completed;
+        },
+        fetchNextPage() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (completed) {
+                    return;
+                }
+                index = 0;
+                page = yield storage.query({
+                    where: { timestamp: (0, storage_1.between)(from, to) },
+                    limit: 10000,
+                    offset: count,
+                    orderBy: 'ASC'
+                });
+                count += page.length;
+                completed = page.length === 0;
+            });
+        }
+    };
+});

package/lib/backtest/use-backtest-query-cursor.d.ts

@@ -0,0 +1,30 @@
+import { BacktestStorage } from './use-backtest';
+export declare const useBacktestQueryCursor: () => {
+    get<T>(query: BacktestStorage<T>): {
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: T;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: T;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    };
+    cursor(): Promise<{
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: any;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: any;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    } | undefined>;
+};
+//# sourceMappingURL=use-backtest-query-cursor.d.ts.map

package/lib/backtest/use-backtest-query-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-query-cursor.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-query-cursor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCjC,CAAC"}

package/lib/backtest/use-backtest-query-cursor.js

@@ -0,0 +1,43 @@
+"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.useBacktestQueryCursor = void 0;
+const with_memo_1 = require("../with-memo");
+const use_backtest_query_buffer_1 = require("./use-backtest-query-buffer");
+exports.useBacktestQueryCursor = (0, with_memo_1.withMemo)(() => {
+    const cursors = Array.of();
+    return {
+        get(query) {
+            const buffer = (0, use_backtest_query_buffer_1.useBacktestQueryBuffer)(query);
+            cursors.push(buffer);
+            return buffer;
+        },
+        cursor() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let current;
+                for (const cursor of cursors) {
+                    if (cursor.completed()) {
+                        continue;
+                    }
+                    if (cursor.size() == 0) {
+                        yield cursor.fetchNextPage();
+                    }
+                    if (cursor.peek()) {
+                        if (!current || current.peek().timestamp > cursor.peek().timestamp) {
+                            current = cursor;
+                        }
+                    }
+                }
+                return current;
+            });
+        }
+    };
+});

package/lib/backtest/use-backtest-scheduler.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { BacktestStorage } from './use-backtest';
+export declare const useBacktestScheduler: () => {
+    stream: Observable<[{
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: any;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: any;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    }, {
+        timestamp: number;
+        payload: any;
+    }]>;
+    timestamp(): number;
+    stop(): void;
+    tryContinue: () => void;
+    watch<T>(query: BacktestStorage<T>): Observable<{
+        timestamp: number;
+        payload: T;
+    }>;
+};
+//# sourceMappingURL=use-backtest-scheduler.d.ts.map

package/lib/backtest/use-backtest-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-scheduler.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAI/D,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;mBASiC,MAAM;iBAAW,GAAG;;;;;;mBA+DrB,MAAM;;;CAgBrE,CAAC"}

package/lib/backtest/use-backtest-scheduler.js

@@ -0,0 +1,77 @@
+"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.useBacktestScheduler = void 0;
+const rxjs_1 = require("rxjs");
+const with_memo_1 = require("../with-memo");
+const use_backtest_options_1 = require("./use-backtest-options");
+const use_backtest_query_cursor_1 = require("./use-backtest-query-cursor");
+exports.useBacktestScheduler = (0, with_memo_1.withMemo)(() => {
+    const { from } = (0, use_backtest_options_1.useBacktestOptions)();
+    const { get, cursor } = (0, use_backtest_query_cursor_1.useBacktestQueryCursor)();
+    let timestamp = from;
+    let stopAcquire = 1;
+    let processing = false;
+    const stream$ = new rxjs_1.Subject();
+    const processNext = () => __awaiter(void 0, void 0, void 0, function* () {
+        const storage = yield cursor();
+        if (!storage || !storage.peek()) {
+            stream$.complete();
+            return false;
+        }
+        const sample = storage.dequeue();
+        timestamp = sample.timestamp;
+        stream$.next([storage, sample]);
+        return true;
+    });
+    const next = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (processing) {
+            return;
+        }
+        processing = true;
+        while (stopAcquire === 0) {
+            if (!(yield processNext())) {
+                break;
+            }
+            yield new Promise(it => setImmediate(it));
+        }
+        processing = false;
+    });
+    const tryContinue = () => {
+        if (stopAcquire === 0) {
+            return;
+        }
+        stopAcquire--;
+        if (stopAcquire === 0) {
+            next();
+        }
+    };
+    return {
+        stream: stream$.asObservable(),
+        timestamp() {
+            return timestamp;
+        },
+        stop() {
+            stopAcquire++;
+        },
+        tryContinue,
+        watch(query) {
+            const storage = get(query);
+            return (0, rxjs_1.defer)(() => {
+                tryContinue();
+                return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === storage), (0, rxjs_1.map)(([, it]) => ({
+                    timestamp: it.timestamp,
+                    payload: it.payload
+                })));
+            });
+        }
+    };
+});

package/lib/backtest/use-backtest-storage.d.ts

@@ -0,0 +1,20 @@
+import { InferQueryObject, Query, QueryObject, QueryObjectType } from '../storage';
+import { Uri } from '../uri';
+import { BacktestStorage } from './use-backtest';
+export type BacktestStorageQuery<V> = {
+    sync: <T extends QueryObjectType<K>, K extends QueryObject>(query: Query<InferQueryObject<T>> & {
+        where: {
+            timestamp: {
+                min: number;
+                max: number;
+            };
+        };
+    }, storage: {
+        save: (objects: {
+            timestamp: number;
+            payload: V;
+        }[]) => Promise<void>;
+    }) => Promise<void>;
+};
+export declare function useBacktestStorage<V, P extends Record<string, string | number>>(uri: Uri<P>, { sync }: BacktestStorageQuery<V>): BacktestStorage<V>;
+//# sourceMappingURL=use-backtest-storage.d.ts.map

package/lib/backtest/use-backtest-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-storage.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAChB,KAAK,EACL,WAAW,EACX,eAAe,EAGhB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,IAAI,EAAE,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACxD,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG;QAClC,KAAK,EAAE;YAAE,SAAS,EAAE;gBAAE,GAAG,EAAE,MAAM,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAC;KACpD,EACD,OAAO,EAAE;QAAE,IAAI,EAAE,CAAC,OAAO,EAAE;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,CAAC,CAAA;SAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,KAC/E,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,CAAC;AASF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC7E,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EACX,EAAE,IAAI,EAAE,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAChC,eAAe,CAAC,CAAC,CAAC,CA8CpB"}

package/lib/backtest/use-backtest-storage.js

@@ -0,0 +1,63 @@
+"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.useBacktestStorage = void 0;
+const storage_1 = require("../storage");
+const storageIndexObject = storage_1.Storage.createObject('index://range', {
+    timestamp: 'number',
+    uri: 'string',
+    min: 'number',
+    max: 'number'
+});
+function useBacktestStorage(uri, { sync }) {
+    const storage = (0, storage_1.useStorage)(['backtest']);
+    const storageObjectKey = uri.query;
+    const storageObject = storage_1.Storage.createObject(storageObjectKey, {
+        timestamp: 'number',
+        payload: 'string'
+    });
+    return {
+        query(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const [index] = yield storage.query(storageIndexObject, {
+                    limit: 1,
+                    where: { uri: (0, storage_1.eq)(storageObjectKey) }
+                });
+                const { min, max } = query.where.timestamp;
+                if (!index || min < index.min || max > index.max) {
+                    yield sync(query, {
+                        save(objects) {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                yield storage.save(storageObject, objects.map(it => ({
+                                    timestamp: it.timestamp,
+                                    payload: JSON.stringify(it.payload)
+                                })));
+                            });
+                        }
+                    });
+                    yield storage.save(storageIndexObject, [
+                        {
+                            timestamp: 0,
+                            max,
+                            min,
+                            uri: storageObjectKey
+                        }
+                    ]);
+                }
+                return (yield storage.query(storageObject, query)).map(it => ({
+                    timestamp: it.timestamp,
+                    payload: JSON.parse(it.payload)
+                }));
+            });
+        }
+    };
+}
+exports.useBacktestStorage = useBacktestStorage;

package/lib/backtest/use-backtest-sync.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+export declare function useBacktestSync<T>(input: Observable<T>): Observable<T>;
+//# sourceMappingURL=use-backtest-sync.d.ts.map

package/lib/backtest/use-backtest-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest-sync.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest-sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,MAAM,CAAC;AAM5C,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAYtE"}

package/lib/backtest/use-backtest-sync.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBacktestSync = void 0;
+const rxjs_1 = require("rxjs");
+const use_execution_mode_1 = require("../use-execution-mode");
+const use_backtest_scheduler_1 = require("./use-backtest-scheduler");
+function useBacktestSync(input) {
+    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
+    if (!isReplay) {
+        return input;
+    }
+    const { stop, tryContinue } = (0, use_backtest_scheduler_1.useBacktestScheduler)();
+    stop();
+    return input.pipe((0, rxjs_1.finalize)(() => tryContinue()));
+}
+exports.useBacktestSync = useBacktestSync;

package/lib/backtest/use-backtest.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+import { Query, QueryObject } from '../storage';
+export interface BacktestStorage<V> {
+    query(query: Query<QueryObject> & {
+        where: {
+            timestamp: {
+                min: number;
+                max: number;
+            };
+        };
+    }): Promise<{
+        timestamp: number;
+        payload: V;
+    }[]>;
+}
+export declare function useBacktest<T>(input: Observable<{
+    timestamp: number;
+    payload: T;
+}>, query: BacktestStorage<T>): Observable<{
+    timestamp: number;
+    payload: T;
+}>;
+//# sourceMappingURL=use-backtest.d.ts.map

package/lib/backtest/use-backtest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-backtest.d.ts","sourceRoot":"","sources":["../../src/backtest/use-backtest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKlD,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,KAAK,CACH,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG;QAAE,KAAK,EAAE;YAAE,SAAS,EAAE;gBAAE,GAAG,EAAE,MAAM,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAA;KAAE,GACjF,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE,CAAC,CAAC;CACjD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,EACpD,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC;eADM,MAAM;aAAW,CAAC;GAWlD"}

package/lib/backtest/use-backtest.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBacktest = void 0;
+const use_execution_mode_1 = require("../use-execution-mode");
+const use_backtest_scheduler_1 = require("./use-backtest-scheduler");
+function useBacktest(input, query) {
+    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
+    if (isReplay) {
+        const { watch } = (0, use_backtest_scheduler_1.useBacktestScheduler)();
+        return watch(query);
+    }
+    return input;
+}
+exports.useBacktest = useBacktest;

package/lib/backtest/when-backtest-finished.d.ts

@@ -0,0 +1,2 @@
+export declare function whenBacktestFinished(): import("rxjs").Observable<boolean>;
+//# sourceMappingURL=when-backtest-finished.d.ts.map

package/lib/backtest/when-backtest-finished.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when-backtest-finished.d.ts","sourceRoot":"","sources":["../../src/backtest/when-backtest-finished.ts"],"names":[],"mappings":"AAMA,wBAAgB,oBAAoB,uCAanC"}

package/lib/backtest/when-backtest-finished.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whenBacktestFinished = void 0;
+const rxjs_1 = require("rxjs");
+const use_execution_mode_1 = require("../use-execution-mode");
+const use_backtest_scheduler_1 = require("./use-backtest-scheduler");
+function whenBacktestFinished() {
+    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
+    if (!isReplay) {
+        return new rxjs_1.Subject().asObservable();
+    }
+    const { stream } = (0, use_backtest_scheduler_1.useBacktestScheduler)();
+    return (0, rxjs_1.from)(stream).pipe((0, rxjs_1.last)(), (0, rxjs_1.map)(() => true));
+}
+exports.whenBacktestFinished = whenBacktestFinished;

package/lib/cli/index.js

@@ -19,7 +19,6 @@ const node_watch_1 = __importDefault(require("node-watch"));
 const build_1 = __importDefault(require("../cli/build"));
 const live_1 = __importDefault(require("../cli/live"));
 const paper_1 = __importDefault(require("../cli/paper"));
-const pull_1 = __importDefault(require("../cli/pull"));
 const replay_1 = __importDefault(require("../cli/replay"));
 commander_1.program
     .command('build')
@@ -52,14 +51,6 @@ commander_1.program
     .option('-t, --to <to>', 'date to')
     .option('-w', 'watch mode')
     .action(replay_1.default);
-commander_1.program
-    .command('pull')
-    .description('pulls instrument historical data to storage')
-    .argument('<name>', 'strategy to execute')
-    .argument('<instrument>', 'instrument to import')
-    .option('-f, --from <from>', 'date from')
-    .option('-t, --to <to>', 'date to')
-    .action(pull_1.default);
 commander_1.program.name('quantform').description('quantform tools');
 if (process.argv.length < 3) {
     commander_1.program.help();

package/lib/cli/replay.js

@@ -24,7 +24,7 @@ function default_1(name, options) {
             return;
         }
         const from = options.from ? new Date(options.from).getTime() : 0;
-        const to = options.to ? new Date(options.to).getTime() : Number.MAX_VALUE;
+        const to = options.to ? new Date(options.to).getTime() : 1893452400; // 01-01-2030;
         const script = new script_1.Script(name, [
             session_1.useSession.options({ id: (_a = options.id) !== null && _a !== void 0 ? _a : Date.now().toString() }),
             (0, replay_1.replayOptions)({ from, to }),

package/lib/index.d.ts

@@ -18,4 +18,6 @@ export * from './with-memo';
 export * from './session';
 export * from './strategy';
 export * from './operators';
+export * from './backtest';
+export * from './uri';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC"}

package/lib/index.js

@@ -34,3 +34,5 @@ __exportStar(require("./with-memo"), exports);
 __exportStar(require("./session"), exports);
 __exportStar(require("./strategy"), exports);
 __exportStar(require("./operators"), exports);
+__exportStar(require("./backtest"), exports);
+__exportStar(require("./uri"), exports);

package/lib/uri.d.ts

@@ -0,0 +1,11 @@
+export type Uri<T> = {
+    base: `${string}://${string}`;
+    params: T;
+    query: string;
+};
+export declare function uri<T extends Record<string, string | number>>(base: `${string}://${string}`, params: T): {
+    base: `${string}://${string}`;
+    params: T;
+    query: string;
+};
+//# sourceMappingURL=uri.d.ts.map

package/lib/uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../src/uri.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI;IACnB,IAAI,EAAE,GAAG,MAAM,MAAM,MAAM,EAAE,CAAC;IAC9B,MAAM,EAAE,CAAC,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3D,IAAI,EAAE,GAAG,MAAM,MAAM,MAAM,EAAE,EAC7B,MAAM,EAAE,CAAC;;;;EAaV"}

package/lib/uri.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uri = void 0;
+function uri(base, params) {
+    const search = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+        search.set(k, String(v));
+    }
+    return {
+        base,
+        params,
+        query: `${base}?${search.toString()}`
+    };
+}
+exports.uri = uri;

package/lib/use-timestamp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-timestamp.d.ts","sourceRoot":"","sources":["../src/use-timestamp.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,WAQ3B"}
+{"version":3,"file":"use-timestamp.d.ts","sourceRoot":"","sources":["../src/use-timestamp.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,WAQ3B"}

package/lib/use-timestamp.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTimestamp = void 0;
-const replay_1 = require("./replay");
 const use_execution_mode_1 = require("./use-execution-mode");
+const backtest_1 = require("./backtest");
 function useTimestamp() {
     const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
     if (isReplay) {
-        return (0, replay_1.useReplayManager)().timestamp();
+        return (0, backtest_1.useBacktestScheduler)().timestamp();
     }
     return Date.now();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantform/core",
-  "version": "0.7.12",
+  "version": "0.7.17",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",

package/src/backtest/index.ts

@@ -0,0 +1,6 @@
+export * from './use-backtest';
+export * from './use-backtest-options';
+export * from './use-backtest-scheduler';
+export * from './use-backtest-storage';
+export * from './use-backtest-sync';
+export * from './when-backtest-finished';

package/src/backtest/use-backtest-options.ts

@@ -0,0 +1,23 @@
+import { Dependency, useContext } from '@lib/module';
+
+const injectionToken = Symbol('backtest-options');
+
+type BacktestOptions = {
+  from: number;
+  to: number;
+};
+
+/**
+ *
+ */
+export function backtestOptions(options: BacktestOptions): Dependency {
+  return {
+    provide: injectionToken,
+    useValue: options
+  };
+}
+
+/**
+ * Will return current backtest execution options.
+ */
+export const useBacktestOptions = () => useContext<BacktestOptions>(injectionToken);

package/src/backtest/use-backtest-query-buffer.ts

@@ -0,0 +1,50 @@
+import { useReplayOptions } from '@lib/replay';
+import { between } from '@lib/storage';
+import { withMemo } from '@lib/with-memo';
+
+import { BacktestStorage } from './use-backtest';
+
+export const useBacktestQueryBuffer = withMemo(<T>(storage: BacktestStorage<T>) => {
+  const { from, to } = useReplayOptions();
+
+  let page: Array<{ timestamp: number; payload: T }> = [];
+  let index = 0;
+  let completed = false;
+  let count = 0;
+
+  return {
+    size() {
+      return page.length - index;
+    },
+
+    peek() {
+      return page[index];
+    },
+
+    dequeue() {
+      return page[index++];
+    },
+
+    completed() {
+      return completed;
+    },
+
+    async fetchNextPage() {
+      if (completed) {
+        return;
+      }
+
+      index = 0;
+
+      page = await storage.query({
+        where: { timestamp: between(from, to) },
+        limit: 10000,
+        offset: count,
+        orderBy: 'ASC'
+      });
+
+      count += page.length;
+      completed = page.length === 0;
+    }
+  };
+});

package/src/backtest/use-backtest-query-cursor.ts

@@ -0,0 +1,40 @@
+import { withMemo } from '@lib/with-memo';
+
+import { BacktestStorage } from './use-backtest';
+import { useBacktestQueryBuffer } from './use-backtest-query-buffer';
+
+export const useBacktestQueryCursor = withMemo(() => {
+  const cursors = Array.of<ReturnType<typeof useBacktestQueryBuffer<any>>>();
+
+  return {
+    get<T>(query: BacktestStorage<T>) {
+      const buffer = useBacktestQueryBuffer<T>(query);
+
+      cursors.push(buffer);
+
+      return buffer;
+    },
+
+    async cursor() {
+      let current: ReturnType<typeof useBacktestQueryBuffer<any>> | undefined;
+
+      for (const cursor of cursors) {
+        if (cursor.completed()) {
+          continue;
+        }
+
+        if (cursor.size() == 0) {
+          await cursor.fetchNextPage();
+        }
+
+        if (cursor.peek()) {
+          if (!current || current.peek().timestamp > cursor.peek().timestamp) {
+            current = cursor;
+          }
+        }
+      }
+
+      return current;
+    }
+  };
+});

package/src/backtest/use-backtest-scheduler.ts

@@ -0,0 +1,98 @@
+import { defer, filter, map, Observable, Subject } from 'rxjs';
+
+import { withMemo } from '@lib/with-memo';
+
+import { BacktestStorage } from './use-backtest';
+import { useBacktestOptions } from './use-backtest-options';
+import { useBacktestQueryBuffer } from './use-backtest-query-buffer';
+import { useBacktestQueryCursor } from './use-backtest-query-cursor';
+
+export const useBacktestScheduler = withMemo(() => {
+  const { from } = useBacktestOptions();
+  const { get, cursor } = useBacktestQueryCursor();
+
+  let timestamp = from;
+  let stopAcquire = 1;
+  let processing = false;
+
+  const stream$ = new Subject<
+    [ReturnType<typeof useBacktestQueryBuffer<any>>, { timestamp: number; payload: any }]
+  >();
+
+  const processNext = async () => {
+    const storage = await cursor();
+
+    if (!storage || !storage.peek()) {
+      stream$.complete();
+      return false;
+    }
+
+    const sample = storage.dequeue();
+
+    timestamp = sample.timestamp;
+
+    stream$.next([storage, sample]);
+
+    return true;
+  };
+
+  const next = async () => {
+    if (processing) {
+      return;
+    }
+
+    processing = true;
+
+    while (stopAcquire === 0) {
+      if (!(await processNext())) {
+        break;
+      }
+
+      await new Promise(it => setImmediate(it));
+    }
+
+    processing = false;
+  };
+
+  const tryContinue = () => {
+    if (stopAcquire === 0) {
+      return;
+    }
+
+    stopAcquire--;
+
+    if (stopAcquire === 0) {
+      next();
+    }
+  };
+
+  return {
+    stream: stream$.asObservable(),
+
+    timestamp() {
+      return timestamp;
+    },
+
+    stop() {
+      stopAcquire++;
+    },
+
+    tryContinue,
+
+    watch<T>(query: BacktestStorage<T>): Observable<{ timestamp: number; payload: T }> {
+      const storage = get<T>(query);
+
+      return defer(() => {
+        tryContinue();
+
+        return stream$.pipe(
+          filter(([cur]) => cur === storage),
+          map(([, it]) => ({
+            timestamp: it.timestamp,
+            payload: it.payload as T
+          }))
+        );
+      });
+    }
+  };
+});

package/src/backtest/use-backtest-storage.ts

@@ -0,0 +1,79 @@
+import {
+  eq,
+  InferQueryObject,
+  Query,
+  QueryObject,
+  QueryObjectType,
+  Storage,
+  useStorage
+} from '@lib/storage';
+import { Uri } from '@lib/uri';
+
+import { BacktestStorage } from './use-backtest';
+
+export type BacktestStorageQuery<V> = {
+  sync: <T extends QueryObjectType<K>, K extends QueryObject>(
+    query: Query<InferQueryObject<T>> & {
+      where: { timestamp: { min: number; max: number } };
+    },
+    storage: { save: (objects: { timestamp: number; payload: V }[]) => Promise<void> }
+  ) => Promise<void>;
+};
+
+const storageIndexObject = Storage.createObject('index://range', {
+  timestamp: 'number',
+  uri: 'string',
+  min: 'number',
+  max: 'number'
+});
+
+export function useBacktestStorage<V, P extends Record<string, string | number>>(
+  uri: Uri<P>,
+  { sync }: BacktestStorageQuery<V>
+): BacktestStorage<V> {
+  const storage = useStorage(['backtest']);
+  const storageObjectKey = uri.query;
+  const storageObject = Storage.createObject(storageObjectKey, {
+    timestamp: 'number',
+    payload: 'string'
+  });
+
+  return {
+    async query(query) {
+      const [index] = await storage.query(storageIndexObject, {
+        limit: 1,
+        where: { uri: eq(storageObjectKey) }
+      });
+
+      const { min, max } = query.where.timestamp;
+
+      if (!index || min < index.min || max > index.max) {
+        await sync(query, {
+          async save(objects) {
+            await storage.save(
+              storageObject,
+              objects.map(it => ({
+                timestamp: it.timestamp,
+                payload: JSON.stringify(it.payload)
+              }))
+            );
+          }
+        });
+
+        await storage.save(storageIndexObject, [
+          {
+            timestamp: 0,
+            max,
+            min,
+            uri: storageObjectKey
+          }
+        ]);
+      }
+
+      return (await storage.query(storageObject, query)).map(it => ({
+        timestamp: it.timestamp,
+        payload: JSON.parse(it.payload) as V
+      }));
+    }
+  };
+}

package/src/backtest/use-backtest-sync.ts

@@ -0,0 +1,19 @@
+import { finalize, Observable } from 'rxjs';
+
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { useBacktestScheduler } from './use-backtest-scheduler';
+
+export function useBacktestSync<T>(input: Observable<T>): Observable<T> {
+  const { isReplay } = useExecutionMode();
+
+  if (!isReplay) {
+    return input;
+  }
+
+  const { stop, tryContinue } = useBacktestScheduler();
+
+  stop();
+
+  return input.pipe(finalize(() => tryContinue()));
+}

package/src/backtest/use-backtest.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+
+import { Query, QueryObject } from '@lib/storage';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { useBacktestScheduler } from './use-backtest-scheduler';
+
+export interface BacktestStorage<V> {
+  query(
+    query: Query<QueryObject> & { where: { timestamp: { min: number; max: number } } }
+  ): Promise<{ timestamp: number; payload: V }[]>;
+}
+
+export function useBacktest<T>(
+  input: Observable<{ timestamp: number; payload: T }>,
+  query: BacktestStorage<T>
+) {
+  const { isReplay } = useExecutionMode();
+
+  if (isReplay) {
+    const { watch } = useBacktestScheduler();
+    return watch<T>(query);
+  }
+
+  return input;
+}

package/src/backtest/when-backtest-finished.ts

@@ -0,0 +1,20 @@
+import { from, last, map, Subject } from 'rxjs';
+
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { useBacktestScheduler } from './use-backtest-scheduler';
+
+export function whenBacktestFinished() {
+  const { isReplay } = useExecutionMode();
+
+  if (!isReplay) {
+    return new Subject<boolean>().asObservable();
+  }
+
+  const { stream } = useBacktestScheduler();
+
+  return from(stream).pipe(
+    last(),
+    map(() => true)
+  );
+}

package/src/cli/index.ts

@@ -7,7 +7,6 @@ import watch from 'node-watch';
 import build from '@lib/cli/build';
 import live from '@lib/cli/live';
 import paper from '@lib/cli/paper';
-import pull from '@lib/cli/pull';
 import replay from '@lib/cli/replay';
 
 program
@@ -45,15 +44,6 @@ program
   .option('-w', 'watch mode')
   .action(replay);
 
-program
-  .command('pull')
-  .description('pulls instrument historical data to storage')
-  .argument('<name>', 'strategy to execute')
-  .argument('<instrument>', 'instrument to import')
-  .option('-f, --from <from>', 'date from')
-  .option('-t, --to <to>', 'date to')
-  .action(pull);
-
 program.name('quantform').description('quantform tools');
 
 if (process.argv.length < 3) {

package/src/cli/replay.ts

@@ -14,7 +14,7 @@ export default async function (
   }
 
   const from = options.from ? new Date(options.from).getTime() : 0;
-  const to = options.to ? new Date(options.to).getTime() : Number.MAX_VALUE;
+  const to = options.to ? new Date(options.to).getTime() : 1893452400; // 01-01-2030;
 
   const script = new Script(name, [
     useSession.options({ id: options.id ?? Date.now().toString() }),

package/src/index.ts

@@ -18,3 +18,5 @@ export * from '@lib/with-memo';
 export * from '@lib/session';
 export * from '@lib/strategy';
 export * from '@lib/operators';
+export * from '@lib/backtest';
+export * from '@lib/uri';

package/src/uri.ts

@@ -0,0 +1,22 @@
+export type Uri<T> = {
+  base: `${string}://${string}`;
+  params: T;
+  query: string;
+};
+
+export function uri<T extends Record<string, string | number>>(
+  base: `${string}://${string}`,
+  params: T
+) {
+  const search = new URLSearchParams();
+
+  for (const [k, v] of Object.entries(params)) {
+    search.set(k, String(v));
+  }
+
+  return {
+    base,
+    params,
+    query: `${base}?${search.toString()}`
+  };
+}

package/src/use-timestamp.ts

@@ -1,11 +1,12 @@
-import { useReplayManager } from '@lib/replay';
 import { useExecutionMode } from '@lib/use-execution-mode';
 
+import { useBacktestScheduler } from './backtest';
+
 export function useTimestamp() {
   const { isReplay } = useExecutionMode();
 
   if (isReplay) {
-    return useReplayManager().timestamp();
+    return useBacktestScheduler().timestamp();
   }
 
   return Date.now();

package/lib/cli/pull.d.ts

@@ -1,2 +0,0 @@
-export default function (name: string, instrument: string, options: any): Promise<void>;
-//# sourceMappingURL=pull.d.ts.map

package/lib/cli/pull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/cli/pull.ts"],"names":[],"mappings":"AAKA,yBAA+B,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,iBAS5E"}

package/lib/cli/pull.js

@@ -1,28 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const build_1 = __importDefault(require("../cli/build"));
-const use_execution_mode_1 = require("../use-execution-mode");
-const script_1 = require("./internal/script");
-function default_1(name, instrument, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (yield (0, build_1.default)()) {
-            return;
-        }
-        const script = new script_1.Script(name, [use_execution_mode_1.useExecutionMode.idleOptions()]);
-        //const output = await script.run();
-        //console.log(output);
-    });
-}
-exports.default = default_1;

package/src/cli/pull.ts

@@ -1,15 +0,0 @@
-import build from '@lib/cli/build';
-import { useExecutionMode } from '@lib/use-execution-mode';
-
-import { Script } from './internal/script';
-
-export default async function (name: string, instrument: string, options: any) {
-  if (await build()) {
-    return;
-  }
-
-  const script = new Script(name, [useExecutionMode.idleOptions()]);
-  //const output = await script.run();
-
-  //console.log(output);
-}