@jskit-ai/users-web 0.1.70 → 0.1.71

package/test/requestTransportOptions.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  buildEndpointReadRequestOptions,
+  buildEndpointWriteRequestOptions
+} from "../src/client/composables/runtime/useEndpointResource.js";
+import { buildListRequestOptions } from "../src/client/composables/runtime/useListCore.js";
+
+test("endpoint read request options include transport only when provided", () => {
+  assert.deepEqual(
+    buildEndpointReadRequestOptions({
+      method: "get"
+    }),
+    {
+      method: "GET"
+    }
+  );
+
+  assert.deepEqual(
+    buildEndpointReadRequestOptions({
+      method: "get",
+      transport: {
+        kind: "jsonapi-resource",
+        responseType: "user-settings",
+        responseKind: "record"
+      }
+    }),
+    {
+      method: "GET",
+      transport: {
+        kind: "jsonapi-resource",
+        responseType: "user-settings",
+        responseKind: "record"
+      }
+    }
+  );
+});
+
+test("endpoint write request options preserve body/options and append transport", () => {
+  assert.deepEqual(
+    buildEndpointWriteRequestOptions({
+      method: "patch",
+      body: {
+        theme: "dark"
+      },
+      options: {
+        headers: {
+          "x-demo": "1"
+        }
+      },
+      transport: {
+        kind: "jsonapi-resource",
+        requestType: "user-preferences",
+        responseType: "user-settings",
+        responseKind: "record"
+      }
+    }),
+    {
+      method: "PATCH",
+      headers: {
+        "x-demo": "1"
+      },
+      body: {
+        theme: "dark"
+      },
+      transport: {
+        kind: "jsonapi-resource",
+        requestType: "user-preferences",
+        responseType: "user-settings",
+        responseKind: "record"
+      }
+    }
+  );
+});
+
+test("list request options stay GET and carry transport when provided", () => {
+  assert.deepEqual(
+    buildListRequestOptions({
+      requestOptions: {
+        headers: {
+          "x-demo": "1"
+        }
+      },
+      pageParam: "cursor_2",
+      transport: {
+        kind: "jsonapi-resource",
+        responseType: "contacts",
+        responseKind: "collection"
+      }
+    }),
+    {
+      method: "GET",
+      headers: {
+        "x-demo": "1"
+      },
+      query: {
+        cursor: "cursor_2"
+      },
+      transport: {
+        kind: "jsonapi-resource",
+        responseType: "contacts",
+        responseKind: "collection"
+      }
+    }
+  );
+});

package/test/useAddEditCore.test.js

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
+import { computed, createSSRApp, effectScope, h, reactive, ref } from "vue";
+import { useAddEditCore } from "../src/client/composables/runtime/useAddEditCore.js";
+
+test("useAddEditCore writes saved payloads to the submit-time query key", async () => {
+  const queryClient = new QueryClient();
+  const model = reactive({
+    status: "draft"
+  });
+  const payload = {
+    id: 42,
+    status: "published"
+  };
+  const resource = {
+    isSaving: ref(false),
+    async save() {
+      return payload;
+    }
+  };
+  let runtime = null;
+  const app = createSSRApp({
+    render() {
+      return h("div");
+    }
+  });
+  app.use(VueQueryPlugin, {
+    queryClient
+  });
+  const scope = effectScope();
+
+  app.runWithContext(() => {
+    scope.run(() => {
+      runtime = useAddEditCore({
+        model,
+        resource,
+        queryKey: computed(() => ["products", model.status]),
+        canSave: ref(true),
+        fieldBag: {
+          clear() {},
+          apply() {}
+        },
+        feedback: {
+          clear() {},
+          success() {},
+          error() {}
+        },
+        mapLoadedToModel(target = {}, loaded = {}) {
+          target.status = loaded.status;
+        }
+      });
+    });
+  });
+
+  await runtime.submit();
+  scope.stop();
+
+  assert.equal(model.status, "published");
+  assert.deepEqual(queryClient.getQueryData(["products", "draft"]), payload);
+  assert.equal(queryClient.getQueryData(["products", "published"]), undefined);
+});
+
+test("useAddEditCore snapshots the cache key after payload normalization", async () => {
+  const queryClient = new QueryClient();
+  const model = reactive({
+    status: "draft"
+  });
+  const payload = {
+    id: 42,
+    status: "published"
+  };
+  const resource = {
+    isSaving: ref(false),
+    async save() {
+      return payload;
+    }
+  };
+  let runtime = null;
+  const app = createSSRApp({
+    render() {
+      return h("div");
+    }
+  });
+  app.use(VueQueryPlugin, {
+    queryClient
+  });
+  const scope = effectScope();
+
+  app.runWithContext(() => {
+    scope.run(() => {
+      runtime = useAddEditCore({
+        model,
+        resource,
+        queryKey: computed(() => ["products", model.status]),
+        canSave: ref(true),
+        fieldBag: {
+          clear() {},
+          apply() {}
+        },
+        feedback: {
+          clear() {},
+          success() {},
+          error() {}
+        },
+        buildRawPayload() {
+          model.status = "normalized";
+          return {};
+        },
+        mapLoadedToModel(target = {}, loaded = {}) {
+          target.status = loaded.status;
+        }
+      });
+    });
+  });
+
+  await runtime.submit();
+  scope.stop();
+
+  assert.equal(model.status, "published");
+  assert.equal(queryClient.getQueryData(["products", "draft"]), undefined);
+  assert.deepEqual(queryClient.getQueryData(["products", "normalized"]), payload);
+  assert.equal(queryClient.getQueryData(["products", "published"]), undefined);
+});

package/test/useAddEditRequestQueryParams.test.js

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { computed, reactive, ref, shallowRef } from "vue";
+import { createRequestQueryRuntime } from "../src/client/composables/support/requestQueryRuntimeSupport.js";
+
+test("add/edit request query params resolve stable cache tokens and request query objects", () => {
+  const sourceQueryKey = ref(["products", "dev-admin"]);
+  const context = ref(Object.freeze({
+    surfaceId: "admin",
+    scopeParamValue: "dev-admin",
+    ownershipFilter: "workspace",
+    recordId: "product-42",
+    model: {
+      status: "draft"
+    }
+  }));
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams(callbackContext = {}) {
+      assert.deepEqual(callbackContext, context.value);
+
+      return {
+        include: "serviceId,bookingSteps,bookingSteps.requiredRoleId",
+        preview: callbackContext.model.status === "draft"
+      };
+    },
+    context,
+    sourceQueryKey
+  });
+
+  assert.deepEqual(runtime.activeRequestQueryParamEntries.value, [
+    {
+      key: "include",
+      values: ["serviceId,bookingSteps,bookingSteps.requiredRoleId"]
+    },
+    {
+      key: "preview",
+      values: ["1"]
+    }
+  ]);
+  assert.equal(
+    runtime.activeRequestQueryParamsToken.value,
+    "include=serviceId,bookingSteps,bookingSteps.requiredRoleId&preview=1"
+  );
+  assert.deepEqual(
+    runtime.queryKey.value,
+    [
+      "products",
+      "dev-admin",
+      "__request_query__",
+      "include=serviceId,bookingSteps,bookingSteps.requiredRoleId&preview=1"
+    ]
+  );
+  assert.deepEqual(runtime.requestQuery.value, {
+    include: "serviceId,bookingSteps,bookingSteps.requiredRoleId",
+    preview: "1"
+  });
+});
+
+test("add/edit request query params react to callback context changes", () => {
+  const recordId = ref("product-42");
+  const model = reactive({
+    status: "draft"
+  });
+  const context = computed(() => Object.freeze({
+    surfaceId: "admin",
+    scopeParamValue: "dev-admin",
+    ownershipFilter: "workspace",
+    recordId: recordId.value,
+    model
+  }));
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams(callbackContext = {}) {
+      return {
+        include: "bookingSteps",
+        preview: callbackContext.model.status === "draft",
+        recordId: callbackContext.recordId
+      };
+    },
+    context,
+    sourceQueryKey: computed(() => ["products", context.value.scopeParamValue])
+  });
+
+  assert.deepEqual(
+    runtime.queryKey.value,
+    [
+      "products",
+      "dev-admin",
+      "__request_query__",
+      "include=bookingSteps&preview=1&recordId=product-42"
+    ]
+  );
+  assert.deepEqual(runtime.requestQuery.value, {
+    include: "bookingSteps",
+    preview: "1",
+    recordId: "product-42"
+  });
+
+  model.status = "published";
+  recordId.value = "product-99";
+
+  assert.deepEqual(
+    runtime.queryKey.value,
+    [
+      "products",
+      "dev-admin",
+      "__request_query__",
+      "include=bookingSteps&recordId=product-99"
+    ]
+  );
+  assert.deepEqual(runtime.requestQuery.value, {
+    include: "bookingSteps",
+    recordId: "product-99"
+  });
+});
+
+test("request query runtime preserves scalar base query keys", () => {
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams: {
+      include: "bookingSteps"
+    },
+    sourceQueryKey: ref("products"),
+    sourcePath: "/api/products/42"
+  });
+
+  assert.deepEqual(
+    runtime.queryKey.value,
+    [
+      "products",
+      "__request_query__",
+      "include=bookingSteps"
+    ]
+  );
+});
+
+test("request query runtime leaves keys and paths unchanged without active request params", () => {
+  const sourceQueryKey = ["products"];
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams: {
+      include: "",
+      archived: false
+    },
+    sourceQueryKey: shallowRef(sourceQueryKey)
+  });
+
+  assert.deepEqual(runtime.activeRequestQueryParamEntries.value, []);
+  assert.equal(runtime.activeRequestQueryParamsToken.value, "");
+  assert.deepEqual(runtime.queryKey.value, ["products"]);
+  assert.equal(runtime.queryKey.value, sourceQueryKey);
+  assert.equal(runtime.requestQuery.value, null);
+});
+
+test("request query runtime preserves inactive scalar query keys", () => {
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams: {
+      include: ""
+    },
+    sourceQueryKey: ref("products")
+  });
+
+  assert.equal(runtime.queryKey.value, "products");
+  assert.equal(runtime.requestQuery.value, null);
+});

package/test/useCrudAddEdit.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { reactive } from "vue";
-import { Type } from "typebox";
 import {
   normalizeCrudFormFields,
   createCrudFormModel,
@@ -9,8 +8,7 @@ import {
   applyCrudPayloadToForm,
   resolveCrudRouteBoundFieldValues,
   applyCrudRouteBoundFieldValues,
-  resolveCrudFieldErrors,
-  parseCrudResourceOperationInput
+  resolveCrudFieldErrors
 } from "../src/client/composables/crud/crudSchemaFormHelpers.js";
 
 test("normalizeCrudFormFields trims keys, removes invalid entries, and deduplicates", () => {
@@ -290,51 +288,3 @@ 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"), []);
 });
-
-test("parseCrudResourceOperationInput validates and normalizes operation body payloads", () => {
-  const resource = {
-    operations: {
-      create: {
-        bodyValidator: {
-          schema: Type.Object(
-            {
-              name: Type.String({ minLength: 1 }),
-              age: Type.Integer({ minimum: 1 })
-            },
-            { additionalProperties: false }
-          ),
-          normalize(payload = {}) {
-            return {
-              name: String(payload.name || "").trim(),
-              age: Number(payload.age)
-            };
-          }
-        }
-      }
-    }
-  };
-
-  const validResult = parseCrudResourceOperationInput({
-    resource,
-    operationName: "create",
-    rawPayload: {
-      name: "  Ada  ",
-      age: "2"
-    }
-  });
-  assert.equal(validResult.ok, true);
-  assert.deepEqual(validResult.value, {
-    name: "Ada",
-    age: 2
-  });
-
-  const invalidResult = parseCrudResourceOperationInput({
-    resource,
-    operationName: "create",
-    rawPayload: {
-      name: "   ",
-      age: "0"
-    }
-  });
-  assert.equal(invalidResult.ok, false);
-});

package/test/useCrudListFilters.test.js

@@ -53,7 +53,7 @@ test("useCrudListFilters manages values, query params, chips, and presets", asyn
 
   assert.equal(filters.queryParams.onlyStaff.value, true);
   assert.deepEqual(filters.queryParams.status.value, ["active"]);
-  assert.equal(filters.queryParams.arrivalDateFrom.value, "2026-04-01");
+  assert.equal(filters.queryParams.arrivalDate.value, "2026-04-01..");
   assert.equal(filters.hasActiveFilters.value, true);
   assert.deepEqual(
     filters.activeChips.value.map((chip) => chip.label),
@@ -131,6 +131,7 @@ test("useCrudListFilters supports dynamic presets and preset matching", async ()
 
   assert.equal(filters.values.arrivalDate.from, "2026-04-18");
   assert.equal(filters.values.arrivalDate.to, "2026-04-18");
+  assert.equal(filters.queryParams.arrivalDate.value, "2026-04-18");
   assert.deepEqual(filters.values.status, ["archived"]);
   assert.equal(filters.matchesPreset("today"), true);
   assert.equal(filters.matchesPreset("all-dates"), false);
@@ -145,7 +146,7 @@ test("useCrudListFilters supports dynamic presets and preset matching", async ()
   assert.equal(filters.matchesPreset("all-dates"), true);
 });
 
-test("useCrudListFilters preset matching rejects extra enumMany values present in current state", async () => {
+test("useCrudListFilters preset matching ignores invalid extra enumMany values outside the shared contract", async () => {
   const { useCrudListFilters } = await import("@jskit-ai/users-web/client/composables/useCrudListFilters");
 
   const filters = useCrudListFilters(
@@ -174,9 +175,37 @@ test("useCrudListFilters preset matching rejects extra enumMany values present i
 
   filters.values.status = ["archived", "bogus"];
 
-  assert.equal(filters.matchesPreset("archived-only"), false);
+  assert.equal(filters.matchesPreset("archived-only"), true);
+  assert.deepEqual(filters.queryParams.status.value, ["archived"]);
   assert.deepEqual(
     filters.activeChips.value.map((chip) => chip.label),
-    ["Status: Archived", "Status: bogus"]
+    ["Status: Archived"]
   );
 });
+
+test("useCrudListFilters hydrates single-key range query params into structured values", async () => {
+  const { useCrudListFilters } = await import("@jskit-ai/users-web/client/composables/useCrudListFilters");
+
+  const filters = useCrudListFilters({
+    arrivalDate: {
+      type: "dateRange",
+      label: "Arrival Date"
+    },
+    weight: {
+      type: "numberRange",
+      label: "Weight"
+    }
+  });
+
+  filters.queryParams.arrivalDate.value = "..2026-04-30";
+  filters.queryParams.weight.value = "12.5..18";
+
+  assert.deepEqual(filters.values.arrivalDate, {
+    from: "",
+    to: "2026-04-30"
+  });
+  assert.deepEqual(filters.values.weight, {
+    min: "12.5",
+    max: "18"
+  });
+});

package/test/useCrudListParentTitle.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { createSchema } from "json-rest-schema";
 import { resolveCrudListParentDescriptor, resolveCrudListParentRecordTitle, resolveCrudListParentTitleFromItems } from "../src/client/composables/internal/crudListParentTitleSupport.js";
 
 const contactChildResource = Object.freeze({
@@ -8,24 +9,30 @@ const contactChildResource = Object.freeze({
       containerKey: "lookups"
     }
   },
-  fieldMeta: Object.freeze([
-    Object.freeze({
-      key: "contactId",
-      relation: Object.freeze({
-        kind: "lookup",
-        namespace: "contacts",
-        valueKey: "id"
-      })
-    }),
-    Object.freeze({
-      key: "serviceId",
-      relation: Object.freeze({
-        kind: "lookup",
-        namespace: "services",
-        valueKey: "id"
-      })
-    })
-  ])
+  operations: {
+    view: {
+      output: {
+        schema: createSchema({
+          contactId: {
+            type: "integer",
+            relation: {
+              kind: "lookup",
+              namespace: "contacts",
+              valueKey: "id"
+            }
+          },
+          serviceId: {
+            type: "integer",
+            relation: {
+              kind: "lookup",
+              namespace: "services",
+              valueKey: "id"
+            }
+          }
+        })
+      }
+    }
+  }
 });
 
 test("resolveCrudListParentDescriptor selects the nearest lookup route parent", () => {
@@ -116,17 +123,23 @@ test("resolveCrudListParentRecordTitle falls back to entity label plus id", () =
 test("resolveCrudListParentDescriptor supports parentRouteParamKey aliases", () => {
   const descriptor = resolveCrudListParentDescriptor({
     resource: {
-      fieldMeta: [
-        {
-          key: "staffContactId",
-          parentRouteParamKey: "contactId",
-          relation: {
-            kind: "lookup",
-            namespace: "contacts",
-            valueKey: "id"
+      operations: {
+        view: {
+          output: {
+            schema: createSchema({
+              staffContactId: {
+                type: "integer",
+                parentRouteParamKey: "contactId",
+                relation: {
+                  kind: "lookup",
+                  namespace: "contacts",
+                  valueKey: "id"
+                }
+              }
+            })
           }
         }
-      ]
+      }
     },
     route: {
       matched: [{ path: "/w/:workspaceSlug/admin/contacts/:contactId/availabilities" }],

package/test/useViewRequestQueryParams.test.js

@@ -1,20 +1,20 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { appendRequestQueryEntriesToPath } from "../src/client/composables/support/requestQueryPathSupport.js";
+import { buildRequestQueryObject } from "../src/client/composables/support/requestQueryRuntimeSupport.js";
 
-test("appendRequestQueryEntriesToPath appends request query params deterministically", () => {
-  assert.equal(
-    appendRequestQueryEntriesToPath("/api/w/dev-admin/contacts/1", [
+test("buildRequestQueryObject preserves repeated keys as arrays deterministically", () => {
+  assert.deepEqual(
+    buildRequestQueryObject([
       { key: "include", values: ["vetId", "linkedUserId", "pets", "pets.breedId"] },
       { key: "limit", values: ["10"] }
     ]),
-    "/api/w/dev-admin/contacts/1?include=vetId&include=linkedUserId&include=pets&include=pets.breedId&limit=10"
+    {
+      include: ["vetId", "linkedUserId", "pets", "pets.breedId"],
+      limit: "10"
+    }
   );
 });
 
-test("appendRequestQueryEntriesToPath leaves the base path unchanged when no request params are active", () => {
-  assert.equal(
-    appendRequestQueryEntriesToPath("/api/w/dev-admin/contacts/1", []),
-    "/api/w/dev-admin/contacts/1"
-  );
+test("buildRequestQueryObject returns an empty object when no request params are active", () => {
+  assert.deepEqual(buildRequestQueryObject([]), {});
 });

package/src/client/composables/support/requestQueryPathSupport.js

@@ -1,31 +0,0 @@
-import { appendQueryString } from "@jskit-ai/kernel/shared/support";
-
-function appendRequestQueryEntriesToPath(path = "", entries = []) {
-  const normalizedPath = String(path || "").trim();
-  if (!normalizedPath) {
-    return "";
-  }
-
-  const sourceEntries = Array.isArray(entries) ? entries : [];
-  const searchParams = new URLSearchParams();
-  for (const entry of sourceEntries) {
-    const key = String(entry?.key || "").trim();
-    const values = Array.isArray(entry?.values) ? entry.values : [];
-    if (!key || values.length < 1) {
-      continue;
-    }
-
-    for (const value of values) {
-      searchParams.append(key, value);
-    }
-  }
-
-  const serializedSearch = searchParams.toString();
-  if (!serializedSearch) {
-    return normalizedPath;
-  }
-
-  return appendQueryString(normalizedPath, serializedSearch);
-}
-
-export { appendRequestQueryEntriesToPath };