@quantform/sqlite 0.6.7 → 0.7.0-beta.5

package/dist/index.d.ts

@@ -1,2 +1,6 @@
 export * from './sqlite-storage';
+export declare function sqlite(directory?: string): {
+    provide: symbol;
+    useValue: import("@quantform/core").StorageFactory;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC;AAEpC,wBAAgB,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM;;;EAExC"}

package/dist/index.js

@@ -14,4 +14,11 @@ 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 });
+exports.sqlite = void 0;
+const sqlite_storage_1 = require("./sqlite-storage");
+const core_1 = require("@quantform/core");
 __exportStar(require("./sqlite-storage"), exports);
+function sqlite(directory) {
+    return (0, core_1.storage)(new sqlite_storage_1.SQLiteStorageFactory(directory));
+}
+exports.sqlite = sqlite;

package/dist/sqlite-language.d.ts

@@ -0,0 +1,10 @@
+import { InferQueryObject, Query, QueryMappingType, QueryObject, QueryObjectType, QueryWhere } from '@quantform/core';
+export declare class SQLiteLanguage {
+    static getType(type: QueryMappingType): "INTEGER" | "TEXT";
+    static getValue(type: QueryMappingType, value: any): any;
+    static getConstraint(columnName: string, type: QueryMappingType, constraint: QueryWhere): string;
+    static createTable<T extends QueryObjectType<K>, K extends QueryObject>(type: T): string;
+    static query<T extends QueryObjectType<K>, K extends QueryObject>(type: T, query: Query<InferQueryObject<T>>): string;
+    static replace<T extends QueryObjectType<K>, K extends QueryObject>(type: T): string;
+}
+//# sourceMappingURL=sqlite-language.d.ts.map

package/dist/sqlite-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-language.d.ts","sourceRoot":"","sources":["../src/sqlite-language.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,EACL,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACX,MAAM,iBAAiB,CAAC;AAEzB,qBAAa,cAAc;IACzB,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB;IAWrC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,GAAG;IAWlD,MAAM,CAAC,aAAa,CAClB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,UAAU;IAiBxB,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC;IAQ/E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAC9D,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAwCnC,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC;CAW5E"}

package/dist/sqlite-language.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteLanguage = void 0;
+class SQLiteLanguage {
+    static getType(type) {
+        switch (type) {
+            case 'number':
+                return 'INTEGER';
+            case 'decimal':
+                return 'TEXT';
+            case 'string':
+                return 'TEXT';
+        }
+    }
+    static getValue(type, value) {
+        switch (type) {
+            case 'number':
+                return value;
+            case 'decimal':
+                return `'${value.toString()}'`;
+            case 'string':
+                return `'${value}'`;
+        }
+    }
+    static getConstraint(columnName, type, constraint) {
+        switch (constraint === null || constraint === void 0 ? void 0 : constraint.type) {
+            case 'eq':
+                return `${columnName} = ${SQLiteLanguage.getValue(type, constraint.value)}`;
+            case 'gt':
+                return `${columnName} > ${SQLiteLanguage.getValue(type, constraint.value)}`;
+            case 'lt':
+                return `${columnName} < ${SQLiteLanguage.getValue(type, constraint.value)}`;
+            case 'between':
+                return `${columnName} > ${SQLiteLanguage.getValue(type, constraint.min)} AND ${columnName} < ${SQLiteLanguage.getValue(type, constraint.max)}`;
+        }
+    }
+    static createTable(type) {
+        const columns = `${Object.entries(type.type)
+            .map(([name, type]) => `${name} ${SQLiteLanguage.getType(type)} NOT NULL`)
+            .join(', ')}`;
+        return `CREATE TABLE IF NOT EXISTS "${type.discriminator}" (${columns}, PRIMARY KEY (timestamp))`;
+    }
+    static query(type, query) {
+        var _a;
+        const columns = `${Object.entries(type.type)
+            .map(([name]) => `${name}`)
+            .join(', ')}`;
+        let sql = `SELECT ${columns} FROM "${type.discriminator}"`;
+        if (query.where) {
+            const where = Array.of();
+            for (const columnName of Object.keys(query.where)) {
+                const constraint = query.where[columnName];
+                if (!constraint) {
+                    continue;
+                }
+                where.push(SQLiteLanguage.getConstraint(columnName, type.type[columnName], constraint));
+            }
+            sql = `${sql} WHERE ${where.join(' AND ')}`;
+        }
+        if (query.orderBy) {
+            sql = `${sql} ORDER BY timestamp ${(_a = query.orderBy) !== null && _a !== void 0 ? _a : 'ASC'}`;
+        }
+        if (query.limit) {
+            sql = `${sql} LIMIT ${query.limit}`;
+        }
+        if (query.offset) {
+            sql = `${sql} OFFSET ${query.offset}`;
+        }
+        return sql;
+    }
+    static replace(type) {
+        const columns = `${Object.entries(type.type)
+            .map(([name]) => `${name}`)
+            .join(', ')}`;
+        return `REPLACE INTO "${type.discriminator}" (${columns}) VALUES(${Object.entries(type.type)
+            .map(() => '?')
+            .join(', ')})`;
+    }
+}
+exports.SQLiteLanguage = SQLiteLanguage;

package/dist/sqlite-language.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sqlite-language.spec.d.ts.map

package/dist/sqlite-language.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-language.spec.d.ts","sourceRoot":"","sources":["../src/sqlite-language.spec.ts"],"names":[],"mappings":""}

package/dist/sqlite-language.spec.js

@@ -0,0 +1,50 @@
+"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 });
+const core_1 = require("@quantform/core");
+const sqlite_language_1 = require("./sqlite-language");
+describe(sqlite_language_1.SQLiteLanguage.name, () => {
+    test('create table for object', () => __awaiter(void 0, void 0, void 0, function* () {
+        const object = core_1.Storage.createObject('orders', {
+            timestamp: 'number',
+            price: 'decimal',
+            id: 'string'
+        });
+        const sql = sqlite_language_1.SQLiteLanguage.createTable(object);
+        expect(sql).toEqual(`CREATE TABLE IF NOT EXISTS "orders" (timestamp INTEGER NOT NULL, price TEXT NOT NULL, id TEXT NOT NULL, PRIMARY KEY (timestamp))`);
+    }));
+    test('select to query object', () => __awaiter(void 0, void 0, void 0, function* () {
+        const object = core_1.Storage.createObject('orders', {
+            timestamp: 'number',
+            price: 'decimal',
+            id: 'string'
+        });
+        const sql = sqlite_language_1.SQLiteLanguage.query(object, {
+            where: {
+                timestamp: (0, core_1.lt)(100),
+                id: (0, core_1.eq)('unique-id'),
+                price: (0, core_1.eq)((0, core_1.d)('1.123456789123456789'))
+            },
+            limit: 3,
+            offset: 2
+        });
+        expect(sql).toEqual(`SELECT timestamp, price, id FROM "orders" WHERE timestamp < 100 AND id = 'unique-id' AND price = '1.123456789123456789' LIMIT 3 OFFSET 2`);
+    }));
+    test('replace statement', () => __awaiter(void 0, void 0, void 0, function* () {
+        const object = core_1.Storage.createObject('orders', {
+            timestamp: 'number',
+            price: 'decimal',
+            id: 'string'
+        });
+        const sql = sqlite_language_1.SQLiteLanguage.replace(object);
+        expect(sql).toEqual(`REPLACE INTO "orders" (timestamp, price, id) VALUES(?, ?, ?)`);
+    }));
+});

package/dist/sqlite-storage.d.ts

@@ -1,14 +1,17 @@
 import { Database } from 'better-sqlite3';
-import { SessionFeature, Storage, StorageDocument, StorageQueryOptions } from '@quantform/core';
-export declare function sqlite(directory?: string): SessionFeature;
+import { InferQueryObject, Query, QueryObject, QueryObjectType, Storage, StorageFactory } from '@quantform/core';
+export declare class SQLiteStorageFactory implements StorageFactory {
+    private readonly directory?;
+    constructor(directory?: string | undefined);
+    for(key: string): Storage;
+}
 export declare class SQLiteStorage implements Storage {
-    private readonly filename;
-    protected connection?: Database;
+    readonly filename: string;
+    protected connection: Database;
+    private tables?;
     constructor(filename: string);
-    private tryConnect;
-    private tryCreateTable;
     index(): Promise<Array<string>>;
-    query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
-    save(library: string, documents: StorageDocument[]): Promise<void>;
+    query<T extends QueryObjectType<K>, K extends QueryObject>(type: T, query: Query<InferQueryObject<T>>): Promise<InferQueryObject<T>[]>;
+    save<T extends QueryObjectType<K>, K extends QueryObject>(type: T, objects: InferQueryObject<T>[]): Promise<void>;
 }
 //# sourceMappingURL=sqlite-storage.d.ts.map

package/dist/sqlite-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-storage.d.ts","sourceRoot":"","sources":["../src/sqlite-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK1C,OAAO,EAEL,cAAc,EACd,OAAO,EACP,eAAe,EACf,mBAAmB,EAEpB,MAAM,iBAAiB,CAAC;AAIzB,wBAAgB,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAOzD;AAED,qBAAa,aAAc,YAAW,OAAO;IAG/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,SAAS,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC;gBAEH,QAAQ,EAAE,MAAM;IAE7C,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,cAAc;IAehB,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAa/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAwChF,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBzE"}
+{"version":3,"file":"sqlite-storage.d.ts","sourceRoot":"","sources":["../src/sqlite-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK1C,OAAO,EAEL,gBAAgB,EAEhB,KAAK,EACL,WAAW,EACX,eAAe,EACf,OAAO,EACP,cAAc,EAEf,MAAM,iBAAiB,CAAC;AAIzB,qBACa,oBAAqB,YAAW,cAAc;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;gBAAV,SAAS,CAAC,oBAAQ;IAE/C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAK1B;AAED,qBAAa,aAAc,YAAW,OAAO;IAI/B,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAHrC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC/B,OAAO,CAAC,MAAM,CAAC,CAAW;gBAEL,QAAQ,EAAE,MAAM;IAQ/B,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAQ/B,KAAK,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAC7D,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IA0B3B,IAAI,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAC5D,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC;CAuBjB"}

package/dist/sqlite-storage.js

@@ -1,4 +1,13 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 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) {
@@ -9,92 +18,79 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteStorage = exports.sqlite = void 0;
+exports.SQLiteStorage = exports.SQLiteStorageFactory = void 0;
 const bettersqlite3 = require("better-sqlite3");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const core_1 = require("@quantform/core");
-const error_1 = require("./error");
-function sqlite(directory) {
-    return (builder) => {
-        builder.useStorage((type) => new SQLiteStorage((0, path_1.join)(directory !== null && directory !== void 0 ? directory : (0, core_1.workingDirectory)(), `/${type}.sqlite`)));
-    };
-}
-exports.sqlite = sqlite;
+const sqlite_language_1 = require("./sqlite-language");
+let SQLiteStorageFactory = class SQLiteStorageFactory {
+    constructor(directory) {
+        this.directory = directory;
+    }
+    for(key) {
+        var _a;
+        return new SQLiteStorage((0, path_1.join)((_a = this.directory) !== null && _a !== void 0 ? _a : (0, core_1.workingDirectory)(), `/${key}.sqlite`));
+    }
+};
+SQLiteStorageFactory = __decorate([
+    (0, core_1.provider)(),
+    __metadata("design:paramtypes", [String])
+], SQLiteStorageFactory);
+exports.SQLiteStorageFactory = SQLiteStorageFactory;
 class SQLiteStorage {
     constructor(filename) {
         this.filename = filename;
-    }
-    tryConnect() {
-        if (this.connection) {
-            return;
-        }
         if (!(0, fs_1.existsSync)((0, path_1.dirname)(this.filename))) {
             (0, fs_1.mkdirSync)((0, path_1.dirname)(this.filename), { recursive: true });
         }
         this.connection = bettersqlite3(this.filename);
     }
-    tryCreateTable(table) {
-        if (!this.connection) {
-            throw new error_1.NoConnectionError();
-        }
-        this.connection.exec(`CREATE TABLE IF NOT EXISTS "${table}" (
-          timestamp INTEGER NOT NULL, 
-          kind TEXT NOT NULL, 
-          json TEXT NOT NULL, 
-          PRIMARY KEY (timestamp, kind)
-        )`);
-    }
     index() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.tryConnect();
-            if (!this.connection) {
-                throw new error_1.NoConnectionError();
-            }
             return this.connection
                 .prepare("SELECT name FROM sqlite_master WHERE type='table'")
                 .all()
                 .map(it => it.name);
         });
     }
-    query(library, options) {
-        var _a, _b;
+    // eslint-disable-next-line complexity
+    query(type, query) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.tryConnect();
-            if (!this.connection) {
-                throw new error_1.NoConnectionError();
+            if (!this.tables) {
+                this.tables = yield this.index();
             }
-            if (!this.connection
-                .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='${library}'`)
-                .all().length) {
+            if (!this.tables.includes(type.discriminator)) {
                 return [];
             }
-            const isBackward = options.from == undefined;
-            let rows = this.connection
-                .prepare(`SELECT * FROM "${library}"
-           WHERE timestamp > ? AND timestamp < ? ${options.kind ? `AND kind = '${options.kind}'` : ''}
-           ORDER BY timestamp ${isBackward ? 'DESC' : ''}
-           LIMIT ?`)
-                .all([(_a = options.from) !== null && _a !== void 0 ? _a : 0, (_b = options.to) !== null && _b !== void 0 ? _b : Number.MAX_VALUE], Math.min(options.count, 50000));
-            if (isBackward) {
-                rows = rows.reverse();
-            }
-            return rows;
+            const objects = yield this.connection
+                .prepare(sqlite_language_1.SQLiteLanguage.query(type, query))
+                .all();
+            const types = Object.keys(type.type);
+            objects.forEach(it => {
+                for (const prop of types) {
+                    if (type.type[prop] == 'decimal') {
+                        it[prop] = (0, core_1.d)(it[prop]);
+                    }
+                }
+            });
+            return objects;
         });
     }
-    save(library, documents) {
+    save(type, objects) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.tryConnect();
-            if (!this.connection) {
-                throw new error_1.NoConnectionError();
+            if (!this.tables) {
+                this.tables = yield this.index();
+            }
+            if (!this.tables.includes(type.discriminator)) {
+                this.connection.exec(sqlite_language_1.SQLiteLanguage.createTable(type));
+                this.tables = undefined;
             }
-            this.tryCreateTable(library);
-            const statement = this.connection.prepare(`
-      REPLACE INTO "${library}" (timestamp, kind, json)
-      VALUES(?, ?, ?); 
-    `);
-            const insertMany = this.connection.transaction(rows => rows.forEach((it) => statement.run(it.timestamp, it.kind, it.json)));
-            insertMany(documents);
+            const statement = this.connection.prepare(sqlite_language_1.SQLiteLanguage.replace(type));
+            const types = Object.keys(type.type);
+            const mapper = (it) => types.map(type => it[type].toString());
+            const insertMany = this.connection.transaction(rows => rows.forEach((it) => statement.run(mapper(it))));
+            insertMany(objects);
         });
     }
 }

package/dist/sqlite-storage.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sqlite-storage.spec.d.ts.map

package/dist/sqlite-storage.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-storage.spec.d.ts","sourceRoot":"","sources":["../src/sqlite-storage.spec.ts"],"names":[],"mappings":""}

package/dist/sqlite-storage.spec.js

@@ -0,0 +1,204 @@
+"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 });
+const fs_1 = require("fs");
+const core_1 = require("@quantform/core");
+const sqlite_storage_1 = require("./sqlite-storage");
+describe(sqlite_storage_1.SQLiteStorage.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    afterEach(() => {
+        fixtures.dispose();
+    });
+    /*
+    test('index return the names of discriminators', async () => {
+      const { sut } = fixtures;
+  
+      await sut.save({ discriminator: 'pricing' }, [{ timestamp: 1, message: 'test-1' }]);
+      await sut.save({ discriminator: 'ordering' }, [{ timestamp: 1, message: 'test-1' }]);
+  
+      const index = await sut.index();
+  
+      expect(index).toEqual(['pricing', 'ordering']);
+    });
+  */
+    test('write and read single object', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut, object } = fixtures;
+        yield sut.save(object, [
+            { timestamp: 1, id: '123 123', price: (0, core_1.d)('1.123456789123456789'), quantity: 5 }
+        ]);
+        const set = yield sut.query(object, {
+            where: {
+                id: (0, core_1.eq)('123 123')
+            }
+        });
+        expect(set).toEqual([
+            { timestamp: 1, id: '123 123', price: (0, core_1.d)('1.123456789123456789'), quantity: 5 }
+        ]);
+    }));
+    test('save and read full data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, {});
+        expect(set).toEqual([
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+    }));
+    test('save and read limited data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, { limit: 3 });
+        expect(set).toEqual([
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) }
+        ]);
+    }));
+    test('save and read desc ordered data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, { orderBy: 'DESC' });
+        expect(set).toEqual([
+            { timestamp: 5, rate: (0, core_1.d)(5) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 1, rate: (0, core_1.d)(1) }
+        ]);
+    }));
+    test('save and read filtered eq data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, {
+            where: {
+                timestamp: (0, core_1.eq)(4)
+            }
+        });
+        expect(set).toEqual([{ timestamp: 4, rate: (0, core_1.d)(4) }]);
+    }));
+    test('save and read filtered lt data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, {
+            where: {
+                timestamp: (0, core_1.lt)(3)
+            }
+        });
+        expect(set).toEqual([
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) }
+        ]);
+    }));
+    test('save and read filtered gt data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sut } = fixtures;
+        const pricing = core_1.Storage.createObject('pricing', {
+            timestamp: 'number',
+            rate: 'decimal'
+        });
+        yield sut.save(pricing, [
+            { timestamp: 1, rate: (0, core_1.d)(1) },
+            { timestamp: 2, rate: (0, core_1.d)(2) },
+            { timestamp: 3, rate: (0, core_1.d)(3) },
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+        const set = yield sut.query(pricing, {
+            where: {
+                timestamp: (0, core_1.gt)(3)
+            }
+        });
+        expect(set).toEqual([
+            { timestamp: 4, rate: (0, core_1.d)(4) },
+            { timestamp: 5, rate: (0, core_1.d)(5) }
+        ]);
+    }));
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { get } = yield (0, core_1.makeTestModule)([
+            {
+                provide: 'storage',
+                useValue: new sqlite_storage_1.SQLiteStorage('test.db')
+            }
+        ]);
+        const sut = get('storage');
+        return {
+            sut,
+            object: core_1.Storage.createObject('test', {
+                timestamp: 'number',
+                price: 'decimal',
+                quantity: 'number',
+                id: 'string'
+            }),
+            dispose() {
+                if ((0, fs_1.existsSync)(sut.filename)) {
+                    (0, fs_1.unlinkSync)(sut.filename);
+                }
+            }
+        };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantform/sqlite",
-  "version": "0.6.7",
+  "version": "0.7.0-beta.5",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",
@@ -18,10 +18,10 @@
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",
-    "@quantform/core": "0.6.7"
+    "@quantform/core": "0.7.0-beta.5"
   },
   "peerDependencies": {
-    "@quantform/core": "0.6.7"
+    "@quantform/core": "0.7.0-beta.5"
   },
   "scripts": {
     "build": "tsc && tsc-alias",

package/src/index.ts

@@ -1 +1,8 @@
+import { SQLiteStorageFactory } from '@lib/sqlite-storage';
+import { storage } from '@quantform/core';
+
 export * from '@lib/sqlite-storage';
+
+export function sqlite(directory?: string) {
+  return storage(new SQLiteStorageFactory(directory));
+}