@7365admin1/module-hygiene 4.29.1-staging.14 → 4.29.1-staging.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/module-hygiene",
   "license": "MIT",
-  "version": "4.29.1-staging.14",
+  "version": "4.29.1-staging.16",
   "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 src/utils/completion-photo.util.ts src/utils/area-unit.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 src/utils/area-unit.util.ts src/utils/escape-regex.util.ts src/utils/schedule-task-rules.util.ts --format esm --out-dir test/.build --no-dts --silent && node --test \"test/*.test.mjs\""
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.0",

package/test/escape-regex.util.test.mjs

@@ -0,0 +1,26 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { escapeRegex } from "./.build/escape-regex.util.mjs";
+
+test("search text is matched literally, not run as a pattern", () => {
+  for (const typed of [".*", "(a+)+$", "[", "a|b", "^x$", "\\", "50% off (new)"]) {
+    const rx = new RegExp(escapeRegex(typed), "i");
+    assert.ok(rx.test(`xx${typed}yy`), `${typed} should match itself`);
+  }
+  assert.equal(new RegExp(escapeRegex(".*"), "i").test("anything"), false);
+});
+
+test("missing or non-string search stays harmless", () => {
+  assert.equal(escapeRegex(undefined), "");
+  assert.equal(escapeRegex(null), "");
+  assert.equal(escapeRegex(42), "42");
+});
+
+test("every repository $regex on a search box goes through escapeRegex", () => {
+  const dir = new URL("../src/repositories/", import.meta.url);
+  for (const f of readdirSync(dir)) {
+    const src = readFileSync(new URL(f, dir), "utf8");
+    assert.doesNotMatch(src, /\$regex:\s*search\b/, `${f} passes raw search into $regex`);
+  }
+});

package/test/schedule-task-rules.test.mjs

@@ -0,0 +1,185 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import Joi from "joi";
+import {
+  occursOn,
+  shouldRunNow,
+  nextRun,
+  lastRun,
+  scheduleState,
+  scheduleDisplay,
+  validateScheduleRules,
+  scheduleTaskFields,
+  cleanScheduleInput,
+  splitScheduleUpdate,
+  regularSetsMissing,
+  sgtParts,
+  timingChanged,
+} from "./.build/schedule-task-rules.util.mjs";
+
+// 2026-10-20 is a Tuesday. All times Singapore time.
+const at = (s) => new Date(`${s}:00+08:00`);
+const base = { time: "08:00", createdAt: at("2026-10-01T09:00") };
+
+test("old task (dates only) behaves as before", () => {
+  const t = { ...base, dates: ["2026-10-21"] };
+  assert.equal(occursOn(t, "2026-10-21"), true);
+  assert.equal(occursOn(t, "2026-10-22"), false);
+  assert.equal(shouldRunNow(t, at("2026-10-21T08:00")), true);
+  assert.equal(shouldRunNow(t, at("2026-10-22T08:00")), false);
+  assert.equal(shouldRunNow(t, at("2026-10-21T07:59")), false);
+});
+
+test("sgtParts uses the Singapore day, not UTC", () => {
+  // 23:30 UTC on the 20th is 07:30 on the 21st in Singapore
+  assert.deepEqual(sgtParts(new Date("2026-10-20T23:30:00Z")), { date: "2026-10-21", minutes: 450, weekday: 3 });
+});
+
+test("missed minute: runs later the same day, once", () => {
+  const t = { ...base, dates: ["2026-10-21"] };
+  assert.equal(shouldRunNow(t, at("2026-10-21T08:01")), true, "restart at 08:00 -> catches up at 08:01");
+  assert.equal(shouldRunNow(t, at("2026-10-21T17:45")), true, "still catches up in the evening");
+  assert.equal(shouldRunNow({ ...t, lastRunDate: "2026-10-21" }, at("2026-10-21T08:02")), false, "never twice");
+  assert.equal(shouldRunNow({ ...t, lastRunDate: "2026-10-20" }, at("2026-10-21T08:02")), true, "yesterday's marker does not block today");
+});
+
+test("a task saved at or after its due time today does not fire on the save", () => {
+  const t = { ...base, dates: ["2026-10-21"], updatedAt: at("2026-10-21T08:00") };
+  assert.equal(shouldRunNow(t, at("2026-10-21T08:00")), false);
+  assert.equal(shouldRunNow(t, at("2026-10-21T09:30")), false);
+  const early = { ...base, dates: ["2026-10-21"], updatedAt: at("2026-10-21T07:00") };
+  assert.equal(shouldRunNow(early, at("2026-10-21T08:00")), true);
+  // empty updatedAt (new rows) falls back to createdAt
+  assert.equal(shouldRunNow({ ...base, dates: ["2026-10-21"], updatedAt: "" }, at("2026-10-21T08:00")), true);
+});
+
+test("paused never runs; end date stops a repeat", () => {
+  const t = { ...base, repeat: "daily", startDate: "2026-10-01", dates: [] };
+  assert.equal(shouldRunNow(t, at("2026-10-21T08:00")), true);
+  assert.equal(shouldRunNow({ ...t, paused: true }, at("2026-10-21T08:00")), false);
+  assert.equal(shouldRunNow({ ...t, endDate: "2026-10-20" }, at("2026-10-21T08:00")), false);
+  assert.equal(shouldRunNow({ ...t, endDate: "2026-10-21" }, at("2026-10-21T08:00")), true);
+  assert.equal(shouldRunNow({ ...t, startDate: "2026-10-22" }, at("2026-10-21T08:00")), false);
+});
+
+test("repeat rules: weekdays, weekly, monthly", () => {
+  const wk = { ...base, repeat: "weekdays", startDate: "2026-10-01" };
+  assert.equal(occursOn(wk, "2026-10-23"), true); // Fri
+  assert.equal(occursOn(wk, "2026-10-24"), false); // Sat
+  assert.equal(occursOn(wk, "2026-10-25"), false); // Sun
+  const weekly = { ...base, repeat: "weekly", daysOfWeek: [1, 3], startDate: "2026-10-01" };
+  assert.equal(occursOn(weekly, "2026-10-21"), true); // Wed
+  assert.equal(occursOn(weekly, "2026-10-22"), false);
+  assert.equal(occursOn({ ...weekly, daysOfWeek: undefined }, "2026-10-21"), false);
+  const monthly = { ...base, repeat: "monthly", dayOfMonth: 31, startDate: "2026-01-31" };
+  assert.equal(occursOn(monthly, "2026-10-31"), true);
+  assert.equal(occursOn(monthly, "2026-11-30"), true, "31st runs on the last day of a short month");
+  assert.equal(occursOn(monthly, "2026-11-29"), false);
+  assert.equal(occursOn({ ...monthly, dayOfMonth: undefined, startDate: "2026-10-15" }, "2026-11-15"), true, "default day = day of start date");
+  assert.equal(occursOn({ ...base, repeat: "none", dates: ["2026-10-21"] }, "2026-10-21"), true, "repeat none = dates");
+});
+
+test("end date also trims a plain dates list", () => {
+  const t = { ...base, dates: ["2026-10-21", "2026-10-28"], endDate: "2026-10-25" };
+  assert.equal(occursOn(t, "2026-10-28"), false);
+  assert.equal(nextRun(t, at("2026-10-22T09:00")), null);
+});
+
+test("nextRun / lastRun / state", () => {
+  const t = { ...base, repeat: "weekdays", startDate: "2026-10-01" };
+  assert.equal(nextRun(t, at("2026-10-20T07:00")), "2026-10-20T08:00:00+08:00");
+  assert.equal(nextRun({ ...t, lastRunDate: "2026-10-20" }, at("2026-10-20T09:00")), "2026-10-21T08:00:00+08:00");
+  assert.equal(nextRun(t, at("2026-10-23T09:00")), "2026-10-23T08:00:00+08:00", "due today and not run yet: the runner is about to catch it up");
+  assert.equal(nextRun({ ...t, lastRunDate: "2026-10-23" }, at("2026-10-23T09:00")), "2026-10-26T08:00:00+08:00", "Friday already run -> Monday");
+  assert.equal(nextRun({ ...t, paused: true }, at("2026-10-20T07:00")), null);
+  assert.equal(scheduleState({ ...t, paused: true }, at("2026-10-20T07:00")), "paused");
+  assert.equal(scheduleState(t, at("2026-10-20T07:00")), "active");
+  assert.equal(scheduleState({ ...t, endDate: "2026-10-19" }, at("2026-10-20T07:00")), "ended");
+  const once = { ...base, dates: ["2026-10-20"], lastRunDate: "2026-10-20" };
+  assert.equal(scheduleState(once, at("2026-10-20T12:00")), "ended");
+  assert.equal(lastRun(once), "2026-10-20T08:00:00+08:00");
+  assert.equal(lastRun(base), null);
+  assert.deepEqual(Object.keys(scheduleDisplay(once, at("2026-10-20T12:00"))), ["nextRun", "lastRun", "scheduleStatus"]);
+  const future = { ...base, repeat: "daily", startDate: "2030-01-01" };
+  assert.equal(nextRun(future, at("2026-10-20T07:00")), "2030-01-01T08:00:00+08:00", "start date far ahead");
+  assert.equal(validateScheduleRules(future, at("2026-10-20T07:00")), null);
+  const monthly = { ...base, repeat: "monthly", dayOfMonth: 31, startDate: "2026-01-31" };
+  assert.equal(nextRun(monthly, at("2026-11-01T00:00")), "2026-11-30T08:00:00+08:00");
+});
+
+test("validation: plain-English problems", () => {
+  const now = at("2026-10-20T10:00");
+  const ok = { ...base, dates: ["2026-10-21"] };
+  assert.equal(validateScheduleRules(ok, now), null);
+  assert.match(validateScheduleRules({ ...base, dates: ["2026-10-19"] }, now), /already passed/);
+  assert.match(validateScheduleRules({ ...base, dates: ["2026-10-20"] }, now), /time has already passed today/);
+  assert.equal(validateScheduleRules({ ...base, time: "11:00", dates: ["2026-10-20"] }, now), null);
+  assert.match(validateScheduleRules({ ...ok, endDate: "2026-10-19" }, now), /end date/);
+  assert.match(validateScheduleRules({ ...base, repeat: "daily" }, now), /start date/);
+  assert.match(validateScheduleRules({ ...base, repeat: "weekly", startDate: "2026-10-21" }, now), /at least one weekday/);
+  assert.match(validateScheduleRules({ ...base, repeat: "daily", startDate: "2026-10-25", endDate: "2026-10-22" }, now), /on or after the start date/);
+  assert.equal(validateScheduleRules({ ...base, repeat: "daily", startDate: "2026-10-01", endDate: "2026-12-31" }, now), null);
+  assert.match(validateScheduleRules({ ...base, repeat: "daily", startDate: "2026-10-01", endDate: "2026-10-20" }, now), /never run/);
+});
+
+test("Joi rules: required fields and time format", () => {
+  const schema = Joi.object(scheduleTaskFields);
+  const good = { title: "Extra wipe", time: "08:30", dates: ["2026-10-21"], areas: [{ name: "Lobby", value: "a" }] };
+  assert.equal(schema.validate(good).error, undefined);
+  const msg = (v) => schema.validate(v).error?.message;
+  assert.equal(msg({ ...good, title: "" }), "Please enter a title.");
+  assert.equal(msg({ ...good, title: undefined }), "Please enter a title.");
+  assert.equal(msg({ ...good, time: "8:30" }), "Time must be in 24-hour format like 08:30.");
+  assert.equal(msg({ ...good, time: undefined }), "Please choose a time.");
+  assert.equal(msg({ ...good, areas: [] }), "Pick at least one area.");
+  assert.equal(msg({ ...good, dates: [] }), "Pick at least one date, or choose a repeat.");
+  assert.equal(msg({ ...good, dates: undefined }), "Pick at least one date, or choose a repeat.");
+  assert.equal(msg({ ...good, dates: ["2026-02-30"] }), "That date does not exist. Dates must look like 2026-10-21.");
+  assert.equal(msg({ ...good, repeat: "yearly" }), "Repeat must be one of: none, daily, weekdays, weekly, monthly.");
+  assert.equal(msg({ ...good, daysOfWeek: [7] }), "Weekdays must be numbers from 0 (Sunday) to 6 (Saturday).");
+  // a repeat does not need picked dates
+  assert.equal(schema.validate({ ...good, dates: undefined, repeat: "daily", startDate: "2026-10-21" }).error, undefined);
+  // "" / null on the optional fields is accepted (cleaned away afterwards)
+  assert.equal(schema.validate({ ...good, repeat: "", endDate: null, paused: null }).error, undefined);
+});
+
+test("cleanScheduleInput / splitScheduleUpdate", () => {
+  assert.deepEqual(cleanScheduleInput({ title: "x", repeat: "", endDate: null }), { title: "x" });
+  assert.deepEqual(cleanScheduleInput({ repeat: "none", startDate: "2026-10-21", daysOfWeek: [1] }), { repeat: "none" });
+  const { set, unset } = splitScheduleUpdate({ title: "y", endDate: null, paused: true });
+  assert.deepEqual(set, { title: "y", paused: true });
+  assert.deepEqual(unset, ["endDate"]);
+  const none = splitScheduleUpdate({ repeat: "none", daysOfWeek: [1] });
+  assert.deepEqual(none.set, { repeat: "none" });
+  assert.deepEqual(none.unset.sort(), ["dayOfMonth", "daysOfWeek", "startDate"]);
+});
+
+test("extra visit before the daily list does not cancel the regular visits", () => {
+  const extraOnly = [{ set: 1, isScheduleTask: true }, { set: 2, isScheduleTask: true }];
+  assert.equal(regularSetsMissing(extraOnly, 2), 2, "area wants 2 visits a day: both still to be added");
+  assert.equal(regularSetsMissing([...extraOnly, { set: 3, isScheduleTask: false }], 2), 1);
+  assert.equal(regularSetsMissing([{ set: 1 }, { set: 2 }], 2), 0, "sets with no flag are regular");
+  assert.equal(regularSetsMissing(undefined, 3), 3);
+});
+
+test("edit of a finished task: only a real timing change is re-checked", () => {
+  // stored: all dates past, time already passed. The apps resend the whole form.
+  const stored = { time: "08:00", dates: ["2026-10-19", "2026-10-18"], repeat: "none", description: "old" };
+  const sent = { ...stored, dates: ["2026-10-18", "2026-10-19"], repeat: "", endDate: null, startDate: "", description: "new" };
+  assert.equal(timingChanged(stored, sent), false, "same values, other order / blanks");
+  assert.equal(timingChanged({ ...stored, repeat: undefined }, { ...stored, repeat: "none" }), false);
+  assert.equal(timingChanged(stored, { ...sent, time: "09:00" }), true);
+  assert.equal(timingChanged(stored, { ...sent, dates: ["2026-10-19"] }), true);
+  assert.equal(timingChanged(stored, { ...sent, repeat: "daily", startDate: "2026-10-01" }), true);
+  assert.equal(timingChanged(stored, { ...sent, endDate: "2026-12-31" }), true);
+});
+
+test("a row with no / null time never throws and has no next run", () => {
+  const now = at("2026-10-20T10:00");
+  for (const time of [undefined, null, "", "8am"]) {
+    const row = { time, dates: ["2026-10-21"] };
+    assert.deepEqual(scheduleDisplay(row, now), { nextRun: null, lastRun: null, scheduleStatus: "ended" });
+    assert.equal(shouldRunNow(row, now), false);
+  }
+  assert.doesNotThrow(() => scheduleDisplay({ time: null, dates: null, repeat: "weekly" }, now));
+});