pbtsdb 0.8.0 → 0.9.0

package/dist/{chunk-KMR6I4ZC.js → chunk-YWTU6QXM.js}

@@ -1,57 +1,87 @@
-import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression, deepEquals } from '@tanstack/db';
-export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, toArray } from '@tanstack/db';
+import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression } from '@tanstack/db';
+export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, materialize, toArray } from '@tanstack/db';
 import { queryCollectionOptions, DeleteOperationItemNotFoundError } from '@tanstack/query-db-collection';
 
 // src/core.ts
 
-// src/expand-merge.ts
-function sameRelationValue(a, b) {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+// src/expand-paths.ts
+function normalizePaths(paths) {
+  const set = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const trimmed = path.trim();
+    if (trimmed) set.add(trimmed);
   }
-  return a === b;
+  return [...set].sort();
 }
-function storedIsNewer(incoming, stored) {
-  const a = incoming;
-  const b = stored;
-  if (!a || !b || a.id !== b.id) return false;
-  if (typeof a.updated !== "string" || typeof b.updated !== "string") return false;
-  return b.updated > a.updated;
+function splitPaths(csv) {
+  return csv ? normalizePaths(csv.split(",")) : [];
 }
-function newerEntry(incoming, stored) {
-  if (Array.isArray(incoming) && Array.isArray(stored)) {
-    let changed = false;
-    const merged = incoming.map((entry) => {
-      const match = stored.find(
-        (candidate) => candidate?.id === entry?.id
+function joinPaths(paths) {
+  const normalized = normalizePaths(paths);
+  return normalized.length > 0 ? normalized.join(",") : void 0;
+}
+function validateExpandPath(collectionName, targets, path) {
+  if (!targets) {
+    throw new Error(
+      `Cannot expand "${path}" on collection "${collectionName}": no relations declared`
+    );
+  }
+  let current = targets;
+  for (const segment of path.split(".")) {
+    const next = current?.[segment];
+    if (!next) {
+      throw new Error(
+        `Cannot expand "${path}" on collection "${collectionName}": segment "${segment}" is not a declared relation`
       );
-      if (!storedIsNewer(entry, match)) return entry;
-      changed = true;
-      return match;
-    });
-    return changed ? merged : incoming;
+    }
+    current = next.relationTargets;
   }
-  return storedIsNewer(incoming, stored) ? stored : incoming;
 }
-function mergeExpand(incoming, existing) {
-  const stored = existing?.expand;
-  if (!stored) return incoming;
-  const row = incoming;
-  const merged = { ...row.expand ?? {} };
-  let carried = false;
-  for (const [relation, value] of Object.entries(stored)) {
-    if (relation in merged) {
-      const kept = newerEntry(merged[relation], value);
-      if (kept === merged[relation]) continue;
-      merged[relation] = kept;
-      carried = true;
-      continue;
-    }
-    if (!sameRelationValue(row[relation], existing[relation])) continue;
-    merged[relation] = value;
-    carried = true;
+
+// src/keyed-where.ts
+function isIdRef(node) {
+  return node?.type === "ref" && node.path?.length === 1 && node.path[0] === "id";
+}
+function stringValue(node) {
+  return node?.type === "val" && typeof node.value === "string" ? node.value : void 0;
+}
+function collectEq(a, b) {
+  const other = isIdRef(a) ? b : isIdRef(b) ? a : void 0;
+  if (!other) return void 0;
+  const value = stringValue(other);
+  return value === void 0 ? void 0 : [value];
+}
+function collectIn(a, b) {
+  if (!isIdRef(a) || b?.type !== "val" || !Array.isArray(b.value)) return void 0;
+  return b.value.every((v) => typeof v === "string") ? b.value : void 0;
+}
+function collectOr(args) {
+  const ids = [];
+  for (const arg of args) {
+    const sub = collect(arg);
+    if (!sub) return void 0;
+    ids.push(...sub);
+  }
+  return ids;
+}
+function collect(node) {
+  if (node.type !== "func" || !node.args) return void 0;
+  const [a, b] = node.args;
+  switch (node.name) {
+    case "eq":
+      return collectEq(a, b);
+    case "in":
+      return collectIn(a, b);
+    case "or":
+      return collectOr(node.args);
+    default:
+      return void 0;
   }
-  return carried ? { ...row, expand: merged } : incoming;
+}
+function idsFromWhere(where) {
+  if (!where) return void 0;
+  const ids = collect(where);
+  return ids ? [...new Set(ids)].sort() : void 0;
 }
 
 // src/logger.ts
@@ -84,112 +114,6 @@ function setLogger(customLogger) {
 function resetLogger() {
   currentLogger = defaultLogger;
 }
-
-// src/expand-patch.ts
-function embeddedId(value) {
-  return value?.id;
-}
-function patchUpdate(row, field, record) {
-  const embedded = row.expand?.[field];
-  if (embedded === void 0) return void 0;
-  let next;
-  if (Array.isArray(embedded)) {
-    const index = embedded.findIndex((entry) => embeddedId(entry) === record.id);
-    if (index === -1) return void 0;
-    const replaced = mergeExpand(record, embedded[index]);
-    next = embedded.map((entry, i) => i === index ? replaced : entry);
-  } else {
-    if (embeddedId(embedded) !== record.id) return void 0;
-    next = mergeExpand(record, embedded);
-  }
-  if (deepEquals(next, embedded)) return void 0;
-  return { ...row, expand: { ...row.expand, [field]: next } };
-}
-function patchDelete(row, field, id) {
-  const value = row[field];
-  const embedded = row.expand?.[field];
-  if (Array.isArray(value)) {
-    if (!value.includes(id)) return void 0;
-    const patched2 = { ...row, [field]: value.filter((item) => item !== id) };
-    if (Array.isArray(embedded)) {
-      patched2.expand = {
-        ...row.expand,
-        [field]: embedded.filter((entry) => embeddedId(entry) !== id)
-      };
-    }
-    return patched2;
-  }
-  if (value !== id) return void 0;
-  const patched = { ...row, [field]: "" };
-  if (embedded !== void 0) {
-    const expand = { ...row.expand };
-    delete expand[field];
-    patched.expand = expand;
-  }
-  return patched;
-}
-function patchEmbedded(row, field, action, record) {
-  const current = row;
-  const patched = action === "delete" ? patchDelete(current, field, record.id) : patchUpdate(current, field, record);
-  return patched;
-}
-function fieldsByParent(dependents) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const { field, parent } of dependents) {
-    const fields = grouped.get(parent);
-    if (fields) fields.push(field);
-    else grouped.set(parent, [field]);
-  }
-  return grouped;
-}
-function propagateRelatedChange(source, action, record, visited) {
-  for (const [parent, fields] of fieldsByParent(source.relationDependents ?? [])) {
-    try {
-      parent.applyRelatedChange?.(fields, action, record, visited);
-    } catch (error) {
-      logger.error("Failed to patch a relation dependent", {
-        collectionName: source.collectionName,
-        dependent: parent.collectionName,
-        fields,
-        error
-      });
-    }
-  }
-}
-
-// src/expand-paths.ts
-function normalizePaths(paths) {
-  const set = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    const trimmed = path.trim();
-    if (trimmed) set.add(trimmed);
-  }
-  return [...set].sort();
-}
-function splitPaths(csv) {
-  return csv ? normalizePaths(csv.split(",")) : [];
-}
-function joinPaths(paths) {
-  const normalized = normalizePaths(paths);
-  return normalized.length > 0 ? normalized.join(",") : void 0;
-}
-function validateExpandPath(collectionName, targets, path) {
-  if (!targets) {
-    throw new Error(
-      `Cannot expand "${path}" on collection "${collectionName}": no relations declared`
-    );
-  }
-  let current = targets;
-  for (const segment of path.split(".")) {
-    const next = current?.[segment];
-    if (!next) {
-      throw new Error(
-        `Cannot expand "${path}" on collection "${collectionName}": segment "${segment}" is not a declared relation`
-      );
-    }
-    current = next.relationTargets;
-  }
-}
 function escapeValue(value) {
   if (value === null) {
     return "null";
@@ -292,19 +216,21 @@ var viewPaths = /* @__PURE__ */ new WeakMap();
 function buildCollection(input) {
   const { pb, queryClient, factoryOptions, collectionName, options } = input;
   const relationTargets = options?.relations;
-  const alwaysExpand = normalizePaths(options?.alwaysExpand ?? []);
-  for (const path of alwaysExpand) validateExpandPath(collectionName, relationTargets, path);
+  const alwaysFetch = normalizePaths(options?.alwaysFetchRelations ?? []);
+  for (const path of alwaysFetch) validateExpandPath(collectionName, relationTargets, path);
   const syncMode = options?.syncMode ?? "eager";
   const requestedExpand = /* @__PURE__ */ new Set();
   function toRequest(opts) {
     const request = {};
-    const filter = convertToPocketBaseFilter(opts?.where);
+    const ids = idsFromWhere(opts?.where);
+    const filter = ids ? void 0 : convertToPocketBaseFilter(opts?.where);
     const sort = convertToPocketBaseSort(opts?.orderBy);
-    const expand2 = joinPaths(opts?.expand ?? []);
+    const expand = joinPaths(opts?.expand ?? []);
+    if (ids) request.ids = ids;
     if (filter) request.filter = filter;
     if (sort) request.sort = sort;
     if (opts?.limit) request.limit = opts.limit;
-    if (expand2) request.expand = expand2;
+    if (expand) request.expand = expand;
     return request;
   }
   function queryKeyFor(opts) {
@@ -313,16 +239,34 @@ function buildCollection(input) {
   }
   function activeExpand(request) {
     return joinPaths([
-      ...alwaysExpand,
+      ...alwaysFetch,
       ...splitPaths(request.expand),
       ...syncMode === "eager" ? requestedExpand : []
     ]);
   }
+  function stripFetchedRelations(items, expandString) {
+    const heads = new Set(splitPaths(expandString).map((path) => path.split(".")[0]));
+    if (heads.size === 0) return items;
+    return items.map((item) => {
+      const { expand, ...plain } = item;
+      if (!expand) return item;
+      const kept = Object.fromEntries(
+        Object.entries(expand).filter(([key]) => !heads.has(key))
+      );
+      return Object.keys(kept).length > 0 ? { ...plain, expand: kept } : plain;
+    });
+  }
   const ignoreAutoCancellation = options?.ignoreAutoCancellation ?? true;
   const refetchOnMutation = options?.refetchOnMutation ?? false;
   function eagerSyncInFlight(target) {
     return target.status !== void 0 && target.status !== "idle" && target.status !== "cleaned-up";
   }
+  function withoutExpand(values) {
+    return values.map((value) => {
+      const { expand: _expand, ...plain } = value;
+      return plain;
+    });
+  }
   async function upsertInto(key, target, values) {
     if (!target.utils) return;
     if (!target.isReady()) {
@@ -337,7 +281,7 @@ function buildCollection(input) {
         return;
       }
     }
-    target.utils.writeUpsert(values);
+    target.utils.writeUpsert(withoutExpand(values));
   }
   async function upsertExpandedField(key, value, targets) {
     const target = targets[key];
@@ -359,23 +303,48 @@ function buildCollection(input) {
       }
     }
   }
+  function idFilter(ids) {
+    return ids.map((id) => `id = "${id.replace(/"/g, '\\"')}"`).join(" || ");
+  }
+  function rowsFromStore(ids) {
+    const rows = [];
+    for (const id of ids) {
+      const row = collection._state.syncedData.get(id);
+      if (!row) return void 0;
+      rows.push(row);
+    }
+    return rows;
+  }
+  function servedFromStore(request) {
+    const { ids, sort, limit } = request;
+    if (!ids) return void 0;
+    if (ids.length === 0) return [];
+    if (request.expand) return void 0;
+    if (sort && limit) return void 0;
+    const present = rowsFromStore(ids);
+    if (!present) return void 0;
+    return limit ? present.slice(0, limit) : present;
+  }
   async function fetchItems(request) {
-    const { filter, sort, limit } = request;
-    const expand2 = activeExpand(request);
+    const served = servedFromStore(request);
+    if (served) return served;
+    const { sort, limit, ids } = request;
+    const filter = ids ? idFilter(ids) : request.filter;
+    const expand = activeExpand(request);
     if (limit) {
       const result = await pb.collection(collectionName).getList(1, limit, {
         filter,
         sort,
         skipTotal: true,
         // Optimize by skipping total count
-        expand: expand2
+        expand
       });
       return result.items;
     }
     return await pb.collection(collectionName).getFullList({
       filter,
       sort,
-      expand: expand2
+      expand
     });
   }
   const inFlightConfirmedIds = /* @__PURE__ */ new Set();
@@ -422,52 +391,14 @@ function buildCollection(input) {
         throw error;
       }
       await upsertExpanded(items, relationTargets);
-      if (request.expand) writeExpandedRows(items);
-      return withRowsConfirmedMidFlight(items, confirmedMidFlight);
+      return withRowsConfirmedMidFlight(
+        stripFetchedRelations(items, activeExpand(request)),
+        confirmedMidFlight
+      );
     } finally {
       inFlightConfirmedIds.delete(confirmedMidFlight);
     }
   }
-  function writeExpandedRows(items) {
-    if (!collection.utils || !collection.isReady()) return;
-    collection.utils.writeUpsert(items);
-  }
-  function patchRowFields(row, fields, action, record) {
-    let current;
-    for (const field of fields) {
-      const next = patchEmbedded(current ?? row, field, action, record);
-      if (next) current = next;
-    }
-    return current;
-  }
-  function patchedRows(fields, action, record, visited) {
-    const patched = [];
-    for (const row of collection._state.syncedData.values()) {
-      const id = row.id;
-      if (typeof id !== "string") continue;
-      const key = `${collectionName}:${id}`;
-      if (visited.has(key)) continue;
-      const next = patchRowFields(row, fields, action, record);
-      if (!next) continue;
-      visited.add(key);
-      patched.push(next);
-    }
-    return patched;
-  }
-  function applyRelatedChange(fields, action, record, visited) {
-    if (!collection.utils || !collection.isReady()) return;
-    const patched = patchedRows(fields, action, record, visited);
-    if (patched.length === 0) return;
-    writeOwn(() => collection.utils.writeUpsert(patched));
-    for (const row of patched) {
-      propagateRelatedChange(
-        collection,
-        "update",
-        row,
-        visited
-      );
-    }
-  }
   const queryCollectionConfig = queryCollectionOptions({
     autoIndex: "eager",
     defaultIndexType: BTreeIndex,
@@ -575,11 +506,6 @@ function buildCollection(input) {
     const paths = (opts.subscription && viewPaths.get(opts.subscription)) ?? subscribingViewPaths;
     return paths ? { ...opts, expand: paths } : opts;
   }
-  function mergedWriteValue(op) {
-    const key = syncedWriteKey(op);
-    const existing = key === null ? void 0 : collection._state.syncedData.get(key);
-    return mergeExpand(op.value, existing);
-  }
   const innerSync = collectionOptions.sync.sync;
   collectionOptions.sync = {
     ...collectionOptions.sync,
@@ -587,10 +513,6 @@ function buildCollection(input) {
       const guardedWrite = (message) => {
         const op = message;
         if (shouldDropSyncedWrite(op)) return;
-        if ((op.type === "insert" || op.type === "update") && op.value && typeof op.value === "object") {
-          const merged = mergedWriteValue(op);
-          if (merged !== op.value) return params.write({ ...message, value: merged });
-        }
         return params.write(message);
       };
       const res = innerSync({ ...params, write: guardedWrite });
@@ -604,14 +526,6 @@ function buildCollection(input) {
     }
   };
   const collection = createCollection$1(collectionOptions);
-  const relationDependents = [];
-  for (const [field, target] of Object.entries(relationTargets ?? {})) {
-    target.relationDependents ?? (target.relationDependents = []);
-    target.relationDependents.push({
-      field,
-      parent: collection
-    });
-  }
   const views = /* @__PURE__ */ new Map();
   function createView(paths) {
     const view = Object.create(collection);
@@ -630,18 +544,18 @@ function buildCollection(input) {
           }
         }
       },
-      expand: {
+      fetchRelations: {
         value: () => {
-          throw new Error(`A view of "${collectionName}" cannot be expanded further`);
+          throw new Error(`A view of "${collectionName}" cannot fetch further relations`);
         }
       }
     });
     return view;
   }
-  function expand(...paths) {
+  function fetchRelations(...paths) {
     for (const path of paths) validateExpandPath(collectionName, relationTargets, path);
-    const all = normalizePaths([...alwaysExpand, ...paths]);
-    if (all.every((path) => alwaysExpand.includes(path))) return collection;
+    const all = normalizePaths([...alwaysFetch, ...paths]);
+    if (all.every((path) => alwaysFetch.includes(path))) return collection;
     const key = all.join(",");
     let view = views.get(key);
     if (!view) {
@@ -698,15 +612,16 @@ function buildCollection(input) {
     if (!collection.utils) return;
     markEchoPresence(event);
     if (isStaleEcho(event)) return;
+    const [stored] = stripFetchedRelations([event.record], pendingSubscribeExpand());
     try {
       writeOwn(
         () => collection.utils.writeBatch(() => {
           switch (event.action) {
             case "create":
-              collection.utils.writeInsert(event.record);
+              collection.utils.writeInsert(stored);
               break;
             case "update":
-              collection.utils.writeUpsert(event.record);
+              collection.utils.writeUpsert(stored);
               break;
             case "delete":
               if (event.record && "id" in event.record) {
@@ -734,15 +649,9 @@ function buildCollection(input) {
         })
       );
     }
-    propagateRelatedChange(
-      collection,
-      event.action,
-      event.record,
-      /* @__PURE__ */ new Set()
-    );
   };
   function pendingSubscribeExpand() {
-    return joinPaths([...alwaysExpand, ...requestedExpand]);
+    return joinPaths([...alwaysFetch, ...requestedExpand]);
   }
   function activeExpandTargets() {
     const targets = /* @__PURE__ */ new Set();
@@ -789,11 +698,11 @@ function buildCollection(input) {
   }
   function realtimeSubscribeOptions() {
     const base = factoryOptions?.subscribeOptions?.();
-    const expand2 = joinPaths([
+    const expand = joinPaths([
       ...splitPaths(pendingSubscribeExpand()),
       ...splitPaths(base?.expand)
     ]);
-    return expand2 ? { ...base, expand: expand2 } : base;
+    return expand ? { ...base, expand } : base;
   }
   const doStartSubscription = async () => {
     if (isSubscribed) return;
@@ -915,9 +824,7 @@ function buildCollection(input) {
     waitForSubscription,
     isSubscribed: () => isSubscribed,
     heldRelationTargetCount: () => heldTargetSubscriptions.size,
-    expand,
-    relationDependents,
-    applyRelatedChange
+    fetchRelations
   });
   return collection;
 }
@@ -946,5 +853,5 @@ function newRecordId() {
 }
 
 export { createCollection, newRecordId, resetLogger, setLogger };
-//# sourceMappingURL=chunk-KMR6I4ZC.js.map
-//# sourceMappingURL=chunk-KMR6I4ZC.js.map
+//# sourceMappingURL=chunk-YWTU6QXM.js.map
+//# sourceMappingURL=chunk-YWTU6QXM.js.map