@jskit-ai/users-web 0.1.172 → 0.1.174

package/test/errorMessageHelpers.test.js

@@ -1,28 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/support/errorMessageHelpers.js";
-
-test("toQueryErrorMessage returns empty when query has no error", () => {
-  assert.equal(toQueryErrorMessage(null, "Unable to load list."), "");
-});
-
-test("toQueryErrorMessage resolves specific runtime error messages before fallback", () => {
-  assert.equal(toQueryErrorMessage({ message: "Network timeout" }, "Unable to load list."), "Network timeout");
-  assert.equal(toQueryErrorMessage({}, "Unable to load list."), "Unable to load list.");
-});
-
-test("toQueryErrorMessage prefers fallback for generic transport messages", () => {
-  assert.equal(
-    toQueryErrorMessage({ status: 500, message: "Request failed with status 500." }, "Unable to load list."),
-    "Unable to load list."
-  );
-  assert.equal(
-    toQueryErrorMessage({ status: 0, message: "Network request failed." }, "Unable to load list."),
-    "Unable to load list."
-  );
-});
-
-test("toUiErrorMessage prefers fallback copy before runtime error text", () => {
-  assert.equal(toUiErrorMessage({ message: "Server exploded" }, "Unable to save."), "Unable to save.");
-  assert.equal(toUiErrorMessage({ message: "Server exploded" }, ""), "Server exploded");
-});

package/test/listQueryParamSupport.test.js

@@ -1,223 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ref } from "vue";
-import {
-  normalizeListSyncToRouteConfig,
-  resolveQueryParamDescriptors,
-  resolveActiveQueryParamEntries,
-  resolveWritableQueryParamBindings,
-  buildQueryParamEntriesToken,
-  parseRouteBindingValue,
-  areQueryParamBindingValuesEqual,
-  buildRouteQueryCompareToken,
-  mergeManagedQueryParamKeyHistory,
-  resolveRouteSyncManagedKeys
-} from "../src/client/composables/support/listQueryParamSupport.js";
-
-test("normalizeListSyncToRouteConfig defaults", () => {
-  assert.deepEqual(
-    normalizeListSyncToRouteConfig(false, {
-      defaultSearchParam: "search"
-    }),
-    {
-      enabled: false,
-      mode: "replace",
-      syncSearch: false,
-      syncQueryParams: false,
-      hydrateFromRoute: false,
-      searchParam: "search",
-      queryParamBlacklist: []
-    }
-  );
-
-  assert.deepEqual(
-    normalizeListSyncToRouteConfig(true),
-    {
-      enabled: true,
-      mode: "replace",
-      syncSearch: true,
-      syncQueryParams: true,
-      hydrateFromRoute: true,
-      searchParam: "q",
-      queryParamBlacklist: []
-    }
-  );
-
-  assert.deepEqual(
-    normalizeListSyncToRouteConfig({
-      enabled: true,
-      queryParamBlacklist: [" include ", "cursor", "include", ""]
-    }),
-    {
-      enabled: true,
-      mode: "replace",
-      syncSearch: true,
-      syncQueryParams: true,
-      hydrateFromRoute: true,
-      searchParam: "q",
-      queryParamBlacklist: ["include", "cursor"]
-    }
-  );
-});
-
-test("resolveQueryParamDescriptors keeps declared keys and supports writable bindings", () => {
-  const source = {
-    " status ": ref("open"),
-    " count ": 2,
-    includeArchived: ref(false),
-    empty: ""
-  };
-
-  const descriptors = resolveQueryParamDescriptors(source);
-  assert.deepEqual(
-    descriptors.map((descriptor) => descriptor.key),
-    ["count", "empty", "includeArchived", "status"]
-  );
-
-  const activeEntries = resolveActiveQueryParamEntries(descriptors);
-  assert.deepEqual(
-    activeEntries,
-    [
-      {
-        key: "count",
-        values: ["2"]
-      },
-      {
-        key: "status",
-        values: ["open"]
-      }
-    ]
-  );
-
-  const bindings = resolveWritableQueryParamBindings(descriptors);
-  const countBinding = bindings.find((binding) => binding.key === "count");
-  assert.ok(countBinding);
-  countBinding.set(9);
-  assert.equal(source[" count "], 9);
-  assert.equal(source.count, undefined);
-});
-
-test("buildQueryParamEntriesToken and compare token stay deterministic", () => {
-  assert.equal(
-    buildQueryParamEntriesToken([
-      {
-        key: "status",
-        values: ["open"]
-      },
-      {
-        key: "tags",
-        values: ["a", "b"]
-      }
-    ]),
-    "status=open&tags=a,b"
-  );
-
-  assert.equal(
-    buildRouteQueryCompareToken({
-      b: "2",
-      a: ["1"]
-    }),
-    buildRouteQueryCompareToken({
-      a: "1",
-      b: ["2"]
-    })
-  );
-});
-
-test("parseRouteBindingValue handles boolean, number and array bindings", () => {
-  const booleanBinding = {
-    valueType: "boolean",
-    get: () => false
-  };
-  assert.equal(parseRouteBindingValue(booleanBinding, "1"), true);
-  assert.equal(parseRouteBindingValue(booleanBinding, undefined), false);
-
-  const numberBinding = {
-    valueType: "number",
-    get: () => 7
-  };
-  assert.equal(parseRouteBindingValue(numberBinding, "12"), 12);
-  assert.equal(parseRouteBindingValue(numberBinding, "bad"), 7);
-  assert.equal(parseRouteBindingValue(numberBinding, undefined), null);
-
-  const arrayBinding = {
-    valueType: "array",
-    arrayItemType: "number",
-    get: () => []
-  };
-  assert.deepEqual(
-    parseRouteBindingValue(arrayBinding, ["1", "bad", "3"]),
-    [1, 3]
-  );
-});
-
-test("route-aware query parameter bindings can distinguish initial hydration from later clearing", () => {
-  const currentness = ref("active");
-  const [binding] = resolveWritableQueryParamBindings(
-    resolveQueryParamDescriptors(
-      { currentness },
-      {},
-      {
-        routeValueResolvers: {
-          currentness(routeValue, { initial }) {
-            if (routeValue === undefined) {
-              return initial ? "active" : "";
-            }
-            return String(routeValue || "").trim() || "active";
-          }
-        }
-      }
-    )
-  );
-
-  assert.equal(
-    parseRouteBindingValue(binding, undefined, { initial: true }),
-    "active"
-  );
-  assert.equal(
-    parseRouteBindingValue(binding, "archived", { initial: true }),
-    "archived"
-  );
-  assert.equal(
-    parseRouteBindingValue(binding, undefined, { initial: false }),
-    ""
-  );
-});
-
-test("route sync key helpers preserve declared key history for cleanup", () => {
-  const history = mergeManagedQueryParamKeyHistory(
-    ["status"],
-    ["assignee", "status"]
-  );
-  assert.deepEqual(history, ["assignee", "status"]);
-
-  assert.deepEqual(
-    resolveRouteSyncManagedKeys({
-      searchEnabled: true,
-      searchParam: "q",
-      syncSearch: true,
-      syncQueryParams: true,
-      declaredKeys: ["status"],
-      keyHistory: ["assignee"]
-    }),
-    ["assignee", "q", "status"]
-  );
-});
-
-test("areQueryParamBindingValuesEqual handles arrays and dates", () => {
-  assert.equal(
-    areQueryParamBindingValuesEqual([1, 2], [1, 2]),
-    true
-  );
-  assert.equal(
-    areQueryParamBindingValuesEqual([1, 2], [2, 1]),
-    false
-  );
-  assert.equal(
-    areQueryParamBindingValuesEqual(
-      new Date("2026-01-01T00:00:00.000Z"),
-      new Date("2026-01-01T00:00:00.000Z")
-    ),
-    true
-  );
-});

package/test/listUiRuntime.test.js

@@ -1,102 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ref } from "vue";
-import { createListUiRuntime } from "../src/client/composables/runtime/listUiRuntime.js";
-
-test("createListUiRuntime resolves row keys and relative route templates from string record ids", () => {
-  const items = ref([{ uuid: "abc 123" }]);
-  const runtime = createListUiRuntime({
-    items,
-    isInitialLoading: ref(false),
-    recordIdParam: "contactId",
-    recordIdSelector: (item) => item.uuid,
-    routePath: ref("/w/acme/admin/contacts"),
-    viewUrlTemplate: "./:contactId",
-    editUrlTemplate: "./:contactId/edit"
-  });
-
-  assert.equal(runtime.actionColumnCount, 2);
-  assert.equal(runtime.resolveRowKey(items.value[0], 0), "abc 123");
-  assert.equal(runtime.resolveParams("./new"), "/w/acme/admin/contacts/new");
-  assert.equal(runtime.resolveViewUrl(items.value[0]), "/w/acme/admin/contacts/abc%20123");
-  assert.equal(runtime.resolveEditUrl(items.value[0]), "/w/acme/admin/contacts/abc%20123/edit");
-});
-
-test("createListUiRuntime resolves nested route links from the parent list scope", () => {
-  const runtime = createListUiRuntime({
-    items: ref([{ id: "901" }]),
-    isInitialLoading: ref(false),
-    recordIdParam: "petId",
-    routeParams: ref({
-      workspaceSlug: "dogandgroom",
-      contactId: "541841",
-      petId: "715528"
-    }),
-    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
-    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528"),
-    viewUrlTemplate: "./:petId",
-    editUrlTemplate: "./:petId/edit"
-  });
-
-  assert.equal(runtime.resolveParams("./new"), "/w/dogandgroom/admin/contacts/541841/pets/new");
-  assert.equal(runtime.resolveViewUrl({ id: "901" }), "/w/dogandgroom/admin/contacts/541841/pets/901");
-  assert.equal(runtime.resolveEditUrl({ id: "901" }), "/w/dogandgroom/admin/contacts/541841/pets/901/edit");
-});
-
-test("createListUiRuntime resolves templates that depend on existing route params", () => {
-  const runtime = createListUiRuntime({
-    items: ref([{ id: 42 }]),
-    isInitialLoading: ref(false),
-    recordIdParam: "addressId",
-    recordIdSelector: (item) => item.id,
-    routeParams: ref({ contactId: "7" }),
-    viewUrlTemplate: "/contacts/:contactId/addresses/:addressId",
-    editUrlTemplate: "/contacts/:contactId/addresses/:addressId/edit"
-  });
-
-  assert.equal(runtime.resolveViewUrl({ id: 42 }), "/contacts/7/addresses/42");
-  assert.equal(runtime.resolveEditUrl({ id: 42 }), "/contacts/7/addresses/42/edit");
-});
-
-test("createListUiRuntime returns empty urls and fallback row keys when record id is missing", () => {
-  const runtime = createListUiRuntime({
-    items: ref([]),
-    isInitialLoading: ref(false),
-    recordIdParam: "recordId",
-    recordIdSelector: () => "",
-    viewUrlTemplate: "./:recordId",
-    editUrlTemplate: "./:recordId/edit"
-  });
-
-  assert.equal(runtime.resolveRowKey({}, 5), "row-5");
-  assert.equal(runtime.resolveViewUrl({}), "");
-  assert.equal(runtime.resolveEditUrl({}), "");
-});
-
-test("createListUiRuntime computes list skeleton state from loading and item count", () => {
-  const items = ref([]);
-  const isInitialLoading = ref(true);
-  const runtime = createListUiRuntime({
-    items,
-    isInitialLoading
-  });
-
-  assert.equal(runtime.showListSkeleton.value, true);
-  items.value = [{}];
-  assert.equal(runtime.showListSkeleton.value, false);
-  items.value = [];
-  isInitialLoading.value = false;
-  assert.equal(runtime.showListSkeleton.value, false);
-});
-
-test("createListUiRuntime validates route parameter names", () => {
-  assert.throws(
-    () =>
-      createListUiRuntime({
-        items: ref([]),
-        isInitialLoading: ref(false),
-        recordIdParam: "record-id"
-      }),
-    /recordIdParam "record-id" is invalid/
-  );
-});

package/test/operationValidationHelpers.test.js

@@ -1,64 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createSchema } from "json-rest-schema";
-import { validateOperationInput } from "../src/client/composables/runtime/operationValidationHelpers.js";
-
-test("validateOperationInput validates a schema definition and returns normalized input", () => {
-  const rawPayload = {
-    name: "  Acme  "
-  };
-
-  const result = validateOperationInput({
-    input: {
-      schema: createSchema({
-        name: { type: "string", required: true, minLength: 1 }
-      }),
-      mode: "patch"
-    },
-    rawPayload
-  });
-
-  assert.equal(result.ok, true);
-  assert.deepEqual(result.parsedInput, {
-    name: "Acme"
-  });
-});
-
-test("validateOperationInput returns validation failures for invalid schema input", () => {
-  const result = validateOperationInput({
-    input: {
-      schema: createSchema({
-        name: {
-          type: "string",
-          required: true,
-          minLength: 1,
-          messages: {
-            minLength: "Name is required."
-          }
-        }
-      }),
-      mode: "patch"
-    },
-    rawPayload: {
-      name: ""
-    }
-  });
-
-  assert.equal(result.ok, false);
-  assert.equal(result.failure.code, "validation_failed");
-  assert.equal(result.failure.fieldErrors.name, "Name is required.");
-});
-
-test("validateOperationInput rethrows malformed input contracts", () => {
-  assert.throws(
-    () =>
-      validateOperationInput({
-        input: {
-          schema: null,
-          mode: "patch"
-        },
-        rawPayload: {}
-      }),
-    /must be a json-rest-schema schema instance/
-  );
-});

package/test/permissions.test.js

@@ -1,35 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { arePermissionListsEqual, hasPermission, normalizePermissionList } from "../src/client/lib/permissions.js";
-
-test("normalizePermissionList trims, removes duplicates, and ignores empty entries", () => {
-  assert.deepEqual(
-    normalizePermissionList([" workspace.settings.view ", "", null, "workspace.settings.view", "workspace.members.view"]),
-    ["workspace.settings.view", "workspace.members.view"]
-  );
-});
-
-test("arePermissionListsEqual compares permission sets regardless of order or duplicates", () => {
-  assert.equal(
-    arePermissionListsEqual(
-      ["workspace.settings.view", "workspace.members.view", "workspace.settings.view"],
-      ["workspace.members.view", "workspace.settings.view"]
-    ),
-    true
-  );
-});
-
-test("arePermissionListsEqual returns false for different permission sets", () => {
-  assert.equal(
-    arePermissionListsEqual(
-      ["workspace.settings.view"],
-      ["workspace.members.view"]
-    ),
-    false
-  );
-});
-
-test("hasPermission supports namespace wildcard matches", () => {
-  assert.equal(hasPermission(["crud.contacts.*"], "crud.contacts.update"), true);
-  assert.equal(hasPermission(["crud.contacts.*"], "crud.projects.update"), false);
-});

package/test/refValueHelpers.test.js

@@ -1,14 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { computed, ref } from "vue";
-import { resolveEnabledRef } from "../src/client/composables/support/refValueHelpers.js";
-
-test("resolveEnabledRef unwraps refs", () => {
-  assert.equal(resolveEnabledRef(ref(true)), true);
-  assert.equal(resolveEnabledRef(computed(() => false)), false);
-});
-
-test("resolveEnabledRef executes callable enabled values", () => {
-  assert.equal(resolveEnabledRef(() => true), true);
-  assert.equal(resolveEnabledRef(() => false), false);
-});