@jskit-ai/users-web 0.1.36 → 0.1.38

package/test/{useCrudSchemaForm.test.js → useCrudAddEdit.test.js}

@@ -11,7 +11,7 @@ import {
   applyCrudRouteBoundFieldValues,
   resolveCrudFieldErrors,
   parseCrudResourceOperationInput
-} from "../src/client/composables/crudSchemaFormHelpers.js";
+} from "../src/client/composables/crud/crudSchemaFormHelpers.js";
 
 test("normalizeCrudFormFields trims keys, removes invalid entries, and deduplicates", () => {
   const fields = normalizeCrudFormFields([
@@ -62,6 +62,86 @@ test("buildCrudFormPayload normalizes booleans and numbers while skipping empty
   });
 });
 
+test("buildCrudFormPayload and applyCrudPayloadToForm round-trip date-time fields", () => {
+  const fields = [
+    { key: "scheduledAt", type: "string", format: "date-time" }
+  ];
+  const payload = buildCrudFormPayload(fields, {
+    scheduledAt: "2024-01-02T03:04"
+  });
+
+  assert.match(payload.scheduledAt, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.000Z$/);
+
+  const form = reactive({
+    scheduledAt: ""
+  });
+  applyCrudPayloadToForm(fields, form, payload);
+
+  assert.equal(form.scheduledAt, "2024-01-02T03:04");
+});
+
+test("buildCrudFormPayload normalizes time fields to canonical HH:MM", () => {
+  const fields = [
+    { key: "fromTime", type: "string", format: "time" },
+    { key: "toTime", type: "string", format: "time" }
+  ];
+
+  const payload = buildCrudFormPayload(fields, {
+    fromTime: "06:13 PM",
+    toTime: "18:45:00"
+  });
+
+  assert.deepEqual(payload, {
+    fromTime: "18:13",
+    toTime: "18:45"
+  });
+});
+
+test("buildCrudFormPayload serializes cleared nullable typed fields as null", () => {
+  const payload = buildCrudFormPayload(
+    [
+      { key: "serviceId", type: "integer", nullable: true },
+      { key: "fromDate", type: "string", format: "date", nullable: true },
+      { key: "scheduledAt", type: "string", format: "date-time", nullable: true },
+      { key: "fromTime", type: "string", format: "time", nullable: true }
+    ],
+    {
+      serviceId: null,
+      fromDate: "",
+      scheduledAt: "",
+      fromTime: ""
+    }
+  );
+
+  assert.deepEqual(payload, {
+    serviceId: null,
+    fromDate: null,
+    scheduledAt: null,
+    fromTime: null
+  });
+});
+
+test("applyCrudPayloadToForm normalizes time fields for form inputs", () => {
+  const fields = [
+    { key: "fromTime", type: "string", format: "time" },
+    { key: "toTime", type: "string", format: "time" }
+  ];
+  const form = reactive({
+    fromTime: "",
+    toTime: ""
+  });
+
+  applyCrudPayloadToForm(fields, form, {
+    fromTime: "18:13:00",
+    toTime: "06:45 PM"
+  });
+
+  assert.deepEqual(form, {
+    fromTime: "18:13",
+    toTime: "18:45"
+  });
+});
+
 test("applyCrudPayloadToForm maps payload values into reactive form model", () => {
   const form = reactive({
     name: "",

package/test/useCrudListParentTitle.test.js

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveCrudListParentDescriptor, resolveCrudListParentRecordTitle, resolveCrudListParentTitleFromItems } from "../src/client/composables/internal/crudListParentTitleSupport.js";
+
+const contactChildResource = Object.freeze({
+  contract: {
+    lookup: {
+      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"
+      })
+    })
+  ])
+});
+
+test("resolveCrudListParentDescriptor selects the nearest lookup route parent", () => {
+  const descriptor = resolveCrudListParentDescriptor({
+    resource: contactChildResource,
+    route: {
+      matched: [
+        { path: "/w/:workspaceSlug/admin" },
+        { path: "/w/:workspaceSlug/admin/contacts/:contactId/availabilities" }
+      ],
+      params: {
+        workspaceSlug: "dogandgroom",
+        contactId: "538779"
+      }
+    },
+    recordIdParam: "availabilityRuleId"
+  });
+
+  assert.deepEqual(
+    descriptor,
+    {
+      fieldKey: "contactId",
+      routeParamKey: "contactId",
+      relationNamespace: "contacts",
+      entityLabel: "Contact",
+      labelKey: "",
+      fieldDescriptor: {
+        key: "contactId",
+        relation: {
+          kind: "lookup",
+          valueKey: "id",
+          labelKey: "",
+          containerKey: "lookups"
+        }
+      },
+      apiUrlTemplate: "/contacts/:contactId"
+    }
+  );
+});
+
+test("resolveCrudListParentTitleFromItems uses the hydrated lookup label", () => {
+  const descriptor = resolveCrudListParentDescriptor({
+    resource: contactChildResource,
+    route: {
+      matched: [{ path: "/w/:workspaceSlug/admin/contacts/:contactId/availabilities" }],
+      params: {
+        workspaceSlug: "dogandgroom",
+        contactId: "538779"
+      }
+    },
+    recordIdParam: "availabilityRuleId"
+  });
+
+  const title = resolveCrudListParentTitleFromItems(
+    [
+      {
+        id: 1,
+        contactId: 538779,
+        lookups: {
+          contactId: {
+            id: 538779,
+            firstName: "Jessica",
+            lastName: "Dickinson"
+          }
+        }
+      }
+    ],
+    descriptor
+  );
+
+  assert.equal(title, "Jessica Dickinson");
+});
+
+test("resolveCrudListParentRecordTitle falls back to entity label plus id", () => {
+  const title = resolveCrudListParentRecordTitle(
+    {
+      id: 538779
+    },
+    {
+      entityLabel: "Contact",
+      labelKey: ""
+    }
+  );
+
+  assert.equal(title, "Contact #538779");
+});
+
+test("resolveCrudListParentDescriptor supports parentRouteParamKey aliases", () => {
+  const descriptor = resolveCrudListParentDescriptor({
+    resource: {
+      fieldMeta: [
+        {
+          key: "staffContactId",
+          parentRouteParamKey: "contactId",
+          relation: {
+            kind: "lookup",
+            namespace: "contacts",
+            valueKey: "id"
+          }
+        }
+      ]
+    },
+    route: {
+      matched: [{ path: "/w/:workspaceSlug/admin/contacts/:contactId/availabilities" }],
+      params: {
+        workspaceSlug: "dogandgroom",
+        contactId: "538779"
+      }
+    },
+    recordIdParam: "availabilityRuleId"
+  });
+
+  assert.equal(descriptor?.fieldKey, "staffContactId");
+  assert.equal(descriptor?.routeParamKey, "contactId");
+});

package/test/useListSearchSupport.test.js

@@ -3,7 +3,7 @@ import test from "node:test";
 import {
   normalizeListSearchConfig,
   matchesLocalSearch
-} from "../src/client/composables/listSearchSupport.js";
+} from "../src/client/composables/support/listSearchSupport.js";
 
 test("normalizeListSearchConfig defaults to disabled query search", () => {
   const config = normalizeListSearchConfig();

package/test/usePagedCollection.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { trimInfinitePagesToFirst } from "../src/client/composables/usePagedCollection.js";
+
+test("trimInfinitePagesToFirst leaves non-object payloads untouched", () => {
+  assert.equal(trimInfinitePagesToFirst(null), null);
+  assert.equal(trimInfinitePagesToFirst(""), "");
+  assert.equal(trimInfinitePagesToFirst(12), 12);
+});
+
+test("trimInfinitePagesToFirst leaves single-page payload unchanged", () => {
+  const payload = Object.freeze({
+    pages: Object.freeze([{ items: [1, 2] }]),
+    pageParams: Object.freeze([null])
+  });
+
+  assert.equal(trimInfinitePagesToFirst(payload), payload);
+});
+
+test("trimInfinitePagesToFirst truncates to the first page and first pageParam", () => {
+  const payload = {
+    pages: [
+      { items: [1, 2] },
+      { items: [3, 4] },
+      { items: [5, 6] }
+    ],
+    pageParams: [null, "cursor-1", "cursor-2"],
+    extra: true
+  };
+
+  assert.deepEqual(
+    trimInfinitePagesToFirst(payload),
+    {
+      pages: [{ items: [1, 2] }],
+      pageParams: [null],
+      extra: true
+    }
+  );
+});
+
+test("trimInfinitePagesToFirst injects null pageParam when missing", () => {
+  const payload = {
+    pages: [{ items: [1] }, { items: [2] }]
+  };
+
+  assert.deepEqual(
+    trimInfinitePagesToFirst(payload),
+    {
+      pages: [{ items: [1] }],
+      pageParams: [null]
+    }
+  );
+});

package/test/viewCoreLoading.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { useViewCore } from "../src/client/composables/useViewCore.js";
+import { useViewCore } from "../src/client/composables/runtime/useViewCore.js";
 
 test("useViewCore prefers resource isInitialLoading/isFetching signals when provided", () => {
   const resource = {

package/test/viewUiRuntime.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { createViewUiRuntime } from "../src/client/composables/viewUiRuntime.js";
+import { createViewUiRuntime } from "../src/client/composables/runtime/viewUiRuntime.js";
 
 test("createViewUiRuntime resolves api/list/edit paths with nested params", () => {
   const runtime = createViewUiRuntime({
@@ -23,6 +23,41 @@ test("createViewUiRuntime resolves api/list/edit paths with nested params", () =
   assert.equal(runtime.resolveParams("./edit"), "/users/user-7/addresses/addr-42/edit");
 });
 
+test("createViewUiRuntime resolves view links from the record pathname when route is nested", () => {
+  const runtime = createViewUiRuntime({
+    recordIdParam: "contactId",
+    routeParams: ref({
+      workspaceSlug: "dogandgroom",
+      contactId: "541841",
+      petId: "715528"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528"),
+    listUrlTemplate: "..",
+    editUrlTemplate: "./edit"
+  });
+
+  assert.equal(runtime.listUrl.value, "/w/dogandgroom/admin/contacts");
+  assert.equal(runtime.editUrl.value, "/w/dogandgroom/admin/contacts/541841/edit");
+  assert.equal(runtime.resolveParams("./edit"), "/w/dogandgroom/admin/contacts/541841/edit");
+});
+
+test("createViewUiRuntime uses route param order when repeated values are present", () => {
+  const runtime = createViewUiRuntime({
+    recordIdParam: "contactId",
+    routeParams: ref({
+      workspaceSlug: "123",
+      contactId: "123",
+      petId: "123"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/123/admin/contacts/123/pets/123"),
+    editUrlTemplate: "./edit"
+  });
+
+  assert.equal(runtime.editUrl.value, "/w/123/admin/contacts/123/edit");
+});
+
 test("createViewUiRuntime uses explicit routeRecordId when route params do not include id", () => {
   const runtime = createViewUiRuntime({
     recordIdParam: "addressId",

package/src/client/composables/accountSettingsAvatarUploadRuntime.js

@@ -1,241 +0,0 @@
-import Uppy from "@uppy/core";
-import Dashboard from "@uppy/dashboard";
-import ImageEditor from "@uppy/image-editor";
-import Compressor from "@uppy/compressor";
-import XHRUpload from "@uppy/xhr-upload";
-import "@uppy/core/css/style.min.css";
-import "@uppy/dashboard/css/style.min.css";
-import "@uppy/image-editor/css/style.min.css";
-import { resolveFieldErrors } from "@jskit-ai/http-runtime/client";
-import { usersWebHttpClient } from "../lib/httpClient.js";
-import {
-  AVATAR_ALLOWED_MIME_TYPES,
-  AVATAR_MAX_UPLOAD_BYTES
-} from "./accountSettingsRuntimeConstants.js";
-
-function parseUploadResponse(xhr) {
-  if (!xhr.responseText) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(xhr.responseText);
-  } catch {
-    return {};
-  }
-}
-
-function stopImageEditor(uppy) {
-  const imageEditor = uppy.getPlugin("ImageEditor");
-  if (imageEditor && typeof imageEditor.stop === "function") {
-    imageEditor.stop();
-  }
-}
-
-function createAccountSettingsAvatarUploadRuntime({
-  queryClient,
-  sessionQueryKey,
-  accountSettingsQueryKey,
-  selectedAvatarFileName,
-  applySettingsData,
-  reportAccountFeedback
-} = {}) {
-  let avatarUppy = null;
-
-  async function resolveCsrfToken() {
-    const sessionPayload = await queryClient.fetchQuery({
-      queryKey: sessionQueryKey,
-      queryFn: () =>
-        usersWebHttpClient.request("/api/session", {
-          method: "GET"
-        }),
-      staleTime: 60_000
-    });
-
-    const csrfToken = String(sessionPayload?.csrfToken || "");
-    if (!csrfToken) {
-      throw new Error("Unable to prepare secure avatar upload request.");
-    }
-
-    return csrfToken;
-  }
-
-  function setup() {
-    if (typeof window === "undefined") {
-      return;
-    }
-
-    if (avatarUppy) {
-      return;
-    }
-
-    const uppy = new Uppy({
-      autoProceed: false,
-      restrictions: {
-        maxNumberOfFiles: 1,
-        allowedFileTypes: [...AVATAR_ALLOWED_MIME_TYPES],
-        maxFileSize: AVATAR_MAX_UPLOAD_BYTES
-      }
-    });
-
-    uppy.use(Dashboard, {
-      inline: false,
-      closeAfterFinish: false,
-      showProgressDetails: true,
-      proudlyDisplayPoweredByUppy: false,
-      hideUploadButton: false,
-      doneButtonHandler: () => {
-        const dashboard = uppy.getPlugin("Dashboard");
-        if (dashboard && typeof dashboard.closeModal === "function") {
-          dashboard.closeModal();
-        }
-      },
-      note: `Accepted: ${AVATAR_ALLOWED_MIME_TYPES.join(", ")}, max ${Math.floor(AVATAR_MAX_UPLOAD_BYTES / (1024 * 1024))}MB`
-    });
-
-    uppy.use(ImageEditor, {
-      quality: 0.9
-    });
-
-    uppy.use(Compressor, {
-      quality: 0.84,
-      limit: 1
-    });
-
-    uppy.use(XHRUpload, {
-      endpoint: "/api/settings/profile/avatar",
-      method: "POST",
-      formData: true,
-      fieldName: "avatar",
-      withCredentials: true,
-      onBeforeRequest: async (xhr) => {
-        const csrfToken = await resolveCsrfToken();
-        xhr.setRequestHeader("csrf-token", csrfToken);
-      },
-      getResponseData: parseUploadResponse
-    });
-
-    uppy.on("file-added", (file) => {
-      selectedAvatarFileName.value = String(file?.name || "");
-    });
-
-    uppy.on("file-removed", () => {
-      selectedAvatarFileName.value = "";
-    });
-
-    uppy.on("file-editor:complete", (file) => {
-      selectedAvatarFileName.value = String(file?.name || selectedAvatarFileName.value || "");
-      stopImageEditor(uppy);
-    });
-
-    uppy.on("file-editor:cancel", () => {
-      stopImageEditor(uppy);
-    });
-
-    uppy.on("dashboard:modal-closed", () => {
-      stopImageEditor(uppy);
-    });
-
-    uppy.on("upload-success", (_file, response) => {
-      const data = response?.body;
-      if (!data || typeof data !== "object") {
-        reportAccountFeedback({
-          message: "Avatar uploaded, but the response payload was invalid.",
-          severity: "error",
-          channel: "banner",
-          dedupeKey: "users-web.account-settings-runtime:avatar-upload-invalid-response"
-        });
-        return;
-      }
-
-      applySettingsData(data);
-      queryClient.setQueryData(accountSettingsQueryKey, data);
-
-      const dashboard = uppy.getPlugin("Dashboard");
-      if (dashboard && typeof dashboard.closeModal === "function") {
-        dashboard.closeModal();
-      }
-
-      reportAccountFeedback({
-        message: "Avatar uploaded.",
-        severity: "success",
-        channel: "snackbar",
-        dedupeKey: "users-web.account-settings-runtime:avatar-uploaded"
-      });
-      selectedAvatarFileName.value = "";
-    });
-
-    uppy.on("upload-error", (_file, error, response) => {
-      const body = response?.body && typeof response.body === "object" ? response.body : {};
-      const fieldErrors = resolveFieldErrors(body);
-
-      reportAccountFeedback({
-        message: String(fieldErrors.avatar || body?.error || error?.message || "Unable to upload avatar."),
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:avatar-upload-error"
-      });
-    });
-
-    uppy.on("restriction-failed", (_file, error) => {
-      reportAccountFeedback({
-        message: String(error?.message || "Selected avatar file does not meet upload restrictions."),
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:avatar-upload-restriction"
-      });
-    });
-
-    uppy.on("complete", (result) => {
-      const successfulCount = Array.isArray(result?.successful) ? result.successful.length : 0;
-      if (successfulCount <= 0) {
-        return;
-      }
-
-      try {
-        uppy.clear();
-      } catch {
-        // Upload succeeded; ignore clear timing issues.
-      }
-    });
-
-    avatarUppy = uppy;
-  }
-
-  function openEditor() {
-    setup();
-
-    const uppy = avatarUppy;
-    if (!uppy) {
-      reportAccountFeedback({
-        message: "Avatar editor is unavailable in this environment.",
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:avatar-editor-unavailable"
-      });
-      return;
-    }
-
-    const dashboard = uppy.getPlugin("Dashboard");
-    if (dashboard && typeof dashboard.openModal === "function") {
-      dashboard.openModal();
-    }
-  }
-
-  function destroy() {
-    if (!avatarUppy) {
-      return;
-    }
-
-    avatarUppy.destroy();
-    avatarUppy = null;
-  }
-
-  return Object.freeze({
-    destroy,
-    openEditor,
-    setup
-  });
-}
-
-export { createAccountSettingsAvatarUploadRuntime };