@foretag/tanstack-db-surrealdb 0.6.3 → 0.6.5

package/dist/index.js

@@ -192,6 +192,44 @@ var toNativeRecordIdLikeValue = (value) => {
   }
   return getNativeRecordId(canonical);
 };
+var preferRecordIdLikeIdentity = (value) => {
+  const canonical = asCanonicalRecordIdString(value);
+  if (!canonical) return normalizeRecordIdLikeValue(value);
+  if (value instanceof surrealdb.RecordId) {
+    recordIdIdentityPool.set(canonical, value);
+    return value;
+  }
+  if (isCrossRuntimeRecordIdObject(value)) {
+    recordIdIdentityPool.set(canonical, value);
+    return value;
+  }
+  const wrappedId = unwrapIdWrapper(value);
+  if (wrappedId instanceof surrealdb.RecordId) {
+    recordIdIdentityPool.set(canonical, wrappedId);
+    return wrappedId;
+  }
+  if (isCrossRuntimeRecordIdObject(wrappedId)) {
+    recordIdIdentityPool.set(canonical, wrappedId);
+    return wrappedId;
+  }
+  return internRecordIdIdentity(canonical);
+};
+var preferRecordIdLikeIdentityDeep = (value) => {
+  const preferred = preferRecordIdLikeIdentity(value);
+  if (Array.isArray(preferred)) {
+    return preferred.map(
+      (item) => preferRecordIdLikeIdentityDeep(item)
+    );
+  }
+  if (isPlainObject(preferred)) {
+    const out = {};
+    for (const [k, v] of Object.entries(preferred)) {
+      out[k] = preferRecordIdLikeIdentityDeep(v);
+    }
+    return out;
+  }
+  return preferred;
+};
 var normalizeRecordIdLikeValue = (value) => {
   if (value instanceof surrealdb.RecordId) {
     const canonical2 = asCanonicalRecordIdString(value);
@@ -718,6 +756,100 @@ var subsetCacheKey = (subset) => {
     return value;
   }) ?? "";
 };
+var isPlainObject2 = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+var normalizeSubsetValuesInPlace = (value, seen = /* @__PURE__ */ new WeakSet(), preferredByCanonical = /* @__PURE__ */ new Map()) => {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      normalizeSubsetValuesInPlace(entry, seen, preferredByCanonical);
+    }
+    return preferredByCanonical;
+  }
+  if (!value || typeof value !== "object") return preferredByCanonical;
+  if (seen.has(value)) return preferredByCanonical;
+  seen.add(value);
+  const obj = value;
+  if (obj.type === "val" && "value" in obj) {
+    const canonical = asCanonicalRecordIdString(obj.value);
+    if (canonical) {
+      const preferred = preferRecordIdLikeIdentity(obj.value);
+      obj.value = preferred;
+      preferredByCanonical.set(canonical, preferred);
+    } else {
+      obj.value = preferRecordIdLikeIdentityDeep(obj.value);
+    }
+  }
+  for (const child of Object.values(obj)) {
+    normalizeSubsetValuesInPlace(child, seen, preferredByCanonical);
+  }
+  return preferredByCanonical;
+};
+var primeRecordIdIdentityFromSubset = (subset) => {
+  if (!subset) return /* @__PURE__ */ new Map();
+  return normalizeSubsetValuesInPlace(subset);
+};
+var rebindRecordIdIdentityDeep = (value, preferredByCanonical) => {
+  const canonical = asCanonicalRecordIdString(value);
+  if (canonical && preferredByCanonical.has(canonical)) {
+    const preferred = preferredByCanonical.get(canonical);
+    return {
+      value: preferred,
+      changed: value !== preferred
+    };
+  }
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const out2 = value.map((entry) => {
+      const rebound = rebindRecordIdIdentityDeep(
+        entry,
+        preferredByCanonical
+      );
+      changed2 = changed2 || rebound.changed;
+      return rebound.value;
+    });
+    return changed2 ? { value: out2, changed: true } : { value, changed: false };
+  }
+  if (!isPlainObject2(value)) return { value, changed: false };
+  let changed = false;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const rebound = rebindRecordIdIdentityDeep(entry, preferredByCanonical);
+    if (rebound.changed) changed = true;
+    out[key] = rebound.value;
+  }
+  return changed ? { value: out, changed: true } : { value, changed: false };
+};
+var applyPreferredRecordIdIdentityToCollection = (ctx, preferredByCanonical) => {
+  if (!preferredByCanonical.size) return;
+  const collection = ctx.collection;
+  if (!collection || typeof collection.entries !== "function") return;
+  const rebound = [];
+  for (const [, row] of collection.entries()) {
+    const updated = rebindRecordIdIdentityDeep(row, preferredByCanonical);
+    if (!updated.changed) continue;
+    rebound.push(updated.value);
+  }
+  if (!rebound.length) return;
+  ctx.begin();
+  try {
+    for (const row of rebound) {
+      ctx.write({
+        type: "delete",
+        value: { id: row.id }
+      });
+      ctx.write({ type: "insert", value: row });
+    }
+  } finally {
+    ctx.commit();
+  }
+  const collectionWithInternals = collection;
+  const entries = collectionWithInternals._state?.entries?.();
+  const indexes = collectionWithInternals._indexes?.indexes;
+  if (entries && indexes) {
+    for (const index of indexes.values()) {
+      index.build?.(entries);
+    }
+  }
+};
 function modernSurrealCollectionOptions(config) {
   const {
     db,
@@ -735,7 +867,8 @@ function modernSurrealCollectionOptions(config) {
   const syncMode = syncModeFrom(inputSyncMode);
   const isOnDemandLike = syncMode === "on-demand" || syncMode === "progressive";
   const isStrictOnDemand = syncMode === "on-demand";
-  const queryDrivenSyncMode = isOnDemandLike ? "on-demand" : "eager";
+  const queryDrivenSyncMode = "on-demand";
+  const queryDrivenUsesSubsets = queryDrivenSyncMode === "on-demand";
   const tableOptions = toTableOptions(table);
   const tableName = tableOptions.name;
   const tableResource = toTableResource(table);
@@ -1028,7 +1161,8 @@ function modernSurrealCollectionOptions(config) {
       };
     };
     const loadSubset = async (subset) => {
-      if (!isOnDemandLike) return;
+      const preferredFromSubset = primeRecordIdIdentityFromSubset(subset);
+      applyPreferredRecordIdIdentityToCollection(ctx, preferredFromSubset);
       const key = subsetCacheKey(subset);
       const rows = await tableAccess.loadSubset(subset);
       const ids = new Set(
@@ -1061,7 +1195,7 @@ function modernSurrealCollectionOptions(config) {
       await ensureUpdateLive();
     };
     const unloadSubset = (subset) => {
-      if (!isOnDemandLike) return;
+      primeRecordIdIdentityFromSubset(subset);
       const key = subsetCacheKey(subset);
       subsetIds.delete(key);
       updateActiveOnDemandIds();
@@ -1099,21 +1233,12 @@ function modernSurrealCollectionOptions(config) {
     syncMode: queryDrivenSyncMode,
     queryFn: async ({ meta }) => {
       try {
-        if (isOnDemandLike && !meta?.loadSubsetOptions) {
+        primeRecordIdIdentityFromSubset(meta?.loadSubsetOptions);
+        if (queryDrivenUsesSubsets && !meta?.loadSubsetOptions) {
           return [];
         }
         if (!crdtEnabled) {
-          if (!isOnDemandLike) {
-            const rows2 = await toRecordArray(
-              await db.select(tableResource)
-            );
-            const decoded2 = await Promise.all(
-              rows2.map(
-                (row) => decodeBaseRow(row)
-              )
-            );
-            return decoded2;
-          }
+          if (!queryDrivenUsesSubsets) ;
           const rows = await tableAccess.loadSubset(
             meta?.loadSubsetOptions
           );
@@ -1124,7 +1249,7 @@ function modernSurrealCollectionOptions(config) {
           );
           return decoded;
         }
-        if (isOnDemandLike) return [];
+        if (queryDrivenUsesSubsets) return [];
         if (!updatesTableName) return [];
         const updates = await queryRows(
           db,