@7365admin1/module-hygiene 4.28.1 → 4.28.2-staging.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/module-hygiene",
   "license": "MIT",
-  "version": "4.28.1",
+  "version": "4.28.2-staging.11",
   "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 --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 --format esm --out-dir test/.build --no-dts --silent && node --test \"test/*.test.mjs\""
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.0",
@@ -27,7 +27,7 @@
     "typescript": "^4.9.4"
   },
   "dependencies": {
-    "@7365admin1/core": "^3.41.0",
+    "@7365admin1/core": "^3.50.1",
     "@7365admin1/node-server-utils": "^1.6.0",
     "@types/qrcode": "^1.5.6",
     "@types/urllib": "^2.33.0",

package/test/hygiene-checkout-decision.util.test.mjs

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  CHECKOUT_DECIDABLE_STATUS,
+  CHECKOUT_DECISIONS,
+  applyCheckOutDecision,
+  buildCheckOutDecision,
+  isCheckOutDecision,
+} from "./.build/hygiene-checkout-decision.util.mjs";
+
+/*
+  The check out item approval decision, without a database.
+
+  These assertions pin the two things the repository relies on: the `$set` the
+  decision produces, and the status the update must MATCH on. If the second one
+  is ever dropped, approving an already-decided item stops being a refusal and
+  starts silently overwriting the first decision — which is the failure the
+  match filter exists to prevent.
+*/
+
+const NOW = "2026-09-04T09:00:00.000Z";
+
+test("approving flips the row to completed and records approve, not reject", () => {
+  const set = buildCheckOutDecision("approve", null, NOW);
+
+  assert.equal(set.status, "completed");
+  assert.equal(set.approve, true);
+  assert.equal(set.reject, false);
+  assert.equal(set.updatedAt, NOW);
+});
+
+test("disapproving also terminates the row, and keeps the remarks", () => {
+  const set = buildCheckOutDecision("disapprove", "wrong item drawn", NOW);
+
+  assert.equal(set.status, "completed");
+  assert.equal(set.approve, false);
+  assert.equal(set.reject, true);
+  assert.equal(set.remarks, "wrong item drawn");
+});
+
+test("remarks are never undefined — an absent remark is an empty string", () => {
+  assert.equal(buildCheckOutDecision("approve", undefined, NOW).remarks, "");
+  assert.equal(buildCheckOutDecision("approve", null, NOW).remarks, "");
+});
+
+test("no third status value enters the vocabulary", () => {
+  // `allowedCheckOutItemStatus` is ["pending", "completed"]. A decision must
+  // land inside it, whichever way it goes.
+  for (const decision of CHECKOUT_DECISIONS) {
+    assert.equal(buildCheckOutDecision(decision, "", NOW).status, "completed");
+  }
+});
+
+test("only a pending row is decidable", () => {
+  assert.equal(CHECKOUT_DECIDABLE_STATUS, "pending");
+});
+
+test("the decision vocabulary is exactly the two the client calls", () => {
+  assert.deepEqual([...CHECKOUT_DECISIONS], ["approve", "disapprove"]);
+  assert.ok(isCheckOutDecision("approve"));
+  assert.ok(isCheckOutDecision("disapprove"));
+  assert.equal(isCheckOutDecision("reject"), false);
+  assert.equal(isCheckOutDecision(""), false);
+});
+
+/*
+  Returning the drawn-down quantity to stock on a disapproval.
+
+  A fake stands in for the repository update. It behaves the way the real one
+  does: the row is decided once, and every later attempt matches nothing —
+  which the repository turns into a 404. These tests exist so that a refused
+  decision can never reach the stock call, because a second credit or a second
+  deduction is money the client cannot see going wrong.
+*/
+
+function fakeRow() {
+  let pending = true;
+  const credits = [];
+
+  return {
+    credits,
+    // Mirrors `{ _id, status: "pending" }`: decides once, then matches nothing.
+    decide: async () => {
+      if (!pending) {
+        throw new Error(
+          "Check out item not found or is no longer pending approval.",
+        );
+      }
+      pending = false;
+      return 1;
+    },
+    returnStock: async () => {
+      credits.push(1);
+    },
+  };
+}
+
+test("a disapproval returns the quantity to stock exactly once", async () => {
+  const row = fakeRow();
+
+  assert.equal(
+    await applyCheckOutDecision("disapprove", row.decide, row.returnStock),
+    1,
+  );
+  assert.deepEqual(row.credits, [1]);
+});
+
+test("an approval moves no stock", async () => {
+  const row = fakeRow();
+
+  await applyCheckOutDecision("approve", row.decide, row.returnStock);
+
+  assert.deepEqual(row.credits, []);
+});
+
+test("disapproving twice does not credit stock twice", async () => {
+  const row = fakeRow();
+
+  await applyCheckOutDecision("disapprove", row.decide, row.returnStock);
+
+  await assert.rejects(
+    () => applyCheckOutDecision("disapprove", row.decide, row.returnStock),
+    /no longer pending/,
+  );
+
+  assert.deepEqual(row.credits, [1]);
+});
+
+test("approving after a disapproval is refused, so nothing is deducted again", async () => {
+  const row = fakeRow();
+
+  await applyCheckOutDecision("disapprove", row.decide, row.returnStock);
+
+  await assert.rejects(
+    () => applyCheckOutDecision("approve", row.decide, row.returnStock),
+    /no longer pending/,
+  );
+
+  assert.deepEqual(row.credits, [1]);
+});
+
+test("a decision that matched no row never reaches the stock call", async () => {
+  const credits = [];
+
+  const decided = await applyCheckOutDecision(
+    "disapprove",
+    async () => 0,
+    async () => credits.push(1),
+  );
+
+  assert.equal(decided, 0);
+  assert.deepEqual(credits, []);
+});
+
+test("a failed stock return propagates, so the caller can abort the transaction", async () => {
+  await assert.rejects(
+    () =>
+      applyCheckOutDecision(
+        "disapprove",
+        async () => 1,
+        async () => {
+          throw new Error("Supply not found.");
+        },
+      ),
+    /Supply not found/,
+  );
+});