feat(modules): add ticker entity

assets/init.sql

@@ -114,6 +114,25 @@ CREATE TABLE `transaction` (
 
 
 
+# テーブルのダンプ ticker
+# ------------------------------------------------------------
+CREATE TABLE `ticker` (
+  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'primary auto generated id',
+  `exchange` varchar(20) NOT NULL COMMENT 'exchange name',
+  `symbol` varchar(20) NOT NULL COMMENT 'symbol name',
+  `ask` decimal(21,9) unsigned NOT NULL,
+  `bid` decimal(21,9) unsigned NOT NULL,
+  `open` decimal(21,9) unsigned NOT NULL,
+  `high` decimal(21,9) unsigned NOT NULL,
+  `low` decimal(21,9) unsigned NOT NULL,
+  `last` decimal(21,9) unsigned NOT NULL,
+  `volume` decimal(21,9) unsigned NOT NULL,
+  `time` datetime(3) NOT NULL,
+  `created_at` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  `updated_at` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
 
 /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
 /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;

modules/models/common/testing/entity-test-bed/constants.ts

@@ -9,6 +9,8 @@ import {
   MasterPairRepository,
   OrderbookEntity,
   OrderbookRepository,
+  TickerEntity,
+  TickerRepository,
   TransactionEntity,
   TransactionRepository,
 } from '../../../entity';
@@ -19,6 +21,7 @@ export const allEntityTypes: ObjectType<any>[] = [
   OrderbookEntity,
   TransactionEntity,
   CandlestickEntity,
+  TickerEntity,
 ];
 
 export const allRepositoryTypes: ObjectType<any>[] = [
@@ -27,4 +30,5 @@ export const allRepositoryTypes: ObjectType<any>[] = [
   OrderbookRepository,
   TransactionRepository,
   CandlestickRepository,
+  TickerRepository,
 ];

modules/models/entity/candlestick/candlestick.entity.ts

@@ -99,7 +99,6 @@ export class CandlestickEntity {
     default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly createdAt!: Timestamp;
 
   @Column({
@@ -110,6 +109,5 @@ export class CandlestickEntity {
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly updatedAt!: Timestamp;
 }

modules/models/entity/index.ts

@@ -3,3 +3,4 @@ export * from './master-exchange';
 export * from './orderbook';
 export * from './candlestick';
 export * from './transaction';
+export * from './ticker';

modules/models/entity/master-exchange/master-exchange.entity.ts

@@ -49,7 +49,6 @@ export class MasterExchangeEntity {
     default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly createdAt!: Timestamp;
 
   @Column({
@@ -60,6 +59,5 @@ export class MasterExchangeEntity {
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly updatedAt!: Timestamp;
 }

modules/models/entity/master-pair/master-pair.entity.ts

@@ -122,7 +122,6 @@ export class MasterPairEntity {
     default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly createdAt!: Timestamp;
 
   @Column({
@@ -133,6 +132,5 @@ export class MasterPairEntity {
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly updatedAt!: Timestamp;
 }

modules/models/entity/orderbook/orderbook.entity.ts

@@ -53,7 +53,6 @@ export class OrderbookEntity {
     default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly createdAt!: Timestamp;
 
   @Column({
@@ -64,6 +63,5 @@ export class OrderbookEntity {
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly updatedAt!: Timestamp;
 }

modules/models/entity/ticker/index.ts

@@ -0,0 +1,2 @@
+export * from './ticker.entity';
+export * from './ticker.repository';

modules/models/entity/ticker/ticker.entity.ts

@@ -0,0 +1,123 @@
+import { Timestamp } from '@dripjs/types';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+import { nullableDateTransformer } from '../../common';
+
+@Entity({
+  name: 'ticker',
+})
+export class TickerEntity {
+  @PrimaryGeneratedColumn({
+    type: 'bigint',
+    name: 'id',
+    unsigned: true,
+    comment: 'primary auto generated id',
+  })
+  readonly id!: string;
+
+  @Column({
+    type: 'varchar',
+    name: 'exchange',
+    length: 20,
+    comment: 'exchange name',
+  })
+  readonly exchange!: string;
+
+  @Column({
+    type: 'varchar',
+    name: 'symbol',
+    length: 20,
+    comment: 'symbol name',
+  })
+  readonly symbol!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'ask',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly ask!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'bid',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly bid!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'open',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly open!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'high',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly high!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'low',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly low!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'last',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly last!: string;
+
+  @Column({
+    type: 'decimal',
+    name: 'volume',
+    precision: 21,
+    scale: 9,
+    unsigned: true,
+  })
+  readonly volume!: string;
+
+  @Column({
+    type: 'datetime',
+    name: 'time',
+    precision: 3,
+    transformer: nullableDateTransformer,
+  })
+  readonly time!: Timestamp;
+
+  @Column({
+    type: 'datetime',
+    name: 'created_at',
+    precision: 3,
+    default: /* istanbul ignore next */ () => 'NOW(3)',
+    transformer: nullableDateTransformer,
+  })
+  readonly createdAt!: Timestamp;
+
+  @Column({
+    type: 'datetime',
+    name: 'updated_at',
+    precision: 3,
+    default: /* istanbul ignore next */ () => 'NOW(3)',
+    onUpdate: 'NOW(3)',
+    transformer: nullableDateTransformer,
+  })
+  readonly updatedAt!: Timestamp;
+}

modules/models/entity/ticker/ticker.repository.spec.ts

@@ -0,0 +1,69 @@
+import { fixByDigits } from '@dripjs/common';
+import { EntityTestBed, TickerEntity, TickerEntityCreateParams, TickerRepository } from '@dripjs/models';
+import { getTickerDefaultData } from '@dripjs/testing';
+import { Timestamp } from '@dripjs/types';
+
+describe('ticker.repository', () => {
+  let tickerReposity: TickerRepository;
+  const defaultData = getTickerDefaultData();
+  const exchange = 'bitmex';
+  const pair = 'xbtusd';
+
+  beforeAll(async () => {
+    await EntityTestBed.setup();
+    tickerReposity = EntityTestBed.getRepository(TickerRepository);
+  });
+
+  afterAll(async () => {
+    await EntityTestBed.cleanup();
+  });
+
+  beforeEach(async () => {
+    await EntityTestBed.reset();
+    await tickerReposity.insertNewTickers(defaultData);
+  });
+
+  describe('insertNewTicker', () => {
+    it('should insert new ticker', async () => {
+      const newData = {
+        ...defaultData[0],
+        exchange: 'bitbank',
+        time: Date.now() as Timestamp,
+      };
+      await tickerReposity.insertNewTicker(newData);
+      const insertedTicker = await tickerReposity.find({
+        exchange: newData.exchange,
+      });
+      expect(insertedTicker.map(getDataFromEntity)).toEqual([newData]);
+    });
+  });
+
+  describe('insertNewTickers', () => {
+    it('should insert new Tickers', async () => {
+      const insertedTickers = await tickerReposity.find();
+      expect(insertedTickers.map(getDataFromEntity)).toEqual(defaultData);
+    });
+  });
+
+  describe('getTickers', () => {
+    it('should get tickers', async () => {
+      const res = await tickerReposity.getTickers(exchange, pair);
+      expect([getDataFromEntity(res[0])]).toEqual(defaultData);
+    });
+  });
+});
+
+function getDataFromEntity(entity: TickerEntity): TickerEntityCreateParams {
+  return {
+    exchange: entity.exchange,
+    symbol: entity.symbol,
+    time: entity.time,
+    ask: fixByDigits(entity.ask, 0),
+    bid: fixByDigits(entity.bid, 0),
+    open: fixByDigits(entity.open, 0),
+    high: fixByDigits(entity.high, 0),
+    low: fixByDigits(entity.low, 0),
+    last: fixByDigits(entity.last, 0),
+    volume: fixByDigits(entity.volume, 0),
+  };
+}

modules/models/entity/ticker/ticker.repository.ts

@@ -0,0 +1,31 @@
+import { EntityRepository, Repository } from 'typeorm';
+
+import { TickerEntity } from './ticker.entity';
+
+export interface TickerEntityCreateParams {
+  exchange: TickerEntity['exchange'];
+  symbol: TickerEntity['symbol'];
+  ask: TickerEntity['ask'];
+  bid: TickerEntity['bid'];
+  time: TickerEntity['time'];
+  open: TickerEntity['open'];
+  high: TickerEntity['high'];
+  low: TickerEntity['low'];
+  last: TickerEntity['last'];
+  volume: TickerEntity['volume'];
+}
+
+@EntityRepository(TickerEntity)
+export class TickerRepository extends Repository<TickerEntity> {
+  async insertNewTicker(params: TickerEntityCreateParams): Promise<TickerEntity> {
+    return this.save(params as TickerEntity, { reload: false });
+  }
+
+  async insertNewTickers(params: TickerEntityCreateParams[]): Promise<TickerEntity[]> {
+    return this.save(params as TickerEntity[], { reload: false });
+  }
+
+  async getTickers(exchange: string, symbol: string): Promise<TickerEntity[]> {
+    return this.find({ where: { exchange, symbol } });
+  }
+}

modules/models/entity/transaction/transaction.entity.ts

@@ -74,7 +74,6 @@ export class TransactionEntity {
     default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly createdAt!: Timestamp;
 
   @Column({
@@ -85,6 +84,5 @@ export class TransactionEntity {
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })
-  /* istanbul ignore next */
   readonly updatedAt!: Timestamp;
 }

modules/testing/data/models/index.ts

@@ -3,3 +3,4 @@ export * from './master-exchange.entity';
 export * from './orderbook.entity';
 export * from './transaction.entity';
 export * from './candlestick.entity';
+export * from './ticker.entity';

modules/testing/data/models/ticker.entity.ts

@@ -0,0 +1,20 @@
+import { TickerEntityCreateParams } from '@dripjs/models';
+import { Timestamp } from '@dripjs/types';
+
+// use function to avoid object mutating when insert to db
+export function getTickerDefaultData(): TickerEntityCreateParams[] {
+  return [
+    {
+      exchange: 'bitmex',
+      symbol: 'xbtusd',
+      time: Date.now() as Timestamp,
+      bid: '4820',
+      ask: '4821',
+      open: '4800',
+      last: '4821',
+      low: '4800',
+      high: '4832',
+      volume: '10',
+    },
+  ];
+}