fix: Bootstrap w/ API for sending payment

package.json

@@ -1,27 +1,28 @@
 {
-  "name": "debug-api",
-  "module": "index.ts",
-  "type": "module",
-  "devDependencies": {
-    "@biomejs/biome": "^1.8.3",
-    "@types/bun": "latest",
-    "@types/react": "18.3.4",
-    "next": "^14.2.5",
-    "redaxios": "^0.5.1"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
+  "name": "fake-algora",
+  "version": "0.1.0",
+  "description": "A fake/mock Algora API server for testing bounty payment flows",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "winterspec": "^0.0.86",
-    "zod": "^3.23.8",
-    "zustand": "^4.5.5",
-    "zustand-hoist": "^2.0.1"
+    "express": "^4.18.2",
+    "zod": "^3.22.4",
+    "uuid": "^9.0.0"
   },
-  "scripts": {
-    "start": "bun run dev",
-    "dev": "winterspec dev",
-    "build": "winterspec bundle -o dist/bundle.js",
-    "next:dev": "next dev"
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.5",
+    "@types/uuid": "^9.0.7",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.2",
+    "supertest": "^6.3.4",
+    "@types/supertest": "^6.0.2"
   }
 }

src/app.ts

@@ -0,0 +1,29 @@
+import express from "express";
+import bountiesRouter from "./routes/bounties";
+import paymentsRouter from "./routes/payments";
+
+const app = express();
+
+app.use(express.json());
+
+// ---------------------------------------------------------------------------
+// Health check
+// ---------------------------------------------------------------------------
+app.get("/health", (_req, res) => {
+  res.json({ status: "ok", service: "fake-algora" });
+});
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+app.use("/bounties", bountiesRouter);
+app.use("/payments", paymentsRouter);
+
+// ---------------------------------------------------------------------------
+// 404 fallthrough
+// ---------------------------------------------------------------------------
+app.use((_req, res) => {
+  res.status(404).json({ error: "Not found" });
+});
+
+export default app;

src/index.ts

@@ -0,0 +1,14 @@
+import app from "./app";
+
+const PORT = process.env.PORT ?? 3000;
+
+app.listen(PORT, () => {
+  console.log(`🚀 fake-algora running on http://localhost:${PORT}`);
+  console.log(`   GET  /health`);
+  console.log(`   GET  /bounties`);
+  console.log(`   POST /bounties`);
+  console.log(`   GET  /bounties/:id`);
+  console.log(`   GET  /payments`);
+  console.log(`   GET  /payments/:id`);
+  console.log(`   POST /payments/send`);
+});

src/routes/bounties.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import request from "supertest";
+import app from "../app";
+import { store } from "../store";
+
+beforeEach(() => {
+  store.reset();
+});
+
+describe("GET /bounties", () => {
+  it("returns an empty list when no bounties exist", async () => {
+    const res = await request(app).get("/bounties");
+    expect(res.status).toBe(200);
+    expect(res.body.bounties).toEqual([]);
+  });
+
+  it("returns seeded bounties when store is populated", async () => {
+    store.createBounty({
+      issue_number: 1,
+      repo: "tscircuit/fake-algora",
+      amount_usd: 10,
+      currency: "USD",
+      status: "open",
+      recipient_username: null,
+    });
+    const res = await request(app).get("/bounties");
+    expect(res.status).toBe(200);
+    expect(res.body.bounties).toHaveLength(1);
+  });
+});
+
+describe("POST /bounties", () => {
+  it("creates a bounty with valid body", async () => {
+    const res = await request(app).post("/bounties").send({
+      issue_number: 5,
+      repo: "tscircuit/core",
+      amount_usd: 25,
+    });
+    expect(res.status).toBe(201);
+    expect(res.body.bounty.amount_usd).toBe(25);
+    expect(res.body.bounty.status).toBe("open");
+  });
+
+  it("returns 400 for invalid body", async () => {
+    const res = await request(app).post("/bounties").send({});
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/invalid/i);
+  });
+});
+
+describe("GET /bounties/:id", () => {
+  it("returns 404 for unknown id", async () => {
+    const res = await request(app).get("/bounties/nonexistent");
+    expect(res.status).toBe(404);
+  });
+
+  it("returns the bounty for a known id", async () => {
+    const bounty = store.createBounty({
+      issue_number: 10,
+      repo: "tscircuit/fake-algora",
+      amount_usd: 100,
+      currency: "USD",
+      status: "open",
+      recipient_username: null,
+    });
+    const res = await request(app).get(`/bounties/${bounty.id}`);
+    expect(res.status).toBe(200);
+    expect(res.body.bounty.id).toBe(bounty.id);
+  });
+});

src/routes/bounties.ts

@@ -0,0 +1,44 @@
+import { Router } from "express";
+import { z } from "zod";
+import { store } from "../store";
+
+const router = Router();
+
+// GET /bounties — list all bounties
+router.get("/", (_req, res) => {
+  res.json({ bounties: store.listBounties() });
+});
+
+// GET /bounties/:id — get a single bounty
+router.get("/:id", (req, res) => {
+  const bounty = store.getBounty(req.params.id);
+  if (!bounty) {
+    return res.status(404).json({ error: "Bounty not found" });
+  }
+  res.json({ bounty });
+});
+
+// POST /bounties — create a new bounty
+const CreateBountySchema = z.object({
+  issue_number: z.number().int().positive(),
+  repo: z.string().min(1),
+  amount_usd: z.number().positive(),
+  currency: z.string().default("USD"),
+  recipient_username: z.string().nullable().default(null),
+  status: z
+    .enum(["open", "in_progress", "completed", "payment_pending", "paid"])
+    .default("open"),
+});
+
+router.post("/", (req, res) => {
+  const result = CreateBountySchema.safeParse(req.body);
+  if (!result.success) {
+    return res
+      .status(400)
+      .json({ error: "Invalid request body", details: result.error.format() });
+  }
+  const bounty = store.createBounty(result.data);
+  res.status(201).json({ bounty });
+});
+
+export default router;

src/routes/payments.ts

@@ -0,0 +1,87 @@
+import { Router } from "express";
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+import { store } from "../store";
+
+const router = Router();
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+const SendPaymentSchema = z.object({
+  bounty_id: z.string().min(1, "bounty_id is required"),
+  recipient_username: z.string().min(1, "recipient_username is required"),
+  amount_usd: z.number().positive("amount_usd must be positive"),
+  currency: z.string().default("USD"),
+});
+
+// ---------------------------------------------------------------------------
+// GET /payments — list all payments
+// ---------------------------------------------------------------------------
+router.get("/", (_req, res) => {
+  res.json({ payments: store.listPayments() });
+});
+
+// ---------------------------------------------------------------------------
+// GET /payments/:id — get a single payment
+// ---------------------------------------------------------------------------
+router.get("/:id", (req, res) => {
+  const payment = store.getPayment(req.params.id);
+  if (!payment) {
+    return res.status(404).json({ error: "Payment not found" });
+  }
+  res.json({ payment });
+});
+
+// ---------------------------------------------------------------------------
+// POST /payments/send — send a payment for a bounty
+// ---------------------------------------------------------------------------
+router.post("/send", (req, res) => {
+  const result = SendPaymentSchema.safeParse(req.body);
+  if (!result.success) {
+    return res
+      .status(400)
+      .json({ error: "Invalid request body", details: result.error.format() });
+  }
+
+  const { bounty_id, recipient_username, amount_usd, currency } = result.data;
+
+  // Validate the bounty exists
+  const bounty = store.getBounty(bounty_id);
+  if (!bounty) {
+    return res
+      .status(404)
+      .json({ error: "Bounty not found", details: `No bounty with id "${bounty_id}"` });
+  }
+
+  // Guard: don't allow double-payment
+  if (bounty.status === "paid") {
+    return res.status(409).json({
+      error: "Bounty already paid",
+      details: `Bounty "${bounty_id}" has already been marked as paid`,
+    });
+  }
+
+  // Create payment record (simulate async processing → immediately complete)
+  const payment = store.createPayment({
+    bounty_id,
+    recipient_username,
+    amount_usd,
+    currency,
+    status: "completed",
+    transaction_id: `txn_${uuidv4().replace(/-/g, "").slice(0, 16)}`,
+  });
+
+  // Update bounty status
+  store.updateBounty(bounty_id, {
+    status: "paid",
+    recipient_username,
+  });
+
+  res.status(201).json({
+    payment,
+    message: `Payment of $${amount_usd} ${currency} sent to @${recipient_username} for bounty ${bounty_id}`,
+  });
+});
+
+export default router;