pbtsdb 0.7.2 → 0.8.0

package/dist/chunk-KMR6I4ZC.js

@@ -0,0 +1,950 @@
+import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression, deepEquals } from '@tanstack/db';
+export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, 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]);
+  }
+  return a === b;
+}
+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 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
+      );
+      if (!storedIsNewer(entry, match)) return entry;
+      changed = true;
+      return match;
+    });
+    return changed ? merged : incoming;
+  }
+  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;
+  }
+  return carried ? { ...row, expand: merged } : incoming;
+}
+
+// src/logger.ts
+var defaultLogger = {
+  debug: (msg, context) => {
+    if (process.env.NODE_ENV === "development") {
+      console.debug(`[pbtsdb] ${msg}`, context || "");
+    }
+  },
+  info: (msg, context) => {
+    console.info(`[pbtsdb] ${msg}`, context || "");
+  },
+  warn: (msg, context) => {
+    console.warn(`[pbtsdb] ${msg}`, context || "");
+  },
+  error: (msg, context) => {
+    console.error(`[pbtsdb] ${msg}`, context || "");
+  }
+};
+var currentLogger = defaultLogger;
+var logger = {
+  debug: (msg, context) => currentLogger.debug(msg, context),
+  info: (msg, context) => currentLogger.info(msg, context),
+  warn: (msg, context) => currentLogger.warn(msg, context),
+  error: (msg, context) => currentLogger.error(msg, context)
+};
+function setLogger(customLogger) {
+  currentLogger = 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";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  if (value instanceof Date) {
+    return `"${value.toISOString()}"`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(escapeValue).join(",")}]`;
+  }
+  return `"${String(value)}"`;
+}
+function fieldPathToString(path) {
+  return path.join(".");
+}
+function convertToPocketBaseFilter(where) {
+  if (!where) {
+    return void 0;
+  }
+  const result = parseWhereExpression(where, {
+    handlers: {
+      eq: (field, value) => {
+        return `${fieldPathToString(field)} = ${escapeValue(value)}`;
+      },
+      gt: (field, value) => {
+        return `${fieldPathToString(field)} > ${escapeValue(value)}`;
+      },
+      gte: (field, value) => {
+        return `${fieldPathToString(field)} >= ${escapeValue(value)}`;
+      },
+      lt: (field, value) => {
+        return `${fieldPathToString(field)} < ${escapeValue(value)}`;
+      },
+      lte: (field, value) => {
+        return `${fieldPathToString(field)} <= ${escapeValue(value)}`;
+      },
+      and: (...conditions) => {
+        if (conditions.length === 0) return "";
+        if (conditions.length === 1) return conditions[0];
+        return `(${conditions.join(" && ")})`;
+      },
+      or: (...conditions) => {
+        if (conditions.length === 0) return "";
+        if (conditions.length === 1) return conditions[0];
+        return `(${conditions.join(" || ")})`;
+      },
+      not: (condition) => {
+        return `!(${condition})`;
+      },
+      in: (field, values) => {
+        const valueArray = Array.isArray(values) ? values : [values];
+        const uniqueValues = [...new Set(valueArray)];
+        const fieldStr = fieldPathToString(field);
+        const conditions = uniqueValues.map((v) => `${fieldStr} = ${escapeValue(v)}`);
+        return conditions.length > 1 ? `(${conditions.join(" || ")})` : conditions[0];
+      },
+      like: (field, value) => {
+        return `${fieldPathToString(field)} ~ ${escapeValue(value)}`;
+      },
+      isNull: (field) => {
+        return `${fieldPathToString(field)} = null`;
+      },
+      isUndefined: (field) => {
+        return `${fieldPathToString(field)} = null`;
+      }
+    },
+    onUnknownOperator: (operator, _args) => {
+      throw new Error(
+        `Unsupported operator '${operator}' for PocketBase filter conversion. Supported operators: eq, gt, gte, lt, lte, in, like, and, or, not, isNull, isUndefined`
+      );
+    }
+  });
+  return result || void 0;
+}
+function convertToPocketBaseSort(orderBy) {
+  if (!orderBy) {
+    return void 0;
+  }
+  const sorts = parseOrderByExpression(orderBy);
+  if (sorts.length === 0) {
+    return void 0;
+  }
+  return sorts.map((sort) => {
+    const field = fieldPathToString(sort.field);
+    return sort.direction === "desc" ? `-${field}` : field;
+  }).join(",");
+}
+
+// src/build-collection.ts
+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 syncMode = options?.syncMode ?? "eager";
+  const requestedExpand = /* @__PURE__ */ new Set();
+  function toRequest(opts) {
+    const request = {};
+    const filter = convertToPocketBaseFilter(opts?.where);
+    const sort = convertToPocketBaseSort(opts?.orderBy);
+    const expand2 = joinPaths(opts?.expand ?? []);
+    if (filter) request.filter = filter;
+    if (sort) request.sort = sort;
+    if (opts?.limit) request.limit = opts.limit;
+    if (expand2) request.expand = expand2;
+    return request;
+  }
+  function queryKeyFor(opts) {
+    const request = toRequest(opts);
+    return Object.keys(request).length === 0 ? [collectionName] : [collectionName, request];
+  }
+  function activeExpand(request) {
+    return joinPaths([
+      ...alwaysExpand,
+      ...splitPaths(request.expand),
+      ...syncMode === "eager" ? requestedExpand : []
+    ]);
+  }
+  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";
+  }
+  async function upsertInto(key, target, values) {
+    if (!target.utils) return;
+    if (!target.isReady()) {
+      if (target.config?.syncMode === "on-demand") {
+        await target._sync.startSync();
+      } else if (target.preload && eagerSyncInFlight(target)) {
+        await target.preload();
+      } else {
+        logger.warn(
+          `not syncing ${key} on ${collectionName} because store is not yet ready`
+        );
+        return;
+      }
+    }
+    target.utils.writeUpsert(values);
+  }
+  async function upsertExpandedField(key, value, targets) {
+    const target = targets[key];
+    if (!target) {
+      logger.debug("No relation target for expanded field", { collectionName, key });
+      return;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    await upsertInto(key, target, values);
+    await upsertExpanded(values, target.relationTargets);
+  }
+  async function upsertExpanded(records, targets) {
+    if (!targets) return;
+    for (const record of records) {
+      const expandData = record.expand;
+      if (!expandData) continue;
+      for (const [key, value] of Object.entries(expandData)) {
+        await upsertExpandedField(key, value, targets);
+      }
+    }
+  }
+  async function fetchItems(request) {
+    const { filter, sort, limit } = request;
+    const expand2 = activeExpand(request);
+    if (limit) {
+      const result = await pb.collection(collectionName).getList(1, limit, {
+        filter,
+        sort,
+        skipTotal: true,
+        // Optimize by skipping total count
+        expand: expand2
+      });
+      return result.items;
+    }
+    return await pb.collection(collectionName).getFullList({
+      filter,
+      sort,
+      expand: expand2
+    });
+  }
+  const inFlightConfirmedIds = /* @__PURE__ */ new Set();
+  function markConfirmedPresent(records) {
+    if (inFlightConfirmedIds.size === 0) return;
+    for (const record of records) {
+      const id = record?.id;
+      if (typeof id !== "string") continue;
+      for (const confirmed of inFlightConfirmedIds) confirmed.add(id);
+    }
+  }
+  function withRowsConfirmedMidFlight(items, confirmedMidFlight) {
+    if (confirmedMidFlight.size === 0) return items;
+    const resultIds = new Set(
+      items.map((item) => item?.id)
+    );
+    const mergedIds = [...confirmedMidFlight].filter(
+      (id) => !resultIds.has(id) && collection._state.syncedData.has(id)
+    );
+    if (mergedIds.length === 0) return items;
+    logger.debug("Merging rows confirmed while fetch was in flight", {
+      collectionName,
+      ids: mergedIds
+    });
+    return [
+      ...items,
+      ...mergedIds.map((id) => collection._state.syncedData.get(id))
+    ];
+  }
+  async function fetchRecords(request, queryKey) {
+    const confirmedMidFlight = /* @__PURE__ */ new Set();
+    inFlightConfirmedIds.add(confirmedMidFlight);
+    try {
+      let items;
+      try {
+        items = await fetchItems(request);
+      } catch (error) {
+        if (ignoreAutoCancellation && error instanceof Error && error.message.includes("autocancelled")) {
+          return withRowsConfirmedMidFlight(
+            queryClient.getQueryData(queryKey) ?? [],
+            confirmedMidFlight
+          );
+        }
+        throw error;
+      }
+      await upsertExpanded(items, relationTargets);
+      if (request.expand) writeExpandedRows(items);
+      return withRowsConfirmedMidFlight(items, 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,
+    ...options?.collectionOptions,
+    queryClient,
+    queryKey: queryKeyFor,
+    syncMode,
+    queryFn: async (ctx) => {
+      const request = ctx.queryKey[1] ?? {};
+      return fetchRecords(request, ctx.queryKey);
+    },
+    getKey: (item) => {
+      const record = item;
+      if (!record || typeof record !== "object" || !("id" in record)) {
+        throw new Error(
+          `Record in collection '${collectionName}' is missing required 'id' field. Received: ${JSON.stringify(item)}`
+        );
+      }
+      return record.id;
+    },
+    onInsert: options?.onInsert === false ? void 0 : options?.onInsert ?? (async ({ transaction }) => {
+      const created = await Promise.all(
+        transaction.mutations.map(async (mutation) => {
+          const {
+            created: _created,
+            updated: _updated,
+            collectionId: _collectionId,
+            collectionName: _collectionName,
+            ...data
+          } = mutation.modified;
+          return pb.collection(collectionName).create(data);
+        })
+      );
+      writeBackAfterPersisted(transaction, created);
+      return { refetch: refetchOnMutation };
+    }),
+    onUpdate: options?.onUpdate === false ? void 0 : options?.onUpdate ?? (async ({ transaction }) => {
+      const updated = await Promise.all(
+        transaction.mutations.map(async (mutation) => {
+          const recordWithId = mutation.original;
+          return pb.collection(collectionName).update(recordWithId.id, mutation.changes);
+        })
+      );
+      writeBackAfterPersisted(transaction, updated);
+      return { refetch: refetchOnMutation };
+    }),
+    onDelete: options?.onDelete === false ? void 0 : options?.onDelete ?? (async ({ transaction }) => {
+      await Promise.all(
+        transaction.mutations.map(async (mutation) => {
+          const recordWithId = mutation.original;
+          await pb.collection(collectionName).delete(recordWithId.id);
+        })
+      );
+      return { refetch: refetchOnMutation };
+    })
+  });
+  const collectionOptions = options?.collectionOptions?.gcTime === void 0 ? queryCollectionConfig : { ...queryCollectionConfig, gcTime: options.collectionOptions.gcTime };
+  function writeBackAfterPersisted(transaction, records) {
+    markConfirmedPresent(records);
+    void transaction.isPersisted.promise.then(
+      () => {
+        if (!collection.utils || !collection.isReady()) return;
+        const fresh = records.filter((record) => !isStaleServerRecord(record));
+        if (fresh.length === 0) return;
+        writeOwn(() => collection.utils.writeUpsert(fresh));
+      },
+      // A rejected transaction rolled its draft back; there is
+      // nothing to write and nothing to report here.
+      () => void 0
+    );
+  }
+  let applyingOwnWrite = false;
+  function writeOwn(fn) {
+    applyingOwnWrite = true;
+    try {
+      fn();
+    } finally {
+      applyingOwnWrite = false;
+    }
+  }
+  function syncedWriteKey(op) {
+    if (op.type !== "insert" && op.type !== "update") return null;
+    if (typeof op.key === "string") return op.key;
+    const id = op.value?.id;
+    return typeof id === "string" ? id : null;
+  }
+  function shouldDropSyncedWrite(op) {
+    const key = syncedWriteKey(op);
+    if (key === null) return false;
+    if (!applyingOwnWrite && hasPendingOptimisticMutation(key) && collection._state.syncedData.has(key)) {
+      logger.debug("Dropping synced write for optimistically-pending row", {
+        collectionName,
+        id: key
+      });
+      return true;
+    }
+    if (isStaleServerRecord(op.value)) {
+      logger.debug("Dropping stale synced write", { collectionName, id: key });
+      return true;
+    }
+    return false;
+  }
+  let subscribingViewPaths;
+  function withViewExpand(opts) {
+    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,
+    sync: (params) => {
+      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 });
+      if (!res || typeof res === "function") return res;
+      const { loadSubset, unloadSubset } = res;
+      return {
+        ...res,
+        loadSubset: loadSubset ? (opts) => loadSubset(withViewExpand(opts)) : void 0,
+        unloadSubset: unloadSubset ? (opts) => unloadSubset(withViewExpand(opts)) : void 0
+      };
+    }
+  };
+  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);
+    Object.defineProperties(view, {
+      id: { value: `${collectionName}?expand=${paths.join(",")}` },
+      subscribeChanges: {
+        value: (...args) => {
+          noteViewSubscribed(paths);
+          subscribingViewPaths = paths;
+          try {
+            const subscription = collection.subscribeChanges(...args);
+            viewPaths.set(subscription, paths);
+            return subscription;
+          } finally {
+            subscribingViewPaths = void 0;
+          }
+        }
+      },
+      expand: {
+        value: () => {
+          throw new Error(`A view of "${collectionName}" cannot be expanded further`);
+        }
+      }
+    });
+    return view;
+  }
+  function expand(...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 key = all.join(",");
+    let view = views.get(key);
+    if (!view) {
+      view = createView(all);
+      views.set(key, view);
+    }
+    return view;
+  }
+  function hasPendingOptimisticMutation(key) {
+    const state = collection._state;
+    return state.optimisticUpserts.has(key) || state.optimisticDeletes.has(key);
+  }
+  function recordUpdatedAt(record) {
+    const updated = record?.updated;
+    return typeof updated === "string" && updated !== "" ? updated : void 0;
+  }
+  function isStaleServerRecord(record) {
+    const id = record?.id;
+    if (typeof id !== "string") return false;
+    const incoming = recordUpdatedAt(record);
+    if (!incoming) return false;
+    const current = recordUpdatedAt(
+      collection._state.syncedData.get(id)
+    );
+    if (current === void 0) return false;
+    return incoming < current;
+  }
+  function isStaleEcho(event) {
+    if (event.action !== "create" && event.action !== "update") return false;
+    if (!isStaleServerRecord(event.record)) return false;
+    logger.debug("Ignoring stale realtime echo", {
+      collectionName,
+      id: event.record?.id
+    });
+    return true;
+  }
+  let unsubscribeFn = null;
+  let isSubscribed = false;
+  let subscriptionPromise = null;
+  let subscriptionResolve = null;
+  let subscribedExpand;
+  let subscriptionWork = Promise.resolve();
+  function enqueueSubscriptionWork(fn) {
+    const run = subscriptionWork.then(fn, fn).catch((error) => {
+      logger.error("Subscription work failed", { collectionName, error });
+    });
+    subscriptionWork = run;
+    return run;
+  }
+  function markEchoPresence(event) {
+    if (event.action !== "delete") markConfirmedPresent([event.record]);
+  }
+  const handleRealtimeEvent = (event) => {
+    if (!collection.utils) return;
+    markEchoPresence(event);
+    if (isStaleEcho(event)) return;
+    try {
+      writeOwn(
+        () => collection.utils.writeBatch(() => {
+          switch (event.action) {
+            case "create":
+              collection.utils.writeInsert(event.record);
+              break;
+            case "update":
+              collection.utils.writeUpsert(event.record);
+              break;
+            case "delete":
+              if (event.record && "id" in event.record) {
+                collection.utils.writeDelete(event.record.id);
+              }
+              break;
+          }
+        })
+      );
+    } catch (error) {
+      if (error instanceof DeleteOperationItemNotFoundError) {
+        logger.debug("Ignoring delete echo for already-removed record", {
+          collectionName,
+          id: event.record?.id
+        });
+      } else {
+        throw error;
+      }
+    }
+    if (event.action !== "delete") {
+      upsertExpanded([event.record], relationTargets).catch(
+        (error) => logger.error("Failed to upsert expanded records from realtime echo", {
+          collectionName,
+          error
+        })
+      );
+    }
+    propagateRelatedChange(
+      collection,
+      event.action,
+      event.record,
+      /* @__PURE__ */ new Set()
+    );
+  };
+  function pendingSubscribeExpand() {
+    return joinPaths([...alwaysExpand, ...requestedExpand]);
+  }
+  function activeExpandTargets() {
+    const targets = /* @__PURE__ */ new Set();
+    for (const path of splitPaths(pendingSubscribeExpand())) {
+      let current = relationTargets;
+      for (const segment of path.split(".")) {
+        const target = current?.[segment];
+        if (!target) break;
+        targets.add(target);
+        current = target.relationTargets;
+      }
+    }
+    return targets;
+  }
+  const heldTargetSubscriptions = /* @__PURE__ */ new Map();
+  function releaseHeldTarget(target) {
+    const held = heldTargetSubscriptions.get(target);
+    if (!held) return;
+    heldTargetSubscriptions.delete(target);
+    try {
+      held.unsubscribe();
+    } catch (error) {
+      logger.error("Failed to release relation target subscription", {
+        collectionName,
+        error
+      });
+    }
+  }
+  function holdTarget(target) {
+    if (heldTargetSubscriptions.has(target) || !target.subscribeChanges) return;
+    try {
+      const held = target.subscribeChanges(() => {
+      }, { includeInitialState: false });
+      heldTargetSubscriptions.set(target, held);
+    } catch (error) {
+      logger.error("Failed to hold relation target subscription", { collectionName, error });
+    }
+  }
+  function syncHeldSubscriptions(desired) {
+    for (const target of [...heldTargetSubscriptions.keys()]) {
+      if (!desired.has(target)) releaseHeldTarget(target);
+    }
+    for (const target of desired) holdTarget(target);
+  }
+  function realtimeSubscribeOptions() {
+    const base = factoryOptions?.subscribeOptions?.();
+    const expand2 = joinPaths([
+      ...splitPaths(pendingSubscribeExpand()),
+      ...splitPaths(base?.expand)
+    ]);
+    return expand2 ? { ...base, expand: expand2 } : base;
+  }
+  const doStartSubscription = async () => {
+    if (isSubscribed) return;
+    if (!subscriptionPromise) {
+      subscriptionPromise = new Promise((resolve) => {
+        subscriptionResolve = resolve;
+      });
+    }
+    const pendingExpand = pendingSubscribeExpand();
+    try {
+      unsubscribeFn = await pb.collection(collectionName).subscribe("*", handleRealtimeEvent, realtimeSubscribeOptions());
+      isSubscribed = true;
+      subscribedExpand = pendingExpand;
+      syncHeldSubscriptions(activeExpandTargets());
+      logger.debug("Subscription started", { collectionName });
+      if (subscriptionResolve) {
+        subscriptionResolve();
+      }
+    } catch (error) {
+      logger.error("Failed to start subscription", { collectionName, error });
+    }
+    if (pendingSubscribeExpand() !== subscribedExpand) {
+      enqueueSubscriptionWork(doRestartSubscription).catch(() => {
+      });
+    }
+  };
+  const doStopSubscription = async (releaseTargets = true) => {
+    if (releaseTargets) syncHeldSubscriptions(/* @__PURE__ */ new Set());
+    if (!isSubscribed || !unsubscribeFn) return;
+    try {
+      await unsubscribeFn();
+      logger.debug("Subscription stopped", { collectionName });
+    } catch (error) {
+      logger.debug("Unsubscribe failed (expected if connection closed)", {
+        collectionName,
+        error
+      });
+    } finally {
+      unsubscribeFn = null;
+      isSubscribed = false;
+      subscribedExpand = void 0;
+      subscriptionPromise = null;
+      subscriptionResolve = null;
+    }
+  };
+  const doRestartSubscription = async () => {
+    if (!isSubscribed) return;
+    await doStopSubscription(false);
+    await doStartSubscription();
+  };
+  const startSubscription = () => enqueueSubscriptionWork(doStartSubscription);
+  const stopSubscription = () => enqueueSubscriptionWork(() => doStopSubscription());
+  const restartSubscription = () => enqueueSubscriptionWork(doRestartSubscription);
+  function noteViewSubscribed(paths) {
+    let grew = false;
+    for (const path of paths) {
+      if (requestedExpand.has(path)) continue;
+      requestedExpand.add(path);
+      grew = true;
+    }
+    if (!grew) return;
+    if (syncMode === "eager" && collection.status !== "idle" && collection.status !== "cleaned-up") {
+      void collection.utils.refetch().catch(
+        (error) => logger.error("Failed to refetch after widening expand", {
+          collectionName,
+          error
+        })
+      );
+    }
+    restartSubscription().catch(
+      (error) => logger.error("Failed to restart subscription with wider expand", {
+        collectionName,
+        error
+      })
+    );
+  }
+  const waitForSubscription = async (timeout = 5e3) => {
+    if (isSubscribed) return;
+    if (!subscriptionPromise) {
+      await new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (subscriptionPromise) {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 10);
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve();
+        }, timeout);
+      });
+    }
+    if (subscriptionPromise) {
+      await Promise.race([
+        subscriptionPromise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Subscription timeout")), timeout)
+        )
+      ]);
+    }
+  };
+  collection.on(
+    "subscribers:change",
+    (event) => {
+      const newCount = event.subscriberCount;
+      const previousCount = event.previousSubscriberCount;
+      if (newCount > 0 && previousCount === 0) {
+        startSubscription().catch(() => {
+        });
+      } else if (newCount === 0 && previousCount > 0) {
+        stopSubscription().catch(() => {
+        });
+      }
+    }
+  );
+  Object.assign(collection, {
+    collectionName,
+    relationTargets,
+    waitForSubscription,
+    isSubscribed: () => isSubscribed,
+    heldRelationTargetCount: () => heldTargetSubscriptions.size,
+    expand,
+    relationDependents,
+    applyRelatedChange
+  });
+  return collection;
+}
+
+// src/collection.ts
+function createCollection(pb, queryClient, factoryOptions) {
+  return (collectionName, options) => {
+    return buildCollection({
+      pb,
+      queryClient,
+      factoryOptions,
+      collectionName,
+      options
+    });
+  };
+}
+
+// src/util.ts
+function newRecordId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 15; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+export { createCollection, newRecordId, resetLogger, setLogger };
+//# sourceMappingURL=chunk-KMR6I4ZC.js.map
+//# sourceMappingURL=chunk-KMR6I4ZC.js.map