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

package/build/esm/observable/internal/ListQuery.js

@@ -15,34 +15,134 @@
  */
 
 import deepEqual from "fast-deep-equal";
-import { asyncScheduler, auditTime, combineLatest, connectable, map, observeOn, of, ReplaySubject, switchMap } from "rxjs";
+import groupBy from "object.groupby";
+import { auditTime, combineLatest, connectable, map, of, ReplaySubject, switchMap } from "rxjs";
 import invariant from "tiny-invariant";
 import { additionalContext } from "../../Client.js";
+import { ObjectDefRef, UnderlyingOsdkObject } from "../../object/convertWireToOsdkObjects/InternalSymbols.js";
 import { DEBUG_ONLY__cacheKeysToString } from "./CacheKey.js";
-import { DEBUG_ONLY__changesToString } from "./ChangedObjects.js";
-import { objectSortaMatchesWhereClause } from "./objectMatchesWhereClause.js";
+import { DEBUG_ONLY__changesToString } from "./Changes.js";
+import { objectSortaMatchesWhereClause as objectMatchesWhereClause } from "./objectMatchesWhereClause.js";
+import { storeOsdkInstances } from "./ObjectQuery.js";
 import { Query } from "./Query.js";
-export class ListQuery extends Query {
+export const API_NAME_IDX = 1;
+export const TYPE_IDX = 0;
+export const WHERE_IDX = 2;
+export const ORDER_BY_IDX = 3;
+class BaseListQuery 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(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);
+
+    // whether its append or update we need to retain all the new objects
+    if (!batch.optimisticWrite) {
+      if (!append) {
+        // we need to release all the old objects
+        // N.B. the store keeps the cache keys around for a bit so we don't
+        // need to worry about them being GC'd before we re-retain them
+        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() {
+    // eslint-disable-next-line no-console
+    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);
+        }
+      }
+    });
+  }
+}
+export class ListQuery 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 = new Set();
   #orderBy;
-  constructor(store, subject, objectType, whereClause, orderBy, cacheKey, opts) {
+  #objectSet;
+  #sortFns;
+  constructor(store, subject, apiType, apiName, whereClause, orderBy, cacheKey, opts) {
     super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[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;
-    observeOn(asyncScheduler);
+    this.#objectSet = store.client({
+      type: this.#type,
+      apiName: this.#apiName
+    }).where(this.#whereClause);
+    this.#sortFns = createOrderBySortFns(this.#orderBy);
   }
   get canonicalWhere() {
     return this.#whereClause;
@@ -67,13 +167,14 @@ export class ListQuery 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) {
         // we were aborted
         return;
@@ -106,41 +207,78 @@ export class ListQuery 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
-      } : {})
-    });
-    if (signal?.aborted) {
-      return;
+    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;
+
+      // Our caching really expects to have the full objects in the list
+      // so we need to fetch them all here
+      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);
+
+      // rethrowing would result in many unhandled promise rejections
+      // which i don't think we want
+      // throw e;
     }
-    this.#nextPageToken = nextPageToken;
-    const {
-      retVal
-    } = this.store.batch({}, batch => {
-      return this.updateList(this.store.updateObjects(data, batch), append, nextPageToken ? status : "loaded", batch);
-    });
-    return retVal;
   }
 
+  /**
+   * 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 (this.#apiName in objectMetadata.interfaceMap) {
+      await this.revalidate(/* force */true);
+    }
+  };
+
   /**
    * Note: This method is not async because I want it to return right after it
    *       finishes the synchronous updates. The promise that is returned
@@ -153,45 +291,19 @@ export class ListQuery 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;
+    // mark ourselves as updated so we don't infinite recurse.
+    changes.modified.add(this.cacheKey);
     try {
-      const relevantObjects = {
-        added: {
-          all: changes.addedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
-          strictMatches: new Set(),
-          sortaMatches: new Set()
-        },
-        modified: {
-          all: changes.modifiedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
-          strictMatches: new Set(),
-          sortaMatches: new Set()
-        }
-      };
+      const relevantObjects = this._extractRelevantObjects(changes);
       if (relevantObjects.added.all.length === 0 && relevantObjects.modified.all.length === 0) {
         return;
       }
 
-      // categorize
-      for (const group of Object.values(relevantObjects)) {
-        for (const obj of group.all ?? []) {
-          // if its a strict match we can just insert it into place
-          const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
-          if (strictMatch) {
-            group.strictMatches.add(obj);
-          } else {
-            // sorta match means it used a filter we cannot use on the frontend
-            const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
-            if (sortaMatch) {
-              group.sortaMatches.add(obj);
-            }
-          }
-        }
-      }
-
       // If we got purely strict matches we can just update the list and move
       // on with our lives. But if we got sorta matches, then we need to revalidate
       // the list so we preemptively set it to loading to avoid thrashing the store.
@@ -200,16 +312,13 @@ export class ListQuery extends Query {
       // while we only push updates for the strict matches, we still need to
       // trigger the list updating if some of our objects changed
 
-      // mark ourselves as updated so we don't infinite recurse.
-      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);
@@ -218,10 +327,8 @@ export class ListQuery extends Query {
         // deal with the modified objects
         for (const obj of relevantObjects.modified.all) {
           if (relevantObjects.modified.strictMatches.has(obj)) {
-            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
-
-            // full match and already there, do nothing
-            if (!existingList.has(existingObjectCacheKey)) {
+            const objectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
+            if (!existingList.has(objectCacheKey)) {
               // object is new to the list
               toAdd.add(obj);
             }
@@ -233,7 +340,7 @@ export class ListQuery extends Query {
             continue;
           } else {
             // object is no longer a strict match
-            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)) {
               // since it might still be in the list we need to revalidate
@@ -246,79 +353,83 @@ export class ListQuery 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(newList, /* append */false, status, batch);
+        this._updateList(newList, /* append */false, status, batch);
       });
       if (needsRevalidation) {
-        changes.modifiedLists.add(this.cacheKey);
-        return this.revalidate(true).then(() => void 0); // strip return value
+        return this.revalidate(true);
       }
       return undefined;
     } 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);
+  _extractRelevantObjects(changes) {
+    // TODO refactor this ternary into subclasses
+    const relevantObjects = this.#type === "object" ? this.#extractRelevantObjectsForTypeObject(changes) : this.#extractRelevantObjectsForTypeInterface(changes);
 
-    // whether its append or update we need to retain all the new objects
-    if (!batch.optimisticWrite) {
-      if (!append) {
-        // we need to release all the old objects
-        // N.B. the store keeps the cache keys around for a bit so we don't
-        // need to worry about them being GC'd before we re-retain them
-        for (const objectCacheKey of existingList?.value?.data ?? []) {
-          this.store.release(objectCacheKey);
-          this.#toRelease.delete(objectCacheKey);
+    // categorize
+    for (const group of Object.values(relevantObjects)) {
+      for (const obj of group.all ?? []) {
+        // if its a strict match we can just insert it into place
+        const strictMatch = objectMatchesWhereClause(obj, this.#whereClause, true);
+        if (strictMatch) {
+          group.strictMatches.add(obj);
+        } else {
+          // sorta match means it used a filter we cannot use on the frontend
+          const sortaMatch = objectMatchesWhereClause(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[ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    const modified = Array.from(changes.modifiedObjects).filter(([, object]) => {
+      return this.#apiName in object[ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    return {
+      added: {
+        all: added,
+        strictMatches: new Set(),
+        sortaMatches: new Set()
+      },
+      modified: {
+        all: modified,
+        strictMatches: new Set(),
+        sortaMatches: 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: new Set(),
+        sortaMatches: new Set()
+      },
+      modified: {
+        all: changes.modifiedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        strictMatches: new Set(),
+        sortaMatches: 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;
           }
@@ -326,47 +437,177 @@ export class ListQuery extends Query {
         return 0;
       });
     }
-    const visited = 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");
+    }
+
+    // FIXME: We should only do this once. If we already have one we should probably
+    // just reuse it.
+
+    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(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() {
-    // eslint-disable-next-line no-console
-    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);
+      // Read the truth layer (since not optimistic)
+      const existing = batch.read(this.cacheKey);
+      !existing ? process.env.NODE_ENV !== "production" ? invariant(false, "the truth value for our list should exist as we already subscribed") : invariant(false) : void 0;
+      if (existing.status === "loaded") {
+        const objectCacheKey = this.store.getCacheKey("object", objOrIface.$objectType, objOrIface.$primaryKey);
+        // remove the object from the list
+        const newObjects = existing.value?.data.filter(o => o !== objectCacheKey);
+
+        // If the filter didn't change anything, then the list was already
+        // updated (or didn't exist, which is nonsensical)
+        if (newObjects?.length !== existing.value?.data.length) {
+          batch.changes.registerList(this.cacheKey);
+          batch.write(this.cacheKey, {
+            data: newObjects ?? []
+          }, "loaded");
+          // Should there be an else for this case? Do we need to invalidate
+          // the paging tokens we may have? FIXME
         }
+        return;
       }
+      // There may be a tiny race here where OSW tells us the object has
+      // been removed but an outstanding invalidation of this query is
+      // about to return. In this case, its possible that we remove this item
+      // from the list and then the returned list load re-adds it.
+      // To avoid this, we will just force reload the query to be sure
+      // we don't leave things in a bad state.
+      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 {
+          // Make sure we write to the console if there is no logger!
+          // eslint-disable-next-line no-console
+          console.error("Uncaught error while revalidating list", e);
+        }
+      });
     });
   }
 }
-export function isListCacheKey(cacheKey, apiName) {
-  return cacheKey.type === "list" && (apiName == null || cacheKey.otherKeys[0] === apiName);
+function removeDuplicates(objectCacheKeys, batch) {
+  const visited = new Set();
+  objectCacheKeys = objectCacheKeys.filter(key => {
+    batch.read(key);
+    if (visited.has(key)) {
+      return false;
+    }
+    visited.add(key);
+    return true;
+  });
+  return objectCacheKeys;
 }
+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;
+    };
+  });
+}
+
+// Hopefully this can go away when we can just request the full object properties on first load
+async function reloadDataAsFullObjects(client, data) {
+  const groups = groupBy(data, x => x.$objectType);
+  const objectTypeToPrimaryKeyToObject = Object.fromEntries(await Promise.all(Object.entries(groups).map(async ([apiName, objects]) => {
+    // to keep InternalSimpleOsdkInstance simple, we make both the `ObjectDefRef` and
+    // the `InterfaceDefRef` optional but we know that the right one is on there
+    // thus we can `!`
+    const objectDef = objects[0][UnderlyingOsdkObject][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;
+}
+export function isListCacheKey(cacheKey) {
+  return cacheKey.type === "list";
+}
+
+/**
+ * Copied from @osdk/api
+ */
 //# sourceMappingURL=ListQuery.js.map