@7365admin1/layer-common 3.2.8-staging.210 → 3.3.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "3.2.8-staging.210",
+  "version": "3.3.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/utils/hid-discover.test.ts

@@ -96,20 +96,7 @@ test("the reader form takes site as a prop and puts it in the discover call", ()
   assert.match(source, /discoverReader\(\{[\s\S]*?site:\s*props\.site[\s\S]*?\}\)/);
 });
 
-test("reader management passes its site prop down to the form, ONCE", () => {
+test("reader management passes its site prop down to the form", () => {
   const source = readFileSync(join(root, "components", "HidReaderManagement.vue"), "utf8");
-  const tag = source.match(/<HidReaderForm[\s\S]*?\/>/)?.[0] ?? "";
-
-  // Bound to `props.site`, which is the only name for it that exists in this
-  // component - a bare `site` resolves to nothing.
-  assert.match(tag, /:site="props\.site"/);
-
-  /*
-   * And exactly once. It was written twice - `props.site` and then a bare
-   * `site` - and Vite's Vue plugin treats a duplicate attribute as a COMPILE
-   * ERROR, so every consuming application's `nuxt build` failed on this file.
-   * The layer's own playground build does not import this component, so
-   * nothing here caught it; the first sign was a consumer failing to build.
-   */
-  assert.equal((tag.match(/:site=/g) ?? []).length, 1, tag);
+  assert.match(source, /<HidReaderForm[\s\S]*?:site="site"[\s\S]*?\/>/);
 });

package/utils/promo-code-form.test.ts

@@ -1,437 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import {
-  promoExpiryDate,
-  promoCodeFormValues,
-  promoCodeUpdatePayload,
-  validatePromoCodeEdit,
-  promoCodeApiError,
-} from "./promo-code-form.ts";
-
-/**
- * THE PROMO CODE EDITOR AND THE THREE WRITE CALLS BEHIND IT.
- *
- * Two halves, both pinned here:
- *
- *  1. the rules the edit form applies before it sends anything - taken from
- *     the MERGED backend (`promoCodeUpdateSchema` in `@7365admin1/core`), not
- *     from a guess about it;
- *  2. what `usePromoCode()` actually puts on the wire. The composable is three
- *     `$api` calls, and the thing that can silently be wrong about it is the
- *     verb, the path or the body - a `PUT` to the wrong path, or a body that
- *     carries `code` and so looks as though it renamed a code it cannot.
- *
- * The composable reaches for `useNuxtApp()`, which only exists inside a Nuxt
- * app, so one stub stands in for it and records the call.
- */
-
-const NOW = new Date(2026, 7, 20, 12, 0, 0); // 20 Aug 2026, midday
-
-// ---------------------------------------------------------------------------
-// The expiry rule
-// ---------------------------------------------------------------------------
-
-test("an expiry date is read as the END of its day, in both stored formats", () => {
-  // A code dated today is good for all of today, so a check at midday passes.
-  const usFormat = promoExpiryDate("08/20/2026");
-  assert.ok(usFormat);
-  assert.equal(usFormat!.getHours(), 23);
-  assert.ok(usFormat!.getTime() > NOW.getTime());
-
-  const iso = promoExpiryDate("2026-08-20");
-  assert.ok(iso);
-  assert.equal(iso!.getTime(), usFormat!.getTime());
-});
-
-test("a date that is not a date is no expiry at all, never an Invalid Date", () => {
-  assert.equal(promoExpiryDate(""), null);
-  assert.equal(promoExpiryDate(null), null);
-  assert.equal(promoExpiryDate("whenever"), null);
-  // Month 13 rolls into the next year in JavaScript rather than failing, so
-  // it is caught explicitly - otherwise 13/01/2026 would read as Jan 2027.
-  assert.equal(promoExpiryDate("13/01/2026"), null);
-});
-
-// ---------------------------------------------------------------------------
-// Loading a record into the form, and building the body back out
-// ---------------------------------------------------------------------------
-
-test("the form loads from the record and does NOT carry the code", () => {
-  const values = promoCodeFormValues({
-    _id: "652f1a2b3c4d5e6f70819293",
-    code: "WELCOME2026",
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    status: "active",
-  });
-
-  assert.equal((values as any).code, undefined);
-  assert.deepEqual(values, {
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    tiers: [],
-  });
-});
-
-test("a tiered record keeps its bands; a fixed one is given none", () => {
-  const tiered = promoCodeFormValues({
-    type: "tiered",
-    tiers: [{ min: 1, max: 10, price: 9 }, { min: 11, max: 0, price: 7 }],
-  });
-  assert.equal(tiered.tiers.length, 2);
-  assert.deepEqual(tiered.tiers[1], { min: 11, max: 0, price: 7 });
-
-  // A code stored as fixed but carrying leftover bands must not send them:
-  // `promoCodeUpdateSchema` FORBIDS `tiers` on a fixed code and would 400.
-  const fixed = promoCodeFormValues({
-    type: "fixed",
-    fixed_rate: 5,
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.deepEqual(fixed.tiers, []);
-});
-
-test("an empty record gives a usable, valid, fixed-price form", () => {
-  const values = promoCodeFormValues(null);
-  assert.deepEqual(values, {
-    description: "",
-    type: "fixed",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(validatePromoCodeEdit(promoCodeUpdatePayload(values), NOW), null);
-});
-
-test("the payload never contains code, _id or status", () => {
-  const payload = promoCodeUpdatePayload({
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    tiers: [],
-  });
-
-  assert.deepEqual(Object.keys(payload).sort(), [
-    "description",
-    "expiresAt",
-    "fixed_rate",
-    "type",
-  ]);
-});
-
-test("a tiered payload sends bands and no fixed_rate, and the reverse", () => {
-  const tiered = promoCodeUpdatePayload({
-    description: "",
-    type: "tiered",
-    fixed_rate: 99,
-    expiresAt: "",
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.deepEqual(tiered.tiers, [{ min: 1, max: 10, price: 9 }]);
-  assert.equal("fixed_rate" in tiered, false);
-
-  const fixed = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: 9,
-    expiresAt: "",
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.equal("tiers" in fixed, false);
-  assert.equal(fixed.fixed_rate, 9);
-});
-
-test("a price nobody has typed is NOT quietly saved as free", () => {
-  // `Number("")` is 0. Coercing a blank field would turn "not filled in" into
-  // "every seat is free" - a real price, saved without anyone choosing it.
-  const payload = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: "" as any,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(payload.fixed_rate, "");
-  assert.match(
-    String(validatePromoCodeEdit(payload, NOW)),
-    /Enter a price per seat/
-  );
-
-  // A deliberate 0, however, is a real answer and goes through.
-  const free = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(free.fixed_rate, 0);
-  assert.equal(validatePromoCodeEdit(free, NOW), null);
-});
-
-test("band numbers typed as text reach the API as numbers", () => {
-  const payload = promoCodeUpdatePayload({
-    description: "",
-    type: "tiered",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [{ min: "1", max: "10", price: "9.5" } as any],
-  });
-  assert.deepEqual(payload.tiers, [{ min: 1, max: 10, price: 9.5 }]);
-});
-
-// ---------------------------------------------------------------------------
-// What the form refuses, in the API's terms
-// ---------------------------------------------------------------------------
-
-test("a valid edit is refused nothing", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "fixed", fixed_rate: 0, expiresAt: "", description: "" },
-      NOW
-    ),
-    null
-  );
-  assert.equal(
-    validatePromoCodeEdit(
-      {
-        type: "tiered",
-        tiers: [{ min: 1, max: 10, price: 9 }, { min: 11, max: 0, price: 7 }],
-        expiresAt: "12/31/2026",
-      },
-      NOW
-    ),
-    null
-  );
-});
-
-test("an expiry already in the past is refused, and says what to do", () => {
-  const message = validatePromoCodeEdit(
-    { type: "fixed", fixed_rate: 5, expiresAt: "01/01/2020" },
-    NOW
-  );
-  assert.match(String(message), /already passed/);
-  assert.match(String(message), /clear the date/);
-});
-
-test("TODAY is not in the past - a code expiring today is still savable", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "fixed", fixed_rate: 5, expiresAt: "08/20/2026" },
-      NOW
-    ),
-    null
-  );
-});
-
-test("no expiry at all is allowed - that is a code with no end date", () => {
-  assert.equal(
-    validatePromoCodeEdit({ type: "fixed", fixed_rate: 5, expiresAt: "" }, NOW),
-    null
-  );
-});
-
-test("an unreadable expiry names the format instead of guessing", () => {
-  assert.match(
-    String(
-      validatePromoCodeEdit(
-        { type: "fixed", fixed_rate: 5, expiresAt: "next Tuesday" },
-        NOW
-      )
-    ),
-    /MM\/DD\/YYYY/
-  );
-});
-
-test("a free BAND is refused, because Joi's positive() refuses it", () => {
-  const message = validatePromoCodeEdit(
-    { type: "tiered", tiers: [{ min: 1, max: 10, price: 0 }] },
-    NOW
-  );
-  assert.match(String(message), /^Band 1: /);
-  assert.match(String(message), /above 0/);
-  // ...and it says the way to actually make seats free, which is the other
-  // pricing shape. `fixed_rate` is `min(0)`, not `positive()`.
-  assert.equal(
-    validatePromoCodeEdit({ type: "fixed", fixed_rate: 0 }, NOW),
-    null
-  );
-});
-
-test("the refused band is named, not just 'a band'", () => {
-  assert.match(
-    String(
-      validatePromoCodeEdit(
-        {
-          type: "tiered",
-          tiers: [
-            { min: 1, max: 10, price: 9 },
-            { min: 11, max: 5, price: 7 },
-          ],
-        },
-        NOW
-      )
-    ),
-    /^Band 2: /
-  );
-});
-
-test("a band with no upper limit is allowed - 0 means 'and above'", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "tiered", tiers: [{ min: 5, max: 0, price: 7 }] },
-      NOW
-    ),
-    null
-  );
-});
-
-test("a tiered code with no bands is refused, and offers the other shape", () => {
-  assert.match(
-    String(validatePromoCodeEdit({ type: "tiered", tiers: [] }, NOW)),
-    /at least one quantity band/
-  );
-});
-
-test("a negative fixed price is refused; a missing one is refused too", () => {
-  assert.match(
-    String(validatePromoCodeEdit({ type: "fixed", fixed_rate: -1 }, NOW)),
-    /cannot be less than 0/
-  );
-  assert.match(
-    String(validatePromoCodeEdit({ type: "fixed", fixed_rate: "" }, NOW)),
-    /Enter a price per seat/
-  );
-});
-
-test("a code with no pricing shape is refused first, before anything else", () => {
-  assert.equal(
-    validatePromoCodeEdit({ expiresAt: "01/01/2020" }, NOW),
-    "Choose how this code prices seats."
-  );
-});
-
-// ---------------------------------------------------------------------------
-// What a refusal from the server reads like
-// ---------------------------------------------------------------------------
-
-test("the API's own wording is what the screen shows", () => {
-  assert.equal(
-    promoCodeApiError(
-      { response: { _data: { message: "Promo code not found." } } },
-      "Could not save."
-    ),
-    "Promo code not found."
-  );
-});
-
-test("'Not authorized.' is replaced with something a person can act on", () => {
-  const message = promoCodeApiError(
-    { data: { message: "Not authorized." } },
-    "Could not save."
-  );
-  assert.match(message, /Seven365 staff account/);
-  assert.match(message, /Ask a Seven365 administrator/);
-});
-
-test("an unreadable failure falls back rather than dumping the error", () => {
-  assert.equal(
-    promoCodeApiError(new Error("fetch failed"), "Could not save the changes."),
-    "Could not save the changes."
-  );
-});
-
-// ---------------------------------------------------------------------------
-// The composable: verb, path and body of every write
-// ---------------------------------------------------------------------------
-
-const calls: Array<{ path: string; options: any }> = [];
-
-(globalThis as any).useNuxtApp = () => ({
-  $api: (path: string, options: any = {}) => {
-    calls.push({ path, options });
-    return Promise.resolve({ message: "ok" });
-  },
-});
-
-const promoCodeApi = (await import("../composables/usePromoCode.ts")).default();
-
-function lastCall() {
-  return calls[calls.length - 1];
-}
-
-const ID = "652f1a2b3c4d5e6f70819293";
-
-test("getById reads the one record, from the path the API mounts", async () => {
-  await promoCodeApi.getById(ID);
-  assert.equal(lastCall().path, `/api/promo-codes/id/${ID}`);
-  assert.equal(lastCall().options.method, "GET");
-});
-
-test("update is a PUT to /api/promo-codes/:id", async () => {
-  await promoCodeApi.update(ID, {
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-  } as any);
-
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}`);
-  assert.equal(lastCall().options.method, "PUT");
-  assert.equal(lastCall().options.body.description, "Launch offer");
-});
-
-test("update NEVER sends code, however it is called", async () => {
-  // The screen loads a record and could easily send it back whole. `code` is
-  // immutable on the server; sending it would be accepted and dropped, and
-  // the person would watch a rename succeed and change nothing.
-  await promoCodeApi.update(ID, {
-    code: "RENAMED",
-    type: "fixed",
-    fixed_rate: 1,
-  } as any);
-
-  assert.equal("code" in lastCall().options.body, false);
-  assert.equal(lastCall().options.body.type, "fixed");
-});
-
-test("updateStatus is a PATCH carrying only the new status", async () => {
-  await promoCodeApi.updateStatus(ID, "disabled");
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}/status`);
-  assert.equal(lastCall().options.method, "PATCH");
-  assert.deepEqual(lastCall().options.body, { status: "disabled" });
-
-  await promoCodeApi.updateStatus(ID, "active");
-  assert.deepEqual(lastCall().options.body, { status: "active" });
-});
-
-test("remove is a DELETE, with no body to get wrong", async () => {
-  await promoCodeApi.remove(ID);
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}`);
-  assert.equal(lastCall().options.method, "DELETE");
-  assert.equal(lastCall().options.body, undefined);
-});
-
-test("the four reads and writes are all on the composable", () => {
-  for (const name of [
-    "add",
-    "getPromoCodes",
-    "getByCode",
-    "getById",
-    "update",
-    "updateStatus",
-    "remove",
-  ]) {
-    assert.equal(
-      typeof (promoCodeApi as any)[name],
-      "function",
-      `usePromoCode() is missing ${name}`
-    );
-  }
-});