Add endpoint for fetching new pnl data (#3098)

Author: davidli1997

indexer/packages/postgres/__tests__/stores/pnl-table.test.ts

@@ -137,4 +137,196 @@ describe('Pnl store', () => {
     expect(responsePageAllPages.total).toEqual(2);
   });
 
+  it('Successfully retrieves daily PNL records with latest for current day and earliest for previous days', async () => {
+    const records = [];
+
+    // Day 1 (Jan 1): Create records at 00:00, 06:00, 12:00, 18:00
+    const day1Date = new Date('2023-01-01T00:00:00.000Z');
+    for (let i = 0; i < 24; i += 6) {
+      const date = new Date(day1Date);
+      date.setUTCHours(i);
+      records.push({
+        ...defaultPnl,
+        createdAt: date.toISOString(),
+        createdAtHeight: (1000 + i).toString(),
+        equity: (1000 + i).toString(),
+      });
+    }
+
+    // Day 2 (Jan 2): Create records at 00:00, 06:00, 12:00, 18:00
+    const day2Date = new Date('2023-01-02T00:00:00.000Z');
+    for (let i = 0; i < 24; i += 6) {
+      const date = new Date(day2Date);
+      date.setUTCHours(i);
+      records.push({
+        ...defaultPnl,
+        createdAt: date.toISOString(),
+        createdAtHeight: (2000 + i).toString(),
+        equity: (2000 + i).toString(),
+      });
+    }
+
+    // Day 3 (Jan 3): Create records at 00:00, 06:00, 12:00, 18:00
+    const day3Date = new Date('2023-01-03T00:00:00.000Z');
+    for (let i = 0; i < 24; i += 6) {
+      const date = new Date(day3Date);
+      date.setUTCHours(i);
+      records.push({
+        ...defaultPnl,
+        createdAt: date.toISOString(),
+        createdAtHeight: (3000 + i).toString(),
+        equity: (3000 + i).toString(),
+      });
+    }
+
+    // Insert all records
+    await Promise.all(records.map((record) => PnlTable.create(record)));
+
+    // Get daily records
+    const dailyResults = await PnlTable.findAllDailyPnl(
+      { subaccountId: [defaultSubaccountId] },
+      [],
+      {},
+    );
+
+    // We should get exactly 3 records (one for each day)
+    expect(dailyResults.results.length).toBe(3);
+
+    // The first record should be the latest one from day 3 (18:00)
+    expect(dailyResults.results[0].createdAtHeight).toBe('3018');
+    expect(dailyResults.results[0].createdAt).toBe('2023-01-03T18:00:00.000Z');
+
+    // The second record should be the earliest one from day 2 (00:00)
+    expect(dailyResults.results[1].createdAtHeight).toBe('2000');
+    expect(dailyResults.results[1].createdAt).toBe('2023-01-02T00:00:00.000Z');
+
+    // The third record should be the earliest one from day 1 (00:00)
+    expect(dailyResults.results[2].createdAtHeight).toBe('1000');
+    expect(dailyResults.results[2].createdAt).toBe('2023-01-01T00:00:00.000Z');
+
+    // Test with pagination - first page
+    const dailyPage1 = await PnlTable.findAllDailyPnl(
+      {
+        subaccountId: [defaultSubaccountId],
+        page: 1,
+        limit: 2,
+      },
+      [],
+      {},
+    );
+
+    expect(dailyPage1.results.length).toBe(2);
+    expect(dailyPage1.limit).toBe(2);
+    expect(dailyPage1.offset).toBe(0);
+    expect(dailyPage1.total).toBe(3);
+
+    // First page should have day 3 (latest) and day 2 (earliest)
+    expect(dailyPage1.results[0].createdAtHeight).toBe('3018');
+    expect(dailyPage1.results[1].createdAtHeight).toBe('2000');
+
+    // Test with pagination - second page
+    const dailyPage2 = await PnlTable.findAllDailyPnl(
+      {
+        subaccountId: [defaultSubaccountId],
+        page: 2,
+        limit: 2,
+      },
+      [],
+      {},
+    );
+
+    // The second page should have only day 1
+    expect(dailyPage2.results.length).toBe(1);
+    expect(dailyPage2.limit).toBe(2);
+    expect(dailyPage2.offset).toBe(2);
+    expect(dailyPage2.total).toBe(3);
+    expect(dailyPage2.results[0].createdAtHeight).toBe('1000');
+
+    // Test with date range filter
+    const cutoffDate = new Date('2023-01-02T12:00:00.000Z');
+
+    const dailyWithDateFilter = await PnlTable.findAllDailyPnl(
+      {
+        subaccountId: [defaultSubaccountId],
+        createdBeforeOrAt: cutoffDate.toISOString(),
+      },
+      [],
+      {},
+    );
+
+    // We should get 2 records: day 1 (earliest) and day 2 (records up to 12:00)
+    expect(dailyWithDateFilter.results.length).toBe(2);
+
+    // Day 2 should be represented by the latest record before our cutoff (12:00)
+    expect(dailyWithDateFilter.results[0].createdAtHeight).toBe('2012');
+    expect(dailyWithDateFilter.results[0].createdAt).toBe('2023-01-02T12:00:00.000Z');
+
+    // Day 1 should still be the earliest record
+    expect(dailyWithDateFilter.results[1].createdAtHeight).toBe('1000');
+    expect(dailyWithDateFilter.results[1].createdAt).toBe('2023-01-01T00:00:00.000Z');
+  });
+
+  it('Successfully handles case where latest record is at midnight (00:00)', async () => {
+    const records = [];
+
+    // Day 1 (Jan 1): Create records at 00:00, 06:00, 12:00, 18:00
+    const day1Date = new Date('2023-01-01T00:00:00.000Z');
+    for (let i = 0; i < 24; i += 6) {
+      const date = new Date(day1Date);
+      date.setUTCHours(i);
+      records.push({
+        ...defaultPnl,
+        createdAt: date.toISOString(),
+        createdAtHeight: (1000 + i).toString(),
+        equity: (1000 + i).toString(),
+      });
+    }
+
+    // Day 2 (Jan 2): Create records at 00:00, 06:00, 12:00, 18:00
+    const day2Date = new Date('2023-01-02T00:00:00.000Z');
+    for (let i = 0; i < 24; i += 6) {
+      const date = new Date(day2Date);
+      date.setUTCHours(i);
+      records.push({
+        ...defaultPnl,
+        createdAt: date.toISOString(),
+        createdAtHeight: (2000 + i).toString(),
+        equity: (2000 + i).toString(),
+      });
+    }
+
+    // Day 3 (Jan 3): Create ONLY a record at 00:00 (to test the case where latest is at midnight)
+    // Give this record the highest height to ensure it's the latest
+    records.push({
+      ...defaultPnl,
+      createdAt: '2023-01-03T00:00:00.000Z',
+      createdAtHeight: '3500', // Highest height to ensure it's the latest
+      equity: '3500',
+    });
+
+    // Insert all records
+    await Promise.all(records.map((record) => PnlTable.create(record)));
+
+    // Get daily records
+    const dailyResults = await PnlTable.findAllDailyPnl(
+      { subaccountId: [defaultSubaccountId] },
+      [],
+      {},
+    );
+
+    // We should get exactly 3 records (one for each day)
+    expect(dailyResults.results.length).toBe(3);
+
+    // The first record should be the latest one from day 3 (00:00)
+    expect(dailyResults.results[0].createdAtHeight).toBe('3500');
+    expect(dailyResults.results[0].createdAt).toBe('2023-01-03T00:00:00.000Z');
+
+    // The second record should be the earliest one from day 2 (00:00)
+    expect(dailyResults.results[1].createdAtHeight).toBe('2000');
+    expect(dailyResults.results[1].createdAt).toBe('2023-01-02T00:00:00.000Z');
+
+    // The third record should be the earliest one from day 1 (00:00)
+    expect(dailyResults.results[2].createdAtHeight).toBe('1000');
+    expect(dailyResults.results[2].createdAt).toBe('2023-01-01T00:00:00.000Z');
+  });
 });

indexer/packages/postgres/src/stores/pnl-table.ts

@@ -150,20 +150,20 @@ async function handleLimitAndPagination(
   let query = baseQuery;
 
   /**
-     * If a query is made using a page number, then the limit property is used as 'page limit'
-     */
+   * If a query is made using a page number, then the limit property is used as 'page limit'
+   */
   if (page !== undefined && limit !== undefined) {
     /**
-         * We make sure that the page number is always >= 1
-         */
+     * We make sure that the page number is always >= 1
+     */
     const currentPage: number = Math.max(1, page);
     const offset: number = (currentPage - 1) * limit;
 
     /**
-         * Ensure sorting is applied to maintain consistent pagination results.
-         * Also a casting of the ts type is required since the infer of the type
-         * obtained from the count is not performed.
-         */
+     * Ensure sorting is applied to maintain consistent pagination results.
+     * Also a casting of the ts type is required since the infer of the type
+     * obtained from the count is not performed.
+     */
     const count: { count?: string } = (await query
       .clone()
       .clearOrder()
@@ -191,3 +191,120 @@ async function handleLimitAndPagination(
     results,
   };
 }
+
+export async function findAllDailyPnl(
+  {
+    limit,
+    subaccountId,
+    createdBeforeOrAtHeight,
+    createdBeforeOrAt,
+    createdOnOrAfterHeight,
+    createdOnOrAfter,
+    page,
+    parentSubaccount,
+  }: PnlQueryConfig,
+  requiredFields: QueryableField[],
+  options: Options = DEFAULT_POSTGRES_OPTIONS,
+): Promise<PaginationFromDatabase<PnlFromDatabase>> {
+  if (parentSubaccount !== undefined && subaccountId !== undefined) {
+    throw new Error('Cannot specify both parentSubaccount and subaccountId');
+  }
+
+  verifyAllRequiredFields(
+    {
+      limit,
+      subaccountId,
+      createdBeforeOrAtHeight,
+      createdBeforeOrAt,
+      createdOnOrAfterHeight,
+      createdOnOrAfter,
+      page,
+      parentSubaccount,
+    } as QueryConfig,
+    requiredFields,
+  );
+
+  let baseQuery: QueryBuilder<PnlModel> = setupBaseQuery<PnlModel>(
+    PnlModel,
+    options,
+  );
+
+  if (subaccountId !== undefined) {
+    baseQuery = baseQuery.whereIn(PnlColumns.subaccountId, subaccountId);
+  } else if (parentSubaccount !== undefined) {
+    baseQuery = baseQuery.whereIn(
+      PnlColumns.subaccountId,
+      getSubaccountQueryForParent(parentSubaccount),
+    );
+  }
+
+  if (createdBeforeOrAtHeight !== undefined) {
+    baseQuery = baseQuery.where(
+      PnlColumns.createdAtHeight,
+      '<=',
+      createdBeforeOrAtHeight,
+    );
+  }
+
+  if (createdBeforeOrAt !== undefined) {
+    baseQuery = baseQuery.where(PnlColumns.createdAt, '<=', createdBeforeOrAt);
+  }
+
+  if (createdOnOrAfterHeight !== undefined) {
+    baseQuery = baseQuery.where(
+      PnlColumns.createdAtHeight,
+      '>=',
+      createdOnOrAfterHeight,
+    );
+  }
+
+  if (createdOnOrAfter !== undefined) {
+    baseQuery = baseQuery.where(PnlColumns.createdAt, '>=', createdOnOrAfter);
+  }
+
+  const knex = PnlModel.knex();
+  // 1. Identify the latest record for each subaccount (with RANK = 1 over entire subaccount)
+  // 2. For all other records, rank them within their day (RANK ordered by time ascending)
+  // 3. Select the latest record and earliest records for each other day
+  const rankQuery = baseQuery.clone()
+    .select('*')
+    .select(
+      knex.raw(`
+      RANK() OVER (
+        PARTITION BY "${PnlColumns.subaccountId}" 
+        ORDER BY "${PnlColumns.createdAtHeight}" DESC
+      ) as latest_rank,
+      DATE_TRUNC('day', "${PnlColumns.createdAt}" AT TIME ZONE 'UTC') as day_date,
+      RANK() OVER (
+        PARTITION BY "${PnlColumns.subaccountId}", DATE_TRUNC('day', "${PnlColumns.createdAt}" AT TIME ZONE 'UTC')
+        ORDER BY "${PnlColumns.createdAt}" ASC
+      ) as earliest_in_day_rank
+    `),
+    );
+
+  // Now select only records that are either:
+  // 1. The very latest for their subaccount (latest_rank = 1), OR
+  // 2. The earliest record for their day (day_rank = 1) but NOT the latest day
+  const finalQuery = PnlModel.query(Transaction.get(options.txId))
+    .with('ranked_pnl', rankQuery)
+    .from(
+      knex.raw(`
+      (
+        SELECT DISTINCT ON ("subaccountId", day_date) *
+        FROM ranked_pnl
+        WHERE 
+          -- Either it's the latest record overall
+          (latest_rank = 1)
+          OR 
+          -- Or it's the earliest record of a day
+          (earliest_in_day_rank = 1)
+        ORDER BY "subaccountId", day_date, latest_rank ASC
+      ) AS unique_daily_records
+    `),
+    )
+    .orderBy(PnlColumns.subaccountId, Ordering.ASC)
+    .orderBy(PnlColumns.createdAtHeight, Ordering.DESC);
+
+  // Apply pagination if needed
+  return handleLimitAndPagination(finalQuery, limit, page);
+}