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

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

@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-import { delay } from "msw";
 import { BehaviorSubject } from "rxjs";
 import invariant from "tiny-invariant";
+import { additionalContext } from "../../Client.js";
 import { DEBUG_REFCOUNTS } from "../DebugFlags.js";
+import { ActionApplication } from "./ActionApplication.js";
 import { CacheKeys } from "./CacheKeys.js";
-import { createChangedObjects } from "./ChangedObjects.js";
-import { Layer } from "./Layer.js";
+import { createChangedObjects, DEBUG_ONLY__changesToString } from "./ChangedObjects.js";
+import { Entry, Layer } from "./Layer.js";
 import { isListCacheKey, ListQuery } from "./ListQuery.js";
 import { ObjectQuery } from "./ObjectQuery.js";
-import { runOptimisticJob } from "./OptimisticJob.js";
 import { RefCounts } from "./RefCounts.js";
+import { WeakMapWithEntries } from "./WeakMapWithEntries.js";
 import { WhereClauseCanonicalizer } from "./WhereClauseCanonicalizer.js";
-const ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1000;
 
 /*
     Work still to do:
@@ -35,9 +35,9 @@ const ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1000;
     - [x] automatic optimistic list updates
     - [x] useOsdkObjects
     - [x] imply offline for objects passed directly
-    - [ ] websocket subscriptions
+    - [x] websocket subscriptions
     - [ ] links
-    - [ ] add pagination
+    - [x] add pagination
     - [ ] sub-selection support
     - [ ] interfaces
     - [ ] setup defaults
@@ -59,19 +59,38 @@ function createInitEntry(cacheKey) {
     - Data is one per layer per cache key
 */
 
+export class OrderByCanonicalizer {
+  // crappy version
+  #map = 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;
+    }
+  };
+}
 export class Store {
   whereCanonicalizer = new WhereClauseCanonicalizer();
+  orderByCanonicalizer = new OrderByCanonicalizer();
   #truthLayer = new Layer(undefined, undefined);
   #topLayer;
-  #queries = new WeakMap();
+
+  /** @internal */
+
+  #queries = new WeakMapWithEntries();
   #cacheKeyToSubject = new WeakMap();
   #cacheKeys;
   #refCounts = new RefCounts(DEBUG_REFCOUNTS ? 15_000 : 60_000, k => this.#cleanupCacheKey(k));
   #finalizationRegistry;
   constructor(client) {
     this.client = client;
+    this.logger = client[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 => {
       if (DEBUG_REFCOUNTS) {
         const cacheKeyType = k.type;
         const otherKeys = k.otherKeys;
@@ -185,7 +204,16 @@ export class Store {
     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 => {
+        // we don't want observeObject() to return a promise,
+        // so we settle for logging an error here instead of
+        // dropping it on the floor.
+        if (this.logger) {
+          this.logger.error("Unhandled error in observeObject", e);
+        } else {
+          throw e;
+        }
+      });
     }
     const sub = query.subscribe({
       next: subFn
@@ -197,11 +225,9 @@ export class Store {
       }
     };
   }
-  observeList(apiName, where, options, subFn) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const query = this.getListQuery(apiName, where, options);
+  observeList(options, subFn) {
+    // the ListQuery represents the shared state of the list
+    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");
@@ -209,6 +235,109 @@ export class Store {
     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") {
+            // todo, can we do the update without
+            // the extra invalidation? maybe a flag to updateObject
+            store.updateObject(object.$objectType, object);
+            store.maybeRevalidateLists(changes).catch(err => {
+              // eslint-disable-next-line no-console
+              console.error("Unhandled error in maybeRevalidateLists", err);
+            });
+          } else if (state === "REMOVED") {
+            const changes = createChangedObjects();
+            store.batch({
+              changes
+            }, 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");
+                  // Should there be an else for this case? Do we need to invalidate
+                  // the paging tokens we may have?
+                }
+              } else {
+                // 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") {
+                  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 {
+                    // eslint-disable-next-line no-console
+                    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();
@@ -227,14 +356,15 @@ export class Store {
     }
     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) {
@@ -255,14 +385,13 @@ export class Store {
     return objEntry?.value;
   }
   batch = ({
-    optimisticId
+    optimisticId,
+    changes = createChangedObjects()
   }, batchFn) => {
     !(optimisticId === undefined || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant(false, "optimistic must be undefined or not falsy") : invariant(false) : void 0;
     let needsLayer = optimisticId !== undefined;
     const batchContext = {
-      addedObjects: new Set(),
-      modifiedObjects: new Set(),
-      modifiedLists: new Set(),
+      changes,
       createLayerIfNeeded: () => {
         if (needsLayer) {
           this.#topLayer = this.#topLayer.addLayer(optimisticId);
@@ -274,16 +403,12 @@ export class Store {
         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
           });
@@ -295,6 +420,7 @@ export class Store {
       }
     };
     const retVal = batchFn(batchContext);
+    void this.maybeUpdateLists(changes, optimisticId);
     return {
       batchResult: batchContext,
       retVal: retVal
@@ -315,37 +441,93 @@ export class Store {
     // TODO
     // could we detect that a list WOULD include it?
   }
-  maybeRevalidateLists(changes) {
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey)) {
-        // fixme promise
-        void this.#peekQuery(cacheKey)?.maybeRevalidate(changes);
+  async maybeRevalidateLists(changes) {
+    if (process.env.NODE_ENV !== "production") {
+      // todo
+      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, undefined);
+          if (promise) promises.push(promise);
+        }
+      }
+      await Promise.all(promises);
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        // todo
+        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)) {
-        // fixme promise
-        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) : void 0);
+    }
+    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, {
@@ -361,19 +543,48 @@ export class Store {
       return query.writeToStore(value, "loaded", batch);
     }).retVal.value;
   }
-  updateList(apiName, where, values, {
+  updateObjects(values, batch) {
+    // update the cache for any object that has changed
+    // and save the mapped values to return
+    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) {
@@ -383,82 +594,4 @@ export class Store {
     this.#refCounts.release(cacheKey);
   }
 }
-class ActionApplication {
-  constructor(store) {
-    this.store = store;
-  }
-  applyAction = (action, args, {
-    optimisticUpdate
-  } = {}) => {
-    const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
-    return (async () => {
-      try {
-        // The types for client get confused when we dynamically applyAction so we
-        // have to deal with the `any` here and force cast it to what it should be.
-        // TODO: Update the types so this doesn't happen!
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        const actionResults = await this.store.client(action).applyAction(args, {
-          $returnEdits: true
-        });
-        if (ACTION_DELAY > 0) {
-          // eslint-disable-next-line no-console
-          console.log("action done, pausing");
-          await delay(ACTION_DELAY);
-          // eslint-disable-next-line no-console
-          console.log("action done, pausing done");
-        }
-        await this.#invalidateActionEditResponse(actionResults);
-        return actionResults;
-      } finally {
-        // make sure this happens even if the action fails
-        await removeOptimisticResult();
-      }
-    })();
-  };
-  #invalidateActionEditResponse = value => {
-    const typesToInvalidate = new Set();
-    let promisesToWait = [];
-    if (value.type === "edits") {
-      // TODO we need an backend update for deletes
-      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(() => {
-      // after the single object invalidations are done we can decide if we need to updates any lists
-      for (const objectType of typesToInvalidate) {
-        // TODO make sure this covers individual object loads too
-        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;
-  };
-}
 //# sourceMappingURL=Store.js.map