@jskit-ai/crud-core 0.1.29 → 0.1.31

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-core",
-  version: "0.1.29",
+  version: "0.1.31",
   kind: "runtime",
   description: "Shared CRUD helpers used by CRUD modules.",
   dependsOn: [
@@ -26,7 +26,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/crud-core": "0.1.29"
+        "@jskit-ai/crud-core": "0.1.31"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-core",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -14,6 +14,7 @@
     "./shared/crudNamespaceSupport": "./src/shared/crudNamespaceSupport.js",
     "./server/repositorySupport": "./src/server/repositorySupport.js",
     "./server/repositoryMethods": "./src/server/repositoryMethods.js",
+    "./server/createHooksToCollectChildren": "./src/server/createHooksToCollectChildren.js",
     "./server/createCrudRepositoryFromResource": "./src/server/createCrudRepositoryFromResource.js",
     "./server/lookupProviders": "./src/server/lookupProviders.js",
     "./server/serviceEvents": "./src/server/serviceEvents.js",
@@ -24,11 +25,11 @@
   },
   "dependencies": {
     "@tanstack/vue-query": "^5.90.5",
-    "@jskit-ai/kernel": "0.1.21",
-    "@jskit-ai/realtime": "0.1.20",
-    "@jskit-ai/shell-web": "0.1.20",
-    "@jskit-ai/users-core": "0.1.30",
-    "@jskit-ai/users-web": "0.1.35",
+    "@jskit-ai/kernel": "0.1.23",
+    "@jskit-ai/realtime": "0.1.22",
+    "@jskit-ai/shell-web": "0.1.22",
+    "@jskit-ai/users-core": "0.1.32",
+    "@jskit-ai/users-web": "0.1.37",
     "typebox": "^1.0.81"
   }
 }

package/src/server/createCrudRepositoryFromResource.js

@@ -3,6 +3,7 @@ import {
   crudRepositoryList,
   crudRepositoryFindById,
   crudRepositoryListByIds,
+  crudRepositoryListByForeignIds,
   crudRepositoryCreate,
   crudRepositoryUpdateById,
   crudRepositoryDeleteById
@@ -19,34 +20,39 @@ function createCrudRepositoryFromResource(resource = {}, { context = "crudReposi
       throw new TypeError("crudRepository requires knex.");
     }
 
-    async function listRecords(query = {}, callOptions = {}) {
-      return crudRepositoryList(runtime, knex, query, options, callOptions);
+    async function listRecords(query = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryList(runtime, knex, query, options, callOptions, hooks);
     }
 
-    async function findById(recordId, callOptions = {}) {
-      return crudRepositoryFindById(runtime, knex, recordId, options, callOptions);
+    async function findById(recordId, callOptions = {}, hooks = null) {
+      return crudRepositoryFindById(runtime, knex, recordId, options, callOptions, hooks);
     }
 
-    async function listByIds(ids = [], callOptions = {}) {
-      return crudRepositoryListByIds(runtime, knex, ids, options, callOptions);
+    async function listByIds(ids = [], callOptions = {}, hooks = null) {
+      return crudRepositoryListByIds(runtime, knex, ids, options, callOptions, hooks);
     }
 
-    async function create(payload = {}, callOptions = {}) {
-      return crudRepositoryCreate(runtime, knex, payload, options, callOptions);
+    async function listByForeignIds(ids = [], foreignKey = "", callOptions = {}, hooks = null) {
+      return crudRepositoryListByForeignIds(runtime, knex, ids, foreignKey, options, callOptions, hooks);
     }
 
-    async function updateById(recordId, patch = {}, callOptions = {}) {
-      return crudRepositoryUpdateById(runtime, knex, recordId, patch, options, callOptions);
+    async function create(payload = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryCreate(runtime, knex, payload, options, callOptions, hooks);
     }
 
-    async function deleteById(recordId, callOptions = {}) {
-      return crudRepositoryDeleteById(runtime, knex, recordId, options, callOptions);
+    async function updateById(recordId, patch = {}, callOptions = {}, hooks = null) {
+      return crudRepositoryUpdateById(runtime, knex, recordId, patch, options, callOptions, hooks);
+    }
+
+    async function deleteById(recordId, callOptions = {}, hooks = null) {
+      return crudRepositoryDeleteById(runtime, knex, recordId, options, callOptions, hooks);
     }
 
     return Object.freeze({
       list: listRecords,
       findById,
       listByIds,
+      listByForeignIds,
       create,
       updateById,
       deleteById

package/src/server/createHooksToCollectChildren.js

@@ -0,0 +1,247 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizeOwnerKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : "";
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+
+  return String(value).trim();
+}
+
+function toDefaultChildCallOptions(callOptions = {}) {
+  const nextOptions = {};
+  if (Object.hasOwn(callOptions, "trx")) {
+    nextOptions.trx = callOptions.trx;
+  }
+  if (Object.hasOwn(callOptions, "visibilityContext")) {
+    nextOptions.visibilityContext = callOptions.visibilityContext;
+  }
+
+  return nextOptions;
+}
+
+function resolveListChildrenHandler(options = {}, { context = "createHooksToCollectChildren" } = {}) {
+  if (typeof options.listChildren === "function") {
+    return options.listChildren;
+  }
+
+  const childRepository = options.childRepository;
+  const childListMethod = normalizeText(options.childListMethod) || "listByIds";
+  const childForeignKey = normalizeText(options.childForeignKey);
+  if (!childRepository || typeof childRepository !== "object" || Array.isArray(childRepository)) {
+    throw new TypeError(
+      `${context} requires listChildren(ids, options, ctx) or childRepository.`
+    );
+  }
+
+  const listChildren = childRepository[childListMethod];
+  if (typeof listChildren !== "function") {
+    throw new TypeError(`${context} requires childRepository.${childListMethod} to be a function.`);
+  }
+
+  if (childListMethod === "listByIds") {
+    if (!childForeignKey) {
+      throw new TypeError(`${context} requires childForeignKey when using childRepository.listByIds.`);
+    }
+
+    return (ids = [], childCallOptions = {}, hookContext = {}) =>
+      listChildren.call(childRepository, ids, {
+        ...childCallOptions,
+        valueKey: childForeignKey
+      }, hookContext);
+  }
+
+  if (childListMethod === "listByForeignIds") {
+    if (!childForeignKey) {
+      throw new TypeError(`${context} requires childForeignKey when using childRepository.listByForeignIds.`);
+    }
+
+    return (ids = [], childCallOptions = {}, hookContext = {}) =>
+      listChildren.call(childRepository, ids, childForeignKey, childCallOptions, hookContext);
+  }
+
+  return (ids = [], childCallOptions = {}, hookContext = {}) => {
+    if (childForeignKey) {
+      return listChildren.call(childRepository, ids, childForeignKey, childCallOptions, hookContext);
+    }
+    return listChildren.call(childRepository, ids, childCallOptions, hookContext);
+  };
+}
+
+function resolveGetChildOwnerId(options = {}, { context = "createHooksToCollectChildren" } = {}) {
+  if (typeof options.getChildOwnerId === "function") {
+    return options.getChildOwnerId;
+  }
+
+  const childOwnerIdKey = normalizeText(options.childOwnerIdKey);
+  const childForeignKey = normalizeText(options.childForeignKey);
+  const ownerKey = childOwnerIdKey || childForeignKey;
+  if (!ownerKey) {
+    throw new TypeError(`${context} requires childOwnerIdKey, childForeignKey, or getChildOwnerId.`);
+  }
+
+  return (child = {}) => {
+    if (!child || typeof child !== "object" || Array.isArray(child)) {
+      return undefined;
+    }
+    if (childOwnerIdKey && Object.hasOwn(child, childOwnerIdKey)) {
+      return child[childOwnerIdKey];
+    }
+    return child[ownerKey];
+  };
+}
+
+function resolveLookupContainerKey(record = {}, hookContext = {}, options = {}) {
+  const explicitContainerKey = normalizeText(options.lookupContainerKey);
+  if (explicitContainerKey) {
+    return explicitContainerKey;
+  }
+
+  const runtimeContainerKey = normalizeText(hookContext?.runtime?.lookup?.containerKey);
+  if (runtimeContainerKey) {
+    return runtimeContainerKey;
+  }
+
+  if (Object.hasOwn(record, "lookups")) {
+    return "lookups";
+  }
+
+  return "lookups";
+}
+
+function createHooksToCollectChildren(options = {}) {
+  const context = normalizeText(options.context) || "createHooksToCollectChildren";
+  const childKey = normalizeText(options.childKey);
+  if (!childKey) {
+    throw new TypeError(`${context} requires childKey.`);
+  }
+
+  const listChildren = resolveListChildrenHandler(options, {
+    context
+  });
+  const getParentId = typeof options.getParentId === "function"
+    ? options.getParentId
+    : (record = {}) => record?.id;
+  const getChildOwnerId = resolveGetChildOwnerId(options, {
+    context
+  });
+  const normalizeCollectionOwnerKey = typeof options.normalizeOwnerKey === "function"
+    ? options.normalizeOwnerKey
+    : normalizeOwnerKey;
+  const buildChildCallOptions = typeof options.buildChildCallOptions === "function"
+    ? options.buildChildCallOptions
+    : ({ callOptions = {} } = {}) => toDefaultChildCallOptions(callOptions);
+  const stateMapKey = options.stateMapKey || Symbol(`crud.children.${childKey}`);
+  const attachToLookupContainer = options.attachToLookupContainer !== false;
+  const attachChildren = typeof options.attachChildren === "function"
+    ? options.attachChildren
+    : (record = {}, children = [], hookContext = {}) => {
+      if (!attachToLookupContainer) {
+        return {
+          ...record,
+          [childKey]: children
+        };
+      }
+
+      const containerKey = resolveLookupContainerKey(record, hookContext, options);
+      const sourceContainer = record?.[containerKey];
+      const normalizedContainer =
+        sourceContainer && typeof sourceContainer === "object" && !Array.isArray(sourceContainer)
+          ? sourceContainer
+          : {};
+
+      return {
+        ...record,
+        [containerKey]: {
+          ...normalizedContainer,
+          [childKey]: children
+        }
+      };
+    };
+
+  return Object.freeze({
+    async afterQuery(records = [], ctx = {}) {
+      const normalizedRecords = Array.isArray(records) ? records : [];
+      const ownerIds = [];
+      const seenOwnerKeys = new Set();
+
+      for (const record of normalizedRecords) {
+        const ownerId = getParentId(record, ctx);
+        const ownerKey = normalizeCollectionOwnerKey(ownerId);
+        if (!ownerKey || seenOwnerKeys.has(ownerKey)) {
+          continue;
+        }
+
+        seenOwnerKeys.add(ownerKey);
+        ownerIds.push(ownerId);
+      }
+
+      const state = ctx?.state && typeof ctx.state === "object" ? ctx.state : null;
+      if (!state) {
+        throw new TypeError(`${context} requires ctx.state object.`);
+      }
+
+      if (ownerIds.length < 1) {
+        state[stateMapKey] = new Map();
+        return;
+      }
+
+      const childCallOptions = buildChildCallOptions({
+        callOptions: ctx.callOptions || {},
+        records: normalizedRecords,
+        ownerIds,
+        context: ctx
+      });
+      const children = await listChildren(ownerIds, childCallOptions, ctx);
+      if (!Array.isArray(children)) {
+        throw new TypeError(`${context} listChildren must return an array.`);
+      }
+
+      const childrenByOwnerKey = new Map();
+      for (const child of children) {
+        const childOwnerId = getChildOwnerId(child, ctx);
+        const childOwnerKey = normalizeCollectionOwnerKey(childOwnerId);
+        if (!childOwnerKey) {
+          continue;
+        }
+
+        const currentList = childrenByOwnerKey.get(childOwnerKey);
+        if (currentList) {
+          currentList.push(child);
+          continue;
+        }
+
+        childrenByOwnerKey.set(childOwnerKey, [child]);
+      }
+
+      state[stateMapKey] = childrenByOwnerKey;
+    },
+
+    transformReturnedRecord(record = {}, ctx = {}) {
+      if (!record || typeof record !== "object" || Array.isArray(record)) {
+        return record;
+      }
+
+      const state = ctx?.state && typeof ctx.state === "object" ? ctx.state : null;
+      const childrenByOwnerKey = state ? state[stateMapKey] : null;
+      const ownerKey = normalizeCollectionOwnerKey(getParentId(record, ctx));
+      const children = ownerKey && childrenByOwnerKey instanceof Map
+        ? (childrenByOwnerKey.get(ownerKey) || [])
+        : [];
+
+      return attachChildren(record, children, ctx);
+    }
+  });
+}
+
+export { createHooksToCollectChildren };

package/src/server/lookupHydration.js

@@ -1,4 +1,5 @@
 import { normalizeOpaqueId, normalizeText, normalizeUniqueTextList } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeVisibilityContext } from "@jskit-ai/kernel/shared/support/visibility";
 import {
   normalizeCrudLookupNamespace,
   resolveCrudLookupApiPathFromNamespace,
@@ -10,6 +11,13 @@ import { normalizeCrudLookupApiPath } from "./lookupPathSupport.js";
 const DEFAULT_LOOKUP_INCLUDE = "*";
 const DEFAULT_LOOKUP_MAX_DEPTH = 3;
 const MAX_LOOKUP_MAX_DEPTH = 10;
+const LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES = Object.freeze([
+  "public",
+  "user",
+  "workspace",
+  "workspace_user"
+]);
+const LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET = new Set(LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES);
 
 function normalizeLookupRelationEntry(entry = {}, outputKeys = new Set()) {
   if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
@@ -17,7 +25,7 @@ function normalizeLookupRelationEntry(entry = {}, outputKeys = new Set()) {
   }
 
   const key = normalizeText(entry.key);
-  if (!key || (outputKeys instanceof Set && !outputKeys.has(key))) {
+  if (!key) {
     return null;
   }
 
@@ -27,7 +35,7 @@ function normalizeLookupRelationEntry(entry = {}, outputKeys = new Set()) {
   }
 
   const relationKind = normalizeText(relation.kind).toLowerCase();
-  if (relationKind !== "lookup") {
+  if (relationKind !== "lookup" && relationKind !== "collection") {
     return null;
   }
 
@@ -40,15 +48,43 @@ function normalizeLookupRelationEntry(entry = {}, outputKeys = new Set()) {
   const explicitApiPath = normalizeCrudLookupApiPath(relation.apiPath);
   const apiPath = explicitApiPath || resolveCrudLookupApiPathFromNamespace(namespace);
 
-  const valueKey = normalizeText(relation.valueKey) || "id";
+  if (relationKind === "lookup") {
+    if (outputKeys instanceof Set && !outputKeys.has(key)) {
+      return null;
+    }
+    const valueKey = normalizeText(relation.valueKey) || "id";
+
+    return {
+      key,
+      relation: {
+        kind: "lookup",
+        namespace,
+        apiPath,
+        valueKey,
+        hydrateOnList: relation.hydrateOnList !== false,
+        hydrateOnView: relation.hydrateOnView !== false
+      }
+    };
+  }
+
+  const foreignKey = normalizeText(relation.foreignKey);
+  if (!foreignKey) {
+    return null;
+  }
+
+  const parentValueKey = normalizeText(relation.parentValueKey) || "id";
+  if (outputKeys instanceof Set && !outputKeys.has(parentValueKey)) {
+    return null;
+  }
 
   return {
     key,
     relation: {
-      kind: "lookup",
+      kind: "collection",
       namespace,
       apiPath,
-      valueKey,
+      foreignKey,
+      parentValueKey,
       hydrateOnList: relation.hydrateOnList !== false,
       hydrateOnView: relation.hydrateOnView !== false
     }
@@ -125,9 +161,13 @@ function createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {}) {
   const containerKey = resolveCrudLookupContainerKey(resource, {
     context: "crud lookup runtime container key"
   });
+  const namespace =
+    normalizeCrudLookupNamespace(resource?.resource) ||
+    normalizeCrudLookupNamespace(resource?.apiPath);
   const defaults = resolveLookupRuntimeDefaults(resource);
 
   return {
+    namespace,
     containerKey,
     defaultInclude: defaults.defaultInclude,
     maxDepth: defaults.maxDepth,
@@ -216,7 +256,8 @@ function buildLookupHydrationPlan(
   {
     mode = "list",
     context = "crudRepository",
-    includeWasExplicit = false
+    includeWasExplicit = false,
+    skippedNamespaces = new Set()
   } = {}
 ) {
   const entries = Array.isArray(runtime?.entries) ? runtime.entries : [];
@@ -246,6 +287,9 @@ function buildLookupHydrationPlan(
     if (!entry) {
       return null;
     }
+    if (skippedNamespaces instanceof Set && skippedNamespaces.has(entry?.relation?.namespace)) {
+      return null;
+    }
 
     if (!includeWasExplicit && !shouldHydrateByMode(entry)) {
       return null;
@@ -353,7 +397,10 @@ function resolveLookupDepthRuntime(runtime = {}, repositoryOptions = {}, callOpt
 }
 
 function buildLookupGroupKey(relation = {}) {
-  return `${relation.namespace}::${relation.valueKey}`;
+  if (relation?.kind === "collection") {
+    return `collection::${relation.namespace}::${relation.foreignKey}::${relation.parentValueKey}`;
+  }
+  return `lookup::${relation.namespace}::${relation.valueKey}`;
 }
 
 function normalizeLookupRelationValues(records = [], entries = [], childIncludeByKey = {}) {
@@ -379,7 +426,10 @@ function normalizeLookupRelationValues(records = [], entries = [], childIncludeB
     const seen = new Set();
     for (const record of records) {
       for (const entry of group.entries) {
-        const rawValue = record?.[entry.key];
+        const relation = entry?.relation || {};
+        const rawValue = relation.kind === "collection"
+          ? record?.[relation.parentValueKey]
+          : record?.[entry.key];
         const normalized = normalizeLookupIdentifier(rawValue);
         if (!normalized || seen.has(normalized)) {
           continue;
@@ -437,6 +487,54 @@ function normalizeLookupProvider(provider, relation = {}, { context = "crudRepos
   return provider;
 }
 
+function resolveLookupProviderOwnershipFilter(provider = {}, { context = "crudRepository" } = {}) {
+  const normalizedOwnershipFilter = normalizeText(provider?.ownershipFilter).toLowerCase();
+  if (!normalizedOwnershipFilter) {
+    return "";
+  }
+
+  if (LOOKUP_PROVIDER_OWNERSHIP_FILTER_SET.has(normalizedOwnershipFilter)) {
+    return normalizedOwnershipFilter;
+  }
+
+  throw new TypeError(
+    `${context} lookup provider ownershipFilter must be one of: ${LOOKUP_PROVIDER_OWNERSHIP_FILTER_VALUES.join(", ")}.`
+  );
+}
+
+function resolveLookupVisibilityContext(
+  provider = {},
+  relation = {},
+  callOptions = {},
+  { context = "crudRepository" } = {}
+) {
+  const parentVisibilityContext = normalizeVisibilityContext(callOptions?.visibilityContext);
+  const providerOwnershipFilter = resolveLookupProviderOwnershipFilter(provider, {
+    context
+  });
+
+  if (!providerOwnershipFilter) {
+    if (parentVisibilityContext.visibility !== "public") {
+      throw new Error(
+        `${context} lookup provider for namespace "${relation.namespace}" must declare ownershipFilter when parent visibility is "${parentVisibilityContext.visibility}".`
+      );
+    }
+    return callOptions?.visibilityContext;
+  }
+
+  const nextVisibilityContext = {
+    visibility: providerOwnershipFilter
+  };
+  if (providerOwnershipFilter === "workspace" || providerOwnershipFilter === "workspace_user") {
+    nextVisibilityContext.scopeOwnerId = parentVisibilityContext.scopeOwnerId;
+  }
+  if (providerOwnershipFilter === "user" || providerOwnershipFilter === "workspace_user") {
+    nextVisibilityContext.userOwnerId = parentVisibilityContext.userOwnerId;
+  }
+
+  return nextVisibilityContext;
+}
+
 function buildLookupRecordMap(records = [], valueKey = "") {
   const lookupMap = new Map();
   for (const record of Array.isArray(records) ? records : []) {
@@ -449,6 +547,47 @@ function buildLookupRecordMap(records = [], valueKey = "") {
   return lookupMap;
 }
 
+function buildLookupCollectionMap(records = [], foreignKey = "") {
+  const collectionMap = new Map();
+  for (const record of Array.isArray(records) ? records : []) {
+    const ownerId = normalizeLookupIdentifier(record?.[foreignKey]);
+    if (!ownerId) {
+      continue;
+    }
+    const currentRecords = collectionMap.get(ownerId);
+    if (currentRecords) {
+      currentRecords.push(record);
+      continue;
+    }
+    collectionMap.set(ownerId, [record]);
+  }
+  return collectionMap;
+}
+
+function resolveLookupVisitedNamespaces(runtime = {}, callOptions = {}) {
+  const namespaces = [];
+  const seen = new Set();
+
+  function appendNamespace(value) {
+    const normalized = normalizeCrudLookupNamespace(value);
+    if (!normalized || seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    namespaces.push(normalized);
+  }
+
+  const sourceVisitedNamespaces = Array.isArray(callOptions?.lookupVisitedNamespaces)
+    ? callOptions.lookupVisitedNamespaces
+    : [];
+  for (const namespace of sourceVisitedNamespaces) {
+    appendNamespace(namespace);
+  }
+  appendNamespace(runtime?.namespace);
+
+  return namespaces;
+}
+
 async function hydrateCrudLookupRecords(
   records = [],
   runtime = {},
@@ -472,11 +611,13 @@ async function hydrateCrudLookupRecords(
   const lookupContainerKey = normalizeCrudLookupContainerKey(runtime?.containerKey, {
     context: `${runtime?.context || "crudRepository"} lookup runtime container key`
   });
+  const visitedNamespaces = resolveLookupVisitedNamespaces(runtime, callOptions);
 
   const lookupPlan = buildLookupHydrationPlan(runtime, include, {
     mode,
     context: runtime?.context || "crudRepository",
-    includeWasExplicit: normalizeText(include).length > 0
+    includeWasExplicit: normalizeText(include).length > 0,
+    skippedNamespaces: new Set(visitedNamespaces)
   });
   const selectedEntries = lookupPlan.entries;
   if (selectedEntries.length < 1) {
@@ -498,17 +639,32 @@ async function hydrateCrudLookupRecords(
     const provider = normalizeLookupProvider(resolveLookupProvider(group.relation), group.relation, {
       context: runtime?.context || "crudRepository"
     });
+    const childVisibilityContext = resolveLookupVisibilityContext(
+      provider,
+      group.relation,
+      callOptions,
+      {
+        context: runtime?.context || "crudRepository"
+      }
+    );
     const childInclude = resolveGroupChildInclude(group);
+    const groupValueKey = group?.relation?.kind === "collection"
+      ? group.relation.foreignKey
+      : group.relation.valueKey;
     const groupRecords = await provider.listByIds(group.values, {
       ...callOptions,
+      visibilityContext: childVisibilityContext,
       include: childInclude,
       lookupDepth: depthRuntime.depth + 1,
       lookupMaxDepth: depthRuntime.maxDepth,
-      valueKey: group.relation.valueKey
+      lookupVisitedNamespaces: visitedNamespaces,
+      valueKey: groupValueKey
     });
     groupRecordMaps.set(
       buildLookupGroupKey(group.relation),
-      buildLookupRecordMap(groupRecords, group.relation.valueKey)
+      group?.relation?.kind === "collection"
+        ? buildLookupCollectionMap(groupRecords, group.relation.foreignKey)
+        : buildLookupRecordMap(groupRecords, group.relation.valueKey)
     );
   }
 
@@ -525,6 +681,11 @@ async function hydrateCrudLookupRecords(
     for (const entry of selectedEntries) {
       const relation = entry.relation;
       const lookupMap = groupRecordMaps.get(buildLookupGroupKey(relation)) || new Map();
+      if (relation.kind === "collection") {
+        const ownerId = normalizeLookupIdentifier(baseRecord?.[relation.parentValueKey]);
+        nextLookups[entry.key] = ownerId ? (lookupMap.get(ownerId) || []) : [];
+        continue;
+      }
       const lookupId = normalizeLookupIdentifier(baseRecord?.[entry.key]);
       if (!lookupId) {
         nextLookups[entry.key] = null;