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

package/components/AttendanceSettingsDialog.vue

@@ -169,6 +169,7 @@ const {
   data: getAttendanceSettingsReq,
   refresh: getAttendanceSettingsRefresh,
   pending: loading,
+  error: getAttendanceSettingsError,
 } = await useLazyAsyncData(
   `attendance-settings-${props.site}`,
   () => getAttendanceSettings(props.site, props.serviceType),
@@ -179,6 +180,22 @@ const {
 );
 
 watchEffect(() => {
+  // A failed read used to be indistinguishable from a site with no settings
+  // saved: the dialog just opened with geofencing off and blank fields, and
+  // the operator had no way to tell it was showing them nothing rather than
+  // the truth. Worse, a request answered by the SPA fallback resolves with a
+  // 200 and a STRING, so nothing threw - every field read off it was simply
+  // undefined. Anything that is not an object is a failure, and it is said.
+  const res: any = getAttendanceSettingsReq.value;
+  if (
+    getAttendanceSettingsError.value ||
+    (res !== null && res !== undefined && typeof res !== "object")
+  ) {
+    error.value =
+      "Could not load the saved settings - what you see below is not what is saved. Close and reopen to try again.";
+    return;
+  }
+
   if (getAttendanceSettingsReq.value) {
     isGeofencingEnabled.value =
       getAttendanceSettingsReq.value.isGeofencingEnabled || false;

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/components/ServiceProviderMain.vue

@@ -208,6 +208,16 @@
               </v-list>
             </v-menu>
           </template>
+          <!--
+            "There are none" and "we could not fetch them" are not the same
+            sentence, and this table drew the first for both: a failed request
+            left `items` at [] and the default no-data row read "No data
+            available". That is what hid the Pending tab being unreachable in
+            six apps for months. `loadFailed` splits them.
+          -->
+          <template #no-data>
+            <DashboardEmptyState :error="loadFailed" />
+          </template>
         </v-data-table>
       </div>
 
@@ -812,6 +822,8 @@ const messageColor = ref("");
 
 const items = ref<TableRow[]>([]);
 const loading = ref(false);
+/** The last load failed, as opposed to genuinely returning nothing. */
+const loadFailed = ref(false);
 
 const validServiceProvider = ref(false);
 const disableServiceProvider = ref(false);
@@ -1244,6 +1256,18 @@ async function loadList() {
   // }
 
   loading.value = true;
+  loadFailed.value = false;
+  // A request that never reaches the API can still resolve: a path with no
+  // proxy rule is answered by the SPA fallback with 200 text/html, and ofetch
+  // hands that back as a STRING. `.items` on a string is undefined, so
+  // `?? []` used to turn that into a clean empty table. Anything that is not
+  // an array is a failure, not a zero - say so.
+  const rowsOf = (data: any) => {
+    if (!Array.isArray(data?.items)) {
+      throw new Error("The server did not return a list. Please try again.");
+    }
+    return data.items;
+  };
   try {
     if (listTab.value === "pending") {
       // Everything that is not a finished engagement, so a rejection or a
@@ -1256,7 +1280,7 @@ async function loadList() {
         search: searchText.value?.trim() || "",
         limit: pageSize,
       });
-      items.value = mapInviteRows(data.items ?? []);
+      items.value = mapInviteRows(rowsOf(data));
       pages.value = data.pages ?? 0;
       pageRange.value = data.pageRange ?? "-- - -- of --";
       return;
@@ -1270,10 +1294,11 @@ async function loadList() {
       limit: pageSize,
       status: statusParam,
     });
-    items.value = mapProviderRows(data.items ?? []);
+    items.value = mapProviderRows(rowsOf(data));
     pages.value = data.pages ?? 0;
     pageRange.value = data.pageRange ?? "-- - -- of --";
   } catch (error: any) {
+    loadFailed.value = true;
     showMessage(errorConverter(error), "error");
     items.value = [];
     pages.value = 0;

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.199",
   "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]*?\/>/);
+});