@osdk/client 2.2.0-beta.8 → 2.3.0-beta.1

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

@@ -20,12 +20,12 @@ import { additionalContext } from "../../Client.js";
 import { DEBUG_REFCOUNTS } from "../DebugFlags.js";
 import { ActionApplication } from "./ActionApplication.js";
 import { CacheKeys } from "./CacheKeys.js";
-import { createChangedObjects, DEBUG_ONLY__changesToString } from "./ChangedObjects.js";
+import { createChangedObjects, DEBUG_ONLY__changesToString } from "./Changes.js";
 import { Entry, Layer } from "./Layer.js";
 import { isListCacheKey, ListQuery } from "./ListQuery.js";
 import { ObjectQuery } from "./ObjectQuery.js";
+import { OrderByCanonicalizer } from "./OrderByCanonicalizer.js";
 import { RefCounts } from "./RefCounts.js";
-import { WeakMapWithEntries } from "./WeakMapWithEntries.js";
 import { WhereClauseCanonicalizer } from "./WhereClauseCanonicalizer.js";
 
 /*
@@ -59,18 +59,6 @@ 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();
@@ -79,10 +67,15 @@ export class Store {
 
   /** @internal */
 
-  #queries = new WeakMapWithEntries();
+  // we can use a regular Map here because the refCounting will
+  // handle cleanup.
+  #queries = new Map();
   #cacheKeyToSubject = new WeakMap();
   #cacheKeys;
   #refCounts = new RefCounts(DEBUG_REFCOUNTS ? 15_000 : 60_000, 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;
@@ -140,8 +133,8 @@ export class Store {
     this.#queries.get(key)?.dispose();
     this.#queries.delete(key);
   };
-  applyAction = (action, args, opts) => {
-    return new ActionApplication(this).applyAction(action, args, opts);
+  applyAction = async (action, args, opts) => {
+    return await new ActionApplication(this).applyAction(action, args, opts);
   };
   removeLayer(layerId) {
     !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "undefined is the reserved layerId for the truth layer") : invariant(false) : void 0;
@@ -197,14 +190,18 @@ export class Store {
     }
     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);
         // we don't want observeObject() to return a promise,
         // so we settle for logging an error here instead of
         // dropping it on the floor.
@@ -215,156 +212,55 @@ export class Store {
         }
       });
     }
-    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) {
     // 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);
+    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") {
-            // 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();
-      });
+      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) {
@@ -376,13 +272,8 @@ export class Store {
       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,
@@ -420,73 +311,63 @@ export class Store {
       }
     };
     const retVal = batchFn(batchContext);
-    void this.maybeUpdateLists(changes, optimisticId);
+    this.maybeRevalidateQueries(changes, optimisticId).catch(e => {
+      // we don't want batch() 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 batch", e);
+      } else {
+        // eslint-disable-next-line no-console
+        console.error("Unhandled error in batch", e);
+        throw e;
+      }
+    });
     return {
       batchResult: batchContext,
-      retVal: retVal
+      retVal: retVal,
+      changes: batchContext.changes
     };
   };
   invalidateObject(apiName, pk) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
-
-    // inevitably we will want an internal version of this and a "public" one
-    // so we can avoid extra requests
-
-    const query = this.getObjectQuery(apiName, pk);
-    return query.revalidate(true);
-
-    // potentially trigger updates of the lists that included this object?
-    // TODO
-    // could we detect that a list WOULD include it?
+    return this.getObjectQuery(apiName, pk).revalidate(/* force */true);
   }
-  async maybeRevalidateLists(changes) {
+  async maybeRevalidateQueries(changes, optimisticId) {
+    if (changes.isEmpty()) {
+      if (process.env.NODE_ENV !== "production") {
+        // todo
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("No changes, aborting");
+      }
+      return;
+    }
     if (process.env.NODE_ENV !== "production") {
       // todo
-      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, undefined);
-          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") {
         // todo
-        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);
   }
 
   /**
@@ -499,93 +380,23 @@ export class Store {
       apiName = apiName.apiName;
     }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
+      this.logger?.child({
         methodName: "invalidateObjectType"
-      }, changes ? DEBUG_ONLY__changesToString(changes) : void 0);
+      }).info(changes ? DEBUG_ONLY__changesToString(changes) : void 0);
     }
     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) {
-    // 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 (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(() => void 0);
   }
   retain(cacheKey) {
     this.#refCounts.retain(cacheKey);
@@ -594,4 +405,10 @@ export class Store {
     this.#refCounts.release(cacheKey);
   }
 }
+export async function invalidateList(store, args) {
+  const where = store.whereCanonicalizer.canonicalize(args.where ?? {});
+  const orderBy = store.orderByCanonicalizer.canonicalize(args.orderBy ?? {});
+  const cacheKey = store.getCacheKey("list", args.type.type, args.type.apiName, where, orderBy);
+  await store.peekQuery(cacheKey)?.revalidate(true);
+}
 //# sourceMappingURL=Store.js.map