@jskit-ai/users-web 0.1.173 → 0.1.175

package/src/client/composables/crud/crudBindingSupport.js

@@ -1,75 +0,0 @@
-import { unref } from "vue";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { asPlainObject } from "../support/scopeHelpers.js";
-
-const CRUD_BINDING_MODE_ROUTE = "route";
-const CRUD_BINDING_MODE_MERGE = "merge";
-const CRUD_BINDING_MODE_EXPLICIT = "explicit";
-const CRUD_BINDING_MODE_NONE = "none";
-
-function normalizeCrudBindingMode(value = "") {
-  const normalizedValue = normalizeText(value).toLowerCase();
-  if (normalizedValue === CRUD_BINDING_MODE_MERGE) {
-    return CRUD_BINDING_MODE_MERGE;
-  }
-  if (normalizedValue === CRUD_BINDING_MODE_EXPLICIT) {
-    return CRUD_BINDING_MODE_EXPLICIT;
-  }
-  if (normalizedValue === CRUD_BINDING_MODE_NONE) {
-    return CRUD_BINDING_MODE_NONE;
-  }
-
-  return CRUD_BINDING_MODE_ROUTE;
-}
-
-function normalizeCrudBindingConfig(binding = {}) {
-  const source = asPlainObject(unref(binding));
-  return Object.freeze({
-    mode: normalizeCrudBindingMode(source.mode),
-    values: source.values ?? null
-  });
-}
-
-function resolveCrudBindingValues(values, context = {}) {
-  if (typeof values === "function") {
-    return asPlainObject(values(context));
-  }
-
-  return asPlainObject(unref(values));
-}
-
-function resolveCrudBoundValues({
-  binding = {},
-  routeValues = {},
-  context = {}
-} = {}) {
-  const normalizedBinding = normalizeCrudBindingConfig(binding);
-  const normalizedRouteValues = asPlainObject(routeValues);
-  const explicitValues = resolveCrudBindingValues(normalizedBinding.values, context);
-
-  if (normalizedBinding.mode === CRUD_BINDING_MODE_NONE) {
-    return {};
-  }
-  if (normalizedBinding.mode === CRUD_BINDING_MODE_EXPLICIT) {
-    return explicitValues;
-  }
-  if (normalizedBinding.mode === CRUD_BINDING_MODE_MERGE) {
-    return {
-      ...normalizedRouteValues,
-      ...explicitValues
-    };
-  }
-
-  return normalizedRouteValues;
-}
-
-export {
-  CRUD_BINDING_MODE_ROUTE,
-  CRUD_BINDING_MODE_MERGE,
-  CRUD_BINDING_MODE_EXPLICIT,
-  CRUD_BINDING_MODE_NONE,
-  normalizeCrudBindingMode,
-  normalizeCrudBindingConfig,
-  resolveCrudBindingValues,
-  resolveCrudBoundValues
-};

package/src/client/composables/crud/crudHttpClientSupport.js

@@ -1,57 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { getUsersWebHttpClient } from "../../lib/httpClient.js";
-
-const CRUD_API_ACCESS_AUTHENTICATED = "authenticated";
-const CRUD_API_ACCESS_PUBLIC = "public";
-const CRUD_API_ACCESS_VALUES = Object.freeze([
-  CRUD_API_ACCESS_AUTHENTICATED,
-  CRUD_API_ACCESS_PUBLIC
-]);
-const publicCrudClients = new WeakSet();
-
-function normalizeCrudApiAccess(value = "") {
-  const normalized = normalizeText(value).toLowerCase() || CRUD_API_ACCESS_AUTHENTICATED;
-  if (CRUD_API_ACCESS_VALUES.includes(normalized)) {
-    return normalized;
-  }
-
-  throw new TypeError(
-    `CRUD resource apiAccess must be one of: ${CRUD_API_ACCESS_VALUES.join(", ")}. ` +
-      `Received: ${String(value || "") || "(empty)"}`
-  );
-}
-
-function resolveCrudHttpClient(resource = null, { client = null } = {}) {
-  const activeClient = client || getUsersWebHttpClient();
-  if (!activeClient || typeof activeClient.request !== "function") {
-    throw new TypeError("resolveCrudHttpClient requires a client with request().");
-  }
-
-  if (normalizeCrudApiAccess(resource?.apiAccess) !== CRUD_API_ACCESS_PUBLIC) {
-    return activeClient;
-  }
-  if (publicCrudClients.has(activeClient)) {
-    return activeClient;
-  }
-
-  const publicClient = Object.freeze({
-    request(url, options = {}) {
-      const requestOptions = options && typeof options === "object" && !Array.isArray(options)
-        ? options
-        : {};
-      return activeClient.request(url, {
-        ...requestOptions,
-        csrf: false
-      });
-    }
-  });
-  publicCrudClients.add(publicClient);
-  return publicClient;
-}
-
-export {
-  CRUD_API_ACCESS_AUTHENTICATED,
-  CRUD_API_ACCESS_PUBLIC,
-  normalizeCrudApiAccess,
-  resolveCrudHttpClient
-};

package/src/client/composables/crud/crudJsonApiTransportSupport.js

@@ -1,145 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeCrudLookupNamespace } from "@jskit-ai/kernel/shared/support/crudLookup";
-
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function resolveSchemaFieldDefinitions(definition = null) {
-  const schema = definition?.schema;
-  if (!schema || typeof schema.getFieldDefinitions !== "function") {
-    return {};
-  }
-
-  const definitions = schema.getFieldDefinitions();
-  return isRecord(definitions) ? definitions : {};
-}
-
-function resolveLookupFieldMap(resource = null) {
-  const outputDefinition =
-    resource?.operations?.view?.output ||
-    resource?.operations?.create?.output ||
-    resource?.operations?.patch?.output ||
-    null;
-  const mapping = {};
-
-  for (const [fieldKey, fieldDefinition] of Object.entries(resolveSchemaFieldDefinitions(outputDefinition))) {
-    const normalizedFieldDefinition = isRecord(fieldDefinition) ? fieldDefinition : {};
-    if (!normalizeText(normalizedFieldDefinition.belongsTo)) {
-      continue;
-    }
-
-    const relationshipName = normalizeText(normalizedFieldDefinition.as, {
-      fallback: fieldKey
-    });
-    const normalizedFieldKey = normalizeText(fieldKey);
-    if (!normalizedFieldKey || !relationshipName) {
-      continue;
-    }
-
-    mapping[relationshipName] = normalizedFieldKey;
-  }
-
-  return Object.freeze(mapping);
-}
-
-function isJsonApiResourceTransport(transport = null) {
-  return normalizeText(transport?.kind).toLowerCase() === "jsonapi-resource";
-}
-
-function resolveCrudJsonApiResourceType(resource = null) {
-  return normalizeText(resource?.namespace);
-}
-
-function inferCrudLookupJsonApiTransport({ namespace = "", apiPath = "" } = {}) {
-  const resourceType =
-    normalizeCrudLookupNamespace(namespace) ||
-    normalizeCrudLookupNamespace(apiPath);
-  if (!resourceType) {
-    return null;
-  }
-
-  return Object.freeze({
-    kind: "jsonapi-resource",
-    responseType: resourceType,
-    responseKind: "collection"
-  });
-}
-
-function inferCrudJsonApiTransport(resource = null, { mode = "", operationName = "" } = {}) {
-  const resourceType = resolveCrudJsonApiResourceType(resource);
-  if (!resourceType) {
-    return null;
-  }
-
-  const normalizedMode = normalizeText(mode).toLowerCase();
-  const normalizedOperationName = normalizeText(operationName).toLowerCase();
-  if (normalizedMode === "list") {
-    return Object.freeze({
-      kind: "jsonapi-resource",
-      responseType: resourceType,
-      responseKind: "collection"
-    });
-  }
-
-  if (normalizedMode === "view") {
-    return Object.freeze({
-      kind: "jsonapi-resource",
-      responseType: resourceType,
-      responseKind: "record"
-    });
-  }
-
-  if (normalizedMode === "delete") {
-    return Object.freeze({
-      kind: "jsonapi-resource",
-      responseType: resourceType,
-      responseKind: "record"
-    });
-  }
-
-  if (normalizedMode === "add-edit") {
-    return Object.freeze({
-      kind: "jsonapi-resource",
-      ...(normalizedOperationName ? { requestType: resourceType } : {}),
-      responseType: resourceType,
-      responseKind: "record"
-    });
-  }
-
-  return null;
-}
-
-function resolveCrudJsonApiTransport(transport = null, resource = null, options = {}) {
-  if (transport != null) {
-    throw new TypeError(
-      "CRUD hooks do not accept explicit transport. Derive JSON:API transport from the shared resource."
-    );
-  }
-
-  const baseTransport = inferCrudJsonApiTransport(resource, options);
-  if (!isJsonApiResourceTransport(baseTransport)) {
-    return baseTransport;
-  }
-
-  const lookupFieldMap = resolveLookupFieldMap(resource);
-  const lookupContainerKey = normalizeText(resource?.contract?.lookup?.containerKey, {
-    fallback: "lookups"
-  });
-  if (Object.keys(lookupFieldMap).length < 1 && !lookupContainerKey) {
-    return baseTransport;
-  }
-
-  return Object.freeze({
-    ...baseTransport,
-    ...(Object.keys(lookupFieldMap).length > 0 ? { lookupFieldMap } : {}),
-    ...(lookupContainerKey ? { lookupContainerKey } : {})
-  });
-}
-
-export {
-  inferCrudJsonApiTransport,
-  inferCrudLookupJsonApiTransport,
-  resolveCrudJsonApiTransport,
-  resolveLookupFieldMap
-};

package/src/client/composables/crud/crudLookupFieldLabelSupport.js

@@ -1,151 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeCrudLookupContainerKey } from "@jskit-ai/kernel/shared/support/crudLookup";
-import { asPlainObject } from "../support/scopeHelpers.js";
-
-const LOOKUP_LABEL_COMPOSITION_CANDIDATES = Object.freeze([
-  Object.freeze(["name", "surname"]),
-  Object.freeze(["name", "lastName"]),
-  Object.freeze(["firstName", "surname"]),
-  Object.freeze(["firstName", "lastName"]),
-  Object.freeze(["name"]),
-  Object.freeze(["firstName"])
-]);
-const DEFAULT_RECORD_TITLE = "-";
-
-function hasDisplayValue(value) {
-  if (value == null) {
-    return false;
-  }
-  if (typeof value === "string") {
-    return normalizeText(value).length > 0;
-  }
-
-  return true;
-}
-
-function resolveComposedLabel(source = {}, candidates = LOOKUP_LABEL_COMPOSITION_CANDIDATES) {
-  for (const candidate of candidates) {
-    const parts = [];
-    for (const key of candidate) {
-      const part = normalizeText(source[key]);
-      if (!part) {
-        parts.length = 0;
-        break;
-      }
-      parts.push(part);
-    }
-    if (parts.length === candidate.length) {
-      return parts.join(" ");
-    }
-  }
-
-  return "";
-}
-
-function resolveLookupItemLabel(item = {}, labelKey = "") {
-  const source = asPlainObject(item);
-  const composedLabel = resolveComposedLabel(source);
-  if (composedLabel) {
-    return composedLabel;
-  }
-
-  const normalizedLabelKey = normalizeText(labelKey);
-  if (!normalizedLabelKey) {
-    return "";
-  }
-
-  return normalizeText(source[normalizedLabelKey]);
-}
-
-function resolveRecordTitle(record = {}, { fallbackKey = "", defaultValue = DEFAULT_RECORD_TITLE } = {}) {
-  const source = asPlainObject(record);
-  const composedLabel = resolveComposedLabel(source);
-  if (composedLabel) {
-    return composedLabel;
-  }
-
-  const normalizedFallbackKey = normalizeText(fallbackKey);
-  if (normalizedFallbackKey) {
-    const fallbackValue = normalizeText(source[normalizedFallbackKey]);
-    if (fallbackValue) {
-      return fallbackValue;
-    }
-  }
-
-  const normalizedDefaultValue = normalizeText(defaultValue);
-  return normalizedDefaultValue || DEFAULT_RECORD_TITLE;
-}
-
-function resolveLookupFieldDescriptor(field = {}, relationKind = "", valueKey = "", labelKey = "") {
-  if (typeof field === "string") {
-    return {
-      key: normalizeText(field),
-      relation: {
-        kind: normalizeText(relationKind).toLowerCase(),
-        valueKey: normalizeText(valueKey) || "id",
-        labelKey: normalizeText(labelKey),
-        containerKey: ""
-      }
-    };
-  }
-
-  const sourceField = asPlainObject(field);
-  const relation = asPlainObject(sourceField.relation);
-  return {
-    key: normalizeText(sourceField.key),
-    relation: {
-      kind: normalizeText(relation.kind).toLowerCase(),
-      valueKey: normalizeText(relation.valueKey) || "id",
-      labelKey: normalizeText(relation.labelKey),
-      containerKey: normalizeText(relation.containerKey)
-    }
-  };
-}
-
-function resolveFallbackLookupKey(key = "") {
-  const normalizedKey = normalizeText(key);
-  if (!normalizedKey.endsWith("Id") || normalizedKey.length <= 2) {
-    return "";
-  }
-
-  return normalizedKey.slice(0, -2);
-}
-
-function resolveLookupFieldDisplayValue(record = {}, field = {}, relationKind = "", valueKey = "", labelKey = "") {
-  const sourceRecord = asPlainObject(record);
-  const descriptor = resolveLookupFieldDescriptor(field, relationKind, valueKey, labelKey);
-  const key = descriptor.key;
-  if (!key) {
-    return "";
-  }
-
-  if (descriptor.relation.kind !== "lookup") {
-    return sourceRecord[key];
-  }
-
-  const lookupContainerKey = normalizeCrudLookupContainerKey(descriptor.relation.containerKey, {
-    context: `lookup relation "${key}" containerKey`
-  });
-  const sourceLookups = asPlainObject(sourceRecord[lookupContainerKey]);
-  let lookupRecord = asPlainObject(sourceLookups[key]);
-  if (Object.keys(lookupRecord).length < 1) {
-    lookupRecord = asPlainObject(sourceLookups[resolveFallbackLookupKey(key)]);
-  }
-  const lookupLabel = resolveLookupItemLabel(lookupRecord, descriptor.relation.labelKey);
-  if (lookupLabel) {
-    return lookupLabel;
-  }
-
-  const lookupValue = lookupRecord[descriptor.relation.valueKey];
-  if (hasDisplayValue(lookupValue)) {
-    return lookupValue;
-  }
-
-  return sourceRecord[key];
-}
-
-export {
-  resolveLookupItemLabel,
-  resolveLookupFieldDisplayValue,
-  resolveRecordTitle
-};

package/src/client/composables/crud/crudLookupFieldRuntime.js

@@ -1,251 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  normalizeCrudLookupApiPath,
-  normalizeCrudLookupNamespace,
-  normalizeCrudLookupContainerKey,
-  resolveCrudLookupApiPathFromNamespace
-} from "@jskit-ai/kernel/shared/support/crudLookup";
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { useList } from "../records/useList.js";
-import {
-  resolveLookupItemLabel,
-  resolveLookupFieldDisplayValue
-} from "./crudLookupFieldLabelSupport.js";
-import { inferCrudLookupJsonApiTransport } from "./crudJsonApiTransportSupport.js";
-import { asPlainObject } from "../support/scopeHelpers.js";
-
-function normalizeQueryKeyPrefix(value) {
-  const source = Array.isArray(value) ? value : [];
-  return source
-    .map((entry) => normalizeText(entry))
-    .filter(Boolean);
-}
-
-function isSameLookupValue(left, right) {
-  if (left === right) {
-    return true;
-  }
-
-  return String(left ?? "") === String(right ?? "");
-}
-
-function normalizeLookupValue(value) {
-  if (value == null) {
-    return "";
-  }
-
-  return String(value);
-}
-
-function createSelectedLookupItem(selectedValue, selectedRecord = {}, entry = {}) {
-  if (selectedValue == null || selectedValue === "") {
-    return null;
-  }
-
-  const sourceRecord = asPlainObject(selectedRecord);
-  const sourceLookups = asPlainObject(sourceRecord[entry.lookupContainerKey]);
-  const hydratedLookup = asPlainObject(sourceLookups[entry.fieldKey]);
-  const hydratedValue = hydratedLookup[entry.valueKey];
-  const value = normalizeLookupValue(
-    hydratedValue == null || hydratedValue === "" ? selectedValue : hydratedValue
-  );
-  if (!value) {
-    return null;
-  }
-
-  const displayValue = resolveLookupFieldDisplayValue(
-    {
-      [entry.fieldKey]: value,
-      [entry.lookupContainerKey]: {
-        [entry.fieldKey]: hydratedLookup
-      }
-    },
-    {
-      key: entry.fieldKey,
-      relation: entry.relation
-    }
-  );
-  const label = displayValue == null || displayValue === "" ? value : displayValue;
-  return {
-    value,
-    label: String(label ?? ""),
-    record: hydratedLookup
-  };
-}
-
-function createCrudLookupFieldRuntime({
-  formFields = [],
-  adapter = null,
-  recordIdParam = "recordId",
-  queryKeyPrefix = [],
-  placementSourcePrefix = "",
-  lookupContainerKey = "lookups"
-} = {}) {
-  const runtimes = new Map();
-  const normalizedRecordIdParam = normalizeText(recordIdParam) || "recordId";
-  const normalizedPlacementSourcePrefix = normalizeText(placementSourcePrefix);
-  const normalizedQueryKeyPrefix = normalizeQueryKeyPrefix(queryKeyPrefix);
-  const defaultLookupContainerKey = normalizeCrudLookupContainerKey(lookupContainerKey, {
-    context: "createCrudLookupFieldRuntime lookupContainerKey"
-  });
-
-  for (const field of Array.isArray(formFields) ? formFields : []) {
-    const key = normalizeText(field?.key);
-    const rawRelation = field?.relation;
-    if (!key || !rawRelation || typeof rawRelation !== "object" || Array.isArray(rawRelation) || runtimes.has(key)) {
-      continue;
-    }
-
-    const relationKind = normalizeText(rawRelation.kind).toLowerCase();
-    const namespace =
-      normalizeCrudLookupNamespace(rawRelation.namespace) ||
-      normalizeCrudLookupNamespace(rawRelation.apiPath);
-    if (relationKind !== "lookup" || !namespace) {
-      continue;
-    }
-    const explicitApiPath = normalizeCrudLookupApiPath(rawRelation.apiPath);
-    const apiPath = explicitApiPath || resolveCrudLookupApiPathFromNamespace(namespace);
-    const transport = inferCrudLookupJsonApiTransport({
-      namespace,
-      apiPath
-    });
-    const valueKey = normalizeText(rawRelation.valueKey);
-    const labelKey = normalizeText(rawRelation.labelKey);
-    const relationLookupContainerKey = normalizeCrudLookupContainerKey(rawRelation.containerKey, {
-      defaultValue: defaultLookupContainerKey,
-      context: `createCrudLookupFieldRuntime formFields["${key}"].relation.containerKey`
-    });
-    const relationSurfaceId = normalizeSurfaceId(rawRelation.surfaceId);
-    if (!valueKey) {
-      continue;
-    }
-
-    const runtime = useList({
-      adapter: adapter || undefined,
-      ...(relationSurfaceId ? { surfaceId: relationSurfaceId } : {}),
-      apiSuffix: apiPath,
-      ...(transport ? { transport } : {}),
-      queryKeyFactory: (surfaceId = "", scopeParamValue = "") => [
-        ...normalizedQueryKeyPrefix,
-        key,
-        String(surfaceId || ""),
-        String(scopeParamValue || "")
-      ],
-      search: {
-        enabled: true,
-        mode: "query",
-        queryParam: "q"
-      },
-      placementSource: normalizedPlacementSourcePrefix
-        ? `${normalizedPlacementSourcePrefix}.${key}`
-        : `lookup.${key}`,
-      fallbackLoadError: `Unable to load lookup options (${apiPath}).`,
-      recordIdParam: normalizedRecordIdParam,
-      recordIdSelector: (item = {}) => item[valueKey],
-      viewUrlTemplate: "",
-      editUrlTemplate: ""
-    });
-
-    runtimes.set(key, Object.freeze({
-      runtime,
-      fieldKey: key,
-      lookupContainerKey: relationLookupContainerKey,
-      valueKey,
-      labelKey,
-      relation: Object.freeze({
-        kind: "lookup",
-        namespace,
-        ...(explicitApiPath ? { apiPath: explicitApiPath } : {}),
-        ...(relationSurfaceId ? { surfaceId: relationSurfaceId } : {}),
-        containerKey: relationLookupContainerKey,
-        valueKey,
-        ...(labelKey ? { labelKey } : {})
-      })
-    }));
-  }
-
-  function resolveLookupItems(fieldKey = "", options = {}) {
-    const key = normalizeText(fieldKey);
-    const entry = runtimes.get(key);
-    if (!entry) {
-      return [];
-    }
-
-    const items = (Array.isArray(entry.runtime.items) ? entry.runtime.items : []).map((item = {}) => {
-      const sourceRecord = asPlainObject(item);
-      const value = normalizeLookupValue(item?.[entry.valueKey]);
-      const resolvedLabel = resolveLookupItemLabel(item, entry.labelKey);
-      const label = resolvedLabel || value;
-      return {
-        value,
-        label: String(label ?? ""),
-        record: sourceRecord
-      };
-    });
-
-    const selectedItem = createSelectedLookupItem(
-      options?.selectedValue,
-      options?.selectedRecord,
-      entry
-    );
-    if (!selectedItem) {
-      return items;
-    }
-
-    if (items.some((item) => item?.value === selectedItem.value)) {
-      return items;
-    }
-
-    const matchingItem = items.find((item) => isSameLookupValue(item?.value, selectedItem.value));
-    if (matchingItem) {
-      return [
-        {
-          ...selectedItem,
-          label: String(matchingItem.label ?? selectedItem.label ?? "")
-        },
-        ...items
-      ];
-    }
-
-    return [selectedItem, ...items];
-  }
-
-  function resolveLookupLoading(fieldKey = "") {
-    const key = normalizeText(fieldKey);
-    const entry = runtimes.get(key);
-    if (!entry) {
-      return false;
-    }
-
-    return Boolean(entry.runtime.isInitialLoading || entry.runtime.isFetching || entry.runtime.isRefetching);
-  }
-
-  function resolveLookupSearch(fieldKey = "") {
-    const key = normalizeText(fieldKey);
-    const entry = runtimes.get(key);
-    if (!entry) {
-      return "";
-    }
-
-    return String(entry.runtime.searchQuery || "");
-  }
-
-  function setLookupSearch(fieldKey = "", searchValue = "") {
-    const key = normalizeText(fieldKey);
-    const entry = runtimes.get(key);
-    if (!entry) {
-      return;
-    }
-
-    entry.runtime.searchQuery = String(searchValue || "");
-  }
-
-  return Object.freeze({
-    resolveLookupItems,
-    resolveLookupLoading,
-    resolveLookupSearch,
-    setLookupSearch
-  });
-}
-
-export { createCrudLookupFieldRuntime };