@7365admin1/layer-common 4.0.3-staging.232 → 4.0.3-staging.234

package/utils/client-nature.test.ts

@@ -1,77 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-/**
- * THE CLIENT LIST'S "NATURE" COLUMN.
- *
- * The column prints `formatNature(org.nature)`, the same helper the admin app's
- * Organizations list uses - so the two screens say a nature the same way while
- * both exist, and the console keeps saying it after that screen is retired.
- *
- * `nature` is a REQUIRED enum on the organisation model
- * (`iservice365-core/src/models/organization.model.ts` `allowedNatures`), so
- * what this asserts is that every legal value comes out as something a person
- * reads - not a raw `security_agency`.
- *
- * `useUtils()` is a Nuxt composable: it opens with `useState("search", ...)`,
- * which only exists inside a Nuxt app. One stub makes the factory constructible
- * here; `formatNature` itself touches nothing but its argument.
- */
-(globalThis as any).useState = (_key: string, init: () => any) => ({
-  value: init(),
-});
-
-const { formatNature } = (await import("../composables/useUtils.ts")).default();
-
-/** `allowedNatures`, copied from the core model, in the model's own order. */
-const ALLOWED_NATURES = [
-  "real_estate_developer",
-  "property_management_agency",
-  "security_agency",
-  "cleaning_services",
-  "mechanical_electrical_services",
-  "landscaping_services",
-  "pest_control_services",
-  "pool_maintenance_services",
-];
-
-test("every nature the organisation model allows prints as words", () => {
-  assert.deepEqual(
-    ALLOWED_NATURES.map((v) => formatNature(v)),
-    [
-      "Real Estate Developer",
-      "Property Management Agency",
-      "Security Agency",
-      "Cleaning Services",
-      "Mechanical Electrical Services",
-      "Landscaping Services",
-      "Pest Control Services",
-      "Pool Maintenance Services",
-    ],
-  );
-});
-
-test("no allowed nature is left as its stored value", () => {
-  for (const value of ALLOWED_NATURES) {
-    const label = formatNature(value);
-    assert.notEqual(label, value, `${value} was printed raw`);
-    assert.ok(!label.includes("_"), `${value} kept an underscore`);
-  }
-});
-
-test("an organisation with no nature yields nothing, so the column says so itself", () => {
-  // The cell renders `nature ? formatNature(nature) : 'Not recorded'`. This is
-  // the half that decides the fallback is needed: the helper answers "" rather
-  // than a label, and a blank cell reads as a broken screen.
-  assert.equal(formatNature(""), "");
-  assert.equal(formatNature(undefined as unknown as string), "");
-  assert.equal(formatNature(null as unknown as string), "");
-});
-
-test("a value the model does not list is still printed, not swallowed", () => {
-  // `customer.service.ts` creates property-owner orgs with `property_owner`,
-  // which is NOT in `allowedNatures`. Those rows appear in the Client List, and
-  // the column showing what they are is the point - so an unknown value is
-  // formatted like any other rather than blanked.
-  assert.equal(formatNature("property_owner"), "Property Owner");
-});

package/utils/client-subscription.test.ts

@@ -1,240 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import {
-  NOT_SET,
-  describeClientSubscription,
-  formatDate,
-} from "./client-subscription.ts";
-
-/** What the list endpoint really returns for an org that HAS a subscription. */
-function orgWithSub(sub: Record<string, any>) {
-  return {
-    _id: "org1",
-    name: "A Client",
-    status: "active",
-    subscription: {
-      _id: "sub1",
-      org: "org1",
-      type: "organization",
-      billingCycle: "monthly",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      nextBillingDate: "2027-01-01T00:00:00.000Z",
-      status: "active",
-      ...sub,
-    },
-  };
-}
-
-const NOW = new Date("2026-08-20T00:00:00.000Z");
-
-test("no subscription document is a state, not a broken row", () => {
-  // The left join collapses a missing subscription to `{}` - this is the shape
-  // 11 production clients are in, and it used to render as four dashes.
-  for (const org of [{ subscription: {} }, { subscription: null }, {}, null, undefined]) {
-    const v = describeClientSubscription(org as any, NOW);
-    assert.equal(v.state, "none", JSON.stringify(org));
-    assert.equal(v.label, "No subscription set up");
-    assert.equal(v.billingCycle, NOT_SET);
-    assert.equal(v.start, NOT_SET);
-    assert.equal(v.end, NOT_SET);
-    assert.equal(v.needsAttention, false);
-  }
-});
-
-test("a running record with nothing else proven is plain Active, never 'paying'", () => {
-  // Nothing the endpoint sends proves anybody is paying, so it must not say so.
-  const v = describeClientSubscription(orgWithSub({}), NOW);
-  assert.equal(v.state, "active");
-  assert.equal(v.label, "Active");
-  assert.equal(v.billingCycle, "Monthly");
-  assert.equal(v.needsAttention, false);
-});
-
-test("complimentary is only claimed when the record says so", () => {
-  const v = describeClientSubscription(
-    orgWithSub({ billingMode: "complimentary" }),
-    NOW,
-  );
-  assert.equal(v.state, "complimentary");
-  assert.equal(v.label, "Complimentary (not charged)");
-
-  // and the opposite claim needs the same proof
-  assert.equal(
-    describeClientSubscription(orgWithSub({ billingMode: "paid" }), NOW).label,
-    "Active (paying)",
-  );
-});
-
-test("suspended and ended come from the record's own status", () => {
-  assert.equal(
-    describeClientSubscription(orgWithSub({ status: "suspended" }), NOW).state,
-    "suspended",
-  );
-
-  for (const s of ["ended", "canceled", "cancelled", "expired", "TERMINATED", " Ended "]) {
-    const v = describeClientSubscription(orgWithSub({ status: s }), NOW);
-    assert.equal(v.state, "ended", s);
-    assert.equal(v.label, "Ended");
-    assert.equal(v.needsAttention, false);
-  }
-});
-
-test("owner decision 8: a passed end date is flagged, not silently left as Active", () => {
-  const v = describeClientSubscription(
-    orgWithSub({ nextBillingDate: "2026-08-01T00:00:00.000Z" }),
-    NOW,
-  );
-  assert.equal(v.state, "ended");
-  assert.equal(v.label, "Ended (needs attention)");
-  assert.equal(v.needsAttention, true);
-});
-
-test("a suspended record is not re-labelled by its dates", () => {
-  // Status wins: a client already suspended does not need flagging again.
-  const v = describeClientSubscription(
-    orgWithSub({ status: "suspended", nextBillingDate: "2026-08-01T00:00:00.000Z" }),
-    NOW,
-  );
-  assert.equal(v.state, "suspended");
-  assert.equal(v.needsAttention, false);
-});
-
-test("Phase 2's startDate / endDate win over the fallbacks when they arrive", () => {
-  const v = describeClientSubscription(
-    orgWithSub({
-      startDate: "2026-03-05T00:00:00.000Z",
-      endDate: "2027-03-05T00:00:00.000Z",
-      createdAt: "2020-01-01T00:00:00.000Z",
-      nextBillingDate: "2020-02-01T00:00:00.000Z",
-    }),
-    NOW,
-  );
-  // The stale fallbacks are both in the past; if they had won, this row would
-  // have been flagged. It is not, so the real dates were used.
-  assert.equal(v.state, "active");
-  assert.equal(v.start, formatDate("2026-03-05T00:00:00.000Z"));
-  assert.equal(v.end, formatDate("2027-03-05T00:00:00.000Z"));
-});
-
-test("a missing or unreadable value says 'Not set', not a dash", () => {
-  assert.equal(formatDate(null), NOT_SET);
-  assert.equal(formatDate(""), NOT_SET);
-  assert.equal(formatDate("not a date"), NOT_SET);
-  assert.notEqual(formatDate("2026-08-20T00:00:00.000Z"), NOT_SET);
-
-  const v = describeClientSubscription(
-    orgWithSub({ billingCycle: "", createdAt: null, nextBillingDate: null }),
-    NOW,
-  );
-  assert.equal(v.billingCycle, NOT_SET);
-  assert.equal(v.start, NOT_SET);
-  assert.equal(v.end, NOT_SET);
-  assert.equal(v.state, "active");
-});
-
-test("a billing cycle the screen does not know is shown, not swallowed", () => {
-  assert.equal(
-    describeClientSubscription(orgWithSub({ billingCycle: "quarterly" }), NOW).billingCycle,
-    "quarterly",
-  );
-  assert.equal(
-    describeClientSubscription(orgWithSub({ billingCycle: "YEARLY" }), NOW).billingCycle,
-    "Yearly",
-  );
-});
-
-/* ── SUSPEND / REACTIVATE, THE STATE THE LIST HAS TO SHOW AFTERWARDS ──────
- *
- * `PATCH /api/organizations/:id/status` (core `organization.controller.ts`
- * `updateStatus`) writes BOTH `organizations.status` and the organisation's
- * subscription status - the second one so the hourly sync job agrees rather
- * than undoing the decision an hour later. So after the list is re-read, a
- * suspended client arrives with both set, and this is what the row then says.
- * Nothing in the screen holds a second copy of that state.
- */
-
-/** Exactly what `updateStatus` leaves behind, applied to a list row. */
-function afterStatusChange(org: Record<string, any>, status: "active" | "suspended") {
-  return {
-    ...org,
-    status,
-    subscription: org.subscription?._id
-      ? { ...org.subscription, status }
-      : org.subscription,
-  };
-}
-
-test("suspending a client makes the row say Suspended", () => {
-  const before = orgWithSub({});
-  assert.equal(describeClientSubscription(before, NOW).state, "active");
-
-  const after = afterStatusChange(before, "suspended");
-  const v = describeClientSubscription(after, NOW);
-
-  assert.equal(v.state, "suspended");
-  assert.equal(v.label, "Suspended");
-  // Suspension is a decision somebody took, not a thing needing attention.
-  assert.equal(v.needsAttention, false);
-  // The dates are untouched - "data is kept" is visible, not just claimed.
-  assert.equal(v.billingCycle, describeClientSubscription(before, NOW).billingCycle);
-  assert.equal(v.start, describeClientSubscription(before, NOW).start);
-  assert.equal(v.end, describeClientSubscription(before, NOW).end);
-});
-
-test("reactivating puts the row back exactly where it was", () => {
-  const before = orgWithSub({});
-  const round = afterStatusChange(afterStatusChange(before, "suspended"), "active");
-
-  assert.deepEqual(
-    describeClientSubscription(round, NOW),
-    describeClientSubscription(before, NOW),
-  );
-});
-
-test("a complimentary client suspends and reactivates the same way", () => {
-  // All 11 production clients are complimentary, so this is the case that
-  // actually happens - and `billingMode` must survive the round trip.
-  const before = orgWithSub({ billingMode: "complimentary" });
-  assert.equal(describeClientSubscription(before, NOW).state, "complimentary");
-
-  assert.equal(
-    describeClientSubscription(afterStatusChange(before, "suspended"), NOW).state,
-    "suspended",
-  );
-  assert.equal(
-    describeClientSubscription(afterStatusChange(before, "active"), NOW).state,
-    "complimentary",
-  );
-});
-
-test("a client with NO subscription document still suspends", () => {
-  // `updateStatus` writes the organisation's status either way and only
-  // touches a subscription if one exists. This row has none, so the
-  // subscription column keeps saying so - the ORGANISATION's status is what
-  // moved it to the Suspended tab, and that is the honest reading of the
-  // record. The list is fetched per tab, so the row is on the tab that matches.
-  const before = { _id: "o-1", name: "A Client", status: "active", subscription: {} };
-  const after = afterStatusChange(before, "suspended");
-
-  assert.equal(after.status, "suspended");
-  assert.equal(describeClientSubscription(after, NOW).state, "none");
-  assert.equal(describeClientSubscription(after, NOW).label, "No subscription set up");
-});
-
-test("suspending does not clear an end date that had already passed", () => {
-  // Owner decision 8's flag and a suspension are different things, and the
-  // flag is derived at read time - suspending must not hide the fact that the
-  // subscription had run out, because reactivating brings it straight back.
-  const overdue = orgWithSub({ nextBillingDate: "2026-01-01T00:00:00.000Z" });
-  assert.equal(describeClientSubscription(overdue, NOW).needsAttention, true);
-
-  assert.equal(
-    describeClientSubscription(afterStatusChange(overdue, "suspended"), NOW).state,
-    "suspended",
-  );
-  assert.equal(
-    describeClientSubscription(afterStatusChange(overdue, "active"), NOW).needsAttention,
-    true,
-  );
-});

package/utils/console-tier.test.ts

@@ -1,87 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { consoleTier } from "./console-tier.ts";
-
-/** The seeded platform-staff role - `user.service.ts createDefaultUser()`. */
-const OWNER_ROLE = {
-  _id: "r-owner",
-  name: "Super Admin",
-  type: "admin",
-  default: true,
-  permissions: [],
-};
-
-/** A role made through the admin app. `default` is not in its Joi schema. */
-const STAFF_ROLE = {
-  _id: "r-staff",
-  name: "Operations",
-  type: "admin",
-  permissions: ["organization:read"],
-};
-
-const ADMIN_MEMBER = { _id: "m-1", user: "u-1", type: "admin", role: "r-owner" };
-
-test("the owner is an admin member on an admin role marked default", () => {
-  assert.equal(consoleTier(ADMIN_MEMBER, OWNER_ROLE), "owner");
-});
-
-test("ordinary Seven365 staff are admin, but their role is not the default one", () => {
-  assert.equal(consoleTier(ADMIN_MEMBER, STAFF_ROLE), "staff");
-  // The absence of the field, not just `false`, is the ordinary case: the admin
-  // app's create-role form cannot send it at all.
-  assert.equal(consoleTier(ADMIN_MEMBER, { ...STAFF_ROLE, default: false }), "staff");
-});
-
-test("BOTH halves are required - a role name proves nothing", () => {
-  // Staging carries an ordinary ORGANISATION role merely NAMED "Super Admin",
-  // and `web-app-org/pages/index.vue` gated the whole console on that name.
-  // That row must not reach owner, or staff, on the strength of its name.
-  const impostor = { _id: "r-x", name: "Super Admin", type: "organization", default: true };
-  assert.equal(consoleTier(ADMIN_MEMBER, impostor), "none");
-
-  // ...and an admin-typed role held through a non-admin membership is not
-  // staff either. `isSuperAdmin` requires `members.type === "admin"` too.
-  assert.equal(consoleTier({ ...ADMIN_MEMBER, type: "organization" }, OWNER_ROLE), "none");
-});
-
-test("`default` is only honoured when it is exactly true", () => {
-  // A truthy-but-not-true value is not what `createDefaultUser` writes, and the
-  // server compares with `===`. Drawing an owner control off `"true"` or `1`
-  // would show a button the server then refuses.
-  for (const value of ["true", 1, {}, "yes"]) {
-    assert.equal(
-      consoleTier(ADMIN_MEMBER, { ...STAFF_ROLE, default: value }),
-      "staff",
-      JSON.stringify(value),
-    );
-  }
-});
-
-test("anything unproven is `none` - this fails closed", () => {
-  const unproven: Array<[any, any]> = [
-    [null, OWNER_ROLE],
-    [undefined, OWNER_ROLE],
-    [{}, OWNER_ROLE],
-    [ADMIN_MEMBER, null], // the role request failed
-    [ADMIN_MEMBER, undefined],
-    [ADMIN_MEMBER, {}],
-    [null, null],
-    // An error body answered instead of a record. `member.controller.ts`
-    // answers `NotFoundError` as JSON, so this is a real wire shape.
-    [{ status: "error", message: "Member not found." }, OWNER_ROLE],
-  ];
-
-  for (const [member, role] of unproven) {
-    assert.equal(consoleTier(member, role), "none", JSON.stringify([member, role]));
-  }
-});
-
-test("a deleted staff membership is not staff", () => {
-  // `isSuperAdmin` excludes it server-side; the endpoint the browser reads does
-  // not, so it is excluded here to keep the two answers the same.
-  assert.equal(
-    consoleTier({ ...ADMIN_MEMBER, status: "deleted" }, OWNER_ROLE),
-    "none",
-  );
-});

package/utils/dashboard.test.ts

@@ -1,118 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { buildWorkOrderStatus } from "./dashboard.ts";
-
-/**
- * THE DEFECT THIS FILE EXISTS FOR.
- *
- * The Property Management "Work Order Status" panel read
- * `workOrderStatusSummary` - a key no endpoint returns - and fell through to
- * the `openWorkOrder` KPI metric, which carries no `completed` field. So
- * Completed read 0 on every site on every day, and Pending was silently
- * recomputed as (open work orders - in progress) instead of read.
- *
- * The shape below is the one `new-dashboard.repo.ts` actually sends.
- */
-test("the server's breakdown is read, not recomputed", () => {
-  const rows = buildWorkOrderStatus({
-    pending: 20,
-    inProgress: 12,
-    completed: 55,
-  });
-
-  assert.deepEqual(
-    rows.map((r) => [r.label, r.value]),
-    [
-      ["Completed", 55],
-      ["In Progress", 12],
-      ["Pending", 20],
-    ]
-  );
-});
-
-/**
- * The exact regression. Before the fix this same input drew
- * Completed 0 / In Progress 12 / Pending 28.
- */
-test("Completed is never zero when the server says it is not", () => {
-  const completed = buildWorkOrderStatus({
-    pending: 20,
-    inProgress: 12,
-    completed: 55,
-  }).find((r) => r.label === "Completed");
-
-  assert.equal(completed?.value, 55);
-});
-
-/**
- * The bars are share-of-largest-bucket, so the biggest is always full width
- * and the rest are proportional to it. This is the widths the panel draws.
- */
-test("each bar is its share of the largest bucket", () => {
-  const rows = buildWorkOrderStatus({ pending: 25, inProgress: 50, completed: 100 });
-
-  assert.deepEqual(
-    rows.map((r) => r.percent),
-    [100, 50, 25]
-  );
-});
-
-/** Three empty buckets must draw three empty bars, not divide by zero. */
-test("an all-zero breakdown does not divide by zero", () => {
-  const rows = buildWorkOrderStatus({ pending: 0, inProgress: 0, completed: 0 });
-
-  assert.equal(rows.length, 3);
-  for (const row of rows) {
-    assert.equal(row.value, 0);
-    assert.equal(row.percent, 0, row.label);
-    assert.ok(Number.isFinite(row.percent), row.label);
-  }
-});
-
-/** A partial payload is read for what it has and zeroed for what it does not. */
-test("missing buckets read as zero rather than undefined", () => {
-  const rows = buildWorkOrderStatus({ completed: 7 });
-
-  assert.deepEqual(
-    rows.map((r) => r.value),
-    [7, 0, 0]
-  );
-});
-
-/**
- * NO FALLBACK, DELIBERATELY. When the breakdown is absent there is nothing
- * honest to draw, so the panel must show its empty state - not bars built out
- * of a different metric. An empty array is what triggers that.
- */
-test("no breakdown means no bars, never invented ones", () => {
-  assert.deepEqual(buildWorkOrderStatus(undefined), []);
-  assert.deepEqual(buildWorkOrderStatus(null), []);
-  assert.deepEqual(buildWorkOrderStatus(42 as never), []);
-  assert.deepEqual(buildWorkOrderStatus("55" as never), []);
-});
-
-/**
- * The tone is a token NAME, not a colour. The template writes `var(--<tone>)`,
- * so a tone that is not a real token silently paints nothing.
- */
-test("every row carries a real design token name", () => {
-  const rows = buildWorkOrderStatus({ pending: 1, inProgress: 2, completed: 3 });
-
-  assert.deepEqual(
-    rows.map((r) => r.tone),
-    ["ok", "err", "warn"]
-  );
-});
-
-/**
- * The buckets are the whole of the server's status report - it folds every
- * unrecognised status into `pending` rather than dropping it - so nothing the
- * server counted goes missing on the way to the screen.
- */
-test("the three buckets account for the whole breakdown", () => {
-  const src = { pending: 20, inProgress: 12, completed: 55 };
-  const total = buildWorkOrderStatus(src).reduce((sum, r) => sum + r.value, 0);
-
-  assert.equal(total, src.pending + src.inProgress + src.completed);
-});