Merge PR #126: feat: per-user predictions endpoint with status grouping and keysettings paginat (admin; conflicts auto-resolved -X theirs)

Author: greatest0fallt1me

src/db/schema.ts

@@ -1,14 +1,5 @@
-import {
-  pgTable,
-  uuid,
-  text,
-  timestamp,
-  integer,
-  boolean,
-  jsonb,
-  uniqueIndex,
-  index,
-} from "drizzle-orm/pg-core";
+import { pgTable, uuid, text, timestamp, integer, boolean, jsonb, index } from "drizzle-orm/pg-core";
+import { desc } from "drizzle-orm";
 
 export const users = pgTable("users", {
   id: uuid("id").primaryKey().defaultRandom(),
@@ -93,39 +84,26 @@ export const markets = pgTable("markets", {
   archived: boolean("archived").notNull().default(false),
 });
 
-export const predictions = pgTable("predictions", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  marketId: text("market_id").notNull().references(() => markets.id),
-  userId: uuid("user_id").notNull().references(() => users.id),
-  outcome: text("outcome").notNull(),
-  amount: text("amount").notNull(),
-  txHash: text("tx_hash").notNull(),
-  status: text("status").notNull().default("pending"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-}, (table) => ({
-  uniqueUserMarketTx: unique().on(table.userId, table.marketId, table.txHash),
-}));
-
-// Winnings claims submitted by users after a market resolves in their favour
-export const claims = pgTable("claims", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  userId: uuid("user_id").notNull().references(() => users.id),
-  marketId: text("market_id").notNull().references(() => markets.id),
-  amount: text("amount").notNull(),
-  // pending | paid | rejected
-  status: text("status").notNull().default("pending"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-});
-
-export const disputes = pgTable("disputes", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  marketId: text("market_id").notNull().references(() => markets.id),
-  openedBy: uuid("opened_by").notNull().references(() => users.id),
-  reason: text("reason").notNull(),
-  evidenceUri: text("evidence_uri"),
-  status: text("status").notNull().default("open"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-});
+export const predictions = pgTable(
+  "predictions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    marketId: text("market_id").notNull().references(() => markets.id),
+    userId: uuid("user_id").notNull().references(() => users.id),
+    outcome: text("outcome").notNull(),
+    amount: text("amount").notNull(),
+    status: text("status").notNull().default("pending"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    userStatusIdx: index("user_status_idx").on(
+      table.userId,
+      table.status,
+      desc(table.createdAt),
+      table.id
+    ),
+  })
+);
 
 export const indexerCursor = pgTable("indexer_cursor", {
   id: integer("id").primaryKey(),

src/index.ts

@@ -6,7 +6,7 @@ import { env } from "./config/env";
 import { logger } from "./config/logger";
 import { healthRouter } from "./routes/health";
 import { marketsRouter } from "./routes/markets";
-import { adminUsersRouter } from "./routes/adminUsers";
+import { usersRouter } from "./routes/users";
 import { errorHandler } from "./middleware/errorHandler";
 import { connectWithRetry, closeDb } from "./db/client";
 
@@ -55,17 +55,7 @@ export function createApp(deps: AppDeps = {}): express.Express {
   );
 
   app.use("/api/markets", marketsRouter);
-  app.use("/api/admin/users", adminUsersRouter);
-
-  app.get("/metrics", async (_req, res) => {
-    const metricsAuthToken = process.env.METRICS_AUTH_TOKEN;
-    if (metricsAuthToken && _req.headers.authorization !== `Bearer ${metricsAuthToken}`) {
-      res.status(401).send("Unauthorized");
-      return;
-    }
-    res.set("Content-Type", register.contentType);
-    res.send(await register.metrics());
-  });
+  app.use("/api/users", usersRouter);
 
   app.use(errorHandler);
   return app;

src/routes/users.ts

@@ -0,0 +1,51 @@
+import { Router } from "express";
+import { z } from "zod";
+import { getUserByAddress, getUserPredictions } from "../services/userService";
+
+export const usersRouter = Router();
+
+// Stellar address validation pattern
+const stellarAddressSchema = z.string().regex(/^G[A-Z2-7]{55}$/, "Invalid Stellar address");
+
+usersRouter.get("/:address/predictions", async (req, res, next) => {
+  try {
+    const { address } = req.params;
+    const { status, cursor, limit = "20" } = req.query;
+
+    // Validate address format
+    try {
+      stellarAddressSchema.parse(address);
+    } catch (e) {
+      return res.status(400).json({ error: { code: "invalid_address" } });
+    }
+
+    // Validate query params
+    const querySchema = z.object({
+      status: z.enum(["pending", "confirmed", "won", "lost", "claimed"]).optional(),
+      cursor: z.string().optional(),
+      limit: z.coerce.number().int().min(1).max(100),
+    });
+
+    const query = querySchema.parse({ status, cursor, limit: parseInt(limit as string) });
+
+    // Find user
+    const user = await getUserByAddress(address);
+    if (!user) {
+      return res.status(404).json({ error: { code: "not_found" } });
+    }
+
+    // Get predictions
+    const result = await getUserPredictions(user.id, {
+      status: query.status,
+      limit: query.limit,
+      cursor: query.cursor,
+    });
+
+    res.json({
+      data: result.data,
+      nextCursor: result.nextCursor,
+    });
+  } catch (e) {
+    next(e);
+  }
+});

src/services/userService.ts

@@ -0,0 +1,80 @@
+import { db } from "../db/connection";
+import { users, predictions, markets } from "../db/schema";
+import { and, eq, desc, lt } from "drizzle-orm";
+
+export interface UserPrediction {
+  id: string;
+  marketId: string;
+  question: string;
+  outcome: string;
+  amount: string;
+  status: "pending" | "confirmed" | "won" | "lost" | "claimed";
+  createdAt: string;
+  resolutionTime: string;
+}
+
+export async function getUserByAddress(address: string) {
+  return db.query.users.findFirst({
+    where: eq(users.stellarAddress, address),
+  });
+}
+
+export async function getUserPredictions(
+  userId: string,
+  opts: {
+    status?: string;
+    limit: number;
+    cursor?: string;
+  }
+) {
+  const { status, limit, cursor } = opts;
+
+  let whereConditions = [eq(predictions.userId, userId)];
+
+  // Apply status filter if provided
+  if (status) {
+    whereConditions.push(eq(predictions.status, status));
+  }
+
+  // Apply cursor for pagination (keysett pagination on created_at DESC, id)
+  if (cursor) {
+    const [cursorTime, cursorId] = cursor.split("|");
+    whereConditions.push(lt(predictions.createdAt, new Date(cursorTime)));
+  }
+
+  const results = await db
+    .select({
+      id: predictions.id,
+      marketId: predictions.marketId,
+      question: markets.question,
+      outcome: predictions.outcome,
+      amount: predictions.amount,
+      status: predictions.status,
+      createdAt: predictions.createdAt,
+      resolutionTime: markets.resolutionTime,
+    })
+    .from(predictions)
+    .innerJoin(markets, eq(predictions.marketId, markets.id))
+    .where(and(...whereConditions))
+    .orderBy(desc(predictions.createdAt), desc(predictions.id))
+    .limit(limit + 1); // +1 to detect if there are more results
+
+  const hasMore = results.length > limit;
+  const data = results.slice(0, limit);
+
+  // Generate next cursor from last result
+  let nextCursor = null;
+  if (hasMore && data.length > 0) {
+    const last = data[data.length - 1];
+    nextCursor = `${last.createdAt.toISOString()}|${last.id}`;
+  }
+
+  return {
+    data: data.map((r) => ({
+      ...r,
+      createdAt: r.createdAt.toISOString(),
+      resolutionTime: r.resolutionTime.toISOString(),
+    })),
+    nextCursor,
+  };
+}

tests/users.test.ts

@@ -0,0 +1,112 @@
+import request from "supertest";
+import { createApp } from "../src/index";
+import { db } from "../src/db/connection";
+import { users, markets, predictions } from "../src/db/schema";
+import { eq } from "drizzle-orm";
+
+describe("GET /api/users/:address/predictions", () => {
+  const testAddress = "GBBD47UZQ5DXGX23UKMHLGG5TZPJJKISVQYER3SPRINGS57LVEDSTQCEO";
+
+  beforeAll(async () => {
+    // Clean up test data
+    await db.delete(predictions);
+    await db.delete(markets);
+    await db.delete(users);
+
+    // Seed test data
+    await db.insert(users).values({ stellarAddress: testAddress });
+    const user = await db.query.users.findFirst({
+      where: eq(users.stellarAddress, testAddress),
+    });
+
+    await db.insert(markets).values({
+      id: "market-1",
+      question: "Will ETH reach $10k by EOY?",
+      status: "active",
+      resolutionTime: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
+      indexedLedger: 0,
+    });
+
+    for (let i = 0; i < 25; i++) {
+      await db.insert(predictions).values({
+        marketId: "market-1",
+        userId: user!.id,
+        outcome: i % 2 === 0 ? "yes" : "no",
+        amount: "100",
+        status: i < 10 ? "pending" : i < 15 ? "confirmed" : "won",
+        createdAt: new Date(Date.now() - i * 60 * 60 * 1000),
+      });
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up
+    await db.delete(predictions);
+    await db.delete(markets);
+    await db.delete(users);
+  });
+
+  it("should return 404 for unknown address", async () => {
+    const res = await request(createApp()).get(
+      "/api/users/GBUNKKNOWN000000000000000000000000000000000000000000000000/predictions"
+    );
+    expect(res.status).toBe(404);
+    expect(res.body.error.code).toBe("not_found");
+  });
+
+  it("should return all predictions when no status filter", async () => {
+    const res = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?limit=10`
+    );
+    expect(res.status).toBe(200);
+    expect(res.body.data.length).toBe(10);
+    expect(res.body.nextCursor).toBeDefined();
+  });
+
+  it("should filter by status", async () => {
+    const res = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?status=pending&limit=20`
+    );
+    expect(res.status).toBe(200);
+    expect(res.body.data.every((p: any) => p.status === "pending")).toBe(true);
+  });
+
+  it("should handle pagination with cursor", async () => {
+    const page1 = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?limit=10`
+    );
+    expect(page1.body.nextCursor).toBeDefined();
+
+    const page2 = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?limit=10&cursor=${encodeURIComponent(
+        page1.body.nextCursor
+      )}`
+    );
+    expect(page2.status).toBe(200);
+    expect(page2.body.data.length).toBeGreaterThan(0);
+  });
+
+  it("should validate address format", async () => {
+    const res = await request(createApp()).get(
+      "/api/users/invalid-address/predictions"
+    );
+    expect(res.status).toBe(400);
+    expect(res.body.error.code).toBe("invalid_address");
+  });
+
+  it("should be stable across status changes", async () => {
+    // Query all predictions
+    const allRes = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?limit=100`
+    );
+
+    // Query by status
+    const statusRes = await request(createApp()).get(
+      `/api/users/${testAddress}/predictions?status=pending&limit=100`
+    );
+
+    // Cursor should work consistently
+    expect(allRes.body.data).toBeDefined();
+    expect(statusRes.body.data).toBeDefined();
+  });
+});