@quantform/sqlite 0.6.7 → 0.7.0-beta.5

package/src/sqlite-language.spec.ts

@@ -0,0 +1,53 @@
+import { d, eq, lt, Storage } from '@quantform/core';
+
+import { SQLiteLanguage } from './sqlite-language';
+
+describe(SQLiteLanguage.name, () => {
+  test('create table for object', async () => {
+    const object = Storage.createObject('orders', {
+      timestamp: 'number',
+      price: 'decimal',
+      id: 'string'
+    });
+
+    const sql = 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', async () => {
+    const object = Storage.createObject('orders', {
+      timestamp: 'number',
+      price: 'decimal',
+      id: 'string'
+    });
+
+    const sql = SQLiteLanguage.query(object, {
+      where: {
+        timestamp: lt(100),
+        id: eq('unique-id'),
+        price: eq(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', async () => {
+    const object = Storage.createObject('orders', {
+      timestamp: 'number',
+      price: 'decimal',
+      id: 'string'
+    });
+
+    const sql = SQLiteLanguage.replace(object);
+
+    expect(sql).toEqual(`REPLACE INTO "orders" (timestamp, price, id) VALUES(?, ?, ?)`);
+  });
+});

package/src/sqlite-language.ts

@@ -0,0 +1,114 @@
+import {
+  InferQueryObject,
+  Query,
+  QueryMappingType,
+  QueryObject,
+  QueryObjectType,
+  QueryWhere
+} from '@quantform/core';
+
+export class SQLiteLanguage {
+  static getType(type: QueryMappingType) {
+    switch (type) {
+      case 'number':
+        return 'INTEGER';
+      case 'decimal':
+        return 'TEXT';
+      case 'string':
+        return 'TEXT';
+    }
+  }
+
+  static getValue(type: QueryMappingType, value: any) {
+    switch (type) {
+      case 'number':
+        return value;
+      case 'decimal':
+        return `'${value.toString()}'`;
+      case 'string':
+        return `'${value}'`;
+    }
+  }
+
+  static getConstraint(
+    columnName: string,
+    type: QueryMappingType,
+    constraint: QueryWhere
+  ) {
+    switch (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<T extends QueryObjectType<K>, K extends QueryObject>(type: T) {
+    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<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    query: Query<InferQueryObject<T>>
+  ) {
+    const columns = `${Object.entries(type.type)
+      .map(([name]) => `${name}`)
+      .join(', ')}`;
+
+    let sql = `SELECT ${columns} FROM "${type.discriminator}"`;
+
+    if (query.where) {
+      const where = Array.of<string>();
+
+      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 ${query.orderBy ?? 'ASC'}`;
+    }
+
+    if (query.limit) {
+      sql = `${sql} LIMIT ${query.limit}`;
+    }
+
+    if (query.offset) {
+      sql = `${sql} OFFSET ${query.offset}`;
+    }
+
+    return sql;
+  }
+
+  static replace<T extends QueryObjectType<K>, K extends QueryObject>(type: T) {
+    const columns = `${Object.entries(type.type)
+      .map(([name]) => `${name}`)
+      .join(', ')}`;
+
+    return `REPLACE INTO "${type.discriminator}" (${columns}) VALUES(${Object.entries(
+      type.type
+    )
+      .map(() => '?')
+      .join(', ')})`;
+  }
+}

package/src/sqlite-storage.spec.ts

@@ -0,0 +1,232 @@
+import { existsSync, unlinkSync } from 'fs';
+
+import { d, eq, gt, lt, makeTestModule, Storage } from '@quantform/core';
+
+import { SQLiteStorage } from './sqlite-storage';
+
+describe(SQLiteStorage.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await 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', async () => {
+    const { sut, object } = fixtures;
+
+    await sut.save(object, [
+      { timestamp: 1, id: '123 123', price: d('1.123456789123456789'), quantity: 5 }
+    ]);
+
+    const set = await sut.query(object, {
+      where: {
+        id: eq('123 123')
+      }
+    });
+
+    expect(set).toEqual([
+      { timestamp: 1, id: '123 123', price: d('1.123456789123456789'), quantity: 5 }
+    ]);
+  });
+
+  test('save and read full data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {});
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+  });
+
+  test('save and read limited data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, { limit: 3 });
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) }
+    ]);
+  });
+
+  test('save and read desc ordered data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, { orderBy: 'DESC' });
+
+    expect(set).toEqual([
+      { timestamp: 5, rate: d(5) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 1, rate: d(1) }
+    ]);
+  });
+
+  test('save and read filtered eq data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: eq(4)
+      }
+    });
+
+    expect(set).toEqual([{ timestamp: 4, rate: d(4) }]);
+  });
+
+  test('save and read filtered lt data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: lt(3)
+      }
+    });
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) }
+    ]);
+  });
+
+  test('save and read filtered gt data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: gt(3)
+      }
+    });
+
+    expect(set).toEqual([
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+  });
+});
+
+async function getFixtures() {
+  const { get } = await makeTestModule([
+    {
+      provide: 'storage',
+      useValue: new SQLiteStorage('test.db')
+    }
+  ]);
+
+  const sut = get<SQLiteStorage>('storage');
+
+  return {
+    sut,
+    object: Storage.createObject('test', {
+      timestamp: 'number',
+      price: 'decimal',
+      quantity: 'number',
+      id: 'string'
+    }),
+    dispose() {
+      if (existsSync(sut.filename)) {
+        unlinkSync(sut.filename);
+      }
+    }
+  };
+}

package/src/sqlite-storage.ts

@@ -4,35 +4,35 @@ import { existsSync, mkdirSync } from 'fs';
 import { dirname, join } from 'path';
 
 import {
-  SessionBuilder,
-  SessionFeature,
+  d,
+  InferQueryObject,
+  provider,
+  Query,
+  QueryObject,
+  QueryObjectType,
   Storage,
-  StorageDocument,
-  StorageQueryOptions,
+  StorageFactory,
   workingDirectory
 } from '@quantform/core';
 
-import { NoConnectionError } from '@lib/error';
+import { SQLiteLanguage } from './sqlite-language';
 
-export function sqlite(directory?: string): SessionFeature {
-  return (builder: SessionBuilder) => {
-    builder.useStorage(
-      (type: string) =>
-        new SQLiteStorage(join(directory ?? workingDirectory(), `/${type}.sqlite`))
+@provider()
+export class SQLiteStorageFactory implements StorageFactory {
+  constructor(private readonly directory?: string) {}
+
+  for(key: string): Storage {
+    return new SQLiteStorage(
+      join(this.directory ?? workingDirectory(), `/${key}.sqlite`)
     );
-  };
+  }
 }
 
 export class SQLiteStorage implements Storage {
-  protected connection?: Database;
-
-  constructor(private readonly filename: string) {}
-
-  private tryConnect() {
-    if (this.connection) {
-      return;
-    }
+  protected connection: Database;
+  private tables?: string[];
 
+  constructor(readonly filename: string) {
     if (!existsSync(dirname(this.filename))) {
       mkdirSync(dirname(this.filename), { recursive: true });
     }
@@ -40,92 +40,67 @@ export class SQLiteStorage implements Storage {
     this.connection = bettersqlite3(this.filename);
   }
 
-  private tryCreateTable(table: string) {
-    if (!this.connection) {
-      throw new 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)
-        )`
-    );
-  }
-
   async index(): Promise<Array<string>> {
-    this.tryConnect();
-
-    if (!this.connection) {
-      throw new NoConnectionError();
-    }
-
     return this.connection
       .prepare("SELECT name FROM sqlite_master WHERE type='table'")
       .all()
       .map(it => it.name);
   }
 
-  async query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]> {
-    this.tryConnect();
-
-    if (!this.connection) {
-      throw new NoConnectionError();
+  // eslint-disable-next-line complexity
+  async query<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    query: Query<InferQueryObject<T>>
+  ): Promise<InferQueryObject<T>[]> {
+    if (!this.tables) {
+      this.tables = await 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(
-        [options.from ?? 0, options.to ?? Number.MAX_VALUE],
-        Math.min(options.count, 50000)
-      );
-
-    if (isBackward) {
-      rows = rows.reverse();
-    }
+    const objects = await this.connection
+      .prepare(SQLiteLanguage.query(type, query))
+      .all();
 
-    return rows;
+    const types = Object.keys(type.type);
+
+    objects.forEach(it => {
+      for (const prop of types) {
+        if (type.type[prop] == 'decimal') {
+          it[prop] = d(it[prop]);
+        }
+      }
+    });
+
+    return objects;
   }
 
-  async save(library: string, documents: StorageDocument[]): Promise<void> {
-    this.tryConnect();
+  async save<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    objects: InferQueryObject<T>[]
+  ): Promise<void> {
+    if (!this.tables) {
+      this.tables = await this.index();
+    }
 
-    if (!this.connection) {
-      throw new NoConnectionError();
+    if (!this.tables.includes(type.discriminator)) {
+      this.connection.exec(SQLiteLanguage.createTable(type));
+
+      this.tables = undefined;
     }
 
-    this.tryCreateTable(library);
+    const statement = this.connection.prepare(SQLiteLanguage.replace(type));
+
+    const types = Object.keys(type.type);
 
-    const statement = this.connection.prepare(`
-      REPLACE INTO "${library}" (timestamp, kind, json)
-      VALUES(?, ?, ?); 
-    `);
+    const mapper = (it: InferQueryObject<T>) => types.map(type => it[type].toString());
 
     const insertMany = this.connection.transaction(rows =>
-      rows.forEach((it: any) => statement.run(it.timestamp, it.kind, it.json))
+      rows.forEach((it: InferQueryObject<T>) => statement.run(mapper(it)))
     );
 
-    insertMany(documents);
+    insertMany(objects);
   }
 }

package/dist/error.d.ts

@@ -1,4 +0,0 @@
-export declare class NoConnectionError extends Error {
-    constructor();
-}
-//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,qBAAa,iBAAkB,SAAQ,KAAK;;CAI3C"}

package/dist/error.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoConnectionError = void 0;
-class NoConnectionError extends Error {
-    constructor() {
-        super('Missing database connection connection!');
-    }
-}
-exports.NoConnectionError = NoConnectionError;

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

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

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

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