@terreno/api 0.13.3 → 0.14.1

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,74 @@ 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("handles numeric version parameter directly", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 100,
+      webWarningVersion: 150,
+    });
+
+    const res = await app.get("/version-check?version=50&platform=web");
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("required");
+  });
+
+  it("returns default warning message when warningMessage not set", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 0,
+      webWarningVersion: 100,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 50});
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("warning");
+    expect(res.body.message).toBe(
+      "A new version is available. Please update for the best experience."
+    );
+  });
+
+  it("returns default required message when requiredMessage not set", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 100,
+      webWarningVersion: 150,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 50});
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("required");
+    expect(res.body.message).toBe(
+      "This version is no longer supported. Please update to continue."
+    );
   });
 
   it("version equal to required returns warning not required", async () => {
@@ -130,3 +203,21 @@ describe("VersionCheckPlugin", () => {
     expect(res.body.status).toBe("warning");
   });
 });
+
+describe("VersionCheckPlugin direct usage", () => {
+  it("can be instantiated and register called directly on an express app", async () => {
+    const express = require("express");
+    const plugin = new VersionCheckPlugin();
+    expect(plugin).toBeDefined();
+    expect(plugin).toBeInstanceOf(VersionCheckPlugin);
+    expect(typeof plugin.register).toBe("function");
+
+    const expressApp = express();
+    plugin.register(expressApp);
+
+    const testApp = supertest(expressApp);
+    const res = await testApp.get("/version-check");
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("ok");
+  });
+});

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.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");
+    });
+  });
 });