Resolver for Ticks and Token(s) methods (#177)

* Add query resolvers for Tick and Token entities.

* Implemented query for orderBy.

Co-authored-by: nabarun <nabarun@deepstacksoft.com>

packages/uni-info-watcher/src/database.ts

@@ -367,10 +367,27 @@ export class Database {
     const repo = this._conn.getRepository(entity);
     const { tableName } = repo.metadata;
 
+    let subQuery = await repo.createQueryBuilder('subTable')
+      .select('MAX(subTable.block_number)')
+      .where(`subTable.id = ${tableName}.id`);
+
+    if (blockHash) {
+      const { canonicalBlockNumber, blockHashes } = await this._getBranchInfo(blockHash);
+
+      subQuery = subQuery
+        .andWhere(new Brackets(qb => {
+          qb.where('subTable.block_hash IN (:...blockHashes)', { blockHashes })
+            .orWhere('subTable.block_number <= :canonicalBlockNumber', { canonicalBlockNumber });
+        }));
+    }
+
+    if (blockNumber) {
+      subQuery = subQuery.andWhere('subTable.block_number <= :blockNumber', { blockNumber });
+    }
+
     let selectQueryBuilder = repo.createQueryBuilder(tableName)
-      .distinctOn([`${tableName}.id`])
+      .where(`${tableName}.block_number IN (${subQuery.getQuery()})`)
-      .orderBy(`${tableName}.id`)
+      .setParameters(subQuery.getParameters());
-      .addOrderBy(`${tableName}.block_number`, 'DESC');
 
     relations.forEach(relation => {
       selectQueryBuilder = selectQueryBuilder.leftJoinAndSelect(`${repo.metadata.tableName}.${relation}`, relation);
@@ -380,20 +397,6 @@ export class Database {
       selectQueryBuilder = selectQueryBuilder.andWhere(`${tableName}.${field} = :value`, { value });
     });
 
-    if (blockHash) {
-      const { canonicalBlockNumber, blockHashes } = await this._getBranchInfo(blockHash);
-
-      selectQueryBuilder = selectQueryBuilder
-        .andWhere(new Brackets(qb => {
-          qb.where(`${tableName}.block_hash IN (:...blockHashes)`, { blockHashes })
-            .orWhere(`${tableName}.block_number <= :canonicalBlockNumber`, { canonicalBlockNumber });
-        }));
-    }
-
-    if (blockNumber) {
-      selectQueryBuilder = selectQueryBuilder.andWhere(`${tableName}.block_number <= :blockNumber`, { blockNumber });
-    }
-
     const { limit = DEFAULT_LIMIT, orderBy, orderDirection, skip = DEFAULT_SKIP } = queryOptions;
 
     // TODO: Use skip and take methods. Currently throws error when using with join.
@@ -401,7 +404,7 @@ export class Database {
       .limit(limit);
 
     if (orderBy) {
-      selectQueryBuilder = selectQueryBuilder.addOrderBy(`${tableName}.${orderBy}`, orderDirection === 'desc' ? 'DESC' : 'ASC');
+      selectQueryBuilder = selectQueryBuilder.orderBy(`${tableName}.${orderBy}`, orderDirection === 'desc' ? 'DESC' : 'ASC');
     }
 
     return selectQueryBuilder.getMany();

packages/uni-info-watcher/src/indexer.ts

@@ -199,6 +199,10 @@ export class Indexer {
     return this._db.getPool({ id, blockHash: block.hash, blockNumber: block.number });
   }
 
+  async getToken (id: string, block: BlockHeight): Promise<Token | undefined> {
+    return this._db.getToken({ id, blockHash: block.hash, blockNumber: block.number });
+  }
+
   async getEntities<Entity> (entity: new () => Entity, where: Partial<Entity>, queryOptions: QueryOptions, relations?: string[]): Promise<Entity[]> {
     const res = await this._db.getEntities(entity, where, queryOptions, relations);
     return res;

packages/uni-info-watcher/src/resolvers.ts

@@ -10,6 +10,8 @@ import { Mint } from './entity/Mint';
 import { PoolDayData } from './entity/PoolDayData';
 import { Pool } from './entity/Pool';
 import { Swap } from './entity/Swap';
+import { Tick } from './entity/Tick';
+import { Token } from './entity/Token';
 
 const log = debug('vulcanize:resolver');
 
@@ -79,6 +81,26 @@ export const createResolvers = async (indexer: Indexer): Promise<any> => {
         log('swaps', first, orderBy, orderDirection, where);
 
         return indexer.getEntities(Swap, where, { limit: first, orderBy, orderDirection }, ['pool', 'transaction']);
+      },
+
+      ticks: async (_: any, { block = {}, first, skip, where = {} }: { block: BlockHeight, first: number, skip: number, where: Partial<Tick> }) => {
+        log('ticks', block, first, skip, where);
+        where.blockHash = block.hash;
+        where.blockNumber = block.number;
+
+        return indexer.getEntities(Tick, where, { limit: first, skip });
+      },
+
+      token: async (_: any, { id, block = {} }: { id: string, block: BlockHeight }) => {
+        log('token', id, block);
+
+        return indexer.getToken(id, block);
+      },
+
+      tokens: async (_: any, { orderBy, orderDirection, where }: { orderBy: string, orderDirection: OrderDirection, where: Partial<Token> }) => {
+        log('tokens', orderBy, orderDirection, where);
+
+        return indexer.getEntities(Token, where, { orderBy, orderDirection });
       }
     }
   };