@7365admin1/core 3.73.0 → 3.74.0

package/package.json

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

package/test/e2e/client-invite-service365.e2e.test.mjs

@@ -0,0 +1,119 @@
+// Invite Client for a Property Management client carries the Service365
+// resident app modules too (owner, 2026-09-12: "for the property management
+// they must have their modules and the Service365 modules"; 2026-09-15: "once I
+// choose the Property Management during the invitation of Client the Roles and
+// Modules for Service365 Mobile app is not included").
+//
+// - `POST /api/auth/invite/user` stores `residentAppModules` for staff, only with
+//   modules, only for a Property Management / real estate developer client.
+// - `POST /api/organizations/onboarding` writes them on the organisation, where
+//   the Client details card saves them (`organizations.residentAppModules`).
+//
+// In-process MongoDB, loopback Redis and a loopback mail sink only (harness.mjs).
+
+import { after, before, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { ObjectId } from "mongodb";
+
+import { startHarness } from "./harness.mjs";
+
+const PASSWORD = "ClientS365-Passw0rd!";
+const STAFF = "sevenadmin-cis@e2e.example.com";
+const OUTSIDER = "outsider-cis@e2e.example.com";
+const PM_CLIENT = "pm-cis@e2e.example.com";
+const RED_CLIENT = "red-cis@e2e.example.com";
+
+const MODULES = ["visitor-mgmt", "members", "roles", "invitations", "sites"];
+
+// Every switch explicit, the way the form sends them.
+const RESIDENT_APP = {
+  feedback: true, bulletin: true, bulletinVideos: false, inviteVisitors: true, myVisitors: true,
+  billingAndSoa: false, access: true, facilityBooking: true, onlineForm: true, emergencyContact: true,
+};
+
+describe("Invite Client gives a Property Management client its Service365 modules", { concurrency: 1 }, () => {
+  let h;
+  const sid = {};
+
+  before(async () => {
+    h = await startHarness();
+    await seed(h);
+    for (const email of [STAFF, OUTSIDER, PM_CLIENT, RED_CLIENT]) sid[email] = await h.login(email, PASSWORD);
+  }, { timeout: 300000 });
+
+  after(async () => {
+    if (h) await h.stop();
+  });
+
+  const invite = (who, body) => h.api("/auth/invite/user", { method: "POST", sid: sid[who], body });
+  const inviteOf = (email) =>
+    h.db.collection("verifications").findOne({ type: "user-invite", email }, { sort: { createdAt: -1 } });
+  const onboard = (who, name, nature) =>
+    inviteOf(who).then((row) =>
+      h.api("/organizations/onboarding", {
+        method: "POST",
+        sid: sid[who],
+        body: { name, type: "org", nature, email: who, inviteId: row._id.toString() },
+      }),
+    );
+
+  it("a staff invite for a Property Management client stores the resident app switches", async () => {
+    const res = await invite(STAFF, { email: PM_CLIENT, app: ["property_management_agency"], modules: MODULES, residentAppModules: RESIDENT_APP });
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    assert.deepEqual((await inviteOf(PM_CLIENT)).metadata.residentAppModules, RESIDENT_APP);
+  });
+
+  it("a re-invite replaces them on the pending invitation", async () => {
+    const changed = { ...RESIDENT_APP, facilityBooking: false };
+    const res = await invite(STAFF, { email: PM_CLIENT, app: ["property_management_agency"], modules: MODULES, residentAppModules: changed });
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    const rows = await h.db.collection("verifications").find({ type: "user-invite", email: PM_CLIENT }).toArray();
+    assert.equal(rows.length, 1, "one pending invitation");
+    assert.deepEqual(rows[0].metadata.residentAppModules, changed);
+    // Back to the original for the onboarding case below.
+    await invite(STAFF, { email: PM_CLIENT, app: ["property_management_agency"], modules: MODULES, residentAppModules: RESIDENT_APP });
+  });
+
+  it("refused for another nature, without modules, with an unknown switch, or from a non-staff caller", async () => {
+    const cases = [
+      [STAFF, { email: "sec-cis@e2e.example.com", app: ["security_agency"], modules: MODULES, residentAppModules: RESIDENT_APP }, [400]],
+      [STAFF, { email: "nomod-cis@e2e.example.com", app: ["property_management_agency"], residentAppModules: RESIDENT_APP }, [400]],
+      [STAFF, { email: "badkey-cis@e2e.example.com", app: ["property_management_agency"], modules: MODULES, residentAppModules: { payroll: true } }, [400]],
+      [OUTSIDER, { email: "out-cis@e2e.example.com", app: ["property_management_agency"], modules: MODULES, residentAppModules: RESIDENT_APP }, [401, 403]],
+    ];
+    for (const [who, body, statuses] of cases) {
+      const res = await invite(who, body);
+      assert.ok(statuses.includes(res.status), `${body.email}: got ${res.status} ${JSON.stringify(res.body)}`);
+      assert.equal(await inviteOf(body.email), null, "nothing was written for " + body.email);
+    }
+  });
+
+  it("onboarding writes the modules AND the resident app switches on the organisation", async () => {
+    const res = await onboard(PM_CLIENT, "CIS PM Client", "property_management_agency");
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    const org = await h.db.collection("organizations").findOne({ name: "CIS PM Client" });
+    assert.deepEqual(org.modules, MODULES);
+    assert.deepEqual(org.residentAppModules, RESIDENT_APP);
+  });
+
+  it("a real estate developer gets the same Property Management set", async () => {
+    const res = await invite(STAFF, { email: RED_CLIENT, app: ["real_estate_developer"], modules: MODULES, residentAppModules: RESIDENT_APP });
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    const made = await onboard(RED_CLIENT, "CIS Developer Client", "real_estate_developer");
+    assert.equal(made.status, 201, JSON.stringify(made.body));
+    const org = await h.db.collection("organizations").findOne({ name: "CIS Developer Client" });
+    assert.deepEqual(org.residentAppModules, RESIDENT_APP);
+  });
+});
+
+async function seed(h) {
+  const now = new Date().toISOString();
+  const staffRole = new ObjectId();
+  await h.db.collection("roles").insertOne({ _id: staffRole, name: "Super Admin", type: "admin", default: true, permissions: [], status: "active" });
+  const users = await h.db.collection("users").insertMany(
+    [STAFF, OUTSIDER, PM_CLIENT, RED_CLIENT].map((email) => ({ email, name: email.split("@")[0], status: "active", createdAt: now })),
+  );
+  const hashed = await h.hashPassword(PASSWORD);
+  await h.db.collection("users").updateMany({}, { $set: { password: hashed } });
+  await h.db.collection("members").insertOne({ user: users.insertedIds[0], type: "admin", role: staffRole, status: "active" });
+}

package/test/e2e/person-write-scope.e2e.test.mjs

@@ -260,6 +260,63 @@ describe("people writes are scoped to a site the caller can reach", { concurrenc
     assert.equal(res.status, 200, JSON.stringify(res.body));
     assert.equal((await load(id.residentPerson)).name, "Resubmitted By Themselves");
   });
+
+  // ---- creating a person: POST /api/people -------------------------------
+  // The signed-in branch of `add` used to check only that somebody was signed
+  // in, while `site`/`org` came from the body. The reach gate is enforced by
+  // default now; these cases pin both halves of that.
+
+  const newPerson = (tag) => ({
+    name: `Created ${tag}`,
+    contact: "90000001",
+    type: "guest",
+    isOwner: false,
+    org: String(id.orgB),
+    site: String(id.siteB),
+  });
+  const countCreated = (tag) =>
+    h.db.collection("site.people").countDocuments({ name: `Created ${tag}` });
+
+  record("13. an outsider cannot create a person at site B", async () => {
+    const res = await h.api("/people", { method: "POST", body: newPerson("outsider"), sid: outsiderSid });
+
+    assert.equal(res.status, 401, JSON.stringify(res.body));
+    assert.equal(await countCreated("outsider"), 0, "nothing may be written");
+  });
+
+  record("14. nor by naming only site B's organisation", async () => {
+    const { site, ...orgOnly } = newPerson("outsider-org");
+    const res = await h.api("/people", { method: "POST", body: orgOnly, sid: outsiderSid });
+
+    assert.equal(res.status, 401, JSON.stringify(res.body));
+    assert.equal(await countCreated("outsider-org"), 0);
+  });
+
+  record("15. the site's own manager CAN create one", async () => {
+    // `web-app-property-management components/PeopleFormMgmt.vue` -> `usePeople.create`
+    const res = await h.api("/people", { method: "POST", body: newPerson("manager"), sid: managerSid });
+
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    assert.equal(await countCreated("manager"), 1);
+  });
+
+  record("16. and so can the agency guard posted at site B", async () => {
+    // the field guard app registers visitors at the site it is posted to
+    const res = await h.api("/people", { method: "POST", body: newPerson("guard"), sid: guardSid });
+
+    assert.equal(res.status, 201, JSON.stringify(res.body));
+    assert.equal(await countCreated("guard"), 1);
+  });
+
+  record("17. log mode is a real kill switch: the outsider is let through", async () => {
+    process.env.PEOPLE_CREATE_REACH_MODE = "log";
+    try {
+      const res = await h.api("/people", { method: "POST", body: newPerson("logmode"), sid: outsiderSid });
+      assert.equal(res.status, 201, JSON.stringify(res.body));
+    } finally {
+      delete process.env.PEOPLE_CREATE_REACH_MODE;
+    }
+  });
 });
 
 async function seed(h) {

package/test/people-create-gate.test.mjs

@@ -7,10 +7,9 @@
  * `site.people` is the collection every site-reach decision reads its verdict
  * from, so a row written there manufactures reach into another client's estate.
  *
- * This gate ships SWITCHED OFF (`log`): it records what it would refuse and
- * refuses nothing, because a person row carries no `createdBy` and the real
- * refusal count is only knowable from live traffic. These tests pin that
- * default, so it cannot become enforcing by accident.
+ * The gate shipped in `log` first and is ENFORCED by default since 2026-09-15,
+ * after a staging measurement showed nobody legitimate is refused. These tests
+ * pin that default; `log` stays available as the kill switch.
  */
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -21,11 +20,12 @@ import {
   peopleCreateVerdict,
 } from "./.build/utils/people-create-gate.util.mjs";
 
-test("the code default is LOG - it must not ship refusing anybody", () => {
-  assert.equal(PEOPLE_CREATE_REACH_MODE_DEFAULT, "log");
-  assert.equal(peopleCreateReachMode({}), "log");
-  // An unrecognised value falls back to the safe default rather than enforcing.
-  assert.equal(peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "nonsense" }), "log");
+test("the code default is ENFORCE, with log kept as the kill switch", () => {
+  assert.equal(PEOPLE_CREATE_REACH_MODE_DEFAULT, "enforce");
+  assert.equal(peopleCreateReachMode({}), "enforce");
+  // An unrecognised value falls back to the default, so a typo cannot reopen the hole.
+  assert.equal(peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "nonsense" }), "enforce");
+  assert.equal(peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "log" }), "log");
   assert.equal(peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "ENFORCE" }), "enforce");
   assert.equal(peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "off" }), "off");
 });
@@ -63,9 +63,12 @@ test("OFF does not even look", () => {
 });
 
 test("the flag is the only thing between counting and refusing", () => {
-  // If this ever fails, the default has been changed and people who can create
-  // a person today may stop being able to - which is the RP-5 line.
+  // The default refuses an unreachable estate; `log` is the kill switch that
+  // counts instead. If either half fails, the hole is open or the switch is gone.
   const unreachable = { reachable: false };
-  assert.equal(peopleCreateVerdict({ mode: peopleCreateReachMode({}), ...unreachable }).refuse, false);
-  assert.equal(peopleCreateVerdict({ mode: "enforce", ...unreachable }).refuse, true);
+  assert.equal(peopleCreateVerdict({ mode: peopleCreateReachMode({}), ...unreachable }).refuse, true);
+  assert.equal(
+    peopleCreateVerdict({ mode: peopleCreateReachMode({ PEOPLE_CREATE_REACH_MODE: "log" }), ...unreachable }).refuse,
+    false,
+  );
 });