@lobb-js/core 0.23.0 → 0.24.0

package/src/api/collections/collectionStore.ts

@@ -1,10 +1,10 @@
-import type { FindAllParamsInput } from "../../types/index.ts";
+import type { FindAllParams, FindAllParamsOutput, FindOneParams, ChildParams, CreateChildren, UpdateChildren } from "../../types/index.ts";
 import type { DatabaseDriver } from "../../types/index.ts";
 import type { MassReturn } from "../../types/index.ts";
 import type { PoolClient } from "pg";
 import type { Context as HonoContext } from "hono";
 
-import { findAllParamsSchema } from "../../types/index.ts";
+import { findAllParamsSchema, findOneParamsSchema } from "../../types/index.ts";
 import { ZodError } from "zod";
 import { LobbError } from "../../LobbError.ts";
 import { Lobb } from "../../Lobb.ts";
@@ -36,7 +36,7 @@ export class CollectionStore {
     client,
   }: {
     collectionName: string;
-    params?: FindAllParamsInput;
+    params?: FindAllParams;
     triggeredBy?: TriggeredBy;
     context?: HonoContext;
     client?: PoolClient;
@@ -87,12 +87,19 @@ export class CollectionStore {
           );
         }
 
-        const parsedParams = findAllParamsSchema.parse(params);
+        const parsedParams = findAllParamsSchema.parse(params ?? {});
+
+        const resolvedParams: FindAllParamsOutput = {
+          ...parsedParams,
+          limit: parsedParams.limit ?? 100,
+          offset: parsedParams.offset ?? 0,
+          fields: buildDriverFields(collectionName, parsedParams.fields),
+        };
 
         try {
           const result = await this.dbDriver.findAll(
             collectionName,
-            parsedParams,
+            resolvedParams,
             client,
           );
 
@@ -108,6 +115,13 @@ export class CollectionStore {
             },
           )).data;
 
+          result.data = await this.resolveFields(collectionName, result.data, parsedParams.fields, client) as any;
+          result.data = stripInternalFields(collectionName, parsedParams.fields, result.data) as any;
+
+          if (parsedParams.children && Object.keys(parsedParams.children).length > 0) {
+            result.data = await this.resolveChildren(collectionName, result.data, parsedParams.children, client) as any;
+          }
+
           return result;
         } catch (error: any) {
           if (error instanceof ZodError) {
@@ -128,18 +142,22 @@ export class CollectionStore {
   public async findOne({
     collectionName,
     id,
+    params,
     triggeredBy = "INTERNAL",
     context,
     client,
   }: {
     collectionName: string;
     id: string;
+    params?: FindOneParams;
     triggeredBy?: TriggeredBy;
     context?: HonoContext;
     client?: PoolClient;
   }): Promise<ExposedServiceOutput> {
     return await beginTransaction(
       async (client) => {
+        const { fields } = findOneParamsSchema.parse(params ?? {});
+
         const eventResult: any = await Lobb.instance.eventSystem.emit(
           `core.store.preFindOne`,
           {
@@ -151,32 +169,27 @@ export class CollectionStore {
           },
         );
 
-        const params: FindAllParamsInput = {};
-
-        params.filter = {
-          id: eventResult.id,
+        const queryParams: FindAllParams = {
+          fields,
+          children: params?.children,
+          limit: 1,
+          offset: 0,
+          filter: { id: eventResult.id },
         };
 
         if (eventResult.filter) {
-          if (params.filter) {
-            params.filter = {
-              $and: [
-                params.filter,
-                eventResult.filter,
-              ],
-            };
-          } else {
-            params.filter = eventResult.filter;
-          }
+          queryParams.filter = { $and: [queryParams.filter, eventResult.filter] };
         }
 
-        const parsedParams = findAllParamsSchema.parse(params);
-
-        let data = (await this.dbDriver.findAll(
+        const findAllResult = await this.findAll({
           collectionName,
-          parsedParams,
+          params: queryParams,
+          triggeredBy,
+          context,
           client,
-        )).data[0];
+        });
+
+        let data = findAllResult.data[0];
 
         if (!data) {
           throw new LobbError({
@@ -207,12 +220,14 @@ export class CollectionStore {
   public async createOne({
     collectionName,
     data,
+    children,
     triggeredBy = "INTERNAL",
     context,
     client,
   }: {
     collectionName: string;
     data: Record<string, any>;
+    children?: CreateChildren;
     triggeredBy?: TriggeredBy;
     context?: HonoContext;
     client?: PoolClient;
@@ -221,6 +236,10 @@ export class CollectionStore {
       async (client) => {
         await this.handleSingletonCollection(collectionName, context, client);
 
+        if (!Lobb.instance.configManager.isCollectionVirtual(collectionName)) {
+          data = await this.processInlineFKCreates(collectionName, data, triggeredBy, context, client);
+        }
+
         const result = await Lobb.instance.eventSystem.emit(
           `core.store.preCreateOne`,
           {
@@ -240,6 +259,7 @@ export class CollectionStore {
           );
         }
 
+
         data = (await Lobb.instance.eventSystem.emit(
           `core.store.createOne`,
           {
@@ -251,6 +271,10 @@ export class CollectionStore {
           },
         )).data;
 
+        if (children) {
+          await this.processChildrenOps(collectionName, data.id, children, triggeredBy, context, client);
+        }
+
         return {
           data,
         };
@@ -263,6 +287,7 @@ export class CollectionStore {
     collectionName,
     id,
     data,
+    children,
     triggeredBy = "INTERNAL",
     context,
     client,
@@ -270,6 +295,7 @@ export class CollectionStore {
     collectionName: string;
     id: string;
     data: Record<string, any> | null;
+    children?: UpdateChildren;
     triggeredBy?: TriggeredBy;
     context?: HonoContext;
     client?: PoolClient;
@@ -305,6 +331,10 @@ export class CollectionStore {
           },
         )).data;
 
+        if (children) {
+          await this.processChildrenOps(collectionName, data.id, children, triggeredBy, context, client);
+        }
+
         return {
           data,
         };
@@ -636,6 +666,556 @@ export class CollectionStore {
     return filteredPayload;
   }
 
+  private async resolveFields(
+    collectionName: string,
+    records: Record<string, any>[],
+    fields: string | string[] | undefined,
+    client: PoolClient,
+  ): Promise<Record<string, any>[]> {
+    const { relations } = parseFieldsToTree(normalizeFields(fields));
+    if (Object.keys(relations).length === 0) return records;
+    return this.resolveRelations(collectionName, records, relations, client);
+  }
+
+  private async resolveRelations(
+    collectionName: string,
+    records: Record<string, any>[],
+    relations: Record<string, FieldsTree>,
+    client: PoolClient,
+  ): Promise<Record<string, any>[]> {
+    const results = records.map((r) => ({ ...r }));
+
+    for (const [fieldName, subTree] of Object.entries(relations)) {
+      const relation = Lobb.instance.configManager.getParentRelation(collectionName, fieldName);
+
+      if (!relation) {
+        // Check for polymorphic virtual field
+        const poly = Lobb.instance.configManager.getPolymorphicRelationByVirtualField(collectionName, fieldName);
+        if (!poly) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message: `Cannot resolve field (${fieldName}) on collection (${collectionName}): no relation is defined for this field`,
+          });
+        }
+
+        // Group records by target collection (each record can point to a different one)
+        const groups: Record<string, any[]> = {};
+        for (const result of results) {
+          const targetCollection = result[poly.collectionField];
+          const targetId = result[poly.idField];
+          if (targetCollection && targetId != null) {
+            if (!groups[targetCollection]) groups[targetCollection] = [];
+            groups[targetCollection].push(result);
+          }
+        }
+
+        const subFields = subTree.rootFields.includes("*")
+          ? "*"
+          : [...new Set(["id", ...Object.keys(subTree.relations), ...subTree.rootFields])].join(",") || "id";
+
+        // Batch-fetch per target collection
+        const refMap: Record<string, any> = {};
+        for (const [targetCollection, groupRecords] of Object.entries(groups)) {
+          const ids = [...new Set(groupRecords.map((r) => String(r[poly.idField])))];
+          const fetched = await this.findAll({
+            collectionName: targetCollection,
+            params: { fields: subFields, filter: { id: { $in: ids } } },
+            triggeredBy: "INTERNAL",
+            client,
+          });
+          let fetchedRecords = fetched.data;
+          if (Object.keys(subTree.relations).length > 0 && fetchedRecords.length > 0) {
+            fetchedRecords = await this.resolveRelations(targetCollection, fetchedRecords, subTree.relations, client);
+          }
+          for (const refRecord of fetchedRecords) {
+            refMap[`${targetCollection}:${refRecord.id}`] = refRecord;
+          }
+        }
+
+        for (const result of results) {
+          const key = `${result[poly.collectionField]}:${result[poly.idField]}`;
+          result[fieldName] = refMap[key] ?? null;
+        }
+
+        continue;
+      }
+
+      const uniqueIds = [
+        ...new Set(
+          results
+            .map((r) => r[fieldName])
+            .filter((id) => id != null)
+            .map(String),
+        ),
+      ];
+
+      const refMap: Record<string, any> = {};
+
+      if (uniqueIds.length) {
+        const subFields = subTree.rootFields.includes("*")
+          ? "*"
+          : [...new Set(["id", ...Object.keys(subTree.relations), ...subTree.rootFields])].join(",") || "id";
+
+        const refRecords = await this.findAll({
+          collectionName: relation.to.collection,
+          params: {
+            fields: subFields,
+            filter: { [relation.to.field]: { $in: uniqueIds } },
+          },
+          triggeredBy: "INTERNAL",
+          client,
+        });
+
+        let fetchedRecords = refRecords.data;
+
+        if (Object.keys(subTree.relations).length > 0 && fetchedRecords.length > 0) {
+          fetchedRecords = await this.resolveRelations(
+            relation.to.collection,
+            fetchedRecords,
+            subTree.relations,
+            client,
+          );
+        }
+
+        for (const refRecord of fetchedRecords) {
+          refMap[String(refRecord[relation.to.field])] = refRecord;
+        }
+      }
+
+      for (const result of results) {
+        const refId = result[fieldName];
+        result[fieldName] = refId != null ? (refMap[String(refId)] ?? null) : null;
+      }
+    }
+
+    return results;
+  }
+
+  private async resolveChildren(
+    collectionName: string,
+    records: Record<string, any>[],
+    children: Record<string, ChildParams>,
+    client: PoolClient,
+  ): Promise<Record<string, any>[]> {
+    const results = records.map((r) => ({ ...r }));
+
+    for (const [childCollectionName, childParams] of Object.entries(children)) {
+      const resolved = this.resolveChildRelationType(collectionName, childCollectionName);
+
+      if (!resolved) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message: `Cannot fetch children (${childCollectionName}) for collection (${collectionName}): no relation is defined`,
+        });
+      }
+
+      const userChildFields = childParams.fields;
+      const hasWildcard = !userChildFields ||
+        (Array.isArray(userChildFields) ? userChildFields.includes("*") : userChildFields.includes("*"));
+
+      if (resolved.type === "fk") {
+        const fkField = resolved.relation.from.field;
+        const parentIds = [...new Set(results.map((r) => r[resolved.relation.to.field]).filter((id) => id != null).map(String))];
+
+        if (parentIds.length === 0) {
+          for (const result of results) result[childCollectionName] = [];
+          continue;
+        }
+
+        const childFieldsWithFK = hasWildcard
+          ? userChildFields
+          : Array.isArray(userChildFields)
+          ? [...new Set([...userChildFields, "id", fkField])]
+          : `${userChildFields},id,${fkField}`;
+
+        const fkFilter = { [fkField]: { $in: parentIds } };
+        const filter = childParams.filter ? { $and: [fkFilter, childParams.filter] } : fkFilter;
+
+        const childRecords = await this.findAll({
+          collectionName: childCollectionName,
+          params: { ...childParams, fields: childFieldsWithFK, filter },
+          triggeredBy: "INTERNAL",
+          client,
+        });
+
+        const childMap: Record<string, any[]> = {};
+        for (const parentId of parentIds) childMap[parentId] = [];
+        for (const childRecord of childRecords.data) {
+          const parentId = String(childRecord[fkField]);
+          if (childMap[parentId]) childMap[parentId].push(childRecord);
+        }
+
+        if (!hasWildcard) {
+          const requestedFields = Array.isArray(userChildFields)
+            ? userChildFields
+            : userChildFields?.split(",").map((f) => f.trim()) ?? [];
+          if (!requestedFields.includes(fkField)) {
+            for (const group of Object.values(childMap)) {
+              for (const record of group) delete record[fkField];
+            }
+          }
+        }
+
+        for (const result of results) {
+          result[childCollectionName] = childMap[String(result[resolved.relation.to.field])] ?? [];
+        }
+      } else if (resolved.type === "m2m") {
+        const { junctionCollection, parentFKField, targetFKField } = resolved.junction;
+        const parentIds = [...new Set(results.map((r) => r["id"]).filter((id) => id != null).map(String))];
+
+        if (parentIds.length === 0) {
+          for (const result of results) result[childCollectionName] = [];
+          continue;
+        }
+
+        // Fetch junction rows to get target IDs per parent
+        const junctionRecords = await this.findAll({
+          collectionName: junctionCollection,
+          params: { fields: `${parentFKField},${targetFKField}`, filter: { [parentFKField]: { $in: parentIds } } },
+          triggeredBy: "INTERNAL",
+          client,
+        });
+
+        const targetIdsByParent: Record<string, string[]> = {};
+        for (const parentId of parentIds) targetIdsByParent[parentId] = [];
+        for (const jr of junctionRecords.data) {
+          const parentId = String(jr[parentFKField]);
+          const targetId = String(jr[targetFKField]);
+          if (targetIdsByParent[parentId]) targetIdsByParent[parentId].push(targetId);
+        }
+
+        const allTargetIds = [...new Set(Object.values(targetIdsByParent).flat())];
+        const targetMap: Record<string, any> = {};
+
+        if (allTargetIds.length > 0) {
+          const childFieldsWithId = hasWildcard ? userChildFields : Array.isArray(userChildFields)
+            ? [...new Set([...userChildFields, "id"])]
+            : `${userChildFields},id`;
+
+          const targetRecords = await this.findAll({
+            collectionName: childCollectionName,
+            params: { ...childParams, fields: childFieldsWithId, filter: { id: { $in: allTargetIds } } },
+            triggeredBy: "INTERNAL",
+            client,
+          });
+
+          for (const tr of targetRecords.data) targetMap[String(tr.id)] = tr;
+        }
+
+        for (const result of results) {
+          const parentId = String(result["id"]);
+          result[childCollectionName] = (targetIdsByParent[parentId] ?? []).map((id) => targetMap[id]).filter(Boolean);
+        }
+      } else {
+        // Polymorphic — child records have polymorphic FK pointing to parent
+        const { collectionField, idField } = resolved.poly;
+        const parentIds = [...new Set(results.map((r) => r["id"]).filter((id) => id != null).map(String))];
+
+        if (parentIds.length === 0) {
+          for (const result of results) result[childCollectionName] = [];
+          continue;
+        }
+
+        const childFieldsWithFK = hasWildcard
+          ? userChildFields
+          : Array.isArray(userChildFields)
+          ? [...new Set([...userChildFields, "id", idField])]
+          : `${userChildFields},id,${idField}`;
+
+        const polyFilter = { [collectionField]: collectionName, [idField]: { $in: parentIds } };
+        const filter = childParams.filter ? { $and: [polyFilter, childParams.filter] } : polyFilter;
+
+        const childRecords = await this.findAll({
+          collectionName: childCollectionName,
+          params: { ...childParams, fields: childFieldsWithFK, filter },
+          triggeredBy: "INTERNAL",
+          client,
+        });
+
+        const childMap: Record<string, any[]> = {};
+        for (const parentId of parentIds) childMap[parentId] = [];
+        for (const childRecord of childRecords.data) {
+          const parentId = String(childRecord[idField]);
+          if (childMap[parentId]) childMap[parentId].push(childRecord);
+        }
+
+        if (!hasWildcard) {
+          const requestedFields = Array.isArray(userChildFields)
+            ? userChildFields
+            : userChildFields?.split(",").map((f) => f.trim()) ?? [];
+          if (!requestedFields.includes(idField)) {
+            for (const group of Object.values(childMap)) {
+              for (const record of group) delete record[idField];
+            }
+          }
+        }
+
+        for (const result of results) {
+          result[childCollectionName] = childMap[String(result["id"])] ?? [];
+        }
+      }
+    }
+
+    return results;
+  }
+
+  private async processInlineFKCreates(
+    collectionName: string,
+    data: Record<string, any>,
+    triggeredBy: TriggeredBy,
+    context: HonoContext | undefined,
+    client: PoolClient,
+  ): Promise<Record<string, any>> {
+    const result = { ...data };
+
+    for (const [fieldName, value] of Object.entries(result)) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+
+      // Direct FK inline create: { data: {...} }
+      const fkRelation = Lobb.instance.configManager.getParentRelation(collectionName, fieldName);
+      if (fkRelation && value.data && typeof value.data === "object") {
+        const created = await this.createOne({
+          collectionName: fkRelation.to.collection,
+          data: value.data,
+          triggeredBy,
+          context,
+          client,
+        });
+        result[fieldName] = created.data.id;
+        continue;
+      }
+
+      // Polymorphic inline create: { collection: "...", data: {...} }
+      const polyRelation = Lobb.instance.configManager.getPolymorphicRelationByVirtualField(collectionName, fieldName);
+      if (polyRelation && value.collection && value.data && typeof value.data === "object") {
+        if (!polyRelation.allowedCollections.includes(value.collection)) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message: `Collection (${value.collection}) is not allowed for polymorphic field (${fieldName})`,
+          });
+        }
+        const created = await this.createOne({
+          collectionName: value.collection,
+          data: value.data,
+          triggeredBy,
+          context,
+          client,
+        });
+        result[polyRelation.collectionField] = value.collection;
+        result[polyRelation.idField] = created.data.id;
+        delete result[fieldName];
+      }
+    }
+
+    return result;
+  }
+
+  private resolveChildRelationType(
+    collectionName: string,
+    childCollectionName: string,
+  ): { type: "fk"; relation: any } | { type: "m2m"; junction: any } | { type: "polymorphic"; poly: any } | null {
+    const directRelation = Lobb.instance.configManager.getChildRelations(collectionName)
+      .find((r) => r.from.collection === childCollectionName);
+    if (directRelation) return { type: "fk", relation: directRelation };
+
+    const junction = Lobb.instance.configManager.getM2MJunction(collectionName, childCollectionName);
+    if (junction) return { type: "m2m", junction };
+
+    const poly = Lobb.instance.configManager.getPolymorphicChildRelation(collectionName, childCollectionName);
+    if (poly) return { type: "polymorphic", poly };
+
+    return null;
+  }
+
+  private async processChildrenOps(
+    collectionName: string,
+    parentId: string | number,
+    children: Record<string, { create?: Array<Record<string, any> & { children?: any }>; link?: (string | number)[]; unlink?: (string | number)[]; delete?: (string | number)[]; set?: (string | number)[]; update?: Array<{ id: string | number } & Record<string, any>> }>,
+    triggeredBy: TriggeredBy,
+    context: HonoContext | undefined,
+    client: PoolClient,
+  ): Promise<void> {
+    for (const [childCollectionName, ops] of Object.entries(children)) {
+      if (!ops.create?.length && !ops.link?.length && !ops.unlink?.length && !ops.delete?.length && !ops.set && !ops.update?.length) continue;
+
+      const resolved = this.resolveChildRelationType(collectionName, childCollectionName);
+      if (!resolved) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message: `Cannot process children: no relation found from (${childCollectionName}) to (${collectionName})`,
+        });
+      }
+
+      for (const childData of ops.create ?? []) {
+        const { children: nestedChildren, ...data } = childData;
+
+        if (resolved.type === "fk") {
+          await this.createOne({
+            collectionName: childCollectionName,
+            data: { ...data, [resolved.relation.from.field]: parentId },
+            children: nestedChildren, triggeredBy, context, client,
+          });
+        } else if (resolved.type === "m2m") {
+          const created = await this.createOne({
+            collectionName: childCollectionName,
+            data, children: nestedChildren, triggeredBy, context, client,
+          });
+          await this.createOne({
+            collectionName: resolved.junction.junctionCollection,
+            data: { [resolved.junction.parentFKField]: parentId, [resolved.junction.targetFKField]: created.data.id },
+            triggeredBy, context, client,
+          });
+        } else {
+          await this.createOne({
+            collectionName: childCollectionName,
+            data: { ...data, [resolved.poly.collectionField]: collectionName, [resolved.poly.idField]: parentId },
+            children: nestedChildren, triggeredBy, context, client,
+          });
+        }
+      }
+
+      for (const id of ops.link ?? []) {
+        if (resolved.type === "fk") {
+          await this.updateOne({
+            collectionName: childCollectionName,
+            id: String(id),
+            data: { [resolved.relation.from.field]: parentId },
+            triggeredBy, context, client,
+          });
+        } else if (resolved.type === "m2m") {
+          await this.createOne({
+            collectionName: resolved.junction.junctionCollection,
+            data: { [resolved.junction.parentFKField]: parentId, [resolved.junction.targetFKField]: id },
+            triggeredBy, context, client,
+          });
+        } else {
+          await this.updateOne({
+            collectionName: childCollectionName,
+            id: String(id),
+            data: { [resolved.poly.collectionField]: collectionName, [resolved.poly.idField]: parentId },
+            triggeredBy, context, client,
+          });
+        }
+      }
+
+      for (const id of ops.unlink ?? []) {
+        if (resolved.type === "fk") {
+          await this.updateOne({
+            collectionName: childCollectionName,
+            id: String(id),
+            data: { [resolved.relation.from.field]: null },
+            triggeredBy, context, client,
+          });
+        } else if (resolved.type === "m2m") {
+          await this.deleteMany({
+            collectionName: resolved.junction.junctionCollection,
+            filter: { [resolved.junction.parentFKField]: parentId, [resolved.junction.targetFKField]: id },
+            triggeredBy, context, client,
+          });
+        } else {
+          await this.updateOne({
+            collectionName: childCollectionName,
+            id: String(id),
+            data: { [resolved.poly.collectionField]: null, [resolved.poly.idField]: null },
+            triggeredBy, context, client,
+          });
+        }
+      }
+
+      for (const id of ops.delete ?? []) {
+        if (resolved.type === "m2m") {
+          await this.deleteMany({
+            collectionName: resolved.junction.junctionCollection,
+            filter: { [resolved.junction.parentFKField]: parentId, [resolved.junction.targetFKField]: id },
+            triggeredBy, context, client,
+          });
+        }
+        await this.deleteOne({
+          collectionName: childCollectionName,
+          id: String(id),
+          triggeredBy, context, client,
+        });
+      }
+
+      if (ops.set) {
+        const newIds = ops.set.map(String);
+
+        if (resolved.type === "fk") {
+          const currentIds = await this.dbDriver.getIdsByFilter(
+            childCollectionName,
+            { [resolved.relation.from.field]: parentId },
+            client,
+          );
+          for (const currentId of currentIds) {
+            if (!newIds.includes(String(currentId))) {
+              await this.updateOne({
+                collectionName: childCollectionName,
+                id: String(currentId),
+                data: { [resolved.relation.from.field]: null },
+                triggeredBy, context, client,
+              });
+            }
+          }
+          for (const id of newIds) {
+            await this.updateOne({
+              collectionName: childCollectionName,
+              id,
+              data: { [resolved.relation.from.field]: parentId },
+              triggeredBy, context, client,
+            });
+          }
+        } else if (resolved.type === "m2m") {
+          await this.deleteMany({
+            collectionName: resolved.junction.junctionCollection,
+            filter: { [resolved.junction.parentFKField]: parentId },
+            triggeredBy, context, client,
+          });
+          for (const id of newIds) {
+            await this.createOne({
+              collectionName: resolved.junction.junctionCollection,
+              data: { [resolved.junction.parentFKField]: parentId, [resolved.junction.targetFKField]: id },
+              triggeredBy, context, client,
+            });
+          }
+        } else {
+          const currentIds = await this.dbDriver.getIdsByFilter(
+            childCollectionName,
+            { [resolved.poly.collectionField]: collectionName, [resolved.poly.idField]: parentId },
+            client,
+          );
+          for (const currentId of currentIds) {
+            if (!newIds.includes(String(currentId))) {
+              await this.updateOne({
+                collectionName: childCollectionName,
+                id: String(currentId),
+                data: { [resolved.poly.collectionField]: null, [resolved.poly.idField]: null },
+                triggeredBy, context, client,
+              });
+            }
+          }
+          for (const id of newIds) {
+            await this.updateOne({
+              collectionName: childCollectionName,
+              id,
+              data: { [resolved.poly.collectionField]: collectionName, [resolved.poly.idField]: parentId },
+              triggeredBy, context, client,
+            });
+          }
+        }
+      }
+
+      for (const item of ops.update ?? []) {
+        const { id, ...data } = item;
+        await this.updateOne({
+          collectionName: childCollectionName,
+          id: String(id),
+          data,
+          triggeredBy, context, client,
+        });
+      }
+    }
+  }
+
   private async handleSingletonCollection(
     collectionName: string,
     context?: HonoContext,
@@ -654,3 +1234,81 @@ export class CollectionStore {
     }
   }
 }
+
+interface FieldsTree {
+  rootFields: string[];
+  relations: Record<string, FieldsTree>;
+}
+
+function normalizeFields(fields: string | string[] | undefined): string[] {
+  if (!fields) return ["*"];
+  if (Array.isArray(fields)) return fields.map((f) => f.trim()).filter(Boolean);
+  return fields.split(",").map((f) => f.trim()).filter(Boolean);
+}
+
+function parseFieldsToTree(fields: string[]): FieldsTree {
+  const tree: FieldsTree = { rootFields: [], relations: {} };
+  for (const field of fields) {
+    addToTree(tree, field);
+  }
+  return tree;
+}
+
+function addToTree(tree: FieldsTree, path: string): void {
+  const dot = path.indexOf(".");
+  if (dot === -1) {
+    tree.rootFields.push(path);
+  } else {
+    const relationName = path.slice(0, dot);
+    const rest = path.slice(dot + 1);
+    if (!tree.relations[relationName]) {
+      tree.relations[relationName] = { rootFields: [], relations: {} };
+    }
+    addToTree(tree.relations[relationName], rest);
+  }
+}
+
+function buildDriverFields(
+  collectionName: string,
+  fields: string | string[] | undefined,
+): string {
+  const normalized = normalizeFields(fields).filter((f) => !f.includes("."));
+  const allCollectionFields = Object.entries(
+    Lobb.instance.configManager.getCollection(collectionName).fields,
+  )
+    .filter(([, cfg]) => !cfg.virtual)
+    .map(([name]) => name);
+
+  const requestedFields = normalized.includes("*") ? allCollectionFields : normalized;
+
+  return [
+    ...new Set([
+      "id",
+      ...Lobb.instance.configManager.getCollectionFKFields(collectionName),
+      ...requestedFields,
+    ]),
+  ].join(",");
+}
+
+function stripInternalFields(
+  collectionName: string,
+  fields: string | string[] | undefined,
+  records: Record<string, any>[],
+): Record<string, any>[] {
+  const normalized = normalizeFields(fields);
+  if (normalized.includes("*")) return records;
+
+  const internalFields = ["id", ...Lobb.instance.configManager.getCollectionFKFields(collectionName)];
+  const tree = parseFieldsToTree(normalized);
+  const userRequested = new Set([...tree.rootFields, ...Object.keys(tree.relations)]);
+
+  return records.map((record) => {
+    const stripped: Record<string, any> = {};
+    for (const key of Object.keys(record)) {
+      if (!internalFields.includes(key) || userRequested.has(key)) {
+        stripped[key] = record[key];
+      }
+    }
+    return stripped;
+  });
+}