@7365admin1/core 3.75.1 → 3.77.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/core",
   "license": "MIT",
-  "version": "3.75.1",
+  "version": "3.77.0",
   "author": "7365admin1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/test/camera-live-link.test.mjs

@@ -0,0 +1,163 @@
+/**
+ * The server signs the LIVE view link, the same way it already signs recorded
+ * footage — and hands it out WITHOUT touching `camera.host`.
+ *
+ * Both halves are asserted here, and they are different claims:
+ *
+ *  1. `signLiveLink` produces exactly the string the relay's `playback.js`
+ *     verifies (the expected signature is recomputed here by hand, not taken
+ *     from the function under test).
+ *  2. The camera payloads this estate actually returns CARRY it — proved
+ *     through `withLiveLink(publicCameraFields(...))`, the wrapper the wall,
+ *     the health sweep and the single-camera view all go through.
+ */
+import assert from "node:assert/strict";
+import { createHmac } from "node:crypto";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import {
+  PLAYBACK_LINK_SECONDS,
+  signLiveLink,
+  signPlaybackLink,
+  withLiveLink,
+} from "./.build/utils/camera-playback.util.mjs";
+import {
+  isRelayPlayerUrl,
+} from "./.build/utils/camera-capability.util.mjs";
+import { publicCameraFields } from "./.build/utils/camera-view.util.mjs";
+
+const KEY = "k".repeat(40);
+const RELAY = "the-loft.example.net";
+const RELAYS = { [RELAY]: KEY };
+const NOW = new Date("2026-09-16T08:00:00Z");
+const EXP = Math.floor(NOW.getTime() / 1000) + PLAYBACK_LINK_SECONDS;
+
+/** What the relay computes. Written out here so the test is not the code twice. */
+const expectedSig = (channel, exp = EXP, key = KEY) =>
+  createHmac("sha256", key).update(`${channel}|${exp}`).digest("hex");
+
+test("a live link is signed over channel|exp with the relay's key", () => {
+  const link = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+
+  assert.equal(link.liveAuth, `exp=${EXP}&sig=${expectedSig("7")}`);
+  assert.equal(link.liveUrl, `https://${RELAY}/7?${link.liveAuth}`);
+  assert.equal(link.liveExpiresAt, new Date(EXP * 1000).toISOString());
+});
+
+test("the live link and the recorded-footage link sign DIFFERENT messages", () => {
+  const start = new Date("2026-09-16T07:00:00Z");
+  const end = new Date("2026-09-16T07:10:00Z");
+  const recorded = signPlaybackLink({
+    host: `https://${RELAY}/7`,
+    key: KEY,
+    start,
+    end,
+    now: NOW,
+  });
+  const live = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+
+  // Same key, same expiry, different signature - so a recording link cannot be
+  // replayed as a live link, which is what the relay's tests assert from the
+  // other side.
+  assert.equal(new URL(recorded.playerUrl).searchParams.get("exp"), String(EXP));
+  assert.notEqual(
+    new URL(recorded.playerUrl).searchParams.get("sig"),
+    new URL(live.liveUrl).searchParams.get("sig"),
+  );
+});
+
+test("the link lives as long as a recorded-footage link, and no longer", () => {
+  assert.equal(PLAYBACK_LINK_SECONDS, 120);
+  const link = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+  const exp = Number(new URLSearchParams(link.liveAuth).get("exp"));
+  assert.equal(exp - Math.floor(NOW.getTime() / 1000), PLAYBACK_LINK_SECONDS);
+});
+
+test("no relay configured for that address means NOTHING changes", () => {
+  // The estate has cameras on hosts nobody has configured. They must keep their
+  // plain link rather than get a signature no relay can check.
+  assert.equal(signLiveLink(`https://other.example.net/7`, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink(`https://${RELAY}/7`, { relays: {}, now: NOW }), null);
+  // A host with no channel is genuinely unresolvable, not channel 1.
+  assert.equal(signLiveLink(`https://${RELAY}/lobby`, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink(undefined, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink("", { relays: RELAYS, now: NOW }), null);
+});
+
+test("one signature serves the page, the socket, the still and the clip", () => {
+  // It covers the CHANNEL, not the path - which is why appending it to
+  // /screenshot/<ch> and /record/<ch>/duration/<n> works, and why the clients
+  // that splice `screenshot` into the path are unaffected.
+  const { liveAuth } = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+  for (const path of ["/7", "/api/stream/7", "/screenshot/7", "/record/7/duration/10"]) {
+    const url = new URL(`https://${RELAY}${path}?${liveAuth}`);
+    assert.equal(url.searchParams.get("sig"), expectedSig("7"));
+  }
+});
+
+test("the camera payloads the estate returns carry the signed link", () => {
+  const camera = { _id: "c1", name: "Lobby", type: "ip", status: "active", host: `https://${RELAY}/7` };
+  const fields = withLiveLink(publicCameraFields(camera), { relays: RELAYS, now: NOW });
+
+  assert.equal(fields.liveUrl, `https://${RELAY}/7?exp=${EXP}&sig=${expectedSig("7")}`);
+  assert.equal(fields.liveAuth, `exp=${EXP}&sig=${expectedSig("7")}`);
+});
+
+test("the stored host is handed back UNCHANGED, and stays a relay player URL", () => {
+  const host = `https://${RELAY}/7`;
+  const fields = withLiveLink(publicCameraFields({ _id: "c1", type: "ip", status: "active", host }), {
+    relays: RELAYS,
+    now: NOW,
+  });
+
+  // If `host` ever carried the signature, `isRelayPlayerUrl` would refuse it
+  // (it rejects any query), the liveVideo capability would switch off for both
+  // mobile apps and the web wall, and the patrol-route form would freeze an
+  // expiring signature into the route document. So this is load-bearing.
+  assert.equal(fields.host, host);
+  assert.equal(isRelayPlayerUrl(fields.host), true);
+});
+
+/**
+ * The WIRING, asserted on the service source — the same reason and the same
+ * method as `camera-entitlement-wiring.test.mjs`: constructing the service needs
+ * a live Atlas connection, so the only way to prove the service actually calls
+ * this is to assert the source.
+ *
+ * Without this, every assertion above could pass while the wall still handed out
+ * unsigned links — a helper nobody called.
+ */
+test("EVERY camera payload the service returns goes through withLiveLink", () => {
+  const source = readFileSync(
+    fileURLToPath(new URL("../src/services/camera-view.service.ts", import.meta.url)),
+    "utf8",
+  );
+
+  const uses = [...source.matchAll(/publicCameraFields\(/g)];
+  // The import line names it too; the call sites are what matter.
+  const callSites = uses.filter((m) => !/import|from/.test(source.slice(Math.max(0, m.index - 80), m.index)));
+  assert.ok(callSites.length >= 3, `expected the wall, the health sweep and the single view, found ${callSites.length}`);
+
+  for (const match of callSites) {
+    const before = source.slice(Math.max(0, match.index - 60), match.index);
+    assert.match(
+      before,
+      /withLiveLink\(\s*$/,
+      `a camera payload at offset ${match.index} is handed out without a signed live link`,
+    );
+  }
+});
+
+test("an ANPR camera gets no host and therefore no live link", () => {
+  // `publicCameraFields` already withholds `host` for ANPR; nothing may put one
+  // back. ANPR belongs to visitor and vehicle management, not to CCTV.
+  const fields = withLiveLink(
+    publicCameraFields({ _id: "c2", type: "anpr", status: "active", host: `https://${RELAY}/7` }),
+    { relays: RELAYS, now: NOW },
+  );
+  assert.equal(fields.host, undefined);
+  assert.equal(fields.liveUrl, undefined);
+  assert.equal(fields.liveAuth, undefined);
+});

package/test/e2e/dashboard-inventory-low-stock.e2e.test.mjs

@@ -0,0 +1,59 @@
+// The dashboard supply tile reads Inventory where a store serves the site.
+//
+// With a store: the items at or below their own alert level, lowest first,
+// basis `below-alert-level`, and nothing above its level. Without a store: the
+// three lowest-quantity equipment supplies exactly as before, basis
+// `lowest-quantity` with the no-threshold reason.
+import { after, before, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { ObjectId } from "mongodb";
+
+import { startHarness } from "./harness.mjs";
+
+describe("dashboard supply tile", { concurrency: 1 }, () => {
+  let h;
+  const withStore = new ObjectId();
+  const withoutStore = new ObjectId();
+
+  before(async () => {
+    h = await startHarness();
+    const store = new ObjectId();
+    await h.db.collection("inventory.stores").insertOne({ _id: store, org: new ObjectId(), ownerType: "property", name: "Main", sites: [withStore], status: "active" });
+    await h.db.collection("inventory.items").insertMany([
+      { store, name: "Tube 18W", onHand: 3, reorderLevel: 10, status: "active" },
+      { store, name: "Holder", onHand: 0, reorderLevel: 5, status: "active" },
+      { store, name: "Plenty", onHand: 500, reorderLevel: 10, status: "active" },
+      { store, name: "No alert set", onHand: 0, reorderLevel: 0, status: "active" },
+      { store, name: "Not in use", onHand: 0, reorderLevel: 10, status: "inactive" },
+    ]);
+    await h.db.collection("site.supplies").insertMany([
+      { site: withoutStore, serviceType: "cleaning_services", name: "Gloves", qty: 900, status: "active" },
+      { site: withoutStore, serviceType: "cleaning_services", name: "Bleach", qty: 4, status: "active" },
+      { site: withStore, serviceType: "cleaning_services", name: "Old equipment row", qty: 1, status: "active" },
+    ]);
+  });
+
+  after(async () => {
+    await h?.stop();
+  });
+
+  const tile = async (site) =>
+    (await h.core.useNewDashboardRepo().getServiceDashboard({ site, serviceType: "cleaning_services" })).supplyAlert;
+
+  it("a site with an Inventory store shows only items at or below their alert level, lowest first", async () => {
+    const supply = await tile(withStore);
+    assert.equal(supply.basis, "below-alert-level");
+    assert.deepEqual(supply.items, [
+      { name: "Holder", qty: 0 },
+      { name: "Tube 18W", qty: 3 },
+    ]);
+    assert.equal(supply.thresholdUnavailableReason, undefined);
+  });
+
+  it("a site without a store keeps the old lowest-quantity list", async () => {
+    const supply = await tile(withoutStore);
+    assert.equal(supply.basis, "lowest-quantity");
+    assert.deepEqual(supply.items.map((i) => i.name), ["Bleach", "Gloves"]);
+    assert.ok(supply.thresholdUnavailableReason);
+  });
+});

package/test/notification-category.util.test.mjs

@@ -84,6 +84,24 @@ describe("notification categories", () => {
     }
   });
 
+  it("a role holding any inventory permission is offered the Inventory switch", () => {
+    for (const permission of [
+      "inventory:view-inventory",
+      "inventory:request-stock",
+      "inventory:approve-requests",
+      "inventory:manage-inventory",
+    ]) {
+      assert.deepEqual(
+        keys(categoriesForPermissions({ permissions: [permission] })),
+        ["inventory"],
+        permission,
+      );
+    }
+    const inventory = NOTIFICATION_CATEGORIES.find((c) => c.key === "inventory");
+    assert.equal(inventory.rendered, true);
+    assert.equal(inventory.safety, undefined);
+  });
+
   it("a resident is not offered any safety switch", () => {
     const offered = keys(
       categoriesForPermissions({ permissions: [], isResident: true }),
@@ -360,7 +378,9 @@ describe("marketplace order categories", () => {
 // ---------------------------------------------------------------------------
 
 const NEW_KEYS = ["marketplaceOrder", "marketplaceVendorOrder"];
-const withoutNew = (result) => keys(result).filter((k) => !NEW_KEYS.includes(k));
+// Categories added after this snapshot was taken; each is pinned by its own test.
+const LATER_KEYS = ["inventory"];
+const withoutNew = (result) => keys(result).filter((k) => !NEW_KEYS.includes(k) && !LATER_KEYS.includes(k));
 const onlyNew = (result) => keys(result).filter((k) => NEW_KEYS.includes(k));
 
 const BEFORE = {