@jskit-ai/users-web 0.1.33 → 0.1.34

package/test/crudLookupFieldRuntime.test.js

@@ -0,0 +1,189 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  resolveLookupItemLabel,
+  resolveLookupFieldDisplayValue
+} from "../src/client/composables/crudLookupFieldLabelSupport.js";
+
+test("resolveLookupItemLabel composes name + surname", () => {
+  assert.equal(
+    resolveLookupItemLabel(
+      {
+        name: "South",
+        surname: "Clinic"
+      },
+      "name"
+    ),
+    "South Clinic"
+  );
+});
+
+test("resolveLookupItemLabel composes firstName + surname", () => {
+  assert.equal(
+    resolveLookupItemLabel(
+      {
+        firstName: "Ana",
+        surname: "Marin"
+      },
+      "name"
+    ),
+    "Ana Marin"
+  );
+});
+
+test("resolveLookupItemLabel falls back to explicit labelKey", () => {
+  assert.equal(
+    resolveLookupItemLabel(
+      {
+        clinicName: "Harbor Vet"
+      },
+      "clinicName"
+    ),
+    "Harbor Vet"
+  );
+});
+
+test("resolveLookupItemLabel resolves name when surname is missing", () => {
+  assert.equal(
+    resolveLookupItemLabel(
+      {
+        name: "Harbor Vet"
+      },
+      ""
+    ),
+    "Harbor Vet"
+  );
+});
+
+test("resolveLookupItemLabel returns empty when no label fields match", () => {
+  assert.equal(resolveLookupItemLabel({ id: 42 }, "name"), "");
+});
+
+test("resolveLookupFieldDisplayValue returns hydrated label for lookup fields", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        vetId: 17,
+        lookups: {
+          vetId: {
+            id: 17,
+            name: "Harbor Vet"
+          }
+        }
+      },
+      {
+        key: "vetId",
+        relation: {
+          kind: "lookup",
+          valueKey: "id",
+          labelKey: "name"
+        }
+      }
+    ),
+    "Harbor Vet"
+  );
+});
+
+test("resolveLookupFieldDisplayValue falls back to hydrated valueKey", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        vetId: 17,
+        lookups: {
+          vetId: {
+            id: 99
+          }
+        }
+      },
+      {
+        key: "vetId",
+        relation: {
+          kind: "lookup",
+          valueKey: "id",
+          labelKey: "name"
+        }
+      }
+    ),
+    99
+  );
+});
+
+test("resolveLookupFieldDisplayValue falls back to raw id when lookup is not hydrated", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        vetId: 17
+      },
+      {
+        key: "vetId",
+        relation: {
+          kind: "lookup",
+          valueKey: "id",
+          labelKey: "name"
+        }
+      }
+    ),
+    17
+  );
+});
+
+test("resolveLookupFieldDisplayValue supports custom lookup container key", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        vetId: 17,
+        lookupData: {
+          vetId: {
+            id: 17,
+            name: "Harbor Vet"
+          }
+        }
+      },
+      {
+        key: "vetId",
+        relation: {
+          kind: "lookup",
+          containerKey: "lookupData",
+          valueKey: "id",
+          labelKey: "name"
+        }
+      }
+    ),
+    "Harbor Vet"
+  );
+});
+
+test("resolveLookupFieldDisplayValue returns raw value for non-lookup fields", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        firstName: "Ana"
+      },
+      {
+        key: "firstName"
+      }
+    ),
+    "Ana"
+  );
+});
+
+test("resolveLookupFieldDisplayValue supports scalar lookup descriptor arguments", () => {
+  assert.equal(
+    resolveLookupFieldDisplayValue(
+      {
+        vetId: 17,
+        lookups: {
+          vetId: {
+            id: 17,
+            name: "Harbor Vet"
+          }
+        }
+      },
+      "vetId",
+      "lookup",
+      "id",
+      "name"
+    ),
+    "Harbor Vet"
+  );
+});

package/test/resourceLoadStateHelpers.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import { hasResolvedQueryData } from "../src/client/composables/resourceLoadStateHelpers.js";
+
+test("hasResolvedQueryData returns true when the query succeeded", () => {
+  const query = {
+    isSuccess: ref(true)
+  };
+
+  assert.equal(hasResolvedQueryData({
+    query,
+    data: ref(null)
+  }), true);
+});
+
+test("hasResolvedQueryData returns true when data payload is available", () => {
+  const query = {
+    isSuccess: ref(false)
+  };
+
+  assert.equal(hasResolvedQueryData({
+    query,
+    data: ref({
+      id: 2971
+    })
+  }), true);
+});
+
+test("hasResolvedQueryData returns false when query and payload are unresolved", () => {
+  const query = {
+    isSuccess: ref(false)
+  };
+
+  assert.equal(hasResolvedQueryData({
+    query,
+    data: ref(null)
+  }), false);
+});

package/test/routeTemplateHelpers.test.js

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  extractRouteParamNames,
+  resolveRouteParamNamesInOrder
+} from "../src/client/composables/routeTemplateHelpers.js";
+
+test("extractRouteParamNames reads dynamic params from route templates", () => {
+  assert.deepEqual(
+    extractRouteParamNames("/w/:workspaceSlug/admin/contacts/:contactId/addresses/:addressId"),
+    ["workspaceSlug", "contactId", "addressId"]
+  );
+});
+
+test("resolveRouteParamNamesInOrder prefers matched route templates", () => {
+  const route = {
+    matched: [
+      { path: "/w/:workspaceSlug/admin" },
+      { path: "/contacts/:contactId/addresses/:addressId" }
+    ],
+    params: {
+      workspaceSlug: "acme",
+      contactId: "7",
+      addressId: "42"
+    }
+  };
+
+  assert.deepEqual(resolveRouteParamNamesInOrder(route), ["workspaceSlug", "contactId", "addressId"]);
+});

package/test/useCrudSchemaForm.test.js

@@ -7,6 +7,8 @@ import {
   createCrudFormModel,
   buildCrudFormPayload,
   applyCrudPayloadToForm,
+  resolveCrudRouteBoundFieldValues,
+  applyCrudRouteBoundFieldValues,
   resolveCrudFieldErrors,
   parseCrudResourceOperationInput
 } from "../src/client/composables/crudSchemaFormHelpers.js";
@@ -87,6 +89,43 @@ test("applyCrudPayloadToForm maps payload values into reactive form model", () =
   });
 });
 
+test("resolveCrudRouteBoundFieldValues maps route params for route-bound form fields", () => {
+  const values = resolveCrudRouteBoundFieldValues(
+    [
+      { key: "contactId", routeParamKey: "contactId" },
+      { key: "name" }
+    ],
+    {
+      contactId: " 2971 "
+    }
+  );
+
+  assert.deepEqual(values, {
+    contactId: "2971"
+  });
+});
+
+test("applyCrudRouteBoundFieldValues enforces route-bound field values onto target payload", () => {
+  const payload = {
+    name: "Address one",
+    contactId: "123"
+  };
+  applyCrudRouteBoundFieldValues(
+    [
+      { key: "contactId", routeParamKey: "contactId" }
+    ],
+    payload,
+    {
+      contactId: "2971"
+    }
+  );
+
+  assert.deepEqual(payload, {
+    name: "Address one",
+    contactId: "2971"
+  });
+});
+
 test("resolveCrudFieldErrors returns Vuetify-compatible error arrays", () => {
   assert.deepEqual(resolveCrudFieldErrors({ name: "Name is required." }, "name"), ["Name is required."]);
   assert.deepEqual(resolveCrudFieldErrors({ name: "Name is required." }, "email"), []);

package/test/useListSearchSupport.test.js

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  normalizeListSearchConfig,
+  matchesLocalSearch
+} from "../src/client/composables/listSearchSupport.js";
+
+test("normalizeListSearchConfig defaults to disabled query search", () => {
+  const config = normalizeListSearchConfig();
+  assert.equal(config.enabled, false);
+  assert.equal(config.mode, "query");
+  assert.equal(config.queryParam, "q");
+  assert.equal(config.label, "Search");
+  assert.equal(config.minLength, 1);
+});
+
+test("normalizeListSearchConfig accepts query mode and fields", () => {
+  const config = normalizeListSearchConfig({
+    enabled: true,
+    mode: "query",
+    queryParam: "search",
+    fields: ["name", "name", "email"]
+  });
+  assert.equal(config.enabled, true);
+  assert.equal(config.mode, "query");
+  assert.equal(config.queryParam, "search");
+  assert.deepEqual(config.fields, ["name", "email"]);
+});
+
+test("normalizeListSearchConfig accepts explicit local mode", () => {
+  const config = normalizeListSearchConfig({
+    enabled: true,
+    mode: "local"
+  });
+  assert.equal(config.mode, "local");
+});
+
+test("matchesLocalSearch checks configured fields", () => {
+  const result = matchesLocalSearch(
+    {
+      firstName: "Ana",
+      surname: "Marin",
+      phone: "0400"
+    },
+    "mar",
+    ["surname"]
+  );
+  assert.equal(result, true);
+});
+
+test("matchesLocalSearch scans scalar values when fields are not configured", () => {
+  const result = matchesLocalSearch(
+    {
+      firstName: "Ana",
+      surname: "Marin",
+      count: 42
+    },
+    "42"
+  );
+  assert.equal(result, true);
+});

package/test/viewCoreLoading.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import { useViewCore } from "../src/client/composables/useViewCore.js";
+
+test("useViewCore prefers resource isInitialLoading/isFetching signals when provided", () => {
+  const resource = {
+    data: ref({ id: 42 }),
+    isInitialLoading: ref(false),
+    isFetching: ref(true),
+    query: {
+      isPending: ref(true),
+      isFetching: ref(true),
+      error: ref(null)
+    },
+    loadError: ref("")
+  };
+
+  const view = useViewCore({
+    resource
+  });
+
+  assert.equal(view.isLoading.value, false);
+  assert.equal(view.isFetching.value, true);
+});
+
+test("useViewCore falls back to query pending/fetching when resource-level loading refs are absent", () => {
+  const resource = {
+    data: ref(null),
+    query: {
+      isPending: ref(true),
+      isFetching: ref(false),
+      error: ref(null)
+    },
+    loadError: ref("")
+  };
+
+  const view = useViewCore({
+    resource
+  });
+
+  assert.equal(view.isLoading.value, true);
+  assert.equal(view.isFetching.value, false);
+});