@jskit-ai/users-web 0.1.32 → 0.1.34

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-web",
-  version: "0.1.32",
+  version: "0.1.34",
   kind: "runtime",
   description: "Users web module: workspace selector shell element plus workspace/profile/members UI elements.",
   dependsOn: [
@@ -73,6 +73,10 @@ export default Object.freeze({
           subpath: "./client/composables/useList",
           summary: "Exports list operation composable."
         },
+        {
+          subpath: "./client/composables/crudLookupFieldRuntime",
+          summary: "Exports CRUD lookup field runtime helpers for generated add/edit forms."
+        },
         {
           subpath: "./client/composables/useCommand",
           summary: "Exports command operation composable."
@@ -242,11 +246,11 @@ export default Object.freeze({
         "@uppy/dashboard": "^5.1.1",
         "@uppy/image-editor": "^4.2.0",
         "@uppy/xhr-upload": "^5.1.1",
-        "@jskit-ai/http-runtime": "0.1.17",
-        "@jskit-ai/realtime": "0.1.17",
-        "@jskit-ai/kernel": "0.1.18",
-        "@jskit-ai/shell-web": "0.1.17",
-        "@jskit-ai/users-core": "0.1.27",
+        "@jskit-ai/http-runtime": "0.1.19",
+        "@jskit-ai/realtime": "0.1.19",
+        "@jskit-ai/kernel": "0.1.20",
+        "@jskit-ai/shell-web": "0.1.19",
+        "@jskit-ai/users-core": "0.1.29",
         "vuetify": "^4.0.0"
       },
       dev: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-web",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -10,6 +10,7 @@
     "./client/components/WorkspaceMembersClientElement": "./src/client/components/WorkspaceMembersClientElement.vue",
     "./client/composables/useAddEdit": "./src/client/composables/useAddEdit.js",
     "./client/composables/useCrudSchemaForm": "./src/client/composables/useCrudSchemaForm.js",
+    "./client/composables/crudLookupFieldRuntime": "./src/client/composables/crudLookupFieldRuntime.js",
     "./client/composables/useList": "./src/client/composables/useList.js",
     "./client/composables/useView": "./src/client/composables/useView.js",
     "./client/composables/usePagedCollection": "./src/client/composables/usePagedCollection.js",
@@ -21,11 +22,11 @@
   "dependencies": {
     "@tanstack/vue-query": "5.92.12",
     "@mdi/js": "^7.4.47",
-    "@jskit-ai/users-core": "0.1.27",
-    "@jskit-ai/realtime": "0.1.17",
-    "@jskit-ai/http-runtime": "0.1.17",
-    "@jskit-ai/kernel": "0.1.18",
-    "@jskit-ai/shell-web": "0.1.17",
+    "@jskit-ai/users-core": "0.1.29",
+    "@jskit-ai/realtime": "0.1.19",
+    "@jskit-ai/http-runtime": "0.1.19",
+    "@jskit-ai/kernel": "0.1.20",
+    "@jskit-ai/shell-web": "0.1.19",
     "vuetify": "^4.0.0"
   }
 }

package/src/client/components/WorkspaceMembersClientElement.vue

@@ -389,12 +389,12 @@ const status = computed(() => {
     isCreatingInvite: Boolean(inviteCreateCommand.isRunning.value),
     isRevokingInvite: Boolean(revokeInviteCommand.isRunning.value),
     isRemovingMember: Boolean(memberRemoveCommand.isRunning.value),
-    hasLoadedWorkspaceSettings: !canInviteMembers.value || !workspaceSettingsView.isLoading.value,
-    hasLoadedMembersList: !canViewMembers.value || !workspaceMembersList.isInitialLoading.value,
-    hasLoadedInviteList: !canViewMembers.value || !workspaceInvitesList.isInitialLoading.value,
-    isRefreshingWorkspaceSettings: canInviteMembers.value && Boolean(workspaceSettingsView.isRefetching.value),
-    isRefreshingMembersList: canViewMembers.value && Boolean(workspaceMembersList.isRefetching.value),
-    isRefreshingInviteList: canViewMembers.value && Boolean(workspaceInvitesList.isRefetching.value)
+    hasLoadedWorkspaceSettings: !canInviteMembers.value || !workspaceSettingsView.isLoading,
+    hasLoadedMembersList: !canViewMembers.value || !workspaceMembersList.isInitialLoading,
+    hasLoadedInviteList: !canViewMembers.value || !workspaceInvitesList.isInitialLoading,
+    isRefreshingWorkspaceSettings: canInviteMembers.value && Boolean(workspaceSettingsView.isRefetching),
+    isRefreshingMembersList: canViewMembers.value && Boolean(workspaceMembersList.isRefetching),
+    isRefreshingInviteList: canViewMembers.value && Boolean(workspaceInvitesList.isRefetching)
   };
 });
 
@@ -440,7 +440,7 @@ watch(
 );
 
 watch(
-  () => workspaceSettingsView.record.value,
+  () => workspaceSettingsView.record,
   (payload) => {
     if (!payload) {
       return;
@@ -451,7 +451,7 @@ watch(
 );
 
 watch(
-  () => workspaceSettingsView.loadError.value,
+  () => workspaceSettingsView.loadError,
   (nextLoadError) => {
     if (!nextLoadError) {
       return;
@@ -462,7 +462,7 @@ watch(
 );
 
 watch(
-  () => workspaceRolesView.record.value,
+  () => workspaceRolesView.record,
   (payload) => {
     if (!payload) {
       return;
@@ -473,7 +473,7 @@ watch(
 );
 
 watch(
-  () => workspaceRolesView.loadError.value,
+  () => workspaceRolesView.loadError,
   (nextLoadError) => {
     if (!nextLoadError) {
       return;
@@ -483,7 +483,7 @@ watch(
 );
 
 watch(
-  () => workspaceMembersList.items.value,
+  () => workspaceMembersList.items,
   (nextMembers) => {
     collections.members = Array.isArray(nextMembers) ? [...nextMembers] : [];
   },
@@ -491,7 +491,7 @@ watch(
 );
 
 watch(
-  () => workspaceMembersList.pages.value,
+  () => workspaceMembersList.pages,
   (pages) => {
     const payload = latestPage(pages);
     if (!payload) {
@@ -503,7 +503,7 @@ watch(
 );
 
 watch(
-  () => workspaceMembersList.loadError.value,
+  () => workspaceMembersList.loadError,
   (nextLoadError) => {
     if (!nextLoadError) {
       membersFeedback.clear();
@@ -514,7 +514,7 @@ watch(
 );
 
 watch(
-  () => workspaceInvitesList.items.value,
+  () => workspaceInvitesList.items,
   (nextInvites) => {
     collections.invites = Array.isArray(nextInvites) ? [...nextInvites] : [];
   },
@@ -522,7 +522,7 @@ watch(
 );
 
 watch(
-  () => workspaceInvitesList.pages.value,
+  () => workspaceInvitesList.pages,
   (pages) => {
     const payload = latestPage(pages);
     if (!payload) {
@@ -534,7 +534,7 @@ watch(
 );
 
 watch(
-  () => workspaceInvitesList.loadError.value,
+  () => workspaceInvitesList.loadError,
   (nextLoadError) => {
     if (!nextLoadError) {
       teamFeedback.clear();

package/src/client/components/WorkspacesClientElement.vue

@@ -125,8 +125,8 @@ const pendingInvites = computed(() => {
 });
 const workspaceInvitesEnabled = computed(() => bootstrapModel.workspaceInvitesEnabled === true);
 
-const isBootstrapping = computed(() => Boolean(bootstrapView.isLoading.value));
-const isRefreshingBootstrap = computed(() => Boolean(bootstrapView.isRefetching.value));
+const isBootstrapping = computed(() => Boolean(bootstrapView.isLoading));
+const isRefreshingBootstrap = computed(() => Boolean(bootstrapView.isRefetching));
 const canCreateWorkspace = computed(() => bootstrapModel.workspaceAllowSelfCreate === true);
 const isCreatingWorkspace = computed(() => Boolean(createWorkspaceCommand.isRunning.value));
 

package/src/client/composables/crudLookupFieldLabelSupport.js

@@ -0,0 +1,107 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeCrudLookupContainerKey } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { asPlainObject } from "./scopeHelpers.js";
+
+const LOOKUP_LABEL_COMPOSITION_CANDIDATES = Object.freeze([
+  Object.freeze(["name", "surname"]),
+  Object.freeze(["firstName", "surname"]),
+  Object.freeze(["name"]),
+  Object.freeze(["firstName"])
+]);
+
+function hasDisplayValue(value) {
+  if (value == null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return normalizeText(value).length > 0;
+  }
+
+  return true;
+}
+
+function resolveLookupItemLabel(item = {}, labelKey = "") {
+  const source = asPlainObject(item);
+  for (const candidate of LOOKUP_LABEL_COMPOSITION_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(" ");
+    }
+  }
+
+  const normalizedLabelKey = normalizeText(labelKey);
+  if (!normalizedLabelKey) {
+    return "";
+  }
+
+  return normalizeText(source[normalizedLabelKey]);
+}
+
+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 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]);
+  const lookupRecord = asPlainObject(sourceLookups[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
+};

package/src/client/composables/crudLookupFieldRuntime.js

@@ -0,0 +1,238 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  normalizeCrudLookupApiPath,
+  normalizeCrudLookupNamespace,
+  normalizeCrudLookupContainerKey,
+  resolveCrudLookupApiPathFromNamespace
+} from "@jskit-ai/kernel/shared/support/crudLookup";
+import { useList } from "./useList.js";
+import {
+  resolveLookupItemLabel,
+  resolveLookupFieldDisplayValue
+} from "./crudLookupFieldLabelSupport.js";
+import { asPlainObject } from "./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 ?? "")
+  };
+}
+
+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 valueKey = normalizeText(rawRelation.valueKey);
+    const labelKey = normalizeText(rawRelation.labelKey);
+    const relationLookupContainerKey = normalizeCrudLookupContainerKey(rawRelation.containerKey, {
+      defaultValue: defaultLookupContainerKey,
+      context: `createCrudLookupFieldRuntime formFields["${key}"].relation.containerKey`
+    });
+    if (!valueKey) {
+      continue;
+    }
+
+    const runtime = useList({
+      adapter: adapter || undefined,
+      apiSuffix: apiPath,
+      queryKeyFactory: (surfaceId = "", workspaceSlug = "") => [
+        ...normalizedQueryKeyPrefix,
+        key,
+        String(surfaceId || ""),
+        String(workspaceSlug || "")
+      ],
+      search: {
+        enabled: true,
+        mode: "query",
+        queryParam: "q"
+      },
+      placementSource: normalizedPlacementSourcePrefix
+        ? `${normalizedPlacementSourcePrefix}.${key}`
+        : `crud.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 } : {}),
+        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 value = normalizeLookupValue(item?.[entry.valueKey]);
+      const resolvedLabel = resolveLookupItemLabel(item, entry.labelKey);
+      const label = resolvedLabel || value;
+      return {
+        value,
+        label: String(label ?? "")
+      };
+    });
+
+    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 };

package/src/client/composables/crudSchemaFormHelpers.js

@@ -1,5 +1,6 @@
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
 import { asPlainObject } from "./scopeHelpers.js";
+import { toRouteParamValue } from "./routeTemplateHelpers.js";
 
 function normalizeCrudFormFields(fields = []) {
   const normalizedFields = [];
@@ -109,6 +110,38 @@ function applyCrudPayloadToForm(fields = [], model = {}, payload = {}) {
   }
 }
 
+function resolveCrudRouteBoundFieldValues(fields = [], routeParams = {}) {
+  const sourceRouteParams = asPlainObject(routeParams);
+  const values = {};
+
+  for (const field of normalizeCrudFormFields(fields)) {
+    const routeParamKey = String(field?.routeParamKey || "").trim();
+    if (!routeParamKey) {
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(sourceRouteParams, routeParamKey)) {
+      continue;
+    }
+
+    const routeValue = toRouteParamValue(sourceRouteParams[routeParamKey]);
+    if (!routeValue) {
+      continue;
+    }
+    values[field.key] = routeValue;
+  }
+
+  return values;
+}
+
+function applyCrudRouteBoundFieldValues(fields = [], target = {}, routeParams = {}) {
+  const resolved = resolveCrudRouteBoundFieldValues(fields, routeParams);
+  const destination = asPlainObject(target);
+  for (const [key, value] of Object.entries(resolved)) {
+    destination[key] = value;
+  }
+  return resolved;
+}
+
 function resolveCrudFieldErrors(fieldErrors = {}, fieldKey = "") {
   const key = String(fieldKey || "").trim();
   if (!key) {
@@ -147,6 +180,8 @@ export {
   createCrudFormModel,
   buildCrudFormPayload,
   applyCrudPayloadToForm,
+  resolveCrudRouteBoundFieldValues,
+  applyCrudRouteBoundFieldValues,
   resolveCrudFieldErrors,
   parseCrudResourceOperationInput
 };

package/src/client/composables/listSearchSupport.js

@@ -0,0 +1,70 @@
+import {
+  normalizeInteger,
+  normalizeText,
+  normalizeUniqueTextList
+} from "@jskit-ai/kernel/shared/support/normalize";
+import { asPlainObject } from "./scopeHelpers.js";
+
+const DEFAULT_LIST_SEARCH_DEBOUNCE_MS = 250;
+const DEFAULT_LIST_SEARCH_MIN_LENGTH = 1;
+const LIST_SEARCH_MODE_LOCAL = "local";
+const LIST_SEARCH_MODE_QUERY = "query";
+
+function normalizeListSearchConfig(value = {}) {
+  const source = asPlainObject(value);
+  const modeRaw = normalizeText(source.mode).toLowerCase();
+  const mode = modeRaw === LIST_SEARCH_MODE_LOCAL
+    ? LIST_SEARCH_MODE_LOCAL
+    : LIST_SEARCH_MODE_QUERY;
+
+  return Object.freeze({
+    enabled: source.enabled === true,
+    mode,
+    queryParam: normalizeText(source.queryParam) || "q",
+    label: normalizeText(source.label) || "Search",
+    placeholder: normalizeText(source.placeholder),
+    initialQuery: normalizeText(source.initialQuery),
+    debounceMs: normalizeInteger(source.debounceMs, {
+      fallback: DEFAULT_LIST_SEARCH_DEBOUNCE_MS,
+      min: 0
+    }),
+    minLength: normalizeInteger(source.minLength, {
+      fallback: DEFAULT_LIST_SEARCH_MIN_LENGTH,
+      min: DEFAULT_LIST_SEARCH_MIN_LENGTH
+    }),
+    fields: Object.freeze(normalizeUniqueTextList(source.fields))
+  });
+}
+
+function normalizeSearchableValue(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return normalizeText(value).toLowerCase();
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value).toLowerCase();
+  }
+  return "";
+}
+
+function matchesLocalSearch(item = {}, query = "", searchFields = []) {
+  const source = asPlainObject(item);
+  const normalizedQuery = normalizeText(query).toLowerCase();
+  if (!normalizedQuery) {
+    return true;
+  }
+
+  const fields = Array.isArray(searchFields) ? searchFields : [];
+  if (fields.length > 0) {
+    return fields.some((field) => normalizeSearchableValue(source[field]).includes(normalizedQuery));
+  }
+
+  return Object.values(source).some((value) => normalizeSearchableValue(value).includes(normalizedQuery));
+}
+
+export {
+  normalizeListSearchConfig,
+  matchesLocalSearch
+};

package/src/client/composables/resourceLoadStateHelpers.js

@@ -0,0 +1,10 @@
+import { unref } from "vue";
+
+function hasResolvedQueryData({ query = null, data = null } = {}) {
+  const querySucceeded = Boolean(unref(query?.isSuccess));
+  const hasDataPayload = unref(data) != null;
+
+  return querySucceeded || hasDataPayload;
+}
+
+export { hasResolvedQueryData };