@jskit-ai/users-web 0.1.37 → 0.1.38

package/test/permissions.test.js

@@ -30,6 +30,6 @@ test("arePermissionListsEqual returns false for different permission sets", () =
 });
 
 test("hasPermission supports namespace wildcard matches", () => {
-  assert.equal(hasPermission(["crud_contacts.*"], "crud_contacts.update"), true);
-  assert.equal(hasPermission(["crud_contacts.*"], "crud_projects.update"), false);
+  assert.equal(hasPermission(["crud.contacts.*"], "crud.contacts.update"), true);
+  assert.equal(hasPermission(["crud.contacts.*"], "crud.projects.update"), false);
 });

package/test/refValueHelpers.test.js

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

package/test/resourceLoadStateHelpers.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { hasResolvedQueryData } from "../src/client/composables/resourceLoadStateHelpers.js";
+import { hasResolvedQueryData } from "../src/client/composables/support/resourceLoadStateHelpers.js";
 
 test("hasResolvedQueryData returns true when the query succeeded", () => {
   const query = {

package/test/routeTemplateHelpers.test.js

@@ -4,7 +4,7 @@ import {
   extractRouteParamNames,
   resolveScopedRoutePathname,
   resolveRouteParamNamesInOrder
-} from "../src/client/composables/routeTemplateHelpers.js";
+} from "../src/client/composables/support/routeTemplateHelpers.js";
 
 test("extractRouteParamNames reads dynamic params from route templates", () => {
   assert.deepEqual(

package/test/scopeHelpers.test.js

@@ -6,7 +6,7 @@ import {
   normalizeOwnershipFilter,
   resolveApiSuffix,
   resolveResourceMessages
-} from "../src/client/composables/scopeHelpers.js";
+} from "../src/client/composables/support/scopeHelpers.js";
 
 test("resolveResourceMessages merges defaults with resource messages", () => {
   const messages = resolveResourceMessages(

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/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({

package/src/client/composables/accountSettingsAvatarUploadRuntime.js

@@ -1,95 +0,0 @@
-import "@jskit-ai/uploads-image-web/client/styles";
-import { createImageUploadRuntime } from "@jskit-ai/uploads-image-web/client/composables/createImageUploadRuntime";
-import { resolveFieldErrors } from "@jskit-ai/http-runtime/client";
-import { usersWebHttpClient } from "../lib/httpClient.js";
-
-function createAccountSettingsAvatarUploadRuntime({
-  queryClient,
-  sessionQueryKey,
-  accountSettingsQueryKey,
-  selectedAvatarFileName,
-  applySettingsData,
-  reportAccountFeedback
-} = {}) {
-  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;
-  }
-
-  return createImageUploadRuntime({
-    endpoint: "/api/settings/profile/avatar",
-    fieldName: "avatar",
-    resolveRequestHeaders: async () => ({
-      "csrf-token": await resolveCsrfToken()
-    }),
-    onSelectedFileNameChanged: (fileName) => {
-      selectedAvatarFileName.value = String(fileName || "");
-    },
-    onUploadSuccess: ({ data, uppy }) => {
-      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"
-      });
-    },
-    onInvalidResponse: () => {
-      reportAccountFeedback({
-        message: "Avatar uploaded, but the response payload was invalid.",
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:avatar-upload-invalid-response"
-      });
-    },
-    onUploadError: ({ 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"
-      });
-    },
-    onRestrictionFailed: ({ 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"
-      });
-    },
-    onUnavailable: () => {
-      reportAccountFeedback({
-        message: "Avatar editor is unavailable in this environment.",
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:avatar-editor-unavailable"
-      });
-    }
-  });
-}
-
-export { createAccountSettingsAvatarUploadRuntime };