@osdk/client 2.2.0-beta.3 → 2.2.0-beta.4

package/build/cjs/public/unstable-do-not-use.cjs

@@ -4,8 +4,8 @@ var chunkX7WGNFZ4_cjs = require('../chunk-X7WGNFZ4.cjs');
 require('../chunk-Q7SFCCGT.cjs');
 var rxjs = require('rxjs');
 var invariant2 = require('tiny-invariant');
-var trie = require('@wry/trie');
 var mnemonist = require('mnemonist');
+var trie = require('@wry/trie');
 var deepEqual = require('fast-deep-equal');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -22,8 +22,8 @@ var ObservableClientImpl = class {
   observeObject(apiName, pk, options, subFn) {
     return this.#store.observeObject(apiName, pk, options, subFn);
   }
-  observeList(apiName, where, options, subFn) {
-    return this.#store.observeList(apiName, where, options, subFn);
+  observeList(options, subFn) {
+    return this.#store.observeList(options, subFn);
   }
   applyAction(action, args, opts) {
     return this.#store.applyAction(action, args, opts);
@@ -33,6 +33,10 @@ var ObservableClientImpl = class {
   }
 };
 
+// src/observable/DebugFlags.ts
+process.env.NODE_ENV !== "production" && false;
+var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
+
 // ../../node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
 function isNodeProcess() {
   if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
@@ -86,9 +90,200 @@ async function delay(durationOrMode) {
   return new Promise((resolve) => setTimeout(resolve, delayTime));
 }
 
-// src/observable/DebugFlags.ts
-process.env.NODE_ENV !== "production" && false;
-var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
+// src/observable/internal/CacheKey.ts
+function DEBUG_ONLY__cacheKeyToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return `${x.type}CacheKey<${x.otherKeys.map((xx) => JSON.stringify(xx)).join(", ")}>`.replaceAll('"', "'");
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function DEBUG_ONLY__cacheKeysToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return JSON.stringify(x.map(DEBUG_ONLY__cacheKeyToString), null, 2);
+  } else {
+    throw new Error("not implemented");
+  }
+}
+
+// src/observable/internal/ChangedObjects.ts
+function createChangedObjects() {
+  return {
+    modifiedObjects: new mnemonist.MultiMap(),
+    addedObjects: new mnemonist.MultiMap(),
+    addedLists: /* @__PURE__ */ new Set(),
+    modifiedLists: /* @__PURE__ */ new Set()
+  };
+}
+function DEBUG_ONLY__changesToString(changes) {
+  if (process.env.NODE_ENV !== "production") {
+    return JSON.stringify({
+      modifiedObjects: multimapHelper(changes.modifiedObjects),
+      addedObjects: multimapHelper(changes.addedObjects),
+      addedLists: listHelper(changes.addedLists),
+      modifiedLists: listHelper(changes.modifiedLists)
+    }, null, 2);
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function listHelper(set) {
+  return Array.from(set).map(DEBUG_ONLY__cacheKeyToString);
+}
+function multimapHelper(multimap) {
+  return Object.fromEntries(Array.from(multimap.associations()).map(([type, objects]) => {
+    return [type, objects.map((o) => o.$primaryKey)];
+  }));
+}
+
+// src/observable/internal/OptimisticId.ts
+function createOptimisticId() {
+  if (process.env.NODE_ENV !== "production") {
+    if (createOptimisticId.counter === undefined) {
+      createOptimisticId.counter = 0;
+    }
+    return {
+      __optimisticId: createOptimisticId.counter++
+    };
+  }
+  return /* @__PURE__ */ Object.create(null);
+}
+
+// src/observable/internal/OptimisticJob.ts
+var OptimisticJob = class {
+  #result;
+  constructor(store, optimisticId) {
+    const updatedObjects = [];
+    const addedObjectPromises = [];
+    this.getResult = () => {
+      return this.#result ??= (async () => {
+        const addedObjects = await Promise.allSettled(addedObjectPromises);
+        const {
+          batchResult
+        } = store.batch({
+          optimisticId
+        }, (batch) => {
+          for (const obj of addedObjects) {
+            if (obj.status === "fulfilled") {
+              store.getObjectQuery(obj.value.$objectType, obj.value.$primaryKey).writeToStore(obj.value, "loading", batch);
+            } else {
+              throw obj;
+            }
+          }
+          for (const obj of updatedObjects) {
+            store.getObjectQuery(obj.$objectType, obj.$primaryKey).writeToStore(obj, "loading", batch);
+          }
+        });
+        return batchResult.changes;
+      })();
+    };
+    this.context = {
+      updateObject(value) {
+        updatedObjects.push(value);
+        return this;
+      },
+      createObject(type, pk, properties) {
+        const create = store.client[chunkX7WGNFZ4_cjs.additionalContext].objectFactory2(store.client[chunkX7WGNFZ4_cjs.additionalContext], [{
+          $primaryKey: pk,
+          $apiName: type.apiName,
+          $objectType: type.apiName,
+          ...properties
+        }], undefined).then((objs) => {
+          return objs[0];
+        });
+        addedObjectPromises.push(create);
+        return this;
+      }
+    };
+  }
+};
+function runOptimisticJob(store, optimisticUpdate) {
+  if (!optimisticUpdate) {
+    return () => Promise.resolve();
+  }
+  const optimisticId = createOptimisticId();
+  const job = new OptimisticJob(store, optimisticId);
+  optimisticUpdate(job.context);
+  const optimisticApplicationDone = job.getResult();
+  return () => {
+    return optimisticApplicationDone.then(
+      // we don't want to leak the result
+      () => undefined
+    ).finally(() => {
+      store.removeLayer(optimisticId);
+    });
+  };
+}
+
+// src/observable/internal/ActionApplication.ts
+var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
+var ActionApplication = class {
+  constructor(store) {
+    this.store = store;
+  }
+  applyAction = (action, args, {
+    optimisticUpdate
+  } = {}) => {
+    const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
+    return (async () => {
+      try {
+        const actionResults = await this.store.client(action).applyAction(args, {
+          $returnEdits: true
+        });
+        if (ACTION_DELAY > 0) {
+          console.log("action done, pausing");
+          await delay(ACTION_DELAY);
+          console.log("action done, pausing done");
+        }
+        await this.#invalidateActionEditResponse(actionResults);
+        return actionResults;
+      } finally {
+        if (process.env.NODE_ENV !== "production") {
+          this.store.logger?.debug("optimistic action complete; remove the results");
+        }
+        await removeOptimisticResult();
+      }
+    })();
+  };
+  #invalidateActionEditResponse = async (value) => {
+    const typesToInvalidate = /* @__PURE__ */ new Set();
+    let changes;
+    if (value.type === "edits") {
+      const promisesToWait = [];
+      for (const obj of value.modifiedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+      }
+      for (const obj of value.addedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+        typesToInvalidate.add(obj.objectType);
+      }
+      await Promise.all(promisesToWait);
+      changes = this.#changesFromActionEditResponse(value);
+      await this.store.maybeRevalidateLists(changes);
+    } else {
+      for (const apiName of value.editedObjectTypes) {
+        typesToInvalidate.add(apiName.toString());
+        await this.store.invalidateObjectType(apiName, changes);
+      }
+    }
+    return value;
+  };
+  #changesFromActionEditResponse = (value) => {
+    const changes = createChangedObjects();
+    for (const changeType of ["addedObjects", "modifiedObjects"]) {
+      for (const {
+        objectType,
+        primaryKey
+      } of value[changeType] ?? []) {
+        const obj = this.store.getObject(objectType, primaryKey);
+        if (obj) {
+          changes[changeType].set(objectType, obj);
+        }
+      }
+    }
+    return changes;
+  };
+};
 var CacheKeys = class {
   #cacheKeys = new trie.Trie(false, (keys) => {
     const ret = {
@@ -100,15 +295,15 @@ var CacheKeys = class {
   });
   #cacheKeyFactories = /* @__PURE__ */ new Map();
   #onCreate;
-  constructor(whereCanonicalizer, onCreate) {
+  constructor(whereCanonicalizer, orderByCanonicalizer, onCreate) {
     this.#onCreate = onCreate;
     this.#registerCacheKeyFactory("object", (apiName, pk) => {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
       return this.#cacheKeys.lookupArray(["object", apiName, pk]);
     });
-    this.#registerCacheKeyFactory("list", (apiName, where) => {
+    this.#registerCacheKeyFactory("list", (apiName, where, orderBy) => {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
-      return this.#cacheKeys.lookupArray(["list", apiName, whereCanonicalizer.canonicalize(where)]);
+      return this.#cacheKeys.lookupArray(["list", apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
     });
   }
   #registerCacheKeyFactory(type, factory) {
@@ -123,12 +318,6 @@ var CacheKeys = class {
     this.#cacheKeys.remove(cacheKey.type, ...cacheKey.otherKeys);
   }
 };
-function createChangedObjects() {
-  return {
-    modifiedObjects: new mnemonist.MultiMap(),
-    addedObjects: new mnemonist.MultiMap()
-  };
-}
 
 // src/observable/internal/WeakMapWithEntries.ts
 var WeakMapWithEntries = class {
@@ -262,7 +451,7 @@ var Layer = class _Layer {
       this.#parent = this.#parent.removeLayer(layerId);
       return this;
     }
-    return this.#parent ?? this;
+    return this.#parent.removeLayer(layerId);
   }
   entries() {
     return this.#cache.entries();
@@ -275,11 +464,11 @@ var Layer = class _Layer {
   }
 };
 var Entry = class {
-  constructor(cacheKey, value, lastUpdated) {
+  constructor(cacheKey, value, lastUpdated, status = "init") {
     this.cacheKey = cacheKey;
     this.value = value;
     this.lastUpdated = lastUpdated;
-    this.status = "init";
+    this.status = status;
   }
 };
 function is$and(whereClause) {
@@ -374,11 +563,15 @@ var Query = class {
   #connectable;
   #subscription;
   #subject;
-  constructor(store, observable, opts, cacheKey) {
+  /** @internal */
+  constructor(store, observable, opts, cacheKey, logger) {
     this.options = opts;
     this.cacheKey = cacheKey;
     this.store = store;
     this.#subject = observable;
+    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkX7WGNFZ4_cjs.additionalContext].logger : store.client[chunkX7WGNFZ4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
+    }));
   }
   subscribe(observer) {
     this.#connectable ??= this._createConnectable(this.#subject);
@@ -386,6 +579,11 @@ var Query = class {
     return this.#connectable.subscribe(observer);
   }
   revalidate(force) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "revalidate"
+      });
+    }
     if (force) {
       this.abortController?.abort();
     }
@@ -393,6 +591,11 @@ var Query = class {
       return this.pendingFetch;
     }
     if ((this.options.dedupeInterval ?? 0) > 0 && this.lastFetchStarted != null && Date.now() - this.lastFetchStarted < (this.options.dedupeInterval ?? 0)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.trace({
+          methodName: "revalidate"
+        }, "DEDUPE");
+      }
       return Promise.resolve();
     }
     this.store.batch({}, (batch) => {
@@ -400,14 +603,37 @@ var Query = class {
     });
     this._preFetch();
     this.lastFetchStarted = Date.now();
-    this.pendingFetch = this._fetch().finally(() => {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "revalidate"
+      }, "calling _fetch()");
+    }
+    this.pendingFetch = this._fetch().catch((e) => {
+      this.logger?.error({
+        methodName: "revalidate"
+      }, "_fetch() FAILED", e);
+      throw e;
+    }).finally(() => {
+      this.logger?.info({
+        methodName: "revalidate"
+      }, "finally _fetch()");
       this.pendingFetch = undefined;
     });
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "revalidate"
+      }, "Returning");
+    }
     return this.pendingFetch;
   }
   _preFetch() {
   }
   setStatus(status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "setStatus"
+      }, status);
+    }
     const existing = batch.read(this.cacheKey);
     if (existing?.status === status) return;
     batch.write(this.cacheKey, existing?.value, status);
@@ -424,7 +650,6 @@ var Query = class {
 };
 
 // src/observable/internal/ListQuery.ts
-rxjs.auditTime(0);
 var ListQuery = class extends Query {
   // pageSize?: number; // this is the internal page size. we need to track this properly
   #client;
@@ -435,16 +660,23 @@ var ListQuery = class extends Query {
   #nextPageToken;
   #pendingPageFetch;
   #toRelease = /* @__PURE__ */ new Set();
-  constructor(store, subject, type, whereClause, cacheKey, opts) {
-    super(store, subject, opts, cacheKey);
+  #orderBy;
+  constructor(store, subject, objectType, whereClause, orderBy, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkX7WGNFZ4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : undefined);
     this.#client = store.client;
-    this.#type = type;
+    this.#type = objectType;
     this.#whereClause = whereClause;
+    this.#orderBy = orderBy;
     rxjs.observeOn(rxjs.asyncScheduler);
   }
+  get canonicalWhere() {
+    return this.#whereClause;
+  }
   _createConnectable(subject) {
     return rxjs.connectable(subject.pipe(
-      rxjs.mergeMap((listEntry) => {
+      rxjs.switchMap((listEntry) => {
         return rxjs.combineLatest({
           resolvedList: listEntry?.value?.data == null ? rxjs.of([]) : rxjs.combineLatest(listEntry.value.data.map((cacheKey) => this.store.getSubject(cacheKey).pipe(rxjs.map((objectEntry) => objectEntry?.value)))),
           isOptimistic: rxjs.of(listEntry.isOptimistic),
@@ -518,7 +750,12 @@ var ListQuery = class extends Query {
       nextPageToken
     } = await objectSet.fetchPage({
       $nextPageToken: this.#nextPageToken,
-      $pageSize: this.options.pageSize
+      $pageSize: this.options.pageSize,
+      // For now this keeps the shared test code from falling apart
+      // but shouldn't be needed ideally
+      ...Object.keys(this.#orderBy).length > 0 ? {
+        $orderBy: this.#orderBy
+      } : {}
     });
     if (signal?.aborted) {
       return;
@@ -527,70 +764,121 @@ var ListQuery = class extends Query {
     const {
       retVal
     } = this.store.batch({}, (batch) => {
-      return this.updateList(data, append, nextPageToken ? status : "loaded", batch);
+      return this.updateList(this.store.updateObjects(data, batch), append, nextPageToken ? status : "loaded", batch);
     });
     return retVal;
   }
   /**
-   * Caller is responsible for removing the layer
-   *
-   * @param changedObjects
+   * Note: This method is not async because I want it to return right after it
+   *       finishes the synchronous updates. The promise that is returned
+   *       will resolve after the revalidation is complete.
+   * @param changes
    * @param optimisticId
-   * @returns
+   * @returns If revalidation is needed, a promise that resolves after the
+   *          revalidation is complete. Otherwise, undefined.
    */
-  maybeUpdate(changedObjects, optimisticId) {
-    let needsRevalidation = false;
-    const objectsToInsert = [];
-    for (const [type, objects] of changedObjects.addedObjects.associations()) {
-      if (this.cacheKey.otherKeys[0] !== type) {
-        continue;
+  maybeUpdateAndRevalidate = (changes, optimisticId) => {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "#maybeMaybe"
+      }, DEBUG_ONLY__changesToString(changes));
+    }
+    if (changes.modifiedLists.has(this.cacheKey)) return;
+    try {
+      const relevantObjects = {
+        added: {
+          all: changes.addedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
+          strictMatches: /* @__PURE__ */ new Set(),
+          sortaMatches: /* @__PURE__ */ new Set()
+        },
+        modified: {
+          all: changes.modifiedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
+          strictMatches: /* @__PURE__ */ new Set(),
+          sortaMatches: /* @__PURE__ */ new Set()
+        }
+      };
+      if (relevantObjects.added.all.length === 0 && relevantObjects.modified.all.length === 0) {
+        return;
       }
-      for (const obj of objects) {
-        const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
-        if (strictMatch) {
-          objectsToInsert.push(obj);
-        } else {
-          const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
-          if (sortaMatch) {
-            needsRevalidation = true;
+      for (const group of Object.values(relevantObjects)) {
+        for (const obj of group.all ?? []) {
+          const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
+          if (strictMatch) {
+            group.strictMatches.add(obj);
+          } else {
+            const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
+            if (sortaMatch) {
+              group.sortaMatches.add(obj);
+            }
           }
         }
       }
-    }
-    needsRevalidation ||= objectsToInsert.length > 0;
-    if (objectsToInsert.length > 0) {
+      const status = optimisticId || relevantObjects.added.sortaMatches.size > 0 || relevantObjects.modified.sortaMatches.size > 0 ? "loading" : "loaded";
+      changes.modifiedLists.add(this.cacheKey);
+      const newList = [];
+      let needsRevalidation = false;
       this.store.batch({
-        optimisticId
+        optimisticId,
+        changes
       }, (batch) => {
-        this.updateList(objectsToInsert, true, "loading", batch);
+        const curValue = batch.read(this.cacheKey);
+        const existingList = new Set(curValue?.value?.data);
+        const toAdd = new Set(
+          // easy case. objects are new to the cache and they match this filter
+          relevantObjects.added.strictMatches
+        );
+        const toRemove = /* @__PURE__ */ new Set();
+        for (const obj of relevantObjects.modified.all) {
+          if (relevantObjects.modified.strictMatches.has(obj)) {
+            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
+            if (!existingList.has(existingObjectCacheKey)) {
+              toAdd.add(obj);
+            }
+            continue;
+          } else if (batch.optimisticWrite) {
+            continue;
+          } else {
+            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
+            toRemove.add(existingObjectCacheKey);
+            if (relevantObjects.modified.sortaMatches.has(obj)) {
+              needsRevalidation = true;
+            }
+          }
+        }
+        for (const key of existingList) {
+          if (toRemove.has(key)) continue;
+          newList.push(key);
+        }
+        for (const obj of toAdd) {
+          newList.push(this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey));
+        }
+        this.updateList(
+          newList,
+          /* append */
+          false,
+          status,
+          batch
+        );
       });
-    }
-    return needsRevalidation;
-  }
-  maybeRevalidate(changedObjects) {
-    let needsRevalidation = false;
-    for (const [type, objects] of changedObjects.addedObjects.associations()) {
-      if (this.cacheKey.otherKeys[0] !== type) {
-        continue;
+      if (needsRevalidation) {
+        changes.modifiedLists.add(this.cacheKey);
+        return this.revalidate(true).then(() => void 0);
       }
-      for (const obj of objects) {
-        const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
-        if (sortaMatch) {
-          needsRevalidation = true;
-        }
+      return void 0;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.trace({
+          methodName: "#maybeMaybe"
+        }, "in finally");
       }
     }
-    if (needsRevalidation) {
-      return this.revalidate(true);
+  };
+  updateList(objectCacheKeys, append, status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "updateList"
+      }, `{status: ${status}}`, JSON.stringify(objectCacheKeys, null, 2));
     }
-    return Promise.resolve();
-  }
-  updateList(values, append, status, batch) {
-    let objectCacheKeys = values.map((v) => {
-      if (v instanceof Entry) return v.cacheKey;
-      this.store.getObjectQuery(this.#type, v.$primaryKey).writeToStore(v, "loaded", batch);
-      return this.store.getCacheKey("object", v.$apiName, v.$primaryKey);
-    });
     const existingList = batch.read(this.cacheKey);
     if (!batch.optimisticWrite) {
       if (!append) {
@@ -607,17 +895,67 @@ var ListQuery = class extends Query {
     if (append) {
       objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
     }
+    if (Object.keys(this.#orderBy).length > 0) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.info({
+          methodName: "updateList"
+        }, "Sorting entries");
+        this.logger?.trace({
+          methodName: "updateList"
+        }, DEBUG_ONLY__cacheKeysToString(objectCacheKeys));
+      }
+      const sortFns = Object.entries(this.#orderBy).map(([key, order]) => {
+        return (a, b) => {
+          const aValue = a?.[key];
+          const bValue = b?.[key];
+          if (aValue == null && bValue == null) {
+            return 0;
+          }
+          if (aValue == null) {
+            return 1;
+          }
+          if (bValue == null) {
+            return -1;
+          }
+          const m = order === "asc" ? -1 : 1;
+          return aValue < bValue ? m : aValue > bValue ? -m : 0;
+        };
+      });
+      objectCacheKeys = objectCacheKeys.sort((a, b) => {
+        for (const sortFn of sortFns) {
+          const ret = sortFn(batch.read(a)?.value, batch.read(b)?.value);
+          if (ret !== 0) {
+            return ret;
+          }
+        }
+        return 0;
+      });
+    }
+    const visited = /* @__PURE__ */ new Set();
+    objectCacheKeys = objectCacheKeys.filter((key) => {
+      batch.read(key);
+      if (visited.has(key)) {
+        return false;
+      }
+      visited.add(key);
+      return true;
+    });
     return this.writeToStore({
       data: objectCacheKeys
     }, status, batch);
   }
   writeToStore(data, status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "writeToStore"
+      }, `{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
+    }
     const entry = batch.read(this.cacheKey);
     if (entry && deepEqual__default.default(data, entry.value)) {
       return batch.write(this.cacheKey, entry.value, status);
     }
     const ret = batch.write(this.cacheKey, data, status);
-    batch.modifiedLists.add(this.cacheKey);
+    batch.changes.modifiedLists.add(this.cacheKey);
     return ret;
   }
   _dispose() {
@@ -639,7 +977,9 @@ var ObjectQuery = class extends Query {
   #apiName;
   #pk;
   constructor(store, subject, type, pk, cacheKey, opts) {
-    super(store, subject, opts, cacheKey);
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkX7WGNFZ4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : undefined);
     this.#apiName = type;
     this.#pk = pk;
   }
@@ -661,6 +1001,11 @@ var ObjectQuery = class extends Query {
     });
   }
   async _fetch() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "_fetch"
+      });
+    }
     const objectSet = this.store.client({
       type: "object",
       apiName: this.#apiName
@@ -671,103 +1016,25 @@ var ObjectQuery = class extends Query {
     });
   }
   writeToStore(data, status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "writeToStore"
+      }, `{status: ${status}},`, data);
+    }
     const entry = batch.read(this.cacheKey);
     if (entry && deepEqual__default.default(data, entry.value)) {
       return batch.write(this.cacheKey, entry.value, status);
     }
     const ret = batch.write(this.cacheKey, data, status);
     if (entry) {
-      batch.modifiedObjects.add(this.cacheKey);
+      batch.changes.modifiedObjects.set(data.$apiName, data);
     } else {
-      batch.addedObjects.add(this.cacheKey);
+      batch.changes.addedObjects.set(data.$apiName, data);
     }
     return ret;
   }
 };
 
-// src/observable/internal/OptimisticId.ts
-function createOptimisticId() {
-  if (process.env.NODE_ENV !== "production") {
-    if (createOptimisticId.counter === undefined) {
-      createOptimisticId.counter = 0;
-    }
-    return {
-      __optimisticId: createOptimisticId.counter++
-    };
-  }
-  return /* @__PURE__ */ Object.create(null);
-}
-
-// src/observable/internal/OptimisticJob.ts
-var OptimisticJob = class {
-  #result;
-  constructor(store, optimisticId) {
-    const updatedObjects = [];
-    const addedObjects = [];
-    this.getResult = () => {
-      return this.#result ??= (async () => {
-        const changes = {
-          addedObjects: new mnemonist.MultiMap(),
-          modifiedObjects: new mnemonist.MultiMap()
-        };
-        const settled = await Promise.allSettled(addedObjects);
-        for (const added of settled) {
-          if (added.status === "fulfilled") {
-            changes.addedObjects.set(added.value.$objectType, added.value);
-          } else {
-            throw added;
-          }
-        }
-        for (const modified of updatedObjects) {
-          changes.modifiedObjects.set(modified.$apiName, modified);
-        }
-        store.batch({
-          optimisticId
-        }, (batch) => {
-          for (const a of ["addedObjects", "modifiedObjects"]) {
-            for (const b of changes[a].values()) {
-              store.getObjectQuery(b.$objectType, b.$primaryKey).writeToStore(b, "loading", batch);
-            }
-          }
-        });
-        return changes;
-      })();
-    };
-    this.context = {
-      updateObject(value) {
-        updatedObjects.push(value);
-        return this;
-      },
-      createObject(type, pk, properties) {
-        const create = store.client[chunkX7WGNFZ4_cjs.additionalContext].objectFactory2(store.client[chunkX7WGNFZ4_cjs.additionalContext], [{
-          $primaryKey: pk,
-          $apiName: type.apiName,
-          $objectType: type.apiName,
-          ...properties
-        }], undefined).then((x) => x[0]);
-        addedObjects.push(create);
-        return this;
-      }
-    };
-  }
-};
-function runOptimisticJob(store, optimisticUpdate) {
-  if (!optimisticUpdate) {
-    return () => Promise.resolve();
-  }
-  const optimisticId = createOptimisticId();
-  const job = new OptimisticJob(store, optimisticId);
-  optimisticUpdate(job.context);
-  const optimisticApplicationDone = job.getResult().then((result) => {
-    store.maybeUpdateLists(result, optimisticId);
-  });
-  return () => {
-    return optimisticApplicationDone.finally(() => {
-      store.removeLayer(optimisticId);
-    });
-  };
-}
-
 // src/observable/internal/RefCounts.ts
 var RefCounts = class {
   refCounts = /* @__PURE__ */ new Map();
@@ -871,7 +1138,6 @@ var WhereClauseCanonicalizer = class {
 };
 
 // src/observable/internal/Store.ts
-var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
 function createInitEntry(cacheKey) {
   return {
     cacheKey,
@@ -880,19 +1146,36 @@ function createInitEntry(cacheKey) {
     lastUpdated: 0
   };
 }
+var OrderByCanonicalizer = class {
+  // crappy version
+  #map = /* @__PURE__ */ new Map();
+  canonicalize = (orderBy) => {
+    if (this.#map.has(JSON.stringify(orderBy))) {
+      return this.#map.get(JSON.stringify(orderBy));
+    } else {
+      this.#map.set(JSON.stringify(orderBy), orderBy);
+      return orderBy;
+    }
+  };
+};
 var Store = class {
   whereCanonicalizer = new WhereClauseCanonicalizer();
+  orderByCanonicalizer = new OrderByCanonicalizer();
   #truthLayer = new Layer(undefined, undefined);
   #topLayer;
-  #queries = /* @__PURE__ */ new WeakMap();
+  /** @internal */
+  #queries = new WeakMapWithEntries();
   #cacheKeyToSubject = /* @__PURE__ */ new WeakMap();
   #cacheKeys;
   #refCounts = new RefCounts(6e4, (k) => this.#cleanupCacheKey(k));
   #finalizationRegistry;
   constructor(client) {
     this.client = client;
+    this.logger = client[chunkX7WGNFZ4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: "Store"
+    });
     this.#topLayer = this.#truthLayer;
-    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, (k) => {
+    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, this.orderByCanonicalizer, (k) => {
       this.#refCounts.register(k);
     });
     setInterval(() => {
@@ -977,7 +1260,13 @@ var Store = class {
     const query = this.getObjectQuery(apiName, pk);
     this.#refCounts.retain(query.cacheKey);
     if (options.mode !== "offline") {
-      void query.revalidate(options.mode === "force");
+      query.revalidate(options.mode === "force").catch((e) => {
+        if (this.logger) {
+          this.logger.error("Unhandled error in observeObject", e);
+        } else {
+          throw e;
+        }
+      });
     }
     const sub = query.subscribe({
       next: subFn
@@ -989,11 +1278,8 @@ var Store = class {
       }
     };
   }
-  observeList(apiName, where, options, subFn) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const query = this.getListQuery(apiName, where, options);
+  observeList(options, subFn) {
+    const query = this.getListQuery(options.objectType, options.where ?? {}, options.orderBy ?? {}, options);
     this.#refCounts.retain(query.cacheKey);
     if (options.mode !== "offline") {
       void query.revalidate(options.mode === "force");
@@ -1001,6 +1287,99 @@ var Store = class {
     const sub = query.subscribe({
       next: subFn
     });
+    if (options.streamUpdates) {
+      const miniDef = {
+        type: "object",
+        apiName: typeof options.objectType === "string" ? options.objectType : options.objectType.apiName
+      };
+      let objectSet = this.client(miniDef);
+      if (options.where) {
+        objectSet = objectSet.where(options.where ?? {});
+      }
+      const store = this;
+      const websocketSubscription = objectSet.subscribe({
+        onChange({
+          object,
+          state
+        }) {
+          if (process.env.NODE_ENV !== "production") {
+            store.logger?.debug({
+              methodName: "onError"
+            }, "updates", state, object);
+          }
+          const cacheKey = store.getCacheKey("object", object.$objectType, object.$primaryKey);
+          const type = store.#peekQuery(cacheKey) == null ? "addedObjects" : "modifiedObjects";
+          const changes = createChangedObjects();
+          changes[type].set(object.$objectType, object);
+          if (state === "ADDED_OR_UPDATED") {
+            store.updateObject(object.$objectType, object);
+            store.maybeRevalidateLists(changes).catch((err) => {
+              console.error("Unhandled error in maybeRevalidateLists", err);
+            });
+          } else if (state === "REMOVED") {
+            const changes2 = createChangedObjects();
+            store.batch({
+              changes: changes2
+            }, (batch) => {
+              const existing = batch.read(query.cacheKey);
+              const cacheKeyToRemove = store.getCacheKey("object", object.$objectType, object.$primaryKey);
+              if (existing?.status === "loaded") {
+                const newObjects = existing.value?.data.filter((o) => o !== cacheKeyToRemove);
+                if (newObjects?.length !== existing.value?.data.length) {
+                  batch.changes.modifiedLists.add(query.cacheKey);
+                  batch.write(query.cacheKey, {
+                    data: newObjects ?? []
+                  }, "loaded");
+                }
+              } else {
+                if (process.env.NODE_ENV !== "production") {
+                  store.logger?.info("Removing an object from an object list that is in the middle of being loaded.", existing);
+                }
+                query.revalidate(
+                  /* force */
+                  true
+                ).catch((e) => {
+                  if (store.logger) {
+                    store.logger?.error("Uncaught error while revalidating list", e);
+                  } else {
+                    console.error("Uncaught error while revalidating list", e);
+                  }
+                });
+              }
+            });
+          }
+        },
+        onError(errors) {
+          if (process.env.NODE_ENV !== "production") {
+            store.logger?.info({
+              methodName: "onError"
+            }, "subscription errors", errors);
+          }
+        },
+        onOutOfDate() {
+          if (process.env.NODE_ENV !== "production") {
+            store.logger?.info({
+              methodName: "onOutOfDate"
+            });
+          }
+        },
+        onSuccessfulSubscription() {
+          if (process.env.NODE_ENV !== "production") {
+            store.logger?.info({
+              methodName: "onSuccessfulSubscription"
+            });
+          }
+        }
+      });
+      sub.add(() => {
+        if (process.env.NODE_ENV !== "production") {
+          store.logger?.info({
+            methodName: "observeList"
+          }, "Unsubscribing from websocket");
+        }
+        websocketSubscription.unsubscribe();
+      });
+    }
     return {
       unsubscribe: () => {
         sub.unsubscribe();
@@ -1019,14 +1398,15 @@ var Store = class {
     }
     return query;
   }
-  getListQuery(apiName, where, opts, peek = false) {
+  getListQuery(apiName, where, orderBy, opts) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
     const canonWhere = this.whereCanonicalizer.canonicalize(where);
-    const listCacheKey = this.getCacheKey("list", apiName, canonWhere);
+    const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy);
+    const listCacheKey = this.getCacheKey("list", apiName, canonWhere, canonOrderBy);
     return this.#getQuery(listCacheKey, () => {
-      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, listCacheKey, opts);
+      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, canonOrderBy, listCacheKey, opts);
     });
   }
   getObjectQuery(apiName, pk) {
@@ -1047,14 +1427,13 @@ var Store = class {
     return objEntry?.value;
   }
   batch = ({
-    optimisticId
+    optimisticId,
+    changes = createChangedObjects()
   }, batchFn) => {
     !(optimisticId === undefined || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "optimistic must be undefined or not falsy") : invariant2__default.default(false) : undefined;
     let needsLayer = optimisticId !== undefined;
     const batchContext = {
-      addedObjects: /* @__PURE__ */ new Set(),
-      modifiedObjects: /* @__PURE__ */ new Set(),
-      modifiedLists: /* @__PURE__ */ new Set(),
+      changes,
       createLayerIfNeeded: () => {
         if (needsLayer) {
           this.#topLayer = this.#topLayer.addLayer(optimisticId);
@@ -1066,16 +1445,12 @@ var Store = class {
         const oldTopValue = this.#topLayer.get(cacheKey);
         if (optimisticId) batchContext.createLayerIfNeeded();
         const writeLayer = optimisticId ? this.#topLayer : this.#truthLayer;
-        const newValue = {
-          cacheKey,
-          value,
-          lastUpdated: Date.now(),
-          status
-        };
+        const newValue = new Entry(cacheKey, value, Date.now(), status);
         writeLayer.set(cacheKey, newValue);
         const newTopValue = this.#topLayer.get(cacheKey);
         if (oldTopValue !== newTopValue) {
           this.#cacheKeyToSubject.get(cacheKey)?.next({
+            // eslint-disable-next-line @typescript-eslint/no-misused-spread
             ...newValue,
             isOptimistic: newTopValue?.value !== this.#truthLayer.get(cacheKey)?.value
           });
@@ -1087,6 +1462,7 @@ var Store = class {
       }
     };
     const retVal = batchFn(batchContext);
+    void this.maybeUpdateLists(changes, optimisticId);
     return {
       batchResult: batchContext,
       retVal
@@ -1099,35 +1475,90 @@ var Store = class {
     const query = this.getObjectQuery(apiName, pk);
     return query.revalidate(true);
   }
-  maybeRevalidateLists(changes) {
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey)) {
-        void this.#peekQuery(cacheKey)?.maybeRevalidate(changes);
+  async maybeRevalidateLists(changes) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "maybeRevalidateList"
+      }, DEBUG_ONLY__changesToString(changes));
+    }
+    try {
+      const promises = [];
+      for (const [cacheKey, v] of this.#truthLayer.entries()) {
+        if (isListCacheKey(cacheKey)) {
+          const promise = this.#peekQuery(cacheKey)?.maybeUpdateAndRevalidate(changes, void 0);
+          if (promise) promises.push(promise);
+        }
+      }
+      await Promise.all(promises);
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.trace({
+          methodName: "maybeRevalidateList"
+        }, "in finally", DEBUG_ONLY__changesToString(changes));
       }
     }
   }
   maybeUpdateLists(changes, optimisticId) {
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.trace({
+        methodName: "maybeUpdateLists"
+      }, DEBUG_ONLY__changesToString(changes), {
+        optimisticId
+      });
+    }
+    if (changes.addedObjects.size === 0 && changes.modifiedObjects.size === 0) {
+      return Promise.resolve([]);
+    }
+    const promises = [];
+    for (const cacheKey of this.#queries.keys()) {
       if (isListCacheKey(cacheKey)) {
-        void this.#peekQuery(cacheKey)?.maybeUpdate(changes, optimisticId);
+        if (!changes.modifiedLists.has(cacheKey)) {
+          const promise = this.#peekQuery(cacheKey)?.maybeUpdateAndRevalidate(changes, optimisticId);
+          if (promise) promises.push(promise);
+        }
       }
     }
+    return Promise.all(promises);
   }
-  invalidateObjectType(apiName) {
+  /**
+   * @param apiName
+   * @param changes The changes we know about / to update
+   * @returns
+   */
+  invalidateObjectType(apiName, changes) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "invalidateObjectType"
+      }, changes ? DEBUG_ONLY__changesToString(changes) : undefined);
+    }
+    const promises = [];
     for (const [cacheKey, v] of this.#truthLayer.entries()) {
       if (isListCacheKey(cacheKey, apiName)) {
-        void this.#peekQuery(cacheKey)?.revalidate(true);
+        if (!changes || !changes.modifiedLists.has(cacheKey)) {
+          const promise = this.#peekQuery(cacheKey)?.revalidate(true);
+          if (promise) {
+            promises.push(promise);
+            changes?.modifiedLists.add(cacheKey);
+          }
+        }
       }
     }
+    return Promise.all(promises);
   }
-  invalidateList(apiName, where) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
+  invalidateList({
+    objectType,
+    where,
+    orderBy
+  }) {
+    if (typeof objectType !== "string") {
+      objectType = objectType.apiName;
     }
-    const cacheKey = this.getCacheKey("list", apiName, where);
+    where = this.whereCanonicalizer.canonicalize(where ?? {});
+    orderBy = this.orderByCanonicalizer.canonicalize(orderBy ?? {});
+    const cacheKey = this.getCacheKey("list", objectType, where, orderBy);
     void this.#peekQuery(cacheKey)?.revalidate(true);
   }
   updateObject(apiName, value, {
@@ -1143,19 +1574,45 @@ var Store = class {
       return query.writeToStore(value, "loaded", batch);
     }).retVal.value;
   }
-  updateList(apiName, where, values, {
+  updateObjects(values, batch) {
+    return values.map((v) => {
+      return this.getObjectQuery(v.$apiName, v.$primaryKey).writeToStore(v, "loaded", batch).cacheKey;
+    });
+  }
+  /**
+   * Updates the internal state of a list and will create a new internal query if needed.
+   *
+   * Helper method only for tests right now. May be removed later.
+   *
+   * @param apiName
+   * @param where
+   * @param orderBy
+   * @param objects
+   * @param param4
+   * @param opts
+   */
+  updateList({
+    objectType: apiName,
+    where,
+    orderBy
+  }, objects, {
     optimisticId
   } = {}, opts = {
     dedupeInterval: 0
   }) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.info({
+        methodName: "updateList"
+      }, "", {
+        optimisticId
+      });
     }
-    const query = this.getListQuery(apiName, where, opts);
+    const query = this.getListQuery(apiName, where ?? {}, orderBy ?? {}, opts);
     this.batch({
       optimisticId
-    }, (b) => {
-      query.updateList(values, false, "loaded", b);
+    }, (batch) => {
+      const objectCacheKeys = this.updateObjects(objects, batch);
+      query.updateList(objectCacheKeys, false, "loaded", batch);
     });
   }
   retain(cacheKey) {
@@ -1165,74 +1622,6 @@ var Store = class {
     this.#refCounts.release(cacheKey);
   }
 };
-var ActionApplication = class {
-  constructor(store) {
-    this.store = store;
-  }
-  applyAction = (action, args, {
-    optimisticUpdate
-  } = {}) => {
-    const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
-    return (async () => {
-      try {
-        const actionResults = await this.store.client(action).applyAction(args, {
-          $returnEdits: true
-        });
-        if (ACTION_DELAY > 0) {
-          console.log("action done, pausing");
-          await delay(ACTION_DELAY);
-          console.log("action done, pausing done");
-        }
-        await this.#invalidateActionEditResponse(actionResults);
-        return actionResults;
-      } finally {
-        await removeOptimisticResult();
-      }
-    })();
-  };
-  #invalidateActionEditResponse = (value) => {
-    const typesToInvalidate = /* @__PURE__ */ new Set();
-    let promisesToWait = [];
-    if (value.type === "edits") {
-      for (const obj of value.modifiedObjects) {
-        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
-      }
-      for (const obj of value.addedObjects) {
-        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
-        typesToInvalidate.add(obj.objectType);
-      }
-      promisesToWait = [Promise.allSettled(promisesToWait).then(() => {
-        const changes2 = this.#changesFromActionEditResponse(value);
-        this.store.maybeRevalidateLists(changes2);
-      })];
-    } else {
-      for (const apiName of value.editedObjectTypes) {
-        typesToInvalidate.add(apiName.toString());
-      }
-    }
-    return Promise.allSettled(promisesToWait).then(() => {
-      for (const objectType of typesToInvalidate) {
-        this.store.invalidateObjectType(objectType);
-      }
-      return value;
-    });
-  };
-  #changesFromActionEditResponse = (value) => {
-    const changes = createChangedObjects();
-    for (const changeType of ["addedObjects", "modifiedObjects"]) {
-      for (const {
-        objectType,
-        primaryKey
-      } of value[changeType] ?? []) {
-        const obj = this.store.getObject(objectType, primaryKey);
-        if (obj) {
-          changes[changeType].set(objectType, obj);
-        }
-      }
-    }
-    return changes;
-  };
-};
 
 // src/observable/ObservableClient.ts
 function createObservableClient(client) {