@jskit-ai/http-web 0.1.1

package/test/scopeHelpers.test.js

@@ -0,0 +1,57 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { computed } from "vue";
+import {
+  isScopedOwnershipFilter,
+  normalizeOwnershipFilter,
+  resolveApiSuffix,
+  resolveResourceMessages
+} from "../src/client/composables/support/scopeHelpers.js";
+
+test("resolveResourceMessages merges defaults with resource messages", () => {
+  const messages = resolveResourceMessages(
+    {
+      messages: {
+        saveError: "Unable to update workspace settings.",
+        saveSuccess: "Workspace settings updated."
+      }
+    },
+    {
+      validation: "Fix invalid values and try again.",
+      saveSuccess: "Saved.",
+      saveError: "Unable to save."
+    }
+  );
+
+  assert.deepEqual(messages, {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Workspace settings updated.",
+    saveError: "Unable to update workspace settings."
+  });
+});
+
+test("resolveApiSuffix unwraps computed refs", () => {
+  const suffix = computed(() => "/customers/42");
+
+  assert.equal(resolveApiSuffix(suffix), "/customers/42");
+});
+
+test("resolveApiSuffix unwraps function-returned computed refs", () => {
+  const suffix = computed(() => "/customers/42");
+
+  assert.equal(resolveApiSuffix(() => suffix), "/customers/42");
+});
+
+test("normalizeOwnershipFilter accepts route visibility levels", () => {
+  assert.equal(normalizeOwnershipFilter("public"), "public");
+  assert.equal(normalizeOwnershipFilter("workspace"), "workspace");
+  assert.equal(normalizeOwnershipFilter("user"), "user");
+  assert.equal(normalizeOwnershipFilter("workspace_user"), "workspace_user");
+});
+
+test("isScopedOwnershipFilter only matches scoped ownership levels", () => {
+  assert.equal(isScopedOwnershipFilter("workspace"), true);
+  assert.equal(isScopedOwnershipFilter("workspace_user"), true);
+  assert.equal(isScopedOwnershipFilter("public"), false);
+  assert.equal(isScopedOwnershipFilter("user"), false);
+});

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,190 @@
+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);
+});
+
+test("request query runtime carries typed fieldsets as a first-class query and cache-key dimension", () => {
+  const runtime = createRequestQueryRuntime({
+    requestQueryParams: {
+      include: "operator"
+    },
+    requestFieldsets: {
+      jobs: ["status", "id"],
+      contacts: ["displayName", "id"]
+    },
+    sourceQueryKey: ref(["jobs"])
+  });
+
+  assert.deepEqual(runtime.requestQuery.value, {
+    include: "operator",
+    fields: {
+      contacts: ["displayName", "id"],
+      jobs: ["id", "status"]
+    }
+  });
+  assert.deepEqual(runtime.queryKey.value, [
+    "jobs",
+    "__request_query__",
+    "include=operator",
+    "__request_fieldsets__",
+    '{"contacts":["displayName","id"],"jobs":["id","status"]}'
+  ]);
+});