@7365admin1/core 3.59.1 → 3.59.2

package/package.json

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

package/test/e2e/resident-self-signup-pinning.e2e.test.mjs

@@ -309,6 +309,71 @@ describe("pre-login resident sign-up cannot manufacture access", { concurrency:
     assert.equal(person?.status, "active");
     assert.equal(person?.remarks, "e2e staff may set this");
   });
+
+  // ---- a document that never uploaded is dropped, AND reported -------------
+
+  record("13. a sign-up whose document upload failed still completes", async () => {
+    // Exactly what the wizard sends after a failed upload: the file is named
+    // and listed, and has no `id` because the upload never returned one.
+    const email = "pin-unsent@e2e.example.com";
+    const res = await h.api("/people/resident/create", {
+      method: "POST",
+      body: {
+        ...genuine(id, email),
+        files: [{ name: "tenancy-agreement.pdf", mimeType: "application/pdf" }],
+      },
+    });
+
+    assert.equal(res.status, 201, JSON.stringify(res.status));
+
+    const person = await stored(email);
+    assert.ok(person, "the applicant must not be lost over an attachment we never received");
+    assert.deepEqual(person.files, []);
+    // ...and the reviewer can now tell this apart from "attached nothing".
+    assert.deepEqual(person.filesNotUploaded, ["tenancy-agreement.pdf"]);
+  });
+
+  record("14. a sign-up whose uploads all landed carries no report at all", async () => {
+    const email = "pin-uploaded@e2e.example.com";
+    const fileId = new ObjectId();
+    await h.db.collection("files").insertOne({
+      _id: fileId,
+      name: "tenancy-agreement.pdf",
+      status: "draft",
+    });
+
+    const res = await h.api("/people/resident/create", {
+      method: "POST",
+      body: {
+        ...genuine(id, email),
+        files: [{ id: fileId.toString(), name: "tenancy-agreement.pdf", mimeType: "application/pdf" }],
+      },
+    });
+
+    assert.equal(res.status, 201, JSON.stringify(res.status));
+
+    const person = await stored(email);
+    assert.equal(person.files?.length, 1);
+    assert.equal(person.files[0].id?.toString(), fileId.toString());
+    // Absent, not empty: a normal registration is written exactly as before.
+    assert.equal("filesNotUploaded" in person, false);
+    // And the document was linked - its status flipped out of draft.
+    const file = await h.db.collection("files").findOne({ _id: fileId });
+    assert.equal(file.status, "active");
+  });
+
+  record("15. the caller cannot plant the report itself", async () => {
+    const email = "pin-planted@e2e.example.com";
+    const res = await h.api("/people/resident/create", {
+      method: "POST",
+      body: { ...genuine(id, email), filesNotUploaded: ["planted-by-the-caller.pdf"] },
+    });
+
+    assert.equal(res.status, 201, JSON.stringify(res.status));
+
+    const person = await stored(email);
+    assert.equal("filesNotUploaded" in person, false);
+  });
 });
 
 async function seed(h) {

package/test/self-signup-files.test.mjs

@@ -3,8 +3,13 @@ import test from "node:test";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-import { dropUnsentFiles } from "./.build/utils/self-signup-files.util.mjs";
-import { schemaResidentSelfSignUp, schemaPerson } from "./.build/models/person.model.mjs";
+import {
+  dropUnsentFiles,
+  unsentFileNames,
+  MAX_UNSENT_FILE_NAMES,
+  MAX_UNSENT_FILE_NAME_LENGTH,
+} from "./.build/utils/self-signup-files.util.mjs";
+import { schemaResidentSelfSignUp, schemaPerson, MPerson } from "./.build/models/person.model.mjs";
 
 /**
  * Resident sign-up outage, 2026-09-08.
@@ -150,5 +155,122 @@ test("the filter runs on the self-signup path, before validation, and nowhere el
   // authenticated `add`/`updateById` paths, staff stop being told about a
   // client that is silently losing their attachments.
   assert.equal(controller.match(/dropUnsentFiles\(/g)?.length, 1);
-  assert.match(controller, /import \{ dropUnsentFiles \} from "\.\.\/utils\/self-signup-files\.util"/);
+  // Both helpers come from that one module, whatever shape the import takes.
+  const importBlock = controller.match(/import \{[\s\S]*?\} from "\.\.\/utils\/self-signup-files\.util";/);
+  assert.ok(importBlock, "self-signup-files.util is no longer imported by the controller");
+  assert.ok(importBlock[0].includes("dropUnsentFiles"));
+  assert.ok(importBlock[0].includes("unsentFileNames"));
+});
+
+/**
+ * 2026-09-08, second report. The fix above kept the applicant, and then hid the
+ * problem: `Files:` renders empty whether the resident attached nothing or
+ * attached something we never received. The owner's own registration was
+ * APPROVED in that state, without its tenancy agreement. So the entries we drop
+ * are now recorded on the person as `filesNotUploaded`, and the console has
+ * something to show.
+ */
+
+test("what was dropped is reported, by name, in order", () => {
+  const second = { name: "vehicle-registration.pdf", mimeType: "application/pdf" };
+  const body = { ...base(), files: [validFile, unsentFile, second] };
+
+  assert.deepEqual(unsentFileNames(body), [unsentFile.name, second.name]);
+  // And the two halves agree: what is kept plus what is reported is the input.
+  assert.deepEqual(dropUnsentFiles(body).files, [validFile]);
+});
+
+test("a registration where every upload landed reports nothing", () => {
+  assert.deepEqual(unsentFileNames({ ...base(), files: [validFile] }), []);
+  assert.deepEqual(unsentFileNames({ ...base(), files: [] }), []);
+  assert.deepEqual(unsentFileNames(base()), []);
+  assert.deepEqual(unsentFileNames({ ...base(), files: null }), []);
+  assert.deepEqual(unsentFileNames({ ...base(), files: "nonsense" }), []);
+  assert.deepEqual(unsentFileNames(undefined), []);
+});
+
+test("an unnamed dropped entry still reports something a reviewer can read", () => {
+  assert.deepEqual(unsentFileNames({ files: [{ mimeType: "application/pdf" }] }), ["Unnamed document"]);
+  assert.deepEqual(unsentFileNames({ files: [{ name: "   " }] }), ["Unnamed document"]);
+  assert.deepEqual(unsentFileNames({ files: [{ name: 42 }] }), ["Unnamed document"]);
+  // A null entry is not an unsent file, it is nonsense - and must not crash.
+  assert.deepEqual(unsentFileNames({ files: [null, undefined] }), []);
+});
+
+test("the caller cannot use it as free storage: bounded in count and in length", () => {
+  const many = Array.from({ length: MAX_UNSENT_FILE_NAMES + 5 }, (_, i) => ({ name: `doc-${i}.pdf` }));
+  assert.equal(unsentFileNames({ files: many }).length, MAX_UNSENT_FILE_NAMES);
+
+  const long = unsentFileNames({ files: [{ name: "x".repeat(5000) }] });
+  assert.equal(long[0].length, MAX_UNSENT_FILE_NAME_LENGTH);
+});
+
+test("the report is display text only - it is not accepted from the caller", () => {
+  // stripUnknown means a caller who sends `filesNotUploaded` has it dropped,
+  // exactly like `status` and `platform`. Only the controller sets it.
+  const { error, value } = selfSignUp({ ...base(), filesNotUploaded: ["planted.pdf"] });
+  assert.equal(error, undefined);
+  assert.equal("filesNotUploaded" in value, false);
+
+  // But the finished payload the controller builds must survive MPerson, which
+  // runs schemaPerson over it and refuses unknown keys.
+  const finished = { ...base(), isOwner: true, status: "pending", platform: "mobile", filesNotUploaded: ["a.pdf"] };
+  assert.equal(schemaPerson.validate(finished, { abortEarly: false }).error, undefined);
+});
+
+test("the controller records the dropped names from the ORIGINAL body, and only when there are some", () => {
+  const selfSignUpFn = controller.slice(
+    controller.indexOf("async function addResidentSelfSignUp"),
+    controller.indexOf("async function add("),
+  );
+
+  assert.match(selfSignUpFn, /unsentFileNames\(req\.body\)/);
+  // Read from req.body, not from the already-filtered `body` - which would
+  // always be empty and make the whole thing a silent no-op.
+  assert.equal(selfSignUpFn.includes("unsentFileNames(body)"), false);
+  assert.match(selfSignUpFn, /filesNotUploaded: notUploaded/);
+  assert.match(selfSignUpFn, /notUploaded\.length > 0 \?/);
+
+  // Self-signup only. The authenticated staff path must not start writing it.
+  assert.equal(controller.match(/unsentFileNames\(/g)?.length, 1);
+});
+
+/**
+ * `MPerson` does not return the object it was given: it returns an explicit
+ * whitelist, and anything not named there is dropped on the way to the
+ * database. Every unit test above passed with `filesNotUploaded` never reaching
+ * Mongo at all - only the end-to-end run caught it. Pin it here so the next
+ * field added to the payload is not lost the same way.
+ */
+test("MPerson carries the report through to the document it writes", () => {
+  const person = {
+    name: "Resident Test",
+    email: "resident@example.com",
+    isOwner: true,
+    site: "0123456789abcdef01234567",
+    status: "pending",
+    platform: "mobile",
+    files: [],
+    filesNotUploaded: ["tenancy-agreement.pdf"],
+  };
+
+  assert.deepEqual(MPerson(person).filesNotUploaded, ["tenancy-agreement.pdf"]);
+});
+
+test("a person with nothing to report gets no key at all, not an undefined one", () => {
+  // A fresh object each time: MPerson rewrites `site` into an ObjectId in
+  // place, so a second call on the same literal fails on "site must be a string".
+  const person = (extra) => ({
+    name: "Resident Test",
+    email: "resident@example.com",
+    isOwner: true,
+    site: "0123456789abcdef01234567",
+    files: [],
+    ...extra,
+  });
+
+  // `filesNotUploaded: undefined` would be written into every person document
+  // ever created, on every path, which is exactly what the conditional avoids.
+  assert.equal("filesNotUploaded" in MPerson(person()), false);
+  assert.equal("filesNotUploaded" in MPerson(person({ filesNotUploaded: [] })), false);
 });