@7365admin1/layer-common 3.2.2-staging.197 → 3.2.2-staging.198

package/components/HidReaderForm.vue

@@ -153,6 +153,13 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
+  // The site this reader belongs to. Passed down from HidReaderManagement,
+  // which already has it as a prop from the page's route. Reader discovery is
+  // authorized against it server-side.
+  site: {
+    type: String,
+    default: "",
+  },
 });
 
 const emit = defineEmits<{
@@ -236,6 +243,7 @@ async function connectReader() {
       baseUrl: draft.baseUrl.trim(),
       username: draft.username.trim(),
       password: draft.password,
+      site: props.site,
     });
     const nestedData = response?.data;
     const data = typeof nestedData === "object" && nestedData !== null

package/components/HidReaderManagement.vue

@@ -111,6 +111,7 @@
       :mode="selectedReader ? 'edit' : 'add'"
       :reader="selectedReader"
       :loading="saving"
+      :site="site"
       @submit="saveReader"
     />
 

package/composables/useHidAmico.ts

@@ -90,6 +90,23 @@ export type HidSipAccountData = {
   provisionedAt: string;
 };
 
+/**
+ * True only for the specific validation error an API that predates core #1878
+ * returns when the discover body carries `site`. Deliberately narrow: after
+ * #1878 `site` is required, so this message can no longer be produced and the
+ * fallback below can never hide a real authorization refusal.
+ */
+export function isUnknownSiteFieldError(error: unknown): boolean {
+  const record = typeof error === "object" && error !== null
+    ? error as Record<string, unknown>
+    : {};
+  const data = typeof record.data === "object" && record.data !== null
+    ? record.data as Record<string, unknown>
+    : {};
+  const message = String(data.message || record.message || "");
+  return message.includes("\"site\"") && message.includes("not allowed");
+}
+
 export default function useHidAmico() {
   const basePath = "/api/access-management/hid";
 
@@ -260,11 +277,28 @@ export default function useHidAmico() {
     );
   }
 
-  function discoverReader(payload: Pick<HidReaderPayload, "baseUrl" | "username" | "password">) {
-    return useNuxtApp().$api<Record<string, unknown>>(`${basePath}/readers/discover`, {
-      method: "POST",
-      body: payload,
-    });
+  async function discoverReader(
+    payload: Pick<HidReaderPayload, "baseUrl" | "username" | "password" | "site">,
+  ) {
+    const post = (body: Record<string, unknown>) =>
+      useNuxtApp().$api<Record<string, unknown>>(`${basePath}/readers/discover`, {
+        method: "POST",
+        body,
+      });
+
+    try {
+      return await post(payload as Record<string, unknown>);
+    } catch (error: unknown) {
+      // The discover endpoint only started accepting (and requiring) `site` in
+      // core #1878. An API that predates it validates the body with Joi's
+      // default allowUnknown:false and answers `"site" is not allowed`, so the
+      // web layer would break the moment it shipped ahead of the API. Retry once
+      // without `site` so both API versions work.
+      // ponytail: remove this fallback once core #1878 is deployed everywhere.
+      if (!isUnknownSiteFieldError(error)) throw error;
+      const { site: _site, ...legacy } = payload;
+      return await post(legacy as Record<string, unknown>);
+    }
   }
 
   function getUserPinStatus(readerId: string, hidUserId: string | number) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "3.2.2-staging.197",
+  "version": "3.2.2-staging.198",
   "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

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import test from "node:test";
+
+import useHidAmico, { isUnknownSiteFieldError } from "../composables/useHidAmico.ts";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+type Call = { url: string; body: Record<string, unknown> };
+
+/**
+ * The composable calls the Nuxt auto-import `useNuxtApp().$api(...)`. Install a
+ * stub for it so the request body can be read without a Nuxt app.
+ */
+function stubApi(handler: (call: Call) => unknown) {
+  const calls: Call[] = [];
+  (globalThis as Record<string, unknown>).useNuxtApp = () => ({
+    $api: (url: string, options: { body: Record<string, unknown> }) => {
+      const call = { url, body: options.body };
+      calls.push(call);
+      return Promise.resolve(handler(call));
+    },
+  });
+  return calls;
+}
+
+function fetchError(message: string) {
+  return Object.assign(new Error("400 Bad Request"), { data: { message } });
+}
+
+test("discoverReader sends site in the request body", async () => {
+  const calls = stubApi(() => ({ data: { deviceId: "D1", portals: [] } }));
+
+  await useHidAmico().discoverReader({
+    baseUrl: "https://reader.example",
+    username: "operator",
+    password: "secret",
+    site: "0123456789abcdef01234567",
+  });
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].url, "/api/access-management/hid/readers/discover");
+  assert.equal(calls[0].body.site, "0123456789abcdef01234567");
+  assert.equal(calls[0].body.baseUrl, "https://reader.example");
+});
+
+test("discoverReader retries without site when the API predates core #1878", async () => {
+  const calls = stubApi((call) => {
+    if ("site" in call.body) throw fetchError('"site" is not allowed');
+    return { data: { deviceId: "D1", portals: [] } };
+  });
+
+  const response = await useHidAmico().discoverReader({
+    baseUrl: "https://reader.example",
+    username: "operator",
+    password: "secret",
+    site: "0123456789abcdef01234567",
+  });
+
+  assert.equal(calls.length, 2);
+  assert.equal("site" in calls[1].body, false);
+  assert.equal(calls[1].body.baseUrl, "https://reader.example");
+  assert.deepEqual(response, { data: { deviceId: "D1", portals: [] } });
+});
+
+test("discoverReader does not retry a real refusal", async () => {
+  const calls = stubApi(() => {
+    throw fetchError("You are not authorized to manage readers for this site.");
+  });
+
+  await assert.rejects(
+    useHidAmico().discoverReader({
+      baseUrl: "https://reader.example",
+      username: "operator",
+      password: "secret",
+      site: "0123456789abcdef01234567",
+    }),
+  );
+  assert.equal(calls.length, 1);
+});
+
+test("isUnknownSiteFieldError only matches the unknown-key message", () => {
+  assert.equal(isUnknownSiteFieldError(fetchError('"site" is not allowed')), true);
+  assert.equal(isUnknownSiteFieldError(new Error('"site" is not allowed')), true);
+  assert.equal(isUnknownSiteFieldError(fetchError('"site" is required')), false);
+  assert.equal(isUnknownSiteFieldError(fetchError('"baseUrl" is not allowed')), false);
+  assert.equal(isUnknownSiteFieldError(fetchError("Unauthorized")), false);
+  assert.equal(isUnknownSiteFieldError(null), false);
+});
+
+test("the reader form takes site as a prop and puts it in the discover call", () => {
+  const source = readFileSync(join(root, "components", "HidReaderForm.vue"), "utf8");
+  assert.match(source, /site:\s*\{\s*type:\s*String/);
+  assert.match(source, /discoverReader\(\{[\s\S]*?site:\s*props\.site[\s\S]*?\}\)/);
+});
+
+test("reader management passes its site prop down to the form", () => {
+  const source = readFileSync(join(root, "components", "HidReaderManagement.vue"), "utf8");
+  assert.match(source, /<HidReaderForm[\s\S]*?:site="site"[\s\S]*?\/>/);
+});