@jskit-ai/http-web 0.1.1

package/test/errorMessageHelpers.test.js

@@ -0,0 +1,28 @@
+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/exportsContract.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { evaluatePackageExportsContract } from "../../../tooling/test-support/exportsContract.mjs";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(TEST_DIRECTORY, "..", "..", "..");
+const PACKAGE_DIR = path.join(REPO_ROOT, "packages", "http-web");
+
+test("http-web exports are explicit and aligned with production and generated usage", () => {
+  const result = evaluatePackageExportsContract({
+    repoRoot: REPO_ROOT,
+    packageDir: PACKAGE_DIR,
+    packageId: "@jskit-ai/http-web",
+    requiredExports: [
+      "./client",
+      "./client/components/CrudAddEditScreen",
+      "./client/components/CrudDeleteAction",
+      "./client/components/CrudListBulkActionSurface",
+      "./client/components/CrudListFilterSurface",
+      "./client/components/CrudListScreen",
+      "./client/components/CrudViewScreen",
+      "./client/bulkActions",
+      "./client/filters",
+      "./client/rowActions",
+      "./client/composables/useAddEdit",
+      "./client/composables/useAccess",
+      "./client/composables/useCommand",
+      "./client/composables/useCrudAddEdit",
+      "./client/composables/useCrudAddEditScreen",
+      "./client/composables/useCrudDeleteAction",
+      "./client/composables/useCrudList",
+      "./client/composables/useCrudListBulkActions",
+      "./client/composables/useCrudListFilterLookups",
+      "./client/composables/useCrudListFilters",
+      "./client/composables/useCrudListParentTitle",
+      "./client/composables/useCrudListRowActions",
+      "./client/composables/useCrudListScreen",
+      "./client/composables/useCrudView",
+      "./client/composables/useCrudViewScreen",
+      "./client/composables/crudLookupFieldRuntime",
+      "./client/composables/useEndpointResource",
+      "./client/composables/useList",
+      "./client/composables/usePagedCollection",
+      "./client/composables/useRealtimeQueryInvalidation",
+      "./client/composables/useUiFeedback",
+      "./client/composables/useView",
+      "./client/crudHttpClient",
+      "./client/lib/httpClient",
+      "./client/lib/permissions",
+      "./client/support/contractGuards"
+    ]
+  });
+
+  assert.deepEqual(result.wildcardExports, []);
+  assert.deepEqual(result.missingRequiredExports, []);
+  assert.deepEqual(
+    result.missingExports,
+    [],
+    `http-web imports missing from package exports:\n${result.missingExports.join("\n")}`
+  );
+  assert.deepEqual(
+    result.staleExports,
+    [],
+    `Stale http-web exports found: ${result.staleExports.join(", ")}`
+  );
+});

package/test/listQueryParamSupport.test.js

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,64 @@
+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/packageBoundary.test.js

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import packageJson from "../package.json" with { type: "json" };
+
+const FORBIDDEN_FEATURE_DEPENDENCIES = Object.freeze([
+  "@jskit-ai/auth-core",
+  "@jskit-ai/auth-web",
+  "@jskit-ai/database-runtime",
+  "@jskit-ai/storage-runtime",
+  "@jskit-ai/uploads-runtime",
+  "@jskit-ai/users-core",
+  "@jskit-ai/users-web",
+  "@jskit-ai/workspaces-core",
+  "@jskit-ai/workspaces-web"
+]);
+
+test("http-web remains independent of feature products and persistence", () => {
+  const declared = {
+    ...packageJson.dependencies,
+    ...packageJson.optionalDependencies,
+    ...packageJson.peerDependencies
+  };
+
+  for (const packageId of FORBIDDEN_FEATURE_DEPENDENCIES) {
+    assert.equal(
+      Object.hasOwn(declared, packageId),
+      false,
+      `Neutral http-web must not depend on ${packageId}.`
+    );
+  }
+});

package/test/permissions.test.js

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,14 @@
+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);
+});