@terreno/api 0.13.2 → 0.14.0

package/src/__tests__/versionCheckPlugin.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {afterEach, beforeEach, describe, expect, it} from "bun:test";
 import supertest from "supertest";
 import {VersionConfig} from "../models/versionConfig";
@@ -29,7 +30,7 @@ describe("VersionCheckPlugin", () => {
   it("returns ok when no VersionConfig exists", async () => {
     const res = await app.get("/version-check").query({platform: "web", version: 100});
     expect(res.status).toBe(200);
-    expect(res.body).toEqual({status: "ok"});
+    expect(res.body).toEqual({pollingIntervalMs: 86400000, status: "ok"});
   });
 
   it("returns ok when version param is missing", async () => {
@@ -52,7 +53,12 @@ describe("VersionCheckPlugin", () => {
 
     const res = await app.get("/version-check").query({platform: "web", version: 150});
     expect(res.status).toBe(200);
-    expect(res.body).toEqual({requiredVersion: 50, status: "ok", warningVersion: 100});
+    expect(res.body).toEqual({
+      pollingIntervalMs: 86400000,
+      requiredVersion: 50,
+      status: "ok",
+      warningVersion: 100,
+    });
   });
 
   it("returns warning when client version < warning (web)", async () => {
@@ -116,7 +122,35 @@ describe("VersionCheckPlugin", () => {
 
     const res = await app.get("/version-check").query({platform: "web", version: 100});
     expect(res.status).toBe(200);
-    expect(res.body).toEqual({requiredVersion: 50, status: "ok", warningVersion: 100});
+    expect(res.body).toEqual({
+      pollingIntervalMs: 86400000,
+      requiredVersion: 50,
+      status: "ok",
+      warningVersion: 100,
+    });
+  });
+
+  it("returns pollingIntervalMs from config pollingIntervalMinutes", async () => {
+    await VersionConfig.create({
+      pollingIntervalMinutes: 60,
+      webRequiredVersion: 0,
+      webWarningVersion: 0,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(res.status).toBe(200);
+    expect(res.body.pollingIntervalMs).toBe(3600000);
+  });
+
+  it("returns default pollingIntervalMs (86400000) when pollingIntervalMinutes not set", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 0,
+      webWarningVersion: 0,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(res.status).toBe(200);
+    expect(res.body.pollingIntervalMs).toBe(86400000);
   });
 
   it("version equal to required returns warning not required", async () => {

package/src/api.arrayOperations.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import type express from "express";
 import supertest from "supertest";

package/src/api.asyncHandler.test.ts

@@ -0,0 +1,177 @@
+import {afterEach, describe, expect, it} from "bun:test";
+import express, {type NextFunction, type Request, type Response} from "express";
+import supertest from "supertest";
+
+import {asyncHandler} from "./api";
+import {configureOpenApiValidator, resetOpenApiValidatorConfig} from "./openApiValidator";
+
+afterEach(() => {
+  resetOpenApiValidatorConfig();
+});
+
+const createApp = (): express.Application => {
+  const app = express();
+  app.use(express.json());
+  return app;
+};
+
+const errorHandler = (
+  err: {status?: number; title?: string; message?: string},
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+): void => {
+  res.status(err.status || 500).json({error: err.title || err.message});
+};
+
+describe("asyncHandler with bodySchema validation", () => {
+  it("validates and accepts a conforming body", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.post(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          bodySchema: {name: {required: true, type: "string"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    const res = await supertest(app).post("/test").send({name: "hello"}).expect(200);
+    expect(res.body.ok).toBe(true);
+  });
+
+  it("rejects a body missing a required field", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.post(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          bodySchema: {name: {required: true, type: "string"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    await supertest(app).post("/test").send({}).expect(400);
+  });
+
+  it("skips body validation when validate is false", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.post(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          bodySchema: {name: {required: true, type: "string"}},
+          validate: false,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    const res = await supertest(app).post("/test").send({}).expect(200);
+    expect(res.body.ok).toBe(true);
+  });
+});
+
+describe("asyncHandler with querySchema validation", () => {
+  it("validates and accepts conforming query params", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.get(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          querySchema: {page: {type: "integer"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    const res = await supertest(app).get("/test?page=1").expect(200);
+    expect(res.body.ok).toBe(true);
+  });
+
+  it("rejects invalid query params", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.get(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          querySchema: {page: {required: true, type: "integer"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    await supertest(app).get("/test").expect(400);
+  });
+});
+
+describe("asyncHandler with both schemas", () => {
+  it("runs both body and query validators sequentially", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.post(
+      "/test",
+      asyncHandler(
+        async (_req: Request, res: Response) => {
+          res.json({ok: true});
+        },
+        {
+          bodySchema: {name: {required: true, type: "string"}},
+          querySchema: {page: {type: "integer"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    const res = await supertest(app).post("/test?page=1").send({name: "hi"}).expect(200);
+    expect(res.body.ok).toBe(true);
+  });
+
+  it("forwards handler errors through next", async () => {
+    configureOpenApiValidator({});
+    const app = createApp();
+    app.post(
+      "/test",
+      asyncHandler(
+        async () => {
+          throw new Error("handler boom");
+        },
+        {
+          bodySchema: {name: {type: "string"}},
+          validate: true,
+        }
+      )
+    );
+    app.use(errorHandler);
+
+    const res = await supertest(app).post("/test").send({name: "ok"}).expect(500);
+    expect(res.body.error).toBe("handler boom");
+  });
+});

package/src/api.errors.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {describe, expect, it} from "bun:test";
 import mongoose from "mongoose";
 

package/src/api.hooks.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import type express from "express";
 import supertest from "supertest";

package/src/api.query.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import * as Sentry from "@sentry/bun";
 import type express from "express";

package/src/api.test.ts

@@ -1,5 +1,9 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
+// biome-ignore-all lint/suspicious/noImplicitAnyLet: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import type express from "express";
+import {DateTime} from "luxon";
+import type mongoose from "mongoose";
 import supertest from "supertest";
 import type TestAgent from "supertest/lib/agent";
 
@@ -14,6 +18,7 @@ import {
   getBaseServer,
   RequiredModel,
   setupDb,
+  type User,
   UserModel,
 } from "./tests";
 import {AdminOwnerTransformer} from "./transformers";
@@ -1901,4 +1906,131 @@ describe("@terreno/api", () => {
       expect(res.body.title).toContain("preUpdate hook error");
     });
   });
+
+  describe("conflict detection (If-Unmodified-Since)", () => {
+    let admin: mongoose.HydratedDocument<User>;
+    let _notAdmin: mongoose.HydratedDocument<User>;
+    let agent: TestAgent;
+    let spinach: Food;
+
+    beforeEach(async () => {
+      [admin, _notAdmin] = await setupDb();
+
+      spinach = await FoodModel.create({
+        calories: 10,
+        created: DateTime.fromISO("2025-06-15T12:00:00.000Z").toJSDate(),
+        hidden: false,
+        name: "Spinach",
+        ownerId: admin._id,
+      });
+      await FoodModel.collection.updateOne(
+        {_id: spinach._id as unknown as mongoose.Types.ObjectId},
+        {$set: {updated: DateTime.fromISO("2025-06-15T12:00:00.000Z").toJSDate()}}
+      );
+
+      app = getBaseServer();
+      setupAuth(app, UserModel as unknown as Parameters<typeof setupAuth>[1]);
+      addAuthRoutes(app, UserModel as unknown as Parameters<typeof addAuthRoutes>[1]);
+      app.use(
+        "/food",
+        modelRouter(FoodModel, {
+          permissions: {
+            create: [Permissions.IsAny],
+            delete: [Permissions.IsAny],
+            list: [Permissions.IsAny],
+            read: [Permissions.IsAny],
+            update: [Permissions.IsAny],
+          },
+        })
+      );
+      server = supertest(app);
+      agent = await authAsUser(app, "admin");
+    });
+
+    it("returns 409 when If-Unmodified-Since is older than doc.updated", async () => {
+      const staleTimestamp = DateTime.fromISO("2025-06-15T11:00:00.000Z").toHTTP();
+
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", staleTimestamp)
+        .send({name: "Should Fail"})
+        .expect(409);
+
+      expect(res.body.error).toBe("Conflict");
+      expect(res.body.message).toBe("Document was modified since your last read");
+      expect(res.body.data).toBeDefined();
+      // The response should contain the current server version
+      expect(res.body.data.name).toBe("Spinach");
+    });
+
+    it("succeeds when If-Unmodified-Since matches or is newer than doc.updated", async () => {
+      const freshTimestamp = DateTime.fromISO("2025-06-15T13:00:00.000Z").toHTTP();
+
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", freshTimestamp)
+        .send({name: "Updated Spinach"})
+        .expect(200);
+
+      expect(res.body.data.name).toBe("Updated Spinach");
+    });
+
+    it("succeeds normally when If-Unmodified-Since header is not present", async () => {
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .send({name: "No Header Update"})
+        .expect(200);
+
+      expect(res.body.data.name).toBe("No Header Update");
+    });
+
+    it("succeeds when If-Unmodified-Since exactly matches doc.updated", async () => {
+      const exactTimestamp = DateTime.fromISO("2025-06-15T12:00:00.000Z").toHTTP();
+
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", exactTimestamp)
+        .send({name: "Exact Match"})
+        .expect(200);
+
+      expect(res.body.data.name).toBe("Exact Match");
+    });
+
+    it("prefers precise conflict timestamp header when present", async () => {
+      const roundedStaleTimestamp = DateTime.fromISO("2025-06-15T11:59:59.000Z").toHTTP();
+
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", roundedStaleTimestamp)
+        .set("X-Unmodified-Since-ISO", "2025-06-15T12:00:00.750Z")
+        .send({name: "Precise Match"})
+        .expect(200);
+
+      expect(res.body.data.name).toBe("Precise Match");
+    });
+
+    it("returns 409 when precise conflict timestamp is older than doc.updated", async () => {
+      await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", DateTime.fromISO("2025-06-15T12:00:01.000Z").toHTTP()!)
+        .set("X-Unmodified-Since-ISO", "2025-06-15T11:59:59.500Z")
+        .send({name: "Precise Stale"})
+        .expect(409);
+    });
+
+    it("falls back to doc.created when doc.updated is unavailable", async () => {
+      await FoodModel.collection.updateOne(
+        {_id: spinach._id as unknown as mongoose.Types.ObjectId},
+        {$unset: {updated: ""}}
+      );
+
+      const res = await agent
+        .patch(`/food/${spinach._id}`)
+        .set("If-Unmodified-Since", DateTime.fromISO("2025-06-15T11:59:59.999Z").toHTTP()!)
+        .send({name: "Created Fallback"})
+        .expect(409);
+
+      expect(res.body.data.name).toBe("Spinach");
+    });
+  });
 });