@osdk/client 2.1.0-beta.9 → 2.1.0

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

@@ -0,0 +1,1248 @@
+'use strict';
+
+var chunkFEUFIE6T_cjs = require('../chunk-FEUFIE6T.cjs');
+require('../chunk-Q7SFCCGT.cjs');
+var rxjs = require('rxjs');
+var invariant2 = require('tiny-invariant');
+var trie = require('@wry/trie');
+var mnemonist = require('mnemonist');
+var deepEqual = require('fast-deep-equal');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var invariant2__default = /*#__PURE__*/_interopDefault(invariant2);
+var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
+
+// 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(apiName, where, options, subFn) {
+    return this.#store.observeList(apiName, where, options, subFn);
+  }
+  applyAction(action, args, opts) {
+    return this.#store.applyAction(action, args, opts);
+  }
+  canonicalizeWhereClause(where) {
+    return this.#store.whereCanonicalizer.canonicalize(where);
+  }
+};
+
+// ../../node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
+function isNodeProcess() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process !== "undefined") {
+    const type = process.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process.versions && process.versions.node);
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/msw@2.7.0_@types+node@22.13.1_typescript@5.5.4/node_modules/msw/lib/core/delay.mjs
+var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+var MIN_SERVER_RESPONSE_TIME = 100;
+var MAX_SERVER_RESPONSE_TIME = 400;
+var NODE_SERVER_RESPONSE_TIME = 5;
+function getRealisticResponseTime() {
+  if (isNodeProcess()) {
+    return NODE_SERVER_RESPONSE_TIME;
+  }
+  return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME);
+}
+async function delay(durationOrMode) {
+  let delayTime;
+  if (typeof durationOrMode === "string") {
+    switch (durationOrMode) {
+      case "infinite": {
+        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+        break;
+      }
+      case "real": {
+        delayTime = getRealisticResponseTime();
+        break;
+      }
+      default: {
+        throw new Error(`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`);
+      }
+    }
+  } else if (typeof durationOrMode === "undefined") {
+    delayTime = getRealisticResponseTime();
+  } else {
+    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+      throw new Error(`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`);
+    }
+    delayTime = durationOrMode;
+  }
+  return new Promise((resolve) => setTimeout(resolve, delayTime));
+}
+
+// src/observable/DebugFlags.ts
+process.env.NODE_ENV !== "production" && false;
+var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
+var CacheKeys = class {
+  #cacheKeys = new trie.Trie(false, (keys) => {
+    const ret = {
+      type: keys[0],
+      otherKeys: keys.slice(1)
+    };
+    this.#onCreate(ret);
+    return ret;
+  });
+  #cacheKeyFactories = /* @__PURE__ */ new Map();
+  #onCreate;
+  constructor(whereCanonicalizer, onCreate) {
+    this.#onCreate = onCreate;
+    this.#registerCacheKeyFactory("object", (apiName, pk) => {
+      if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
+      return this.#cacheKeys.lookupArray(["object", apiName, pk]);
+    });
+    this.#registerCacheKeyFactory("list", (apiName, where) => {
+      if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
+      return this.#cacheKeys.lookupArray(["list", apiName, whereCanonicalizer.canonicalize(where)]);
+    });
+  }
+  #registerCacheKeyFactory(type, factory) {
+    this.#cacheKeyFactories.set(type, factory);
+  }
+  get(type, ...args) {
+    const factory = this.#cacheKeyFactories.get(type);
+    !factory ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `no cache key factory for type "${type}"`) : invariant2__default.default(false) : undefined;
+    return factory(...args);
+  }
+  remove(cacheKey) {
+    this.#cacheKeys.remove(cacheKey.type, ...cacheKey.otherKeys);
+  }
+};
+function createChangedObjects() {
+  return {
+    modifiedObjects: new mnemonist.MultiMap(),
+    addedObjects: new mnemonist.MultiMap()
+  };
+}
+
+// src/observable/internal/WeakMapWithEntries.ts
+var WeakMapWithEntries = class {
+  #map = /* @__PURE__ */ new WeakMap();
+  #list = [];
+  #toClean = [];
+  #needsCleaning = false;
+  #registry = new FinalizationRegistry(() => {
+    this.#toClean.push(new WeakRef({}));
+    this.#needsCleaning = true;
+  });
+  constructor() {
+    const weakThis = new WeakRef(this);
+    const intervalId = setInterval(() => {
+      const self = weakThis.deref();
+      if (self) {
+        if (this.#needsCleaning) {
+          this.#clean();
+        }
+      } else {
+        clearInterval(intervalId);
+      }
+    }, 1e3);
+  }
+  #clean() {
+    this.#list = this.#list.filter((ref) => ref.deref() !== undefined);
+  }
+  // functions for WeakMap
+  delete(key) {
+    const ret = this.#map.delete(key);
+    this.#toClean.push(new WeakRef(key));
+    this.#needsCleaning = true;
+    return ret;
+  }
+  get(key) {
+    return this.#map.get(key);
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  /**
+   * Adds a new element with a specified key and value.
+   * @param key Must be an object or symbol.
+   */
+  set(key, value) {
+    if (!this.#map.has(key)) {
+      this.#list.push(new WeakRef(key));
+    }
+    this.#map.set(key, value);
+    return this;
+  }
+  [Symbol.toStringTag] = "WeakMap";
+  // functions for iterables
+  /** Returns an iterable of entries in the map. */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Returns an iterable of key, value pairs for every entry in the map.
+   */
+  entries() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== undefined) {
+          yield [key, self.#map.get(key)];
+        }
+      }
+    }
+    return iter();
+  }
+  /**
+   * Returns an iterable of keys in the map
+   */
+  keys() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== undefined) {
+          yield key;
+        }
+      }
+    }
+    return iter();
+  }
+  /**
+   * Returns an iterable of values in the map
+   */
+  values() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== undefined) {
+          const value = self.#map.get(key);
+          if (value !== undefined) {
+            yield value;
+          }
+        }
+      }
+    }
+    return iter();
+  }
+};
+
+// src/observable/internal/Layer.ts
+var Layer = class _Layer {
+  #parent;
+  #cache = new WeakMapWithEntries();
+  #layerId;
+  constructor(parent, layerId) {
+    this.#parent = parent;
+    this.#layerId = layerId;
+  }
+  get parentLayer() {
+    return this.#parent;
+  }
+  get layerId() {
+    return this.#layerId;
+  }
+  addLayer(layerId) {
+    return new _Layer(this, layerId);
+  }
+  removeLayer(layerId) {
+    if (layerId == null || this.#parent == null) {
+      return this;
+    }
+    if (this.#layerId !== layerId) {
+      this.#parent = this.#parent.removeLayer(layerId);
+      return this;
+    }
+    return this.#parent ?? this;
+  }
+  entries() {
+    return this.#cache.entries();
+  }
+  get(cacheKey) {
+    return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
+  }
+  set(cacheKey, value) {
+    this.#cache.set(cacheKey, value);
+  }
+};
+var Entry = class {
+  constructor(cacheKey, value, lastUpdated) {
+    this.cacheKey = cacheKey;
+    this.value = value;
+    this.lastUpdated = lastUpdated;
+    this.status = "init";
+  }
+};
+function is$and(whereClause) {
+  if (process.env.NODE_ENV !== "production") {
+    if ("$and" in whereClause) {
+      !Array.isArray(whereClause.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : undefined;
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : undefined;
+    }
+  }
+  return "$and" in whereClause;
+}
+function is$or(whereClause) {
+  if (process.env.NODE_ENV !== "production") {
+    if ("$or" in whereClause) {
+      !Array.isArray(whereClause.$or) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $or to be an array") : invariant2__default.default(false) : undefined;
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $or to be present") : invariant2__default.default(false) : undefined;
+    }
+  }
+  return "$or" in whereClause;
+}
+function is$not(whereClause) {
+  if (process.env.NODE_ENV !== "production") {
+    if ("$not" in whereClause) {
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $not to be present") : invariant2__default.default(false) : undefined;
+    }
+  }
+  return "$not" in whereClause;
+}
+function objectSortaMatchesWhereClause(o, whereClause, strict) {
+  if (deepEqual__default.default({}, whereClause)) {
+    return true;
+  }
+  if (is$and(whereClause)) {
+    return whereClause.$and.every((w) => objectSortaMatchesWhereClause(o, w, strict));
+  }
+  if (is$or(whereClause)) {
+    return whereClause.$or.some((w) => objectSortaMatchesWhereClause(o, w, strict));
+  }
+  if (is$not(whereClause)) {
+    return !objectSortaMatchesWhereClause(o, whereClause.$not, strict);
+  }
+  return Object.entries(whereClause).every(([key, filter]) => {
+    if (typeof filter === "object") {
+      const realValue = o[key];
+      const [f] = Object.keys(filter);
+      const expected = filter[f];
+      switch (f) {
+        case "$eq":
+          return realValue === expected;
+        case "$gt":
+          return realValue > expected;
+        case "$lt":
+          return realValue < expected;
+        case "$gte":
+          return realValue >= expected;
+        case "$lte":
+          return realValue <= expected;
+        case "$ne":
+          return realValue !== expected;
+        case "$in":
+          return expected.$in.includes(realValue);
+        case "$isNull":
+          return realValue == null;
+        case "$startsWith":
+          return realValue.startsWith(expected);
+        case "$contains":
+        case "$containsAllTerms":
+        case "$containsAllTermsInOrder":
+        case "$containsAnyTerm":
+        case "$intersects":
+        case "$within":
+          return !strict;
+        default:
+          if (process.env.NODE_ENV !== "production") {
+            process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `Unknown where filter ${f}`) : invariant2__default.default(false) ;
+          }
+          return !strict;
+      }
+    }
+    if (key in o) {
+      if (o[key] === filter) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+// src/observable/internal/Query.ts
+var Query = class {
+  retainCount = 0;
+  #connectable;
+  #subscription;
+  #subject;
+  constructor(store, observable, opts, cacheKey) {
+    this.options = opts;
+    this.cacheKey = cacheKey;
+    this.store = store;
+    this.#subject = observable;
+  }
+  subscribe(observer) {
+    this.#connectable ??= this._createConnectable(this.#subject);
+    this.#subscription = this.#connectable.connect();
+    return this.#connectable.subscribe(observer);
+  }
+  revalidate(force) {
+    if (force) {
+      this.abortController?.abort();
+    }
+    if (this.pendingFetch) {
+      return this.pendingFetch;
+    }
+    if ((this.options.dedupeInterval ?? 0) > 0 && this.lastFetchStarted != null && Date.now() - this.lastFetchStarted < (this.options.dedupeInterval ?? 0)) {
+      return Promise.resolve();
+    }
+    this.store.batch({}, (batch) => {
+      this.setStatus("loading", batch);
+    });
+    this._preFetch();
+    this.lastFetchStarted = Date.now();
+    this.pendingFetch = this._fetch().finally(() => {
+      this.pendingFetch = undefined;
+    });
+    return this.pendingFetch;
+  }
+  _preFetch() {
+  }
+  setStatus(status, batch) {
+    const existing = batch.read(this.cacheKey);
+    if (existing?.status === status) return;
+    batch.write(this.cacheKey, existing?.value, status);
+  }
+  dispose() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.#subscription?.unsubscribe();
+    this._dispose();
+  }
+  _dispose() {
+  }
+};
+
+// src/observable/internal/ListQuery.ts
+rxjs.auditTime(0);
+var ListQuery = class extends Query {
+  // pageSize?: number; // this is the internal page size. we need to track this properly
+  #client;
+  #type;
+  #whereClause;
+  // this represents the minimum number of results we need to load if we revalidate
+  #minNumResults = 0;
+  #nextPageToken;
+  #pendingPageFetch;
+  #toRelease = /* @__PURE__ */ new Set();
+  constructor(store, subject, type, whereClause, cacheKey, opts) {
+    super(store, subject, opts, cacheKey);
+    this.#client = store.client;
+    this.#type = type;
+    this.#whereClause = whereClause;
+    rxjs.observeOn(rxjs.asyncScheduler);
+  }
+  _createConnectable(subject) {
+    return rxjs.connectable(subject.pipe(
+      rxjs.mergeMap((listEntry) => {
+        return rxjs.combineLatest({
+          resolvedList: listEntry?.value?.data == null ? rxjs.of([]) : rxjs.combineLatest(listEntry.value.data.map((cacheKey) => this.store.getSubject(cacheKey).pipe(rxjs.map((objectEntry) => objectEntry?.value)))),
+          isOptimistic: rxjs.of(listEntry.isOptimistic),
+          fetchMore: rxjs.of(this.fetchMore),
+          hasMore: rxjs.of(this.#nextPageToken != null),
+          status: rxjs.of(listEntry.status),
+          lastUpdated: rxjs.of(listEntry.lastUpdated)
+        });
+      }),
+      // like throttle but returns the tail
+      rxjs.auditTime(0)
+    ), {
+      resetOnDisconnect: false,
+      connector: () => new rxjs.ReplaySubject(1)
+    });
+  }
+  _preFetch() {
+    this.#nextPageToken = undefined;
+  }
+  async _fetch() {
+    const objectSet = this.#client({
+      type: "object",
+      apiName: this.#type
+    }).where(this.#whereClause);
+    while (true) {
+      const entry = await this.#fetchPageAndUpdate(objectSet, "loading", this.abortController?.signal);
+      if (!entry) {
+        return;
+      }
+      !entry.value?.data ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : undefined;
+      const count = entry.value.data.length;
+      if (count > this.#minNumResults || this.#nextPageToken == null) {
+        break;
+      }
+    }
+    this.store.batch({}, (batch) => {
+      this.setStatus("loaded", batch);
+    });
+    return Promise.resolve();
+  }
+  fetchMore = () => {
+    if (this.#pendingPageFetch) {
+      return this.#pendingPageFetch;
+    }
+    if (this.pendingFetch) {
+      this.#pendingPageFetch = new Promise(async (res) => {
+        await this.pendingFetch;
+        res(this.fetchMore());
+      });
+      return this.#pendingPageFetch;
+    }
+    if (this.#nextPageToken == null) {
+      return Promise.resolve();
+    }
+    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.#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
+    });
+    if (signal?.aborted) {
+      return;
+    }
+    this.#nextPageToken = nextPageToken;
+    const {
+      retVal
+    } = this.store.batch({}, (batch) => {
+      return this.updateList(data, append, nextPageToken ? status : "loaded", batch);
+    });
+    return retVal;
+  }
+  /**
+   * Caller is responsible for removing the layer
+   *
+   * @param changedObjects
+   * @param optimisticId
+   * @returns
+   */
+  maybeUpdate(changedObjects, optimisticId) {
+    let needsRevalidation = false;
+    const objectsToInsert = [];
+    for (const [type, objects] of changedObjects.addedObjects.associations()) {
+      if (this.cacheKey.otherKeys[0] !== type) {
+        continue;
+      }
+      for (const obj of objects) {
+        const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
+        if (strictMatch) {
+          objectsToInsert.push(obj);
+        } else {
+          const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
+          if (sortaMatch) {
+            needsRevalidation = true;
+          }
+        }
+      }
+    }
+    needsRevalidation ||= objectsToInsert.length > 0;
+    if (objectsToInsert.length > 0) {
+      this.store.batch({
+        optimisticId
+      }, (batch) => {
+        this.updateList(objectsToInsert, true, "loading", batch);
+      });
+    }
+    return needsRevalidation;
+  }
+  maybeRevalidate(changedObjects) {
+    let needsRevalidation = false;
+    for (const [type, objects] of changedObjects.addedObjects.associations()) {
+      if (this.cacheKey.otherKeys[0] !== type) {
+        continue;
+      }
+      for (const obj of objects) {
+        const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
+        if (sortaMatch) {
+          needsRevalidation = true;
+        }
+      }
+    }
+    if (needsRevalidation) {
+      return this.revalidate(true);
+    }
+    return Promise.resolve();
+  }
+  updateList(values, append, status, batch) {
+    let objectCacheKeys = values.map((v) => {
+      if (v instanceof Entry) return v.cacheKey;
+      this.store.getObjectQuery(this.#type, v.$primaryKey).writeToStore(v, "loaded", batch);
+      return this.store.getCacheKey("object", v.$apiName, v.$primaryKey);
+    });
+    const existingList = batch.read(this.cacheKey);
+    if (!batch.optimisticWrite) {
+      if (!append) {
+        for (const objectCacheKey of existingList?.value?.data ?? []) {
+          this.store.release(objectCacheKey);
+          this.#toRelease.delete(objectCacheKey);
+        }
+      }
+      for (const objectCacheKey of objectCacheKeys) {
+        this.#toRelease.add(objectCacheKey);
+        this.store.retain(objectCacheKey);
+      }
+    }
+    if (append) {
+      objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
+    }
+    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)) {
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    batch.modifiedLists.add(this.cacheKey);
+    return ret;
+  }
+  _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);
+        }
+      }
+    });
+  }
+};
+function isListCacheKey(cacheKey, apiName) {
+  return cacheKey.type === "list" && (apiName == null || cacheKey.otherKeys[0] === apiName);
+}
+var ObjectQuery = class extends Query {
+  #apiName;
+  #pk;
+  constructor(store, subject, type, pk, cacheKey, opts) {
+    super(store, subject, opts, cacheKey);
+    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 _fetch() {
+    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)) {
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    if (entry) {
+      batch.modifiedObjects.add(this.cacheKey);
+    } else {
+      batch.addedObjects.add(this.cacheKey);
+    }
+    return ret;
+  }
+};
+
+// src/observable/internal/OptimisticId.ts
+function createOptimisticId() {
+  if (process.env.NODE_ENV !== "production") {
+    if (createOptimisticId.counter === undefined) {
+      createOptimisticId.counter = 0;
+    }
+    return {
+      __optimisticId: createOptimisticId.counter++
+    };
+  }
+  return /* @__PURE__ */ Object.create(null);
+}
+
+// src/observable/internal/OptimisticJob.ts
+var OptimisticJob = class {
+  #result;
+  constructor(store, optimisticId) {
+    const updatedObjects = [];
+    const addedObjects = [];
+    this.getResult = () => {
+      return this.#result ??= (async () => {
+        const changes = {
+          addedObjects: new mnemonist.MultiMap(),
+          modifiedObjects: new mnemonist.MultiMap()
+        };
+        const settled = await Promise.allSettled(addedObjects);
+        for (const added of settled) {
+          if (added.status === "fulfilled") {
+            changes.addedObjects.set(added.value.$objectType, added.value);
+          } else {
+            throw added;
+          }
+        }
+        for (const modified of updatedObjects) {
+          changes.modifiedObjects.set(modified.$apiName, modified);
+        }
+        store.batch({
+          optimisticId
+        }, (batch) => {
+          for (const a of ["addedObjects", "modifiedObjects"]) {
+            for (const b of changes[a].values()) {
+              store.getObjectQuery(b.$objectType, b.$primaryKey).writeToStore(b, "loading", batch);
+            }
+          }
+        });
+        return changes;
+      })();
+    };
+    this.context = {
+      updateObject(value) {
+        updatedObjects.push(value);
+        return this;
+      },
+      createObject(type, pk, properties) {
+        const create = store.client[chunkFEUFIE6T_cjs.additionalContext].objectFactory2(store.client[chunkFEUFIE6T_cjs.additionalContext], [{
+          $primaryKey: pk,
+          $apiName: type.apiName,
+          $objectType: type.apiName,
+          ...properties
+        }], undefined).then((x) => x[0]);
+        addedObjects.push(create);
+        return this;
+      }
+    };
+  }
+};
+function runOptimisticJob(store, optimisticUpdate) {
+  if (!optimisticUpdate) {
+    return () => Promise.resolve();
+  }
+  const optimisticId = createOptimisticId();
+  const job = new OptimisticJob(store, optimisticId);
+  optimisticUpdate(job.context);
+  const optimisticApplicationDone = job.getResult().then((result) => {
+    store.maybeUpdateLists(result, optimisticId);
+  });
+  return () => {
+    return optimisticApplicationDone.finally(() => {
+      store.removeLayer(optimisticId);
+    });
+  };
+}
+
+// src/observable/internal/RefCounts.ts
+var RefCounts = class {
+  refCounts = /* @__PURE__ */ new Map();
+  // keeps our objects around for some extended duration after they are no longer
+  // needed which is good for quick clicks across tabs.
+  gcMap = /* @__PURE__ */ new Map();
+  constructor(keepAlive, cleanup) {
+    this.keepAlive = keepAlive;
+    this.cleanup = cleanup;
+  }
+  register(key) {
+    if (!this.refCounts.has(key)) {
+      this.gcMap.set(key, Date.now() + this.keepAlive);
+    }
+    return key;
+  }
+  retain(key) {
+    const count = this.refCounts.get(key) ?? 0;
+    this.refCounts.set(key, count + 1);
+    if (this.gcMap.has(key)) {
+      this.gcMap.delete(key);
+    }
+  }
+  release(key) {
+    const count = this.refCounts.get(key) ?? 0;
+    if (count === 1) {
+      this.refCounts.delete(key);
+      this.gcMap.set(key, Date.now() + this.keepAlive);
+    } else {
+      this.refCounts.set(key, count - 1);
+    }
+  }
+  has(key) {
+    return this.refCounts.has(key);
+  }
+  gc() {
+    const now = Date.now();
+    for (const [key, deathTime] of this.gcMap) {
+      if (deathTime < now) {
+        this.gcMap.delete(key);
+        this.cleanup(key);
+      }
+    }
+  }
+};
+var WhereClauseCanonicalizer = class {
+  #cache = /* @__PURE__ */ new WeakMap();
+  /**
+   * This is a trie that stores the sorted collapsed keys of a where clause to
+   * the cache key for canonicalized options. In theory this keeps the number of
+   * deepEqual comparisons down to a minimum but its probably overkill.
+   */
+  #trie = new trie.Trie();
+  /**
+   * This is a cache from the cacheKey provided by `this.#trie` to the potential
+   * canonicalized options.
+   */
+  #existingOptions = /* @__PURE__ */ new Map();
+  canonicalize(where) {
+    if (this.#cache.has(where)) {
+      return this.#cache.get(where);
+    }
+    const keysSet = /* @__PURE__ */ new Set();
+    const tmpCanon = 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) {
+      lookupEntry.options.push(new WeakRef(canon));
+    }
+    this.#cache.set(where, canon);
+    return canon;
+  }
+  #toCanon = (where, set = /* @__PURE__ */ new Set()) => {
+    if ("$and" in where) {
+      if (process.env.NODE_ENV !== "production") {
+        !Array.isArray(where.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : undefined;
+        !(Object.keys(where).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : undefined;
+      }
+      if (where.$and.length === 0) {
+        return {};
+      }
+      if (where.$and.length === 1) {
+        return this.#toCanon(where.$and[0], set);
+      }
+    }
+    return Object.fromEntries(Object.entries(where).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => {
+      set.add(k);
+      if (k === "$and" || k === "$or") {
+        return [k, v.map((x) => this.#toCanon(x, set))];
+      }
+      if (k !== "$not" && typeof v === "object" && "$eq" in v) {
+        return [k, v["$eq"]];
+      }
+      return [k, v];
+    }));
+  };
+};
+
+// src/observable/internal/Store.ts
+var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
+function createInitEntry(cacheKey) {
+  return {
+    cacheKey,
+    status: "init",
+    value: undefined,
+    lastUpdated: 0
+  };
+}
+var Store = class {
+  whereCanonicalizer = new WhereClauseCanonicalizer();
+  #truthLayer = new Layer(undefined, undefined);
+  #topLayer;
+  #queries = /* @__PURE__ */ new WeakMap();
+  #cacheKeyToSubject = /* @__PURE__ */ new WeakMap();
+  #cacheKeys;
+  #refCounts = new RefCounts(6e4, (k) => this.#cleanupCacheKey(k));
+  #finalizationRegistry;
+  constructor(client) {
+    this.client = client;
+    this.#topLayer = this.#truthLayer;
+    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, (k) => {
+      this.#refCounts.register(k);
+    });
+    setInterval(() => {
+      this.#refCounts.gc();
+    }, 1e3);
+    this.#finalizationRegistry = new FinalizationRegistry((cleanupCallback) => {
+      try {
+        cleanupCallback();
+      } catch (e) {
+        console.error("Caught an error while running a finalization callback", e);
+      }
+    });
+  }
+  /**
+   * Called after a key is no longer retained and the timeout has elapsed
+   * @param key
+   */
+  #cleanupCacheKey = (key) => {
+    const subject = this.peekSubject(key);
+    this.#cacheKeys.remove(key);
+    if (process.env.NODE_ENV !== "production") {
+      !subject ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : undefined;
+    }
+    if (subject) {
+      subject.complete();
+      this.#cacheKeyToSubject.delete(key);
+    }
+    this.#queries.get(key)?.dispose();
+    this.#queries.delete(key);
+  };
+  applyAction = (action, args, opts) => {
+    return new ActionApplication(this).applyAction(action, args, opts);
+  };
+  removeLayer(layerId) {
+    !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "undefined is the reserved layerId for the truth layer") : invariant2__default.default(false) : undefined;
+    let currentLayer = this.#topLayer;
+    const cacheKeys = /* @__PURE__ */ new Map();
+    while (currentLayer != null && currentLayer.parentLayer != null) {
+      if (currentLayer.layerId === layerId) {
+        for (const [k, v] of currentLayer.entries()) {
+          if (cacheKeys.has(k)) continue;
+          cacheKeys.set(k, v);
+        }
+      }
+      currentLayer = currentLayer.parentLayer;
+    }
+    this.#topLayer = this.#topLayer.removeLayer(layerId);
+    for (const [k, oldEntry] of cacheKeys) {
+      const currentEntry = this.#topLayer.get(k);
+      if (oldEntry !== currentEntry) {
+        this.peekSubject(k)?.next({
+          // eslint-disable-next-line @typescript-eslint/no-misused-spread
+          ...currentEntry ?? createInitEntry(k),
+          isOptimistic: currentEntry?.value !== this.#truthLayer.get(k)?.value
+        });
+      }
+    }
+  }
+  getCacheKey(type, ...args) {
+    return this.#refCounts.register(this.#cacheKeys.get(type, ...args));
+  }
+  peekSubject = (cacheKey) => {
+    return this.#cacheKeyToSubject.get(cacheKey);
+  };
+  getSubject = (cacheKey) => {
+    let subject = this.#cacheKeyToSubject.get(cacheKey);
+    if (!subject) {
+      const initialValue = this.#topLayer.get(cacheKey) ?? createInitEntry(cacheKey);
+      subject = new rxjs.BehaviorSubject({
+        // eslint-disable-next-line @typescript-eslint/no-misused-spread
+        ...initialValue,
+        isOptimistic: initialValue.value !== this.#truthLayer.get(cacheKey)?.value
+      });
+      this.#cacheKeyToSubject.set(cacheKey, subject);
+    }
+    return subject;
+  };
+  observeObject(apiName, pk, options, subFn) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const query = this.getObjectQuery(apiName, pk);
+    this.#refCounts.retain(query.cacheKey);
+    if (options.mode !== "offline") {
+      void query.revalidate(options.mode === "force");
+    }
+    const sub = query.subscribe({
+      next: subFn
+    });
+    return {
+      unsubscribe: () => {
+        sub.unsubscribe();
+        this.#refCounts.release(query.cacheKey);
+      }
+    };
+  }
+  observeList(apiName, where, options, subFn) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const query = this.getListQuery(apiName, where, options);
+    this.#refCounts.retain(query.cacheKey);
+    if (options.mode !== "offline") {
+      void query.revalidate(options.mode === "force");
+    }
+    const sub = query.subscribe({
+      next: subFn
+    });
+    return {
+      unsubscribe: () => {
+        sub.unsubscribe();
+        this.#refCounts.release(query.cacheKey);
+      }
+    };
+  }
+  #peekQuery(cacheKey) {
+    return this.#queries.get(cacheKey);
+  }
+  #getQuery(cacheKey, createQuery) {
+    let query = this.#peekQuery(cacheKey);
+    if (!query) {
+      query = createQuery();
+      this.#queries.set(cacheKey, query);
+    }
+    return query;
+  }
+  getListQuery(apiName, where, opts, peek = false) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const canonWhere = this.whereCanonicalizer.canonicalize(where);
+    const listCacheKey = this.getCacheKey("list", apiName, canonWhere);
+    return this.#getQuery(listCacheKey, () => {
+      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, listCacheKey, opts);
+    });
+  }
+  getObjectQuery(apiName, pk) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const objectCacheKey = this.getCacheKey("object", apiName, pk);
+    return this.#getQuery(objectCacheKey, () => new ObjectQuery(this, this.getSubject(objectCacheKey), apiName, pk, objectCacheKey, {
+      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;
+  }
+  batch = ({
+    optimisticId
+  }, batchFn) => {
+    !(optimisticId === undefined || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "optimistic must be undefined or not falsy") : invariant2__default.default(false) : undefined;
+    let needsLayer = optimisticId !== undefined;
+    const batchContext = {
+      addedObjects: /* @__PURE__ */ new Set(),
+      modifiedObjects: /* @__PURE__ */ new Set(),
+      modifiedLists: /* @__PURE__ */ new Set(),
+      createLayerIfNeeded: () => {
+        if (needsLayer) {
+          this.#topLayer = this.#topLayer.addLayer(optimisticId);
+          needsLayer = false;
+        }
+      },
+      optimisticWrite: !!optimisticId,
+      write: (cacheKey, value, status) => {
+        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
+        };
+        writeLayer.set(cacheKey, newValue);
+        const newTopValue = this.#topLayer.get(cacheKey);
+        if (oldTopValue !== newTopValue) {
+          this.#cacheKeyToSubject.get(cacheKey)?.next({
+            ...newValue,
+            isOptimistic: newTopValue?.value !== this.#truthLayer.get(cacheKey)?.value
+          });
+        }
+        return newValue;
+      },
+      read: (cacheKey) => {
+        return optimisticId ? this.#topLayer.get(cacheKey) : this.#truthLayer.get(cacheKey);
+      }
+    };
+    const retVal = batchFn(batchContext);
+    return {
+      batchResult: batchContext,
+      retVal
+    };
+  };
+  invalidateObject(apiName, pk) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const query = this.getObjectQuery(apiName, pk);
+    return query.revalidate(true);
+  }
+  maybeRevalidateLists(changes) {
+    for (const [cacheKey, v] of this.#truthLayer.entries()) {
+      if (isListCacheKey(cacheKey)) {
+        void this.#peekQuery(cacheKey)?.maybeRevalidate(changes);
+      }
+    }
+  }
+  maybeUpdateLists(changes, optimisticId) {
+    for (const [cacheKey, v] of this.#truthLayer.entries()) {
+      if (isListCacheKey(cacheKey)) {
+        void this.#peekQuery(cacheKey)?.maybeUpdate(changes, optimisticId);
+      }
+    }
+  }
+  invalidateObjectType(apiName) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    for (const [cacheKey, v] of this.#truthLayer.entries()) {
+      if (isListCacheKey(cacheKey, apiName)) {
+        void this.#peekQuery(cacheKey)?.revalidate(true);
+      }
+    }
+  }
+  invalidateList(apiName, where) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const cacheKey = this.getCacheKey("list", apiName, where);
+    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;
+  }
+  updateList(apiName, where, values, {
+    optimisticId
+  } = {}, opts = {
+    dedupeInterval: 0
+  }) {
+    if (typeof apiName !== "string") {
+      apiName = apiName.apiName;
+    }
+    const query = this.getListQuery(apiName, where, opts);
+    this.batch({
+      optimisticId
+    }, (b) => {
+      query.updateList(values, false, "loaded", b);
+    });
+  }
+  retain(cacheKey) {
+    this.#refCounts.retain(cacheKey);
+  }
+  release(cacheKey) {
+    this.#refCounts.release(cacheKey);
+  }
+};
+var ActionApplication = class {
+  constructor(store) {
+    this.store = store;
+  }
+  applyAction = (action, args, {
+    optimisticUpdate
+  } = {}) => {
+    const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
+    return (async () => {
+      try {
+        const actionResults = await this.store.client(action).applyAction(args, {
+          $returnEdits: true
+        });
+        if (ACTION_DELAY > 0) {
+          console.log("action done, pausing");
+          await delay(ACTION_DELAY);
+          console.log("action done, pausing done");
+        }
+        await this.#invalidateActionEditResponse(actionResults);
+        return actionResults;
+      } finally {
+        await removeOptimisticResult();
+      }
+    })();
+  };
+  #invalidateActionEditResponse = (value) => {
+    const typesToInvalidate = /* @__PURE__ */ new Set();
+    let promisesToWait = [];
+    if (value.type === "edits") {
+      for (const obj of value.modifiedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+      }
+      for (const obj of value.addedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+        typesToInvalidate.add(obj.objectType);
+      }
+      promisesToWait = [Promise.allSettled(promisesToWait).then(() => {
+        const changes2 = this.#changesFromActionEditResponse(value);
+        this.store.maybeRevalidateLists(changes2);
+      })];
+    } else {
+      for (const apiName of value.editedObjectTypes) {
+        typesToInvalidate.add(apiName.toString());
+      }
+    }
+    return Promise.allSettled(promisesToWait).then(() => {
+      for (const objectType of typesToInvalidate) {
+        this.store.invalidateObjectType(objectType);
+      }
+      return value;
+    });
+  };
+  #changesFromActionEditResponse = (value) => {
+    const changes = createChangedObjects();
+    for (const changeType of ["addedObjects", "modifiedObjects"]) {
+      for (const {
+        objectType,
+        primaryKey
+      } of value[changeType] ?? []) {
+        const obj = this.store.getObject(objectType, primaryKey);
+        if (obj) {
+          changes[changeType].set(objectType, obj);
+        }
+      }
+    }
+    return changes;
+  };
+};
+
+// src/observable/ObservableClient.ts
+function createObservableClient(client) {
+  return new ObservableClientImpl(new Store(client));
+}
+
+Object.defineProperty(exports, "augment", {
+  enumerable: true,
+  get: function () { return chunkFEUFIE6T_cjs.augment; }
+});
+exports.createObservableClient = createObservableClient;
+//# sourceMappingURL=unstable-do-not-use.cjs.map
+//# sourceMappingURL=unstable-do-not-use.cjs.map