@osdk/client 2.2.0-beta.8 → 2.2.0-beta.9

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

@@ -1,35 +1,30 @@
 'use strict';
 
-var chunkJPENHIJB_cjs = require('../chunk-JPENHIJB.cjs');
+var chunkT4NIFYZS_cjs = require('../chunk-T4NIFYZS.cjs');
+var chunkEY52J5Z4_cjs = require('../chunk-EY52J5Z4.cjs');
 require('../chunk-Q7SFCCGT.cjs');
 var rxjs = require('rxjs');
 var invariant2 = require('tiny-invariant');
 var mnemonist = require('mnemonist');
 var trie = require('@wry/trie');
 var deepEqual = require('fast-deep-equal');
+var groupBy = require('object.groupby');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var invariant2__default = /*#__PURE__*/_interopDefault(invariant2);
 var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
+var groupBy__default = /*#__PURE__*/_interopDefault(groupBy);
 
 // src/observable/internal/ObservableClientImpl.ts
 var ObservableClientImpl = class {
   #store;
   constructor(store) {
     this.#store = store;
-  }
-  observeObject(apiName, pk, options, subFn) {
-    return this.#store.observeObject(apiName, pk, options, subFn);
-  }
-  observeList(options, subFn) {
-    return this.#store.observeList(options, subFn);
-  }
-  applyAction(action, args, opts) {
-    return this.#store.applyAction(action, args, opts);
-  }
-  canonicalizeWhereClause(where) {
-    return this.#store.whereCanonicalizer.canonicalize(where);
+    this.observeObject = store.observeObject.bind(store);
+    this.observeList = store.observeList.bind(store);
+    this.applyAction = store.applyAction.bind(store);
+    this.canonicalizeWhereClause = store.canonicalizeWhereClause.bind(store);
   }
 };
 
@@ -100,28 +95,39 @@ function DEBUG_ONLY__cacheKeyToString(x) {
 }
 function DEBUG_ONLY__cacheKeysToString(x) {
   if (process.env.NODE_ENV !== "production") {
-    return JSON.stringify(x.map(DEBUG_ONLY__cacheKeyToString), null, 2);
+    return "\n  - " + x.map(DEBUG_ONLY__cacheKeyToString).join("\n  - ");
   } 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()
+// src/observable/internal/Changes.ts
+var Changes = class {
+  modifiedObjects = new mnemonist.MultiMap();
+  addedObjects = new mnemonist.MultiMap();
+  added = /* @__PURE__ */ new Set();
+  modified = /* @__PURE__ */ new Set();
+  registerObject = (cacheKey, data, isNew) => {
+    this[isNew ? "addedObjects" : "modifiedObjects"].set(data.$apiName, data);
+    this[isNew ? "added" : "modified"].add(cacheKey);
   };
+  registerList = (key) => {
+    this.modified.add(key);
+  };
+  isEmpty() {
+    return this.modifiedObjects.size === 0 && this.addedObjects.size === 0 && this.added.size === 0 && this.modified.size === 0;
+  }
+};
+function createChangedObjects() {
+  return new Changes();
 }
 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)
+      added: listHelper(changes.added),
+      modified: listHelper(changes.modified)
     }, null, 2);
   } else {
     throw new Error("not implemented");
@@ -183,7 +189,7 @@ var OptimisticJob = class {
         return this;
       },
       createObject(type, pk, properties) {
-        const create = store.client[chunkJPENHIJB_cjs.additionalContext].objectFactory2(store.client[chunkJPENHIJB_cjs.additionalContext], [{
+        const create = store.client[chunkEY52J5Z4_cjs.additionalContext].objectFactory2(store.client[chunkEY52J5Z4_cjs.additionalContext], [{
           $primaryKey: pk,
           $apiName: type.apiName,
           $objectType: type.apiName,
@@ -224,22 +230,27 @@ var ActionApplication = class {
   applyAction = (action, args, {
     optimisticUpdate
   } = {}) => {
+    const logger = process.env.NODE_ENV !== "production" ? this.store.logger?.child({
+      methodName: "applyAction"
+    }) : this.store.logger;
     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");
+        if (process.env.NODE_ENV !== "production") {
+          if (ACTION_DELAY > 0) {
+            logger?.debug("action done, pausing");
+            await delay(ACTION_DELAY);
+            logger?.debug("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");
+          logger?.debug("optimistic action complete; remove the results");
         }
         await removeOptimisticResult();
       }
@@ -258,8 +269,20 @@ var ActionApplication = class {
         typesToInvalidate.add(obj.objectType);
       }
       await Promise.all(promisesToWait);
-      changes = this.#changesFromActionEditResponse(value);
-      await this.store.maybeRevalidateLists(changes);
+      const changes2 = createChangedObjects();
+      for (const changeType of ["addedObjects", "modifiedObjects"]) {
+        for (const {
+          objectType,
+          primaryKey
+        } of value[changeType] ?? []) {
+          const cacheKey = this.store.getCacheKey("object", objectType, primaryKey);
+          const obj = this.store.getValue(cacheKey);
+          if (obj && obj.value) {
+            changes2[changeType].set(objectType, obj.value);
+            (changeType === "addedObjects" ? changes2.added : changes2.modified).add(cacheKey);
+          }
+        }
+      }
     } else {
       for (const apiName of value.editedObjectTypes) {
         typesToInvalidate.add(apiName.toString());
@@ -268,21 +291,6 @@ var ActionApplication = class {
     }
     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) => {
@@ -301,9 +309,9 @@ var CacheKeys = class {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
       return this.#cacheKeys.lookupArray(["object", apiName, pk]);
     });
-    this.#registerCacheKeyFactory("list", (apiName, where, orderBy) => {
+    this.#registerCacheKeyFactory("list", (type, apiName, where, orderBy) => {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
-      return this.#cacheKeys.lookupArray(["list", apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
+      return this.#cacheKeys.lookupArray(["list", type, apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
     });
   }
   #registerCacheKeyFactory(type, factory) {
@@ -456,6 +464,9 @@ var Layer = class _Layer {
   entries() {
     return this.#cache.entries();
   }
+  keys() {
+    return this.#cache.keys();
+  }
   get(cacheKey) {
     return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
   }
@@ -569,7 +580,7 @@ var Query = class {
     this.cacheKey = cacheKey;
     this.store = store;
     this.#subject = observable;
-    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger : store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkEY52J5Z4_cjs.additionalContext].logger : store.client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
       msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
     }));
   }
@@ -578,61 +589,66 @@ var Query = class {
     this.#subscription = this.#connectable.connect();
     return this.#connectable.subscribe(observer);
   }
-  revalidate(force) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "revalidate"
-      });
-    }
+  /**
+   * Causes the query to revalidate. This will cause the query to fetch
+   * the latest data from the server and update the store if it is deemed
+   * "stale" or if `force` is true.
+   *
+   * @param force
+   * @returns
+   */
+  async revalidate(force) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "revalidate"
+    }) : this.logger;
     if (force) {
       this.abortController?.abort();
     }
     if (this.pendingFetch) {
-      return this.pendingFetch;
+      if (process.env.NODE_ENV !== "production") {
+        logger?.info("Fetch is already pending, using it");
+      }
+      await this.pendingFetch;
+      return;
     }
     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");
+        logger?.debug("Within dupeInterval, aborting revalidate");
       }
       return Promise.resolve();
     }
+    if (process.env.NODE_ENV !== "production") {
+      logger?.debug("Starting actual revalidate");
+    }
     this.store.batch({}, (batch) => {
       this.setStatus("loading", batch);
     });
     this._preFetch();
     this.lastFetchStarted = Date.now();
     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()");
+      logger?.debug("calling _fetchAndStore()");
+    }
+    this.pendingFetch = this._fetchAndStore().finally(() => {
+      logger?.info("finally _fetchAndStore()");
       this.pendingFetch = undefined;
     });
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "revalidate"
-      }, "Returning");
-    }
-    return this.pendingFetch;
+    await this.pendingFetch;
+    return;
   }
   _preFetch() {
   }
+  /**
+   * Sets the status of the query in the store (but does not store that in `changes`).
+   *
+   * @param status
+   * @param batch
+   * @returns
+   */
   setStatus(status, batch) {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
+      this.logger?.child({
         methodName: "setStatus"
-      }, status);
+      }).debug(status);
     }
     const existing = batch.read(this.cacheKey);
     if (existing?.status === status) return;
@@ -645,31 +661,209 @@ var Query = class {
     this.#subscription?.unsubscribe();
     this._dispose();
   }
+  /**
+   * Per query type dispose functionality
+   */
   _dispose() {
   }
+  /**
+   * The purpose of this method is to provide a way for others to write
+   * directly into the store for this query.
+   *
+   * @param data
+   * @param status
+   * @param batch
+   */
+  /**
+   * @param changes
+   * @param optimisticId
+   * @returns If revalidation is needed, a promise that resolves after the
+   *          revalidation is complete. Otherwise, undefined.
+   */
+};
+
+// src/observable/internal/ObjectQuery.ts
+var ObjectQuery = class extends Query {
+  #apiName;
+  #pk;
+  constructor(store, subject, type, pk, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : undefined);
+    this.#apiName = type;
+    this.#pk = pk;
+  }
+  _createConnectable(subject) {
+    return rxjs.connectable(subject.pipe(rxjs.map((x) => {
+      return {
+        status: x.status,
+        object: x.value,
+        lastUpdated: x.lastUpdated,
+        isOptimistic: x.isOptimistic
+      };
+    })), {
+      connector: () => new rxjs.BehaviorSubject({
+        status: "init",
+        object: undefined,
+        lastUpdated: 0,
+        isOptimistic: false
+      })
+    });
+  }
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("calling fetchOne");
+    }
+    const objectSet = this.store.client({
+      type: "object",
+      apiName: this.#apiName
+    });
+    const obj = await objectSet.fetchOne(this.#pk);
+    this.store.batch({}, (batch) => {
+      this.writeToStore(obj, "loaded", batch);
+    });
+  }
+  writeToStore(data, status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual__default.default(data, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Object was deep equal, just setting status`);
+      }
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "writeToStore"
+      }).debug(JSON.stringify({
+        status
+      }), data);
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    batch.changes.registerObject(
+      this.cacheKey,
+      data,
+      /* isNew */
+      !entry
+    );
+    return ret;
+  }
 };
+function storeOsdkInstances(store, values, batch) {
+  return values.map((v) => {
+    return store.getObjectQuery(v.$apiName, v.$primaryKey).writeToStore(v, "loaded", batch).cacheKey;
+  });
+}
 
 // src/observable/internal/ListQuery.ts
-var ListQuery = class extends Query {
+var API_NAME_IDX = 1;
+var BaseListQuery = class extends Query {
+  //
+  // Per list type implementations
+  //
+  //
+  // Shared Implementations
+  //
+  /**
+   * Only intended to be "protected" and used by subclasses but exposed for
+   * testing.
+   *
+   * @param objectCacheKeys
+   * @param append
+   * @param status
+   * @param batch
+   * @returns
+   */
+  _updateList(objectCacheKeys, append, status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+        methodName: "updateList"
+      }) : this.logger;
+      logger?.debug(`{status: ${status}}`, JSON.stringify(objectCacheKeys, null, 2));
+    }
+    objectCacheKeys = this.#retainReleaseAppend(batch, append, objectCacheKeys);
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, status, batch);
+  }
+  writeToStore(data, status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual__default.default(data, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Object was deep equal, just setting status`);
+      }
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "writeToStore"
+      }).debug(`{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    batch.changes.registerList(this.cacheKey);
+    return ret;
+  }
+  #retainReleaseAppend(batch, append, objectCacheKeys) {
+    const existingList = batch.read(this.cacheKey);
+    if (!batch.optimisticWrite) {
+      if (!append) {
+        for (const objectCacheKey of existingList?.value?.data ?? []) {
+          this.store.release(objectCacheKey);
+        }
+      }
+      for (const objectCacheKey of objectCacheKeys) {
+        this.store.retain(objectCacheKey);
+      }
+    }
+    if (append) {
+      objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
+    }
+    return objectCacheKeys;
+  }
+  _dispose() {
+    console.log("DISPOSE LIST QUERY");
+    this.store.batch({}, (batch) => {
+      const entry = batch.read(this.cacheKey);
+      if (entry) {
+        for (const objectCacheKey of entry.value?.data ?? []) {
+          this.store.release(objectCacheKey);
+        }
+      }
+    });
+  }
+};
+var ListQuery = class extends BaseListQuery {
   // pageSize?: number; // this is the internal page size. we need to track this properly
-  #client;
   #type;
+  #apiName;
   #whereClause;
   // this represents the minimum number of results we need to load if we revalidate
   #minNumResults = 0;
   #nextPageToken;
   #pendingPageFetch;
-  #toRelease = /* @__PURE__ */ new Set();
   #orderBy;
-  constructor(store, subject, objectType, whereClause, orderBy, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+  #objectSet;
+  #sortFns;
+  constructor(store, subject, apiType, apiName, whereClause, orderBy, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
       msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
     }) : undefined);
-    this.#client = store.client;
-    this.#type = objectType;
+    this.#type = apiType;
+    this.#apiName = apiName;
     this.#whereClause = whereClause;
     this.#orderBy = orderBy;
-    rxjs.observeOn(rxjs.asyncScheduler);
+    this.#objectSet = store.client({
+      type: this.#type,
+      apiName: this.#apiName
+    }).where(this.#whereClause);
+    this.#sortFns = createOrderBySortFns(this.#orderBy);
   }
   get canonicalWhere() {
     return this.#whereClause;
@@ -696,13 +890,14 @@ var ListQuery = class extends Query {
   _preFetch() {
     this.#nextPageToken = undefined;
   }
-  async _fetch() {
-    const objectSet = this.#client({
-      type: "object",
-      apiName: this.#type
-    }).where(this.#whereClause);
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("fetching pages");
+    }
     while (true) {
-      const entry = await this.#fetchPageAndUpdate(objectSet, "loading", this.abortController?.signal);
+      const entry = await this.#fetchPageAndUpdate(this.#objectSet, "loading", this.abortController?.signal);
       if (!entry) {
         return;
       }
@@ -734,40 +929,75 @@ var ListQuery = class extends Query {
     this.store.batch({}, (batch) => {
       this.setStatus("loading", batch);
     });
-    const objectSet = this.#client({
-      type: "object",
-      apiName: this.#type
-    }).where(this.#whereClause);
-    this.pendingFetch = this.#fetchPageAndUpdate(objectSet, "loaded", this.abortController?.signal).finally(() => {
+    this.pendingFetch = this.#fetchPageAndUpdate(this.#objectSet, "loaded", this.abortController?.signal).finally(() => {
       this.#pendingPageFetch = undefined;
     });
     return this.pendingFetch;
   };
   async #fetchPageAndUpdate(objectSet, status, signal) {
     const append = this.#nextPageToken != null;
-    const {
-      data,
-      nextPageToken
-    } = await objectSet.fetchPage({
-      $nextPageToken: this.#nextPageToken,
-      $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
-      } : {}
+    try {
+      let {
+        data,
+        nextPageToken
+      } = await objectSet.fetchPage({
+        $nextPageToken: this.#nextPageToken,
+        $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;
+      }
+      this.#nextPageToken = nextPageToken;
+      if (this.#type === "interface") {
+        data = await reloadDataAsFullObjects(this.store.client, data);
+      }
+      const {
+        retVal
+      } = this.store.batch({}, (batch) => {
+        return this._updateList(storeOsdkInstances(this.store, data, batch), append, nextPageToken ? status : "loaded", batch);
+      });
+      return retVal;
+    } catch (e) {
+      this.logger?.error("error", e);
+      this.store.getSubject(this.cacheKey).error(e);
+    }
+  }
+  /**
+   * Will revalidate the list if its query is affected by invalidating the
+   * apiName of the object type passed in.
+   *
+   * @param apiName to invalidate
+   * @returns
+   */
+  revalidateObjectType = async (apiName) => {
+    if (this.#type === "object") {
+      if (this.#apiName === apiName) {
+        await this.revalidate(
+          /* force */
+          true
+        );
+        return;
+      } else {
+        return;
+      }
+    }
+    const objectMetadata = await this.store.client.fetchMetadata({
+      type: "object",
+      apiName
     });
-    if (signal?.aborted) {
+    if (this.#apiName in objectMetadata.interfaceMap) {
+      await this.revalidate(
+        /* force */
+        true
+      );
       return;
     }
-    this.#nextPageToken = nextPageToken;
-    const {
-      retVal
-    } = this.store.batch({}, (batch) => {
-      return this.updateList(this.store.updateObjects(data, batch), append, nextPageToken ? status : "loaded", batch);
-    });
-    return retVal;
-  }
+  };
   /**
    * Note: This method is not async because I want it to return right after it
    *       finishes the synchronous updates. The promise that is returned
@@ -779,50 +1009,25 @@ var ListQuery = class extends Query {
    */
   maybeUpdateAndRevalidate = (changes, optimisticId) => {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "#maybeMaybe"
-      }, DEBUG_ONLY__changesToString(changes));
+      this.logger?.child({
+        methodName: "maybeUpdateAndRevalidate"
+      }).debug(DEBUG_ONLY__changesToString(changes));
     }
-    if (changes.modifiedLists.has(this.cacheKey)) return;
+    if (changes.modified.has(this.cacheKey)) return;
+    changes.modified.add(this.cacheKey);
     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()
-        }
-      };
+      const relevantObjects = this._extractRelevantObjects(changes);
       if (relevantObjects.added.all.length === 0 && relevantObjects.modified.all.length === 0) {
         return;
       }
-      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);
-            }
-          }
-        }
-      }
       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,
         changes
       }, (batch) => {
-        const curValue = batch.read(this.cacheKey);
-        const existingList = new Set(curValue?.value?.data);
+        const existingList = new Set(batch.read(this.cacheKey)?.value?.data);
         const toAdd = new Set(
           // easy case. objects are new to the cache and they match this filter
           relevantObjects.added.strictMatches
@@ -830,15 +1035,15 @@ var ListQuery = class extends Query {
         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)) {
+            const objectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
+            if (!existingList.has(objectCacheKey)) {
               toAdd.add(obj);
             }
             continue;
           } else if (batch.optimisticWrite) {
             continue;
           } else {
-            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
+            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
             toRemove.add(existingObjectCacheKey);
             if (relevantObjects.modified.sortaMatches.has(obj)) {
               needsRevalidation = true;
@@ -850,9 +1055,9 @@ var ListQuery = class extends Query {
           newList.push(key);
         }
         for (const obj of toAdd) {
-          newList.push(this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey));
+          newList.push(this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey));
         }
-        this.updateList(
+        this._updateList(
           newList,
           /* append */
           false,
@@ -861,69 +1066,73 @@ var ListQuery = class extends Query {
         );
       });
       if (needsRevalidation) {
-        changes.modifiedLists.add(this.cacheKey);
-        return this.revalidate(true).then(() => void 0);
+        return this.revalidate(true);
       }
       return void 0;
     } finally {
       if (process.env.NODE_ENV !== "production") {
-        this.logger?.trace({
-          methodName: "#maybeMaybe"
-        }, "in finally");
+        this.logger?.child({
+          methodName: "maybeUpdateAndRevalidate"
+        }).debug("in finally");
       }
     }
   };
-  updateList(objectCacheKeys, append, status, batch) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "updateList"
-      }, `{status: ${status}}`, JSON.stringify(objectCacheKeys, null, 2));
-    }
-    const existingList = batch.read(this.cacheKey);
-    if (!batch.optimisticWrite) {
-      if (!append) {
-        for (const objectCacheKey of existingList?.value?.data ?? []) {
-          this.store.release(objectCacheKey);
-          this.#toRelease.delete(objectCacheKey);
+  _extractRelevantObjects(changes) {
+    const relevantObjects = this.#type === "object" ? this.#extractRelevantObjectsForTypeObject(changes) : this.#extractRelevantObjectsForTypeInterface(changes);
+    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);
+          }
         }
       }
-      for (const objectCacheKey of objectCacheKeys) {
-        this.#toRelease.add(objectCacheKey);
-        this.store.retain(objectCacheKey);
-      }
     }
-    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));
+    return relevantObjects;
+  }
+  #extractRelevantObjectsForTypeInterface(changes) {
+    const added = Array.from(changes.addedObjects).filter(([, object]) => {
+      return this.#apiName in object[chunkT4NIFYZS_cjs.ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    const modified = Array.from(changes.modifiedObjects).filter(([, object]) => {
+      return this.#apiName in object[chunkT4NIFYZS_cjs.ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    return {
+      added: {
+        all: added,
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      },
+      modified: {
+        all: modified,
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
       }
-      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;
-        };
-      });
+    };
+  }
+  #extractRelevantObjectsForTypeObject(changes) {
+    return {
+      added: {
+        all: changes.addedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      },
+      modified: {
+        all: changes.modifiedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      }
+    };
+  }
+  _sortCacheKeys(objectCacheKeys, batch) {
+    if (Object.keys(this.#orderBy).length > 0) {
       objectCacheKeys = objectCacheKeys.sort((a, b) => {
-        for (const sortFn of sortFns) {
-          const ret = sortFn(batch.read(a)?.value, batch.read(b)?.value);
+        for (const sortFn of this.#sortFns) {
+          const ret = sortFn(batch.read(a)?.value?.$as(this.#apiName), batch.read(b)?.value?.$as(this.#apiName));
           if (ret !== 0) {
             return ret;
           }
@@ -931,108 +1140,206 @@ var ListQuery = class extends Query {
         return 0;
       });
     }
-    const visited = /* @__PURE__ */ new Set();
-    objectCacheKeys = objectCacheKeys.filter((key) => {
-      batch.read(key);
-      if (visited.has(key)) {
-        return false;
+    return objectCacheKeys;
+  }
+  registerStreamUpdates(sub) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "registerStreamUpdates"
+    }) : this.logger;
+    if (process.env.NODE_ENV !== "production") {
+      logger?.child({
+        methodName: "observeList"
+      }).info("Subscribing from websocket");
+    }
+    const websocketSubscription = this.#objectSet.subscribe({
+      onChange: this.#onOswChange.bind(this),
+      onError: this.#onOswError.bind(this),
+      onOutOfDate: this.#onOswOutOfDate.bind(this),
+      onSuccessfulSubscription: this.#onOswSuccessfulSubscription.bind(this)
+    });
+    sub.add(() => {
+      if (process.env.NODE_ENV !== "production") {
+        logger?.child({
+          methodName: "observeList"
+        }).info("Unsubscribing from websocket");
       }
-      visited.add(key);
-      return true;
+      websocketSubscription.unsubscribe();
     });
-    return this.writeToStore({
-      data: objectCacheKeys
-    }, status, batch);
   }
-  writeToStore(data, status, batch) {
+  #onOswSuccessfulSubscription() {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "writeToStore"
-      }, `{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
+      this.logger?.child({
+        methodName: "onSuccessfulSubscription"
+      }).debug("");
     }
-    const entry = batch.read(this.cacheKey);
-    if (entry && deepEqual__default.default(data, entry.value)) {
-      return batch.write(this.cacheKey, entry.value, status);
+  }
+  #onOswOutOfDate() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "onOutOfDate"
+      }).info("");
     }
-    const ret = batch.write(this.cacheKey, data, status);
-    batch.changes.modifiedLists.add(this.cacheKey);
-    return ret;
   }
-  _dispose() {
-    console.log("DISPOSE LIST QUERY");
+  #onOswError(errors) {
+    if (this.logger) {
+      this.logger?.child({
+        methodName: "onError"
+      }).error("subscription errors", errors);
+    }
+  }
+  #onOswChange({
+    object: objOrIface,
+    state
+  }) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "registerStreamUpdates"
+    }) : this.logger;
+    if (process.env.NODE_ENV !== "production") {
+      logger?.child({
+        methodName: "onChange"
+      }).debug(`Got an update of type: ${state}`, objOrIface);
+    }
+    if (state === "ADDED_OR_UPDATED") {
+      const object = objOrIface.$apiName !== objOrIface.$objectType ? objOrIface.$as(objOrIface.$objectType) : objOrIface;
+      this.store.batch({}, (batch) => {
+        storeOsdkInstances(this.store, [object], batch);
+      });
+    } else if (state === "REMOVED") {
+      this.#onOswRemoved(objOrIface, logger);
+    }
+  }
+  #onOswRemoved(objOrIface, logger) {
     this.store.batch({}, (batch) => {
-      const entry = batch.read(this.cacheKey);
-      if (entry) {
-        for (const objectCacheKey of entry.value?.data ?? []) {
-          this.store.release(objectCacheKey);
+      const existing = batch.read(this.cacheKey);
+      !existing ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "the truth value for our list should exist as we already subscribed") : invariant2__default.default(false) : undefined;
+      if (existing.status === "loaded") {
+        const objectCacheKey = this.store.getCacheKey("object", objOrIface.$objectType, objOrIface.$primaryKey);
+        const newObjects = existing.value?.data.filter((o) => o !== objectCacheKey);
+        if (newObjects?.length !== existing.value?.data.length) {
+          batch.changes.registerList(this.cacheKey);
+          batch.write(this.cacheKey, {
+            data: newObjects ?? []
+          }, "loaded");
         }
+        return;
       }
+      if (process.env.NODE_ENV !== "production") {
+        logger?.info("Removing an object from an object list that is in the middle of being loaded.", existing);
+      }
+      this.revalidate(
+        /* force */
+        true
+      ).catch((e) => {
+        if (logger) {
+          logger?.error("Uncaught error while revalidating list", e);
+        } else {
+          console.error("Uncaught error while revalidating list", e);
+        }
+      });
     });
   }
 };
-function isListCacheKey(cacheKey, apiName) {
-  return cacheKey.type === "list" && (apiName == null || cacheKey.otherKeys[0] === apiName);
+function removeDuplicates(objectCacheKeys, batch) {
+  const visited = /* @__PURE__ */ new Set();
+  objectCacheKeys = objectCacheKeys.filter((key) => {
+    batch.read(key);
+    if (visited.has(key)) {
+      return false;
+    }
+    visited.add(key);
+    return true;
+  });
+  return objectCacheKeys;
 }
-var ObjectQuery = class extends Query {
-  #apiName;
-  #pk;
-  constructor(store, subject, type, pk, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
-      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
-    }) : undefined);
-    this.#apiName = type;
-    this.#pk = pk;
-  }
-  _createConnectable(subject) {
-    return rxjs.connectable(subject.pipe(rxjs.map((x) => {
-      return {
-        status: x.status,
-        object: x.value,
-        lastUpdated: x.lastUpdated,
-        isOptimistic: x.isOptimistic
-      };
-    })), {
-      connector: () => new rxjs.BehaviorSubject({
-        status: "init",
-        object: undefined,
-        lastUpdated: 0,
-        isOptimistic: false
-      })
+function createOrderBySortFns(orderBy) {
+  return Object.entries(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;
+    };
+  });
+}
+async function reloadDataAsFullObjects(client, data) {
+  const groups = groupBy__default.default(data, (x) => x.$objectType);
+  const objectTypeToPrimaryKeyToObject = Object.fromEntries(await Promise.all(Object.entries(groups).map(async ([apiName, objects]) => {
+    const objectDef = objects[0][chunkT4NIFYZS_cjs.UnderlyingOsdkObject][chunkT4NIFYZS_cjs.ObjectDefRef];
+    const where = {
+      [objectDef.primaryKeyApiName]: {
+        $in: objects.map((x) => x.$primaryKey)
+      }
+    };
+    const result = await client(objectDef).where(where).fetchPage();
+    return [apiName, Object.fromEntries(result.data.map((x) => [x.$primaryKey, x]))];
+  })));
+  data = data.map((obj) => objectTypeToPrimaryKeyToObject[obj.$objectType][obj.$primaryKey]);
+  return data;
+}
+function isListCacheKey(cacheKey) {
+  return cacheKey.type === "list";
+}
+var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
+var WeakRefTrie = class {
+  #finalizer = new FinalizationRegistry((orderBy) => {
+    this.#trie.removeArray(Object.entries(orderBy).flat());
+  });
+  #trie;
+  constructor(makeData = defaultMakeData) {
+    this.#trie = new trie.Trie(false, (array) => {
+      const data = makeData(array);
+      this.#finalizer.register(data, array);
+      return new WeakRef(data);
     });
   }
-  async _fetch() {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "_fetch"
-      });
+  lookupArray(array) {
+    const maybe = this.#trie.lookupArray(array);
+    let ret = maybe.deref();
+    if (maybe && !ret) {
+      this.#trie.removeArray(array);
+      ret = this.#trie.lookupArray(array).deref();
     }
-    const objectSet = this.store.client({
-      type: "object",
-      apiName: this.#apiName
-    });
-    const obj = await objectSet.fetchOne(this.#pk);
-    this.store.batch({}, (batch) => {
-      this.writeToStore(obj, "loaded", batch);
-    });
+    return ret;
   }
-  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.changes.modifiedObjects.set(data.$apiName, data);
-    } else {
-      batch.changes.addedObjects.set(data.$apiName, data);
+  peekArray(array) {
+    const maybe = this.#trie.peekArray(array);
+    const ret = maybe?.deref();
+    if (maybe && !ret) {
+      this.#trie.removeArray(array);
     }
     return ret;
   }
+  removeArray(array) {
+    return this.#trie.removeArray(array)?.deref();
+  }
+};
+var OrderByCanonicalizer = class {
+  #trie = new WeakRefTrie((array) => {
+    const pairs = array.reduce(function(result, _, index, array2) {
+      if (index % 2 === 0 && array2[index] != null) {
+        result.push(array2.slice(index, index + 2));
+      }
+      return result;
+    }, []);
+    let data = Object.fromEntries(pairs);
+    if (process.env.NODE_ENV !== "production") {
+      data = Object.freeze(data);
+    }
+    return data;
+  });
+  canonicalize = (orderBy) => {
+    const strings = Object.entries(orderBy).flat();
+    return this.#trie.lookupArray(strings);
+  };
 };
 
 // src/observable/internal/RefCounts.ts
@@ -1059,8 +1366,8 @@ var RefCounts = class {
     }
   }
   release(key) {
-    const count = this.refCounts.get(key) ?? 0;
-    if (count === 1) {
+    const count = this.refCounts.get(key);
+    if (count === undefined) ; else if (count === 1) {
       this.refCounts.delete(key);
       this.gcMap.set(key, Date.now() + this.keepAlive);
     } else {
@@ -1081,6 +1388,14 @@ var RefCounts = class {
   }
 };
 var WhereClauseCanonicalizer = class {
+  /**
+   * This is a shortcut cache for any WhereClause's that we have
+   * seen and already canonicalized. The theory behind this
+   * is that well behaving React applications will either `useMemo`
+   * their where clause, or store it in state or pass it through as
+   * props such that we are likely to get the same WhereClause
+   * object multiple times and we can skip unnecessary work.
+   */
   #cache = /* @__PURE__ */ new WeakMap();
   /**
    * This is a trie that stores the sorted collapsed keys of a where clause to
@@ -1098,14 +1413,14 @@ var WhereClauseCanonicalizer = class {
       return this.#cache.get(where);
     }
     const keysSet = /* @__PURE__ */ new Set();
-    const tmpCanon = this.#toCanon(where, keysSet);
+    const calculatedCanon = this.#toCanon(where, keysSet);
     const cacheKey = this.#trie.lookupArray(Array.from(keysSet).sort());
     const lookupEntry = this.#existingOptions.get(cacheKey) ?? {
       options: []
     };
     this.#existingOptions.set(cacheKey, lookupEntry);
-    const canon = lookupEntry.options.find((ref) => deepEqual__default.default(ref.deref(), tmpCanon))?.deref() ?? tmpCanon;
-    if (canon === tmpCanon) {
+    const canon = lookupEntry.options.find((ref) => deepEqual__default.default(ref.deref(), calculatedCanon))?.deref() ?? calculatedCanon;
+    if (canon === calculatedCanon) {
       lookupEntry.options.push(new WeakRef(canon));
     }
     this.#cache.set(where, canon);
@@ -1146,32 +1461,24 @@ 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;
   /** @internal */
-  #queries = new WeakMapWithEntries();
+  // we can use a regular Map here because the refCounting will
+  // handle cleanup.
+  #queries = /* @__PURE__ */ new Map();
   #cacheKeyToSubject = /* @__PURE__ */ new WeakMap();
   #cacheKeys;
   #refCounts = new RefCounts(6e4, (k) => this.#cleanupCacheKey(k));
+  // we are currently only using this for debug logging and should just remove it in the future if that
+  // continues to be true
   #finalizationRegistry;
   constructor(client) {
     this.client = client;
-    this.logger = client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+    this.logger = client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
       msgPrefix: "Store"
     });
     this.#topLayer = this.#truthLayer;
@@ -1253,14 +1560,18 @@ var Store = class {
     }
     return subject;
   };
+  canonicalizeWhereClause(where) {
+    return this.whereCanonicalizer.canonicalize(where);
+  }
   observeObject(apiName, pk, options, subFn) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
     const query = this.getObjectQuery(apiName, pk);
-    this.#refCounts.retain(query.cacheKey);
+    this.retain(query.cacheKey);
     if (options.mode !== "offline") {
       query.revalidate(options.mode === "force").catch((e) => {
+        subFn.error(e);
         if (this.logger) {
           this.logger.error("Unhandled error in observeObject", e);
         } else {
@@ -1268,145 +1579,54 @@ var Store = class {
         }
       });
     }
-    const sub = query.subscribe({
-      next: subFn
-    });
+    const sub = query.subscribe(subFn);
     return {
       unsubscribe: () => {
         sub.unsubscribe();
-        this.#refCounts.release(query.cacheKey);
+        this.release(query.cacheKey);
       }
     };
   }
   observeList(options, subFn) {
-    const query = this.getListQuery(options.objectType, options.where ?? {}, options.orderBy ?? {}, options);
-    this.#refCounts.retain(query.cacheKey);
+    const query = this.getListQuery(options.type, options.where ?? {}, options.orderBy ?? {}, options);
+    this.retain(query.cacheKey);
     if (options.mode !== "offline") {
-      void query.revalidate(options.mode === "force");
+      query.revalidate(options.mode === "force").catch((x) => {
+        subFn.error(x);
+      });
     }
-    const sub = query.subscribe({
-      next: subFn
-    });
+    const sub = query.subscribe(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();
-      });
+      query.registerStreamUpdates(sub);
     }
     return {
       unsubscribe: () => {
         sub.unsubscribe();
-        this.#refCounts.release(query.cacheKey);
+        this.release(query.cacheKey);
       }
     };
   }
-  #peekQuery(cacheKey) {
+  peekQuery(cacheKey) {
     return this.#queries.get(cacheKey);
   }
   #getQuery(cacheKey, createQuery) {
-    let query = this.#peekQuery(cacheKey);
+    let query = this.peekQuery(cacheKey);
     if (!query) {
       query = createQuery();
       this.#queries.set(cacheKey, query);
     }
     return query;
   }
-  getListQuery(apiName, where, orderBy, opts) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
+  getListQuery(def, where, orderBy, opts) {
+    const {
+      apiName,
+      type
+    } = def;
     const canonWhere = this.whereCanonicalizer.canonicalize(where);
     const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy);
-    const listCacheKey = this.getCacheKey("list", apiName, canonWhere, canonOrderBy);
+    const listCacheKey = this.getCacheKey("list", type, apiName, canonWhere, canonOrderBy);
     return this.#getQuery(listCacheKey, () => {
-      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, canonOrderBy, listCacheKey, opts);
+      return new ListQuery(this, this.getSubject(listCacheKey), type, apiName, canonWhere, canonOrderBy, listCacheKey, opts);
     });
   }
   getObjectQuery(apiName, pk) {
@@ -1418,13 +1638,8 @@ var Store = class {
       dedupeInterval: 0
     }));
   }
-  getObject(apiName, pk) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const objectCacheKey = this.getCacheKey("object", apiName, pk);
-    const objEntry = this.#topLayer.get(objectCacheKey);
-    return objEntry?.value;
+  getValue(cacheKey) {
+    return this.#topLayer.get(cacheKey);
   }
   batch = ({
     optimisticId,
@@ -1462,63 +1677,59 @@ var Store = class {
       }
     };
     const retVal = batchFn(batchContext);
-    void this.maybeUpdateLists(changes, optimisticId);
+    this.maybeRevalidateQueries(changes, optimisticId).catch((e) => {
+      if (this.logger) {
+        this.logger.error("Unhandled error in batch", e);
+      } else {
+        console.error("Unhandled error in batch", e);
+        throw e;
+      }
+    });
     return {
       batchResult: batchContext,
-      retVal
+      retVal,
+      changes: batchContext.changes
     };
   };
   invalidateObject(apiName, pk) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
-    const query = this.getObjectQuery(apiName, pk);
-    return query.revalidate(true);
+    return this.getObjectQuery(apiName, pk).revalidate(
+      /* force */
+      true
+    );
   }
-  async maybeRevalidateLists(changes) {
+  async maybeRevalidateQueries(changes, optimisticId) {
+    if (changes.isEmpty()) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("No changes, aborting");
+      }
+      return;
+    }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "maybeRevalidateList"
-      }, DEBUG_ONLY__changesToString(changes));
+      this.logger?.child({
+        methodName: "maybeRevalidateQueries"
+      }).debug(DEBUG_ONLY__changesToString(changes), {
+        optimisticId
+      });
     }
     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);
-        }
+      for (const cacheKey of this.#queries.keys()) {
+        const promise = this.peekQuery(cacheKey)?.maybeUpdateAndRevalidate?.(changes, optimisticId);
+        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) {
-    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)) {
-        if (!changes.modifiedLists.has(cacheKey)) {
-          const promise = this.#peekQuery(cacheKey)?.maybeUpdateAndRevalidate(changes, optimisticId);
-          if (promise) promises.push(promise);
-        }
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("in finally", DEBUG_ONLY__changesToString(changes));
       }
     }
-    return Promise.all(promises);
   }
   /**
    * @param apiName
@@ -1530,90 +1741,23 @@ var Store = class {
       apiName = apiName.apiName;
     }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
+      this.logger?.child({
         methodName: "invalidateObjectType"
-      }, changes ? DEBUG_ONLY__changesToString(changes) : undefined);
+      }).info(changes ? DEBUG_ONLY__changesToString(changes) : undefined);
     }
     const promises = [];
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey, apiName)) {
-        if (!changes || !changes.modifiedLists.has(cacheKey)) {
-          const promise = this.#peekQuery(cacheKey)?.revalidate(true);
+    for (const cacheKey of this.#truthLayer.keys()) {
+      if (isListCacheKey(cacheKey)) {
+        if (!changes || !changes.modified.has(cacheKey)) {
+          const promise = this.peekQuery(cacheKey)?.revalidate(true);
           if (promise) {
             promises.push(promise);
-            changes?.modifiedLists.add(cacheKey);
+            changes?.modified.add(cacheKey);
           }
         }
       }
     }
-    return Promise.all(promises);
-  }
-  invalidateList({
-    objectType,
-    where,
-    orderBy
-  }) {
-    if (typeof objectType !== "string") {
-      objectType = objectType.apiName;
-    }
-    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, {
-    optimisticId
-  } = {}) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const query = this.getObjectQuery(apiName, value.$primaryKey);
-    return this.batch({
-      optimisticId
-    }, (batch) => {
-      return query.writeToStore(value, "loaded", batch);
-    }).retVal.value;
-  }
-  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 (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "updateList"
-      }, "", {
-        optimisticId
-      });
-    }
-    const query = this.getListQuery(apiName, where ?? {}, orderBy ?? {}, opts);
-    this.batch({
-      optimisticId
-    }, (batch) => {
-      const objectCacheKeys = this.updateObjects(objects, batch);
-      query.updateList(objectCacheKeys, false, "loaded", batch);
-    });
+    return Promise.all(promises).then(() => undefined);
   }
   retain(cacheKey) {
     this.#refCounts.retain(cacheKey);
@@ -1630,7 +1774,7 @@ function createObservableClient(client) {
 
 Object.defineProperty(exports, "augment", {
   enumerable: true,
-  get: function () { return chunkJPENHIJB_cjs.augment; }
+  get: function () { return chunkEY52J5Z4_cjs.augment; }
 });
 exports.createObservableClient = createObservableClient;
 //# sourceMappingURL=unstable-do-not-use.cjs.map