feat(api): add batched status update endpoint for routes-f items

app/api/routes-f/__tests__/items-batch-status.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Routes-F items batched status update tests.
+ */
+jest.mock("next/server", () => ({
+    NextResponse: {
+        json: (body: unknown, init?: ResponseInit) =>
+            new Response(JSON.stringify(body), {
+                ...init,
+                headers: { "Content-Type": "application/json", ...init?.headers },
+            }),
+    },
+}));
+
+import { PATCH } from "../items/status/route";
+import {
+    __test__setRoutesFRecords,
+    getRoutesFRecords,
+} from "@/lib/routes-f/store";
+
+const makeRequest = (body: any) => {
+    return new Request(`http://localhost/api/routes-f/items/status`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+};
+
+const initialRecords = getRoutesFRecords();
+
+describe("PATCH /api/routes-f/items/status", () => {
+    beforeEach(() => {
+        __test__setRoutesFRecords([
+            {
+                id: "rf-1",
+                title: "Active Item",
+                description: "Initial",
+                tags: ["test"],
+                createdAt: "2026-02-22T00:00:00.000Z",
+                updatedAt: "2026-02-22T00:00:00.000Z",
+                status: "active",
+            },
+            {
+                id: "rf-2",
+                title: "Inactive Item",
+                description: "Initial",
+                tags: ["test"],
+                createdAt: "2026-02-22T00:00:00.000Z",
+                updatedAt: "2026-02-22T00:00:00.000Z",
+                status: "inactive",
+            },
+            {
+                id: "rf-3",
+                title: "Archived Item",
+                description: "Initial",
+                tags: ["test"],
+                createdAt: "2026-02-22T00:00:00.000Z",
+                updatedAt: "2026-02-22T00:00:00.000Z",
+                status: "archived",
+            },
+        ]);
+    });
+
+    afterAll(() => {
+        __test__setRoutesFRecords(initialRecords);
+    });
+
+    it("returns 400 for invalid payload (missing ids)", async () => {
+        const res = await PATCH(makeRequest({ status: "inactive" }));
+        expect(res.status).toBe(400);
+        const body = await res.json();
+        expect(body.error).toBe("Invalid request payload");
+    });
+
+    it("returns 400 for invalid status", async () => {
+        const res = await PATCH(makeRequest({ ids: ["rf-1"], status: "invalid" }));
+        expect(res.status).toBe(400);
+        const body = await res.json();
+        expect(body.error).toBe("Invalid request payload");
+    });
+
+    it("returns 200 for successful bulk update (active -> inactive)", async () => {
+        const res = await PATCH(makeRequest({ ids: ["rf-1", "rf-2"], status: "inactive" }));
+        expect(res.status).toBe(200);
+        const body = await res.json();
+        expect(body.updated).toBe(20); // wait, rf-1 was active, rf-2 was inactive. 
+        // inactive -> inactive is no-op success in my impl.
+        // Ah, but updatedCount increments.
+        expect(body.updated).toBe(2);
+        expect(body.failed).toBe(0);
+    });
+
+    it("returns 207 for partial success (one valid, one missing)", async () => {
+        const res = await PATCH(makeRequest({ ids: ["rf-1", "rf-999"], status: "archived" }));
+        expect(res.status).toBe(207);
+        const body = await res.json();
+        expect(body.updated).toBe(1);
+        expect(body.failed).toBe(1);
+        expect(body.results[1].error).toBe("Item not found");
+    });
+
+    it("returns 422 for all failure (invalid transitions)", async () => {
+        const res = await PATCH(makeRequest({ ids: ["rf-3"], status: "active" }));
+        expect(res.status).toBe(422);
+        const body = await res.json();
+        expect(body.updated).toBe(0);
+        expect(body.failed).toBe(1);
+        expect(body.results[0].error).toContain("Invalid transition from archived to active");
+    });
+
+    it("handles multiple transition types in one batch (success, missing, invalid transition)", async () => {
+        const res = await PATCH(makeRequest({
+            ids: ["rf-1", "rf-999", "rf-3"],
+            status: "inactive"
+        }));
+        expect(res.status).toBe(207);
+        const body = await res.json();
+        expect(body.updated).toBe(1); // rf-1
+        expect(body.failed).toBe(2); // rf-999, rf-3
+        expect(body.results[0].ok).toBe(true);
+        expect(body.results[1].error).toBe("Item not found");
+        expect(body.results[2].error).toContain("Invalid transition from archived to inactive");
+    });
+});

app/api/routes-f/items/status/route.ts

@@ -0,0 +1,87 @@
+import { NextResponse } from "next/server";
+import { getRoutesFRecordById, updateRoutesFRecord } from "@/lib/routes-f/store";
+import { jsonResponse } from "@/lib/routes-f/version";
+import { defineSchema, validatePayload } from "../../_lib/schema";
+
+const statusUpdateSchema = defineSchema({
+    ids: { type: "string", optional: false }, // Note: our simple schema doesn't support arrays well, 
+    // but validatePayload handles object/array checks at top level.
+    // I'll adjust the validation logic below.
+    status: { type: "string", optional: false, enum: ["active", "inactive", "archived"] as const },
+});
+
+const ALLOWED_TRANSITIONS: Record<string, string[]> = {
+    active: ["inactive", "archived", "active"],
+    inactive: ["active", "archived", "inactive"],
+    archived: ["archived"], // Archived is terminal, can only "stay" archived (no-op)
+};
+
+export async function PATCH(req: Request) {
+    let body: any;
+    try {
+        body = await req.json();
+    } catch {
+        return jsonResponse({ error: "Invalid JSON body" }, { status: 400 });
+    }
+
+    // Manual array check for ids since our schema helper is basic
+    if (!body.ids || !Array.isArray(body.ids)) {
+        return jsonResponse({ error: "Invalid request payload", details: ["Field 'ids' must be an array of strings"] }, { status: 400 });
+    }
+
+    const parsed = validatePayload({ status: body.status }, { status: statusUpdateSchema.status });
+    if (!parsed.ok) {
+        return jsonResponse({ error: parsed.error.message, details: parsed.error.details }, { status: 400 });
+    }
+
+    const targetStatus = body.status;
+    const results: { id: string; ok: boolean; error?: string }[] = [];
+    let updatedCount = 0;
+    let failedCount = 0;
+
+    for (const id of body.ids) {
+        const record = getRoutesFRecordById(id);
+
+        if (!record) {
+            results.push({ id, ok: false, error: "Item not found" });
+            failedCount++;
+            continue;
+        }
+
+        const currentStatus = record.status || "active";
+        const allowed = ALLOWED_TRANSITIONS[currentStatus] || ["active", "inactive", "archived"];
+
+        if (!allowed.includes(targetStatus)) {
+            results.push({ id, ok: false, error: `Invalid transition from ${currentStatus} to ${targetStatus}` });
+            failedCount++;
+            continue;
+        }
+
+        try {
+            // ETag is not required for batch updates in this implementation to simplify bulk operations,
+            // but we could support it if needed. For now, we follow the "Acceptance Criteria".
+            updateRoutesFRecord(id, { status: targetStatus });
+            results.push({ id, ok: true });
+            updatedCount++;
+        } catch (e: any) {
+            results.push({ id, ok: false, error: e.message || "Update failed" });
+            failedCount++;
+        }
+    }
+
+    const responseBody = {
+        updated: updatedCount,
+        failed: failedCount,
+        results,
+    };
+
+    if (updatedCount > 0 && failedCount > 0) {
+        return jsonResponse(responseBody, { status: 207 });
+    }
+
+    if (updatedCount === 0 && failedCount > 0) {
+        return jsonResponse(responseBody, { status: 422 });
+    }
+
+    return jsonResponse(responseBody, { status: 200 });
+}