@7365admin1/module-hygiene 4.30.0 → 4.30.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/module-hygiene",
   "license": "MIT",
-  "version": "4.30.0",
+  "version": "4.30.2",
   "author": "7365admin1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -13,7 +13,7 @@
     "build": "tsup src/index.ts --format cjs,esm --dts",
     "release": "yarn run build && changeset publish",
     "lint": "tsc",
-    "test": "tsup src/utils/hygiene-dashboard-metrics.util.ts src/utils/hygiene-checkout-decision.util.ts --format esm --out-dir test/.build --no-dts --silent && node --test \"test/*.test.mjs\""
+    "test": "tsup src/utils/hygiene-dashboard-metrics.util.ts src/utils/hygiene-checkout-decision.util.ts src/utils/completion-photo.util.ts --format esm --out-dir test/.build --no-dts --silent && node --test \"test/*.test.mjs\""
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.0",

package/test/require-photo-on-completion.test.mjs

@@ -1,160 +1,204 @@
 /*
- * A PHOTO IS REQUIRED TO COMPLETE A TASK.
+ * A PHOTO IS REQUIRED TO COMPLETE A TASK — and only to COMPLETE one.
  *
  * Owner requirement, 2026-09-10: "once task was completed they required to take
  * photo before completing the task ... all the services that has this module
  * must be the same process."
  *
- * This endpoint is where every service and every client meets. The five field
- * apps — M&E, Cleaning, Landscape, Pest, Pool — all PATCH
- * `/api/hygiene-area-checklist/id/:id/set/:set/units/:unit/:decision` with a
- * `serviceType`, and the web checklist posts here too. Enforcing it here is what
- * makes "the same process" true, rather than five client guards that drift.
+ * The first version of this rule sat in the Joi schema and demanded a photo on
+ * every approve. A task in this product is a SET, not a unit: both clients tick
+ * units one at a time and open the photographs dialog on the tick that finishes
+ * the set. So that version broke every intermediate tick on both platforms —
+ * the owner hit it on the web M&E checklist, and `meareaunits.tsx` makes the
+ * same call with `attachment: []`.
  *
- * The rule is exercised against the SHIPPED Joi schema, lifted out of the
- * controller — not a re-typed copy, so a change to the real validation fails
- * this file.
+ * This exercises the SHIPPED decision function, compiled from source by the
+ * test script — not a re-typed copy.
  */
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import Joi from "joi";
-
-const SRC = readFileSync(
-  new URL("../src/controllers/hygiene-area-checklist.controller.ts", import.meta.url),
-  "utf8",
-);
-
-/** The validation object from `updateAreaChecklistUnits`, evaluated for real. */
-function schema() {
-  const fn = SRC.slice(SRC.indexOf("async function updateAreaChecklistUnits("));
-  const start = fn.indexOf("const validation = Joi.object({");
-  assert.notEqual(start, -1, "the validation block is gone");
-
-  // Walk braces from the opening `{` of Joi.object( ... ) to its match.
-  const open = fn.indexOf("{", start + "const validation = Joi.object(".length);
-  let depth = 0;
-  let end = -1;
-  for (let i = open; i < fn.length; i++) {
-    if (fn[i] === "{") depth++;
-    else if (fn[i] === "}") {
-      depth--;
-      if (depth === 0) {
-        end = i;
-        break;
-      }
-    }
-  }
-  assert.notEqual(end, -1, "could not read the validation block");
-
-  const body = fn
-    .slice(open, end + 1)
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\/\/[^\n]*/g, "");
-  return new Function("Joi", `return Joi.object(${body});`)(Joi);
-}
-
-const base = {
-  id: "6923d6664150ca6a69b9f2b2",
-  set: 1,
-  unit: "69251faf8c8936c9e6ebf095",
-  completedBy: "6925a31630abdbb211ecd9a8",
-  remarks: "done",
+import {
+  COMPLETION_PHOTO_MESSAGE,
+  readCompletion,
+  requiresCompletionPhoto,
+} from "./.build/completion-photo.util.mjs";
+
+/** Approving a unit that still has un-actioned siblings — the common tick. */
+const midSet = {
+  decision: "approve",
+  completesSet: false,
+  hasEvidence: false,
 };
 
-const validate = (payload) => schema().validate(payload);
+/** Approving the unit that finishes the set — the act evidence is for. */
+const completing = {
+  decision: "approve",
+  completesSet: true,
+  hasEvidence: false,
+};
+
+/* ── the regression the owner reported ─────────────────────────────────── */
+
+test("ticking a unit mid-set needs NO photo", () => {
+  // This is what broke: the web posts it with nothing attached, and
+  // `meareaunits.tsx` posts it with `attachment: []`.
+  assert.equal(requiresCompletionPhoto(midSet), false);
+  assert.equal(requiresCompletionPhoto({ ...midSet, attachment: [] }), false);
+  assert.equal(
+    requiresCompletionPhoto({ ...midSet, attachment: undefined }),
+    false
+  );
+});
 
-/* ── completing requires evidence ──────────────────────────────────────── */
+/* ── completing still requires evidence ────────────────────────────────── */
 
-test("approving WITHOUT a photo is refused", () => {
-  const { error } = validate({ ...base, decision: "approve", approve: true });
-  assert.ok(error, "a task was completed with no photo");
-  assert.match(error.message, /photo is required/i);
+test("completing the set WITHOUT a photo is refused", () => {
+  assert.equal(requiresCompletionPhoto(completing), true);
 });
 
-test("an EMPTY attachment array is refused too", () => {
-  // This is the shape a client sends when its uploader failed — it satisfies
-  // `.optional()` while carrying no evidence at all.
-  const { error } = validate({
-    ...base,
-    decision: "approve",
-    approve: true,
-    attachment: [],
-  });
-  assert.ok(error, "an empty attachment list was accepted as evidence");
-  assert.match(error.message, /photo is required/i);
+test("an EMPTY attachment array is not evidence", () => {
+  // The shape a client sends when its uploader failed.
+  assert.equal(
+    requiresCompletionPhoto({ ...completing, attachment: [] }),
+    true
+  );
 });
 
 test("a BLANK id is not a photo", () => {
-  const { error } = validate({
-    ...base,
-    decision: "approve",
-    approve: true,
-    attachment: [""],
-  });
-  assert.ok(error, "a blank attachment id counted as a photo");
+  assert.equal(
+    requiresCompletionPhoto({ ...completing, attachment: ["", "   "] }),
+    true
+  );
 });
 
-test("approving WITH a photo is accepted", () => {
-  const { error } = validate({
-    ...base,
-    decision: "approve",
-    approve: true,
-    attachment: ["68f05fbe0c11062938dadad9"],
-  });
-  assert.equal(error, undefined, error?.message);
+test("completing WITH a photo is allowed", () => {
+  assert.equal(
+    requiresCompletionPhoto({
+      ...completing,
+      attachment: ["68f05fbe0c11062938dadad9"],
+    }),
+    false
+  );
 });
 
-test("MULTIPLE photos are accepted — that is the point", () => {
-  const { error } = validate({
-    ...base,
-    decision: "approve",
-    approve: true,
-    attachment: ["a1", "b2", "c3", "d4"],
-  });
-  assert.equal(error, undefined, error?.message);
+test("MULTIPLE photos are allowed — that is the point", () => {
+  assert.equal(
+    requiresCompletionPhoto({ ...completing, attachment: ["a1", "b2", "c3"] }),
+    false
+  );
+});
+
+/* ── the web posts a set's approves in a loop ──────────────────────────── */
+
+test("a set already carrying a photo on another unit is not blocked", () => {
+  /*
+   * `ManageChecklistMain` loops over the set's approved items and puts the ids
+   * on only ONE of them, so the approve that completes the set is not reliably
+   * the one holding the evidence. Asking only "does THIS request have a photo"
+   * would reject a set that is in fact fully documented.
+   */
+  assert.equal(
+    requiresCompletionPhoto({ ...completing, hasEvidence: true }),
+    false
+  );
+  assert.equal(
+    requiresCompletionPhoto({
+      ...completing,
+      hasEvidence: true,
+      attachment: [],
+    }),
+    false
+  );
 });
 
 /* ── rejecting must NOT be blocked ─────────────────────────────────────── */
 
-test("REJECTING without a photo is still allowed", () => {
+test("REJECTING is never blocked, even completing the set", () => {
   /*
    * A reject is the technician reporting a problem. Demanding a photograph
    * before somebody can report one would stop them reporting it.
    */
-  const { error } = validate({ ...base, decision: "reject", reject: true });
-  assert.equal(error, undefined, error?.message);
+  assert.equal(
+    requiresCompletionPhoto({
+      decision: "reject",
+      completesSet: true,
+      hasEvidence: false,
+    }),
+    false
+  );
+});
+
+/* ── which approve finishes the set: ONE definition with the clients ───── */
+
+test("an approve finishes the set when every other unit is approved or rejected", () => {
+  const units = [
+    { unit: "u1", approve: true, reject: false, status: "completed" },
+    { unit: "u2", approve: false, reject: true, status: "completed" },
+    { unit: "u3", approve: false, reject: false, status: "open" },
+  ];
+  assert.equal(readCompletion(units, "u3").completesSet, true);
+  // Intermediate: another unit is still untouched.
+  assert.equal(readCompletion(units, "u1").completesSet, false);
 });
 
-test("rejecting WITH photos is still allowed", () => {
-  const { error } = validate({
-    ...base,
-    decision: "reject",
-    reject: true,
-    attachment: ["a1", "b2"],
+test("actioned means approve/reject, NOT status — status at rest is open/closed", () => {
+  /*
+   * Staging holds units that are `closed` while approved or rejected. The units
+   * list (`isFullyActioned`) and both clients count those as done, so the photo
+   * rule must too, or the server and the screen disagree about the last tick.
+   */
+  const units = [
+    { unit: "u1", approve: true, reject: false, status: "closed" },
+    { unit: "u2", approve: false, reject: false, status: "open" },
+  ];
+  assert.equal(readCompletion(units, "u2").completesSet, true);
+
+  // And a status alone, with neither flag, is not an action.
+  const statusOnly = [
+    { unit: "u1", approve: false, reject: false, status: "completed" },
+    { unit: "u2", approve: false, reject: false, status: "open" },
+  ];
+  assert.equal(readCompletion(statusOnly, "u2").completesSet, false);
+});
+
+test("a one-unit set: its only tick finishes it; an empty set finishes nothing", () => {
+  assert.equal(readCompletion([{ unit: "u1" }], "u1").completesSet, true);
+  assert.deepEqual(readCompletion([], "u1"), {
+    completesSet: false,
+    hasEvidence: false,
   });
-  assert.equal(error, undefined, error?.message);
+});
+
+test("ids compare as strings (ObjectId vs the route param)", () => {
+  const oid = { toString: () => "68f05fbe0c11062938dadad9" };
+  const units = [
+    { unit: oid, approve: false, reject: false },
+    { unit: "u2", approve: true, reject: false },
+  ];
+  assert.equal(
+    readCompletion(units, "68f05fbe0c11062938dadad9").completesSet,
+    true
+  );
+});
+
+test("evidence counts only OTHER units' photos", () => {
+  const units = [
+    { unit: "u1", approve: false, reject: true, attachment: ["f1"] },
+    { unit: "u2", approve: false, reject: false, attachment: [] },
+  ];
+  assert.equal(readCompletion(units, "u2").hasEvidence, true);
+  assert.equal(readCompletion(units, "u1").hasEvidence, false);
 });
 
 /* ── controls ──────────────────────────────────────────────────────────── */
 
-test("CONTROL: the other required fields still are", () => {
-  // Without this, the assertions above could pass against a schema that
-  // validates nothing.
-  for (const missing of ["id", "unit", "completedBy"]) {
-    const payload = {
-      ...base,
-      decision: "approve",
-      approve: true,
-      attachment: ["a1"],
-    };
-    delete payload[missing];
-    assert.ok(validate(payload).error, `${missing} is no longer required`);
-  }
+test("CONTROL: the rule can actually say yes", () => {
+  // Without this, every assertion above could be passing against a function
+  // that returns false unconditionally.
+  assert.equal(requiresCompletionPhoto(completing), true);
 });
 
 test("CONTROL: the message names the action a person must take", () => {
   // "Invalid payload" tells a technician standing in a plant room nothing.
-  const { error } = validate({ ...base, decision: "approve", approve: true });
-  assert.match(error.message, /take or upload at least one photo/i);
+  assert.match(COMPLETION_PHOTO_MESSAGE, /take or upload at least one photo/i);
 });