@jskit-ai/users-web 0.1.70 → 0.1.72

package/src/client/composables/useCrudListFilters.js

@@ -1,17 +1,17 @@
-import { computed, reactive, toRef } from "vue";
-import { normalizeText, normalizeUniqueTextList } from "@jskit-ai/kernel/shared/support/normalize";
+import { computed, reactive } from "vue";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   defineCrudListFilters,
+  createCrudListFilterInitialValue,
+  isCrudListFilterMultiValue,
+  isCrudListFilterStructuredValue,
+  normalizeCrudListFilterUiValue,
+  areCrudListFilterUiValuesEqual,
+  listCrudListFilterChipValues,
+  formatCrudListFilterDefaultChipLabel,
+  formatCrudListFilterQueryValue,
   resolveCrudListFilterOptionLabel,
-  CRUD_LIST_FILTER_TYPE_FLAG,
-  CRUD_LIST_FILTER_TYPE_ENUM,
-  CRUD_LIST_FILTER_TYPE_ENUM_MANY,
-  CRUD_LIST_FILTER_TYPE_RECORD_ID,
-  CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY,
-  CRUD_LIST_FILTER_TYPE_DATE,
-  CRUD_LIST_FILTER_TYPE_DATE_RANGE,
-  CRUD_LIST_FILTER_TYPE_NUMBER_RANGE,
-  CRUD_LIST_FILTER_TYPE_PRESENCE
+  CRUD_LIST_FILTER_TYPE_FLAG
 } from "@jskit-ai/kernel/shared/support/crudListFilters";
 
 function normalizeFunctionMap(value = {}) {
@@ -32,29 +32,6 @@ function normalizeFunctionMap(value = {}) {
   return Object.freeze(normalized);
 }
 
-function createInitialFilterValue(filter = {}) {
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    return false;
-  }
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    return [];
-  }
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    return reactive({
-      from: "",
-      to: ""
-    });
-  }
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    return reactive({
-      min: "",
-      max: ""
-    });
-  }
-
-  return "";
-}
-
 function normalizePresetEntries(presets = []) {
   const source = Array.isArray(presets) ? presets : [];
   const normalized = [];
@@ -105,150 +82,52 @@ function resolvePresetValues(preset = {}, { values = {}, filters = {} } = {}) {
     : {};
 }
 
-function normalizePresetFilterValue(filter = {}, rawValue) {
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    return rawValue === true;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    const allowedValues = filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY
-      ? new Set((filter.options || []).map((entry) => entry.value))
-      : null;
-    const normalizedList = normalizeUniqueTextList(rawValue, {
-      acceptSingle: true
-    });
-    if (!allowedValues) {
-      return normalizedList;
-    }
-
-    return normalizedList.filter((entry) => allowedValues.has(entry));
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    const source = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)
-      ? rawValue
-      : {};
-    return {
-      from: normalizeText(source.from),
-      to: normalizeText(source.to)
-    };
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    const source = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)
-      ? rawValue
-      : {};
-    return {
-      min: normalizeText(source.min),
-      max: normalizeText(source.max)
-    };
-  }
-
-  const normalized = normalizeText(rawValue);
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM || filter.type === CRUD_LIST_FILTER_TYPE_PRESENCE) {
-    const allowedValues = new Set((filter.options || []).map((entry) => entry.value));
-    return allowedValues.has(normalized) ? normalized : "";
-  }
-
-  return normalized;
-}
-
-function normalizeCurrentManyFilterValues(value) {
-  const source = Array.isArray(value) ? value : [value];
-  return source
-    .map((entry) => normalizeText(entry))
-    .filter(Boolean);
-}
-
-function matchArrayValues(currentValue = [], expectedValue = []) {
-  const currentList = Array.isArray(currentValue) ? [...currentValue].sort() : [];
-  const expectedList = Array.isArray(expectedValue) ? [...expectedValue].sort() : [];
-  if (currentList.length !== expectedList.length) {
-    return false;
-  }
-
-  return currentList.every((entry, index) => entry === expectedList[index]);
-}
-
-function matchesPresetFilterValue(filter = {}, currentValue, rawExpectedValue) {
-  const expectedValue = normalizePresetFilterValue(filter, rawExpectedValue);
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    return matchArrayValues(normalizeCurrentManyFilterValues(currentValue), expectedValue);
-  }
-
-  const normalizedCurrentValue = normalizePresetFilterValue(filter, currentValue);
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    return (
-      normalizeText(normalizedCurrentValue?.from) === normalizeText(expectedValue?.from) &&
-      normalizeText(normalizedCurrentValue?.to) === normalizeText(expectedValue?.to)
-    );
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    return (
-      normalizeText(normalizedCurrentValue?.min) === normalizeText(expectedValue?.min) &&
-      normalizeText(normalizedCurrentValue?.max) === normalizeText(expectedValue?.max)
-    );
-  }
-
-  return normalizedCurrentValue === expectedValue;
+function createRuntimeFilterValue(filter = {}) {
+  const initialValue = createCrudListFilterInitialValue(filter);
+  return isCrudListFilterStructuredValue(filter)
+    ? reactive(initialValue)
+    : initialValue;
 }
 
-function resetFilterValue(values, filter = {}) {
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    values[filter.key] = false;
-    return;
-  }
+function assignFilterValue(values, filter = {}, rawValue) {
+  const normalizedValue = normalizeCrudListFilterUiValue(filter, rawValue);
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    values[filter.key] = [];
+  if (!isCrudListFilterStructuredValue(filter)) {
+    values[filter.key] = normalizedValue;
     return;
   }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    values[filter.key].from = "";
-    values[filter.key].to = "";
+  if (values[filter.key] && typeof values[filter.key] === "object" && !Array.isArray(values[filter.key])) {
+    Object.assign(values[filter.key], normalizedValue);
     return;
   }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    values[filter.key].min = "";
-    values[filter.key].max = "";
-    return;
-  }
+  values[filter.key] = reactive(normalizedValue);
+}
 
-  values[filter.key] = "";
+function resetFilterValue(values, filter = {}) {
+  assignFilterValue(values, filter, createCrudListFilterInitialValue(filter));
 }
 
 function applyPresetFilterValue(values, filter = {}, rawValue) {
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE || filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    const nextValue = normalizePresetFilterValue(filter, rawValue);
-    Object.assign(values[filter.key], nextValue);
-    return;
-  }
-
-  values[filter.key] = normalizePresetFilterValue(filter, rawValue);
+  assignFilterValue(values, filter, rawValue);
 }
 
 function createQueryParams(values, filterEntries = []) {
   const queryParams = {};
 
   for (const filter of filterEntries) {
-    if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-      queryParams[filter.fromKey] = toRef(values[filter.key], "from");
-      queryParams[filter.toKey] = toRef(values[filter.key], "to");
-      continue;
-    }
-
-    if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-      queryParams[filter.minKey] = toRef(values[filter.key], "min");
-      queryParams[filter.maxKey] = toRef(values[filter.key], "max");
-      continue;
-    }
-
-    queryParams[filter.queryKey] = toRef(values, filter.key);
+    queryParams[filter.queryKey] = computed({
+      get() {
+        return formatCrudListFilterQueryValue(
+          filter,
+          normalizeCrudListFilterUiValue(filter, values[filter.key])
+        );
+      },
+      set(nextValue) {
+        assignFilterValue(values, filter, nextValue);
+      }
+    });
   }
 
   return Object.freeze(queryParams);
@@ -268,46 +147,6 @@ function resolveAtomicValueLabel(filter = {}, value = "", labelResolvers = {}) {
   });
 }
 
-function defaultChipLabel(filter = {}, value, labelResolvers = {}) {
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    return filter.label;
-  }
-
-  if (
-    filter.type === CRUD_LIST_FILTER_TYPE_ENUM ||
-    filter.type === CRUD_LIST_FILTER_TYPE_PRESENCE ||
-    filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID
-  ) {
-    return `${filter.label}: ${resolveAtomicValueLabel(filter, value, labelResolvers)}`;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE) {
-    return `${filter.label}: ${value}`;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    if (value?.from && value?.to) {
-      return `${filter.label}: ${value.from} to ${value.to}`;
-    }
-    if (value?.from) {
-      return `${filter.label}: from ${value.from}`;
-    }
-    return `${filter.label}: to ${value?.to || ""}`;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    if (value?.min && value?.max) {
-      return `${filter.label}: ${value.min} to ${value.max}`;
-    }
-    if (value?.min) {
-      return `${filter.label}: min ${value.min}`;
-    }
-    return `${filter.label}: max ${value?.max || ""}`;
-  }
-
-  return filter.label;
-}
-
 function useCrudListFilters(definitions = {}, { labelResolvers = {}, chipLabels = {}, presets = [] } = {}) {
   const filters = defineCrudListFilters(definitions);
   const filterEntries = Object.values(filters);
@@ -318,7 +157,7 @@ function useCrudListFilters(definitions = {}, { labelResolvers = {}, chipLabels
   const options = {};
 
   for (const filter of filterEntries) {
-    values[filter.key] = createInitialFilterValue(filter);
+    values[filter.key] = createRuntimeFilterValue(filter);
     if (Array.isArray(filter.options) && filter.options.length > 0) {
       options[filter.key] = filter.options;
     }
@@ -331,62 +170,22 @@ function useCrudListFilters(definitions = {}, { labelResolvers = {}, chipLabels
 
     for (const filter of filterEntries) {
       const customChipLabel = normalizedChipLabels[filter.key];
-      const rawValue = values[filter.key];
-
-      if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-        if (rawValue === true) {
-          chips.push({
-            id: filter.key,
-            filterKey: filter.key,
-            label: normalizeText(customChipLabel?.(rawValue, filter, values))
-              || normalizeText(filter.chipLabel?.(rawValue, filter, values))
-              || defaultChipLabel(filter, rawValue, normalizedLabelResolvers)
-          });
-        }
-        continue;
-      }
-
-      if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-        for (const value of Array.isArray(rawValue) ? rawValue : []) {
-          chips.push({
-            id: `${filter.key}:${value}`,
-            filterKey: filter.key,
-            value,
-            label: normalizeText(customChipLabel?.(value, filter, values))
-              || normalizeText(filter.chipLabel?.(value, filter, values))
-              || `${filter.label}: ${resolveAtomicValueLabel(filter, value, normalizedLabelResolvers)}`
-          });
-        }
-        continue;
-      }
-
-      if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE || filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-        const hasValue = Boolean(rawValue?.from || rawValue?.to || rawValue?.min || rawValue?.max);
-        if (!hasValue) {
-          continue;
-        }
+      const chipValues = listCrudListFilterChipValues(filter, values[filter.key]);
 
+      for (const chipValue of chipValues) {
         chips.push({
-          id: filter.key,
+          id: isCrudListFilterMultiValue(filter) ? `${filter.key}:${chipValue}` : filter.key,
           filterKey: filter.key,
-          label: normalizeText(customChipLabel?.(rawValue, filter, values))
-            || normalizeText(filter.chipLabel?.(rawValue, filter, values))
-            || defaultChipLabel(filter, rawValue, normalizedLabelResolvers)
+          ...(isCrudListFilterMultiValue(filter) ? { value: chipValue } : {}),
+          label: normalizeText(customChipLabel?.(chipValue, filter, values))
+            || normalizeText(filter.chipLabel?.(chipValue, filter, values))
+            || formatCrudListFilterDefaultChipLabel(filter, chipValue, {
+              resolveAtomicValue(value) {
+                return resolveAtomicValueLabel(filter, value, normalizedLabelResolvers);
+              }
+            })
         });
-        continue;
       }
-
-      if (!normalizeText(rawValue)) {
-        continue;
-      }
-
-      chips.push({
-        id: filter.key,
-        filterKey: filter.key,
-        label: normalizeText(customChipLabel?.(rawValue, filter, values))
-          || normalizeText(filter.chipLabel?.(rawValue, filter, values))
-          || defaultChipLabel(filter, rawValue, normalizedLabelResolvers)
-      });
     }
 
     return chips;
@@ -415,9 +214,13 @@ function useCrudListFilters(definitions = {}, { labelResolvers = {}, chipLabels
       return;
     }
 
-    if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-      values[filter.key] = (Array.isArray(values[filter.key]) ? values[filter.key] : [])
-        .filter((entry) => entry !== chip.value);
+    if (isCrudListFilterMultiValue(filter)) {
+      assignFilterValue(
+        values,
+        filter,
+        (Array.isArray(values[filter.key]) ? values[filter.key] : [])
+          .filter((entry) => entry !== chip.value)
+      );
       return;
     }
 
@@ -475,7 +278,7 @@ function useCrudListFilters(definitions = {}, { labelResolvers = {}, chipLabels
       }
 
       matchedFilter = true;
-      if (!matchesPresetFilterValue(filter, values[filter.key], presetValues[filter.key])) {
+      if (!areCrudListFilterUiValuesEqual(filter, values[filter.key], presetValues[filter.key])) {
         return false;
       }
     }

package/src/client/providers/UsersWebClientProvider.js

@@ -1,17 +1,19 @@
 import UsersHomeToolsWidget from "../components/UsersHomeToolsWidget.vue";
 import ProfileClientElement from "../components/ProfileClientElement.vue";
+import { registerUsersBootstrapPayloadHandlers } from "../bootstrap/user-bootstrap-handler.js";
 
 class UsersWebClientProvider {
   static id = "users.web.client";
   static dependsOn = ["shell.web.client"];
 
   register(app) {
-    if (!app || typeof app.singleton !== "function") {
-      throw new Error("UsersWebClientProvider requires application singleton().");
+    if (!app || typeof app.singleton !== "function" || typeof app.tag !== "function") {
+      throw new Error("UsersWebClientProvider requires application singleton()/tag().");
     }
 
     app.singleton("users.web.home.tools.widget", () => UsersHomeToolsWidget);
     app.singleton("users.web.profile.element", () => ProfileClientElement);
+    registerUsersBootstrapPayloadHandlers(app);
   }
 }
 

package/test/bootstrap.test.js

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { resolveBootstrapPayloadHandlers } from "@jskit-ai/shell-web/client/bootstrap";
 import { resolvePlacementUserFromBootstrapPayload } from "../src/client/lib/bootstrap.js";
+import {
+  createUsersBootstrapUserHandler,
+  registerUsersBootstrapPayloadHandlers
+} from "../src/client/bootstrap/user-bootstrap-handler.js";
 
 test("resolvePlacementUserFromBootstrapPayload returns null for anonymous sessions", () => {
   assert.equal(
@@ -36,3 +41,128 @@ test("resolvePlacementUserFromBootstrapPayload maps profile fields used by place
     avatarUrl: "https://cdn.example.com/ada.png"
   });
 });
+
+function createPlacementRuntimeDouble() {
+  return {
+    context: Object.freeze({}),
+    getContext() {
+      return this.context;
+    },
+    setContext(patch = {}, { replace = false } = {}) {
+      this.context = Object.freeze(
+        replace
+          ? { ...patch }
+          : {
+              ...this.context,
+              ...patch
+            }
+      );
+      return this.context;
+    }
+  };
+}
+
+function createBootstrapRegistryAppDouble() {
+  const singletons = new Map();
+  const instances = new Map();
+  const tags = new Map();
+
+  return {
+    singleton(token, factory) {
+      singletons.set(token, factory);
+    },
+    tag(token, tagName) {
+      const current = tags.get(tagName) || [];
+      current.push(token);
+      tags.set(tagName, current);
+    },
+    resolveTag(tagName) {
+      return (tags.get(tagName) || []).map((token) => this.make(token));
+    },
+    make(token) {
+      if (instances.has(token)) {
+        return instances.get(token);
+      }
+      const factory = singletons.get(token);
+      if (typeof factory !== "function") {
+        throw new Error(`Unknown token ${String(token)}`);
+      }
+      const instance = factory(this);
+      instances.set(token, instance);
+      return instance;
+    }
+  };
+}
+
+test("users web bootstrap user handler writes placement user", async () => {
+  const handler = createUsersBootstrapUserHandler();
+  const placementRuntime = createPlacementRuntimeDouble();
+  await handler.applyBootstrapPayload({
+    payload: {
+      session: {
+        authenticated: true,
+        userId: "42"
+      },
+      profile: {
+        displayName: "Ada Lovelace",
+        email: "ADA@EXAMPLE.COM",
+        avatar: {
+          effectiveUrl: "https://cdn.example.com/ada.png"
+        }
+      }
+    },
+    placementRuntime,
+    source: "test"
+  });
+
+  assert.deepEqual(placementRuntime.getContext().user, {
+    id: "42",
+    displayName: "Ada Lovelace",
+    name: "Ada Lovelace",
+    email: "ada@example.com",
+    avatarUrl: "https://cdn.example.com/ada.png"
+  });
+});
+
+test("users web bootstrap user handler clears placement user on bootstrap 401 only", async () => {
+  const handler = createUsersBootstrapUserHandler();
+  const placementRuntime = createPlacementRuntimeDouble();
+  placementRuntime.setContext({
+    user: {
+      id: "42",
+      displayName: "Ada Lovelace"
+    }
+  });
+
+  await handler.handleBootstrapError({
+    error: {
+      statusCode: 404
+    },
+    placementRuntime,
+    source: "test"
+  });
+  assert.deepEqual(placementRuntime.getContext().user, {
+    id: "42",
+    displayName: "Ada Lovelace"
+  });
+
+  await handler.handleBootstrapError({
+    error: {
+      statusCode: 401
+    },
+    placementRuntime,
+    source: "test"
+  });
+  assert.equal(placementRuntime.getContext().user, null);
+});
+
+test("registerUsersBootstrapPayloadHandlers registers the users bootstrap user handler", () => {
+  const app = createBootstrapRegistryAppDouble();
+  registerUsersBootstrapPayloadHandlers(app);
+
+  const handlers = resolveBootstrapPayloadHandlers(app);
+  assert.equal(handlers.length, 1);
+  assert.equal(handlers[0]?.handlerId, "users.web.bootstrap.user");
+  assert.equal(typeof handlers[0]?.applyBootstrapPayload, "function");
+  assert.equal(typeof handlers[0]?.handleBootstrapError, "function");
+});

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/
+  );
+});