feat(backend): add GET /policies and GET /policies/:holder/:policy_id endpoints - Closes #40

Author: niffyInsure Dev

backend/jest.config.js

@@ -0,0 +1,12 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/tests"],
+  testMatch: ["**/*.test.ts"],
+  globals: {
+    "ts-jest": {
+      tsconfig: "tsconfig.test.json",
+    },
+  },
+};

backend/src/controllers/policy.controller.ts

@@ -0,0 +1,109 @@
+import { Request, Response, NextFunction } from "express";
+import {
+  getPoliciesList,
+  getPolicySingle,
+  CursorError,
+} from "../services/policy.service";
+import { PolicyFilter } from "../repositories/policy.repository";
+import { DEFAULT_LIMIT, MAX_LIMIT } from "../helpers/pagination";
+
+/**
+ * GET /policies
+ *
+ * Query params:
+ *   status  — "active" | "expired"  (omit for all)
+ *   holder  — Stellar address string
+ *   after   — opaque cursor from previous response
+ *   limit   — integer 1–100 (default 20)
+ */
+export function listPolicies(
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void {
+  try {
+    const filter: PolicyFilter = {};
+
+    const { status, holder, after, limit: limitRaw } = req.query;
+
+    if (status !== undefined) {
+      if (status !== "active" && status !== "expired") {
+        res.status(400).json({
+          error: "invalid_filter",
+          message: `"status" must be "active" or "expired".`,
+        });
+        return;
+      }
+      filter.status = status;
+    }
+
+    if (typeof holder === "string" && holder.length > 0) {
+      filter.holder = holder;
+    }
+
+    let limit = DEFAULT_LIMIT;
+    if (limitRaw !== undefined) {
+      const parsed = parseInt(String(limitRaw), 10);
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        res.status(400).json({
+          error: "invalid_param",
+          message: `"limit" must be a positive integer (max ${MAX_LIMIT}).`,
+        });
+        return;
+      }
+      limit = parsed;
+    }
+
+    const result = getPoliciesList(filter, {
+      after: typeof after === "string" ? after : undefined,
+      limit,
+    });
+
+    res.json(result);
+  } catch (err) {
+    if (err instanceof CursorError) {
+      res.status(400).json({ error: "invalid_cursor", message: (err as Error).message });
+      return;
+    }
+    next(err);
+  }
+}
+
+/**
+ * GET /policies/:holder/:policy_id
+ *
+ * Path params:
+ *   holder    — URL-encoded Stellar address
+ *   policy_id — per-holder u32 integer
+ */
+export function getPolicy(
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void {
+  try {
+    const { holder, policy_id: pidRaw } = req.params;
+
+    const policy_id = parseInt(pidRaw, 10);
+    if (!Number.isInteger(policy_id) || policy_id < 1) {
+      res.status(400).json({
+        error: "invalid_param",
+        message: `"policy_id" must be a positive integer.`,
+      });
+      return;
+    }
+
+    const result = getPolicySingle(decodeURIComponent(holder), policy_id);
+    if (!result) {
+      res.status(404).json({
+        error: "not_found",
+        message: `Policy (holder=${holder}, policy_id=${policy_id}) not found.`,
+      });
+      return;
+    }
+
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+}

backend/src/db/seed.ts

@@ -0,0 +1,80 @@
+/**
+ * Seeds the in-memory store with representative dev data.
+ * Call once at startup in non-production environments.
+ */
+
+import { insertClaim, insertPolicy } from "./store";
+
+export function seedDevData(): void {
+  const p1 = insertPolicy({
+    holder: "GABC1111111111111111111111111111111111111111111111111111",
+    policy_id: 1,
+    policy_type: "Auto",
+    region: "Medium",
+    premium: "5000000",
+    coverage: "500000000",
+    is_active: true,
+    start_ledger: 1000,
+    end_ledger: 9000,
+  });
+
+  const p2 = insertPolicy({
+    holder: "GABC1111111111111111111111111111111111111111111111111111",
+    policy_id: 2,
+    policy_type: "Health",
+    region: "High",
+    premium: "8000000",
+    coverage: "1000000000",
+    is_active: false,
+    start_ledger: 500,
+    end_ledger: 800,
+  });
+
+  const p3 = insertPolicy({
+    holder: "GXYZ9999999999999999999999999999999999999999999999999999",
+    policy_id: 1,
+    policy_type: "Property",
+    region: "Low",
+    premium: "3000000",
+    coverage: "200000000",
+    is_active: true,
+    start_ledger: 2000,
+    end_ledger: 12000,
+  });
+
+  insertClaim({
+    claim_id: 1,
+    policy_id: p2.policy_id,
+    claimant: p2.holder,
+    amount: "100000000",
+    details: "Hospital visit after accident",
+    image_urls: ["ipfs://bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi"],
+    status: "Approved",
+    approve_votes: 5,
+    reject_votes: 1,
+  });
+
+  insertClaim({
+    claim_id: 2,
+    policy_id: p1.policy_id,
+    claimant: p1.holder,
+    amount: "50000000",
+    details: "Rear-end collision repair",
+    image_urls: [],
+    status: "Processing",
+    approve_votes: 2,
+    reject_votes: 0,
+  });
+
+  insertClaim({
+    claim_id: 3,
+    policy_id: p3.policy_id,
+    claimant: p3.holder,
+    amount: "20000000",
+    details: "Storm damage to roof",
+    image_urls: [],
+    status: "Rejected",
+    approve_votes: 1,
+    reject_votes: 4,
+  });
+}

backend/src/db/store.ts

@@ -0,0 +1,110 @@
+/**
+ * In-memory data store with indexed maps for O(1) lookups and
+ * sorted insertion order for stable cursor-based pagination.
+ *
+ * Indexes maintained:
+ *   - byGlobalSeq: Map<global_seq, Policy>  — primary cursor index
+ *   - byHolder:    Map<holder, Policy[]>     — filter by holder
+ *   - byComposite: Map<"holder:policy_id", Policy> — point lookup
+ *
+ * All writes go through `insertPolicy` / `upsertPolicy` to keep indexes
+ * consistent. Concurrent inserts are safe because JS is single-threaded.
+ */
+
+import { Claim, Policy } from "../types/policy";
+
+let _seq = 0;
+
+const byGlobalSeq = new Map<number, Policy>();
+const byHolder = new Map<string, Policy[]>();
+const byComposite = new Map<string, Policy>();
+
+const claims = new Map<number, Claim>();
+/** claim_id → policy composite key, for join without N+1 */
+const claimsByComposite = new Map<string, Claim[]>();
+
+function compositeKey(holder: string, policy_id: number): string {
+  return `${holder}:${policy_id}`;
+}
+
+export function insertPolicy(p: Omit<Policy, "global_seq">): Policy {
+  _seq += 1;
+  const record: Policy = { ...p, global_seq: _seq };
+  const ck = compositeKey(p.holder, p.policy_id);
+
+  byGlobalSeq.set(_seq, record);
+  byComposite.set(ck, record);
+
+  const holderList = byHolder.get(p.holder) ?? [];
+  holderList.push(record);
+  byHolder.set(p.holder, holderList);
+
+  return record;
+}
+
+export function upsertPolicy(p: Omit<Policy, "global_seq">): Policy {
+  const ck = compositeKey(p.holder, p.policy_id);
+  const existing = byComposite.get(ck);
+  if (existing) {
+    // Update in-place, preserving global_seq for stable pagination
+    Object.assign(existing, p);
+    return existing;
+  }
+  return insertPolicy(p);
+}
+
+export function getPolicyByComposite(
+  holder: string,
+  policy_id: number
+): Policy | undefined {
+  return byComposite.get(compositeKey(holder, policy_id));
+}
+
+export function getPolicyBySeq(seq: number): Policy | undefined {
+  return byGlobalSeq.get(seq);
+}
+
+/** Returns all policies in ascending global_seq order. */
+export function allPoliciesOrdered(): Policy[] {
+  return Array.from(byGlobalSeq.values());
+}
+
+export function getPoliciesByHolder(holder: string): Policy[] {
+  return byHolder.get(holder) ?? [];
+}
+
+// ── Claims ───────────────────────────────────────────────────────────────────
+
+export function insertClaim(c: Claim): void {
+  claims.set(c.claim_id, c);
+  const ck = compositeKey(c.claimant, c.policy_id);
+  const list = claimsByComposite.get(ck) ?? [];
+  list.push(c);
+  claimsByComposite.set(ck, list);
+}
+
+export function getClaimsByPolicy(holder: string, policy_id: number): Claim[] {
+  return claimsByComposite.get(compositeKey(holder, policy_id)) ?? [];
+}
+
+/** Bulk-fetch claims for a list of (holder, policy_id) pairs — avoids N+1. */
+export function getClaimsBatch(
+  keys: Array<{ holder: string; policy_id: number }>
+): Map<string, Claim[]> {
+  const result = new Map<string, Claim[]>();
+  for (const { holder, policy_id } of keys) {
+    const ck = compositeKey(holder, policy_id);
+    result.set(ck, claimsByComposite.get(ck) ?? []);
+  }
+  return result;
+}
+
+/** Reset store — used in tests only. */
+export function _resetStore(): void {
+  _seq = 0;
+  byGlobalSeq.clear();
+  byHolder.clear();
+  byComposite.clear();
+  claims.clear();
+  claimsByComposite.clear();
+}