✨ server: add maturity check and worker

Author: aguxez

.changeset/dull-candies-cheer.md

@@ -0,0 +1,5 @@
+---
+"@exactly/server": patch
+---
+
+✨ add maturity check and worker

server/index.ts

@@ -21,6 +21,7 @@ import persona from "./hooks/persona";
 import androidFingerprints from "./utils/android/fingerprints";
 import appOrigin from "./utils/appOrigin";
 import { closeQueue as closeAccountQueue } from "./utils/createCredential";
+import { closeQueue as closeMaturityQueue, scheduleMaturityChecks } from "./utils/maturity";
 import { close as closeRedis } from "./utils/redis";
 import { closeAndFlush as closeSegment } from "./utils/segment";
 
@@ -323,8 +324,15 @@ const server = serve(app);
 export async function close() {
   return new Promise((resolve, reject) => {
     server.close((error) => {
-      Promise.allSettled([closeSentry(), closeRedis(), closeSegment(), database.$client.end(), closeAccountQueue()])
-        .then((results) => {
+      Promise.allSettled([
+        closeSentry(),
+        closeSegment(),
+        database.$client.end(),
+        closeMaturityQueue(),
+        closeAccountQueue(),
+      ])
+        .then(async (results) => {
+          await closeRedis();
           if (error) reject(error);
           else if (results.some((result) => result.status === "rejected")) reject(new Error("closing services failed"));
           else resolve(null);
@@ -335,6 +343,10 @@ export async function close() {
 }
 
 if (!process.env.VITEST) {
+  scheduleMaturityChecks().catch((error: unknown) => {
+    captureException(error, { level: "error", tags: { unhandled: true } });
+  });
+
   ["SIGINT", "SIGTERM"].map((code) => {
     process.on(code, () => {
       close()

server/test/utils/maturity.test.ts

@@ -0,0 +1,293 @@
+import "../mocks/onesignal";
+import "../mocks/sentry";
+
+import { Redis } from "ioredis";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { previewerAbi, previewerAddress } from "@exactly/common/generated/chain";
+import { MATURITY_INTERVAL } from "@exactly/lib";
+
+import { closeQueue, processor, queue, scheduleMaturityChecks } from "../../utils/maturity";
+import * as onesignal from "../../utils/onesignal";
+import { close as closeRedis } from "../../utils/redis";
+
+import type { CheckDebtsData } from "../../utils/maturity";
+import type { Job } from "bullmq";
+
+const mocks = vi.hoisted(() => ({
+  select: vi.fn(),
+  readContract: vi.fn(),
+}));
+
+vi.mock("../../database", () => ({
+  default: { select: mocks.select },
+  credentials: { account: "account" },
+}));
+
+vi.mock("../../utils/publicClient", () => ({
+  default: { readContract: mocks.readContract },
+}));
+
+function mockAccounts(accounts: { account: string }[]) {
+  const offsetMock = vi.fn().mockResolvedValueOnce(accounts).mockResolvedValueOnce([]);
+  const limitMock = vi.fn().mockReturnValue({ offset: offsetMock });
+  const orderByMock = vi.fn().mockReturnValue({ limit: limitMock });
+  const fromMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
+  mocks.select.mockReturnValue({ from: fromMock });
+}
+
+function mockExactly(
+  result: { fixedBorrowPositions: { maturity: bigint; position: { fee: bigint; principal: bigint } }[] }[],
+) {
+  mocks.readContract.mockResolvedValue(result);
+}
+
+let testRedis: Redis;
+
+describe("worker", () => {
+  const sendPushNotification = vi.spyOn(onesignal, "sendPushNotification");
+
+  beforeAll(() => {
+    if (!process.env.REDIS_URL) throw new Error("missing REDIS_URL");
+    testRedis = new Redis(process.env.REDIS_URL);
+  });
+
+  afterAll(async () => {
+    await closeQueue();
+    await closeRedis();
+    await testRedis.quit();
+  });
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    await testRedis.flushdb();
+  });
+
+  it("schedules maturity checks", async () => {
+    await scheduleMaturityChecks();
+    const jobs = await queue.getJobs(["delayed", "waiting"]);
+    expect(jobs).toHaveLength(2);
+    expect(jobs.map((index) => (index.data as CheckDebtsData).window).toSorted()).toStrictEqual(["1h", "24h"]);
+  });
+
+  it("processes check-debts job with debt in single market", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+    const window = "24h";
+
+    mockAccounts([{ account }]);
+    mockExactly([{ fixedBorrowPositions: [{ maturity: BigInt(maturity), position: { principal: 100n, fee: 0n } }] }]);
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    expect(mocks.readContract).toHaveBeenCalledWith({
+      address: previewerAddress,
+      abi: previewerAbi,
+      functionName: "exactly",
+      args: [account],
+    });
+    const key = `notification:sent:${account}:${String(maturity)}:${window}`;
+    const value = await testRedis.get(key);
+    expect(value).not.toBeNull();
+    const ttl = await testRedis.ttl(key);
+    expect(ttl).toBeGreaterThan(0);
+    expect(ttl).toBeLessThanOrEqual(86_400);
+    expect(sendPushNotification).toHaveBeenCalledWith({
+      userId: account,
+      headings: { en: "Debt Maturity Alert" },
+      contents: { en: "Your debt is due in 24 hours. Repay now to avoid liquidation." },
+    });
+  });
+
+  it("handles duplicate notification", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+    const window = "24h";
+
+    mockAccounts([{ account }]);
+    await testRedis.set(`notification:sent:${account}:${String(maturity)}:${window}`, String(Date.now()), "EX", 86_400);
+
+    mockExactly([{ fixedBorrowPositions: [{ maturity: BigInt(maturity), position: { principal: 100n, fee: 0n } }] }]);
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    expect(sendPushNotification).not.toHaveBeenCalled();
+  });
+
+  it("handles position with principal = 0", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+
+    mockAccounts([{ account }]);
+    mockExactly([{ fixedBorrowPositions: [{ maturity: BigInt(maturity), position: { principal: 0n, fee: 0n } }] }]);
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window: "24h" },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    const keys = await testRedis.keys("notification:sent:*");
+    expect(keys).toHaveLength(0);
+    expect(sendPushNotification).not.toHaveBeenCalled();
+  });
+
+  it("handles account with no debt in any market", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+
+    mockAccounts([{ account }]);
+    mockExactly([{ fixedBorrowPositions: [] }, { fixedBorrowPositions: [] }]);
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window: "24h" },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    const keys = await testRedis.keys("notification:sent:*");
+    expect(keys).toHaveLength(0);
+    expect(sendPushNotification).not.toHaveBeenCalled();
+  });
+
+  it("detects debt across any market", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+    const window = "24h";
+
+    mockAccounts([{ account }]);
+    mockExactly([
+      { fixedBorrowPositions: [] },
+      { fixedBorrowPositions: [] },
+      { fixedBorrowPositions: [{ maturity: BigInt(maturity), position: { principal: 50n, fee: 0n } }] },
+    ]);
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    const key = `notification:sent:${account}:${String(maturity)}:${window}`;
+    const value = await testRedis.get(key);
+    expect(value).not.toBeNull();
+    expect(sendPushNotification).toHaveBeenCalledWith({
+      userId: account,
+      headings: { en: "Debt Maturity Alert" },
+      contents: { en: "Your debt is due in 24 hours. Repay now to avoid liquidation." },
+    });
+  });
+
+  it("handles exactly() call failure", async () => {
+    const { captureException } = await import("@sentry/node");
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+
+    mockAccounts([{ account }]);
+    mocks.readContract.mockRejectedValue(new Error("rpc error"));
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window: "24h" },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    expect(captureException).toHaveBeenCalledWith(expect.any(Error), { extra: { account } });
+    const keys = await testRedis.keys("notification:sent:*");
+    expect(keys).toHaveLength(0);
+    expect(sendPushNotification).not.toHaveBeenCalled();
+  });
+
+  it("does not set dedupe key when push notification fails", async () => {
+    const account = "0x1234567890123456789012345678901234567890";
+    const maturity = 1_234_567_890;
+    const window = "24h";
+    const { captureException } = await import("@sentry/node");
+
+    mockAccounts([{ account }]);
+    mockExactly([{ fixedBorrowPositions: [{ maturity: BigInt(maturity), position: { principal: 100n, fee: 0n } }] }]);
+    sendPushNotification.mockRejectedValueOnce(new Error("onesignal error"));
+
+    await processor({
+      name: "check-debts",
+      data: { maturity, window },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    expect(sendPushNotification).toHaveBeenCalledOnce();
+    const key = `notification:sent:${account}:${String(maturity)}:${window}`;
+    const value = await testRedis.get(key);
+    expect(value).toBeNull();
+    expect(captureException).toHaveBeenCalledWith(expect.any(Error), { level: "error" });
+  });
+
+  it("skips stale window jobs on schedule", async () => {
+    const now = Math.floor(Date.now() / 1000);
+    const nextMaturity = now - (now % MATURITY_INTERVAL) + MATURITY_INTERVAL;
+    vi.spyOn(Date, "now").mockReturnValue((nextMaturity + 1) * 1000);
+    try {
+      await scheduleMaturityChecks(nextMaturity - MATURITY_INTERVAL);
+      const jobs = await queue.getJobs(["delayed", "waiting"]);
+      const maturityJobs = jobs.filter((index) => (index.data as CheckDebtsData).maturity === nextMaturity);
+      expect(maturityJobs).toHaveLength(0);
+    } finally {
+      vi.mocked(Date.now).mockRestore();
+    }
+  });
+
+  it("does not fail job when scheduleMaturityChecks throws in finally", async () => {
+    const { captureException } = await import("@sentry/node");
+    const now = Math.floor(Date.now() / 1000);
+    const jobMaturity = now - (now % MATURITY_INTERVAL) + MATURITY_INTERVAL;
+
+    const offsetMock = vi.fn().mockResolvedValueOnce([]);
+    const limitMock = vi.fn().mockReturnValue({ offset: offsetMock });
+    const orderByMock = vi.fn().mockReturnValue({ limit: limitMock });
+    const fromMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
+    mocks.select.mockReturnValue({ from: fromMock });
+
+    const addSpy = vi.spyOn(queue, "add").mockRejectedValue(new Error("redis down"));
+
+    await expect(
+      processor({
+        name: "check-debts",
+        data: { maturity: jobMaturity, window: "1h" },
+      } as unknown as Job<CheckDebtsData, unknown>),
+    ).resolves.not.toThrow();
+
+    expect(captureException).toHaveBeenCalledWith(expect.any(Error), { level: "fatal" });
+    addSpy.mockRestore();
+  });
+
+  it("should throw an error for unknown job names", async () => {
+    const job = { name: "unknown", data: {} } as unknown as Job<CheckDebtsData>;
+    await expect(processor(job)).rejects.toThrow("Unknown job name: unknown");
+  });
+
+  it("reschedules on 1h window", async () => {
+    const now = Math.floor(Date.now() / 1000);
+    const jobMaturity = now - (now % MATURITY_INTERVAL) + MATURITY_INTERVAL;
+
+    const offsetMock = vi.fn().mockResolvedValueOnce([]);
+    const limitMock = vi.fn().mockReturnValue({ offset: offsetMock });
+    const orderByMock = vi.fn().mockReturnValue({ limit: limitMock });
+    const fromMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
+    mocks.select.mockReturnValue({ from: fromMock });
+
+    await processor({
+      name: "check-debts",
+      data: { maturity: jobMaturity, window: "1h" },
+    } as unknown as Job<CheckDebtsData, unknown>);
+
+    const expectedNextMaturity = jobMaturity + MATURITY_INTERVAL;
+    const jobs = await queue.getJobs(["delayed", "waiting"]);
+    expect(jobs).toHaveLength(2);
+    const windows = jobs.map((index) => {
+      const data = index.data as CheckDebtsData;
+      return { maturity: data.maturity, window: data.window };
+    });
+    expect(windows).toContainEqual({ maturity: expectedNextMaturity, window: "24h" });
+    expect(windows).toContainEqual({ maturity: expectedNextMaturity, window: "1h" });
+  });
+});