@osdk/client 2.4.2 → 2.5.0-beta.10

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Trie } from "@wry/trie";
+const defaultMakeData = () => Object.create(null);
+
+/**
+ * The `WeakRefTrie` class uses weak references to store data, allowing for automatic garbage collection
+ * of entries that are no longer in use.
+ *
+ * The original trie from @wry/trie does not do automatic cleanup of old entries.
+ */
+export class WeakRefTrie {
+  #finalizer = new FinalizationRegistry(orderBy => {
+    this.#trie.removeArray(Object.entries(orderBy).flat());
+  });
+  #trie;
+  constructor(makeData = defaultMakeData) {
+    this.#trie = new Trie(false, array => {
+      const data = makeData(array);
+      this.#finalizer.register(data, array);
+      return new WeakRef(data);
+    });
+  }
+  lookupArray(array) {
+    const maybe = this.#trie.lookupArray(array);
+    let ret = maybe.deref();
+    if (maybe && !ret) {
+      // in case finalizer hasn't run
+      this.#trie.removeArray(array);
+      ret = this.#trie.lookupArray(array).deref();
+    }
+    return ret;
+  }
+  peekArray(array) {
+    const maybe = this.#trie.peekArray(array);
+    const ret = maybe?.deref();
+    if (maybe && !ret) {
+      // in case finalizer hasn't run
+      this.#trie.removeArray(array);
+    }
+    return ret;
+  }
+  removeArray(array) {
+    return this.#trie.removeArray(array)?.deref();
+  }
+}
+//# sourceMappingURL=WeakRefTrie.js.map

package/build/browser/observable/internal/WeakRefTrie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeakRefTrie.js","names":["Trie","defaultMakeData","Object","create","WeakRefTrie","finalizer","FinalizationRegistry","orderBy","trie","removeArray","entries","flat","constructor","makeData","array","data","register","WeakRef","lookupArray","maybe","ret","deref","peekArray"],"sources":["WeakRefTrie.ts"],"sourcesContent":["/*\n * Copyright 2025 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Trie } from \"@wry/trie\";\n\nconst defaultMakeData = () => Object.create(null);\n\n/**\n * The `WeakRefTrie` class uses weak references to store data, allowing for automatic garbage collection\n * of entries that are no longer in use.\n *\n * The original trie from @wry/trie does not do automatic cleanup of old entries.\n */\nexport class WeakRefTrie<X extends object> {\n  #finalizer = new FinalizationRegistry<\n    Array<string>\n  >((orderBy) => {\n    this.#trie.removeArray(\n      Object.entries(orderBy).flat(),\n    );\n  });\n\n  #trie: Trie<WeakRef<X>>;\n\n  constructor(makeData: (array: any[]) => X = defaultMakeData) {\n    this.#trie = new Trie<WeakRef<X>>(\n      false,\n      (array) => {\n        const data = makeData(array);\n        this.#finalizer.register(data, array);\n        return new WeakRef(data);\n      },\n    );\n  }\n\n  lookupArray<T extends IArguments | any[]>(array: T): X {\n    const maybe = this.#trie.lookupArray(array);\n    let ret = maybe.deref();\n    if (maybe && !ret) {\n      // in case finalizer hasn't run\n      this.#trie.removeArray(array);\n      ret = this.#trie.lookupArray(array).deref();\n    }\n    return ret!;\n  }\n\n  peekArray<T extends IArguments | any[]>(array: T): X | undefined {\n    const maybe = this.#trie.peekArray(array);\n    const ret = maybe?.deref();\n    if (maybe && !ret) {\n      // in case finalizer hasn't run\n      this.#trie.removeArray(array);\n    }\n    return ret;\n  }\n\n  removeArray<T extends IArguments | any[]>(array: T): X | undefined {\n    return this.#trie.removeArray(array)?.deref();\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,IAAI,QAAQ,WAAW;AAEhC,MAAMC,eAAe,GAAGA,CAAA,KAAMC,MAAM,CAACC,MAAM,CAAC,IAAI,CAAC;;AAEjD;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,WAAW,CAAmB;EACzC,CAACC,SAAS,GAAG,IAAIC,oBAAoB,CAElCC,OAAO,IAAK;IACb,IAAI,CAAC,CAACC,IAAI,CAACC,WAAW,CACpBP,MAAM,CAACQ,OAAO,CAACH,OAAO,CAAC,CAACI,IAAI,CAAC,CAC/B,CAAC;EACH,CAAC,CAAC;EAEF,CAACH,IAAI;EAELI,WAAWA,CAACC,QAA6B,GAAGZ,eAAe,EAAE;IAC3D,IAAI,CAAC,CAACO,IAAI,GAAG,IAAIR,IAAI,CACnB,KAAK,EACJc,KAAK,IAAK;MACT,MAAMC,IAAI,GAAGF,QAAQ,CAACC,KAAK,CAAC;MAC5B,IAAI,CAAC,CAACT,SAAS,CAACW,QAAQ,CAACD,IAAI,EAAED,KAAK,CAAC;MACrC,OAAO,IAAIG,OAAO,CAACF,IAAI,CAAC;IAC1B,CACF,CAAC;EACH;EAEAG,WAAWA,CAA+BJ,KAAQ,EAAK;IACrD,MAAMK,KAAK,GAAG,IAAI,CAAC,CAACX,IAAI,CAACU,WAAW,CAACJ,KAAK,CAAC;IAC3C,IAAIM,GAAG,GAAGD,KAAK,CAACE,KAAK,CAAC,CAAC;IACvB,IAAIF,KAAK,IAAI,CAACC,GAAG,EAAE;MACjB;MACA,IAAI,CAAC,CAACZ,IAAI,CAACC,WAAW,CAACK,KAAK,CAAC;MAC7BM,GAAG,GAAG,IAAI,CAAC,CAACZ,IAAI,CAACU,WAAW,CAACJ,KAAK,CAAC,CAACO,KAAK,CAAC,CAAC;IAC7C;IACA,OAAOD,GAAG;EACZ;EAEAE,SAASA,CAA+BR,KAAQ,EAAiB;IAC/D,MAAMK,KAAK,GAAG,IAAI,CAAC,CAACX,IAAI,CAACc,SAAS,CAACR,KAAK,CAAC;IACzC,MAAMM,GAAG,GAAGD,KAAK,EAAEE,KAAK,CAAC,CAAC;IAC1B,IAAIF,KAAK,IAAI,CAACC,GAAG,EAAE;MACjB;MACA,IAAI,CAAC,CAACZ,IAAI,CAACC,WAAW,CAACK,KAAK,CAAC;IAC/B;IACA,OAAOM,GAAG;EACZ;EAEAX,WAAWA,CAA+BK,KAAQ,EAAiB;IACjE,OAAO,IAAI,CAAC,CAACN,IAAI,CAACC,WAAW,CAACK,KAAK,CAAC,EAAEO,KAAK,CAAC,CAAC;EAC/C;AACF","ignoreList":[]}

package/build/browser/observable/internal/{ActionApplication.js → actions/ActionApplication.js}

@@ -86,8 +86,8 @@ export class ActionApplication {
           objectType,
           primaryKey
         } of deletedObjects ?? []) {
-          const cacheKey = this.store.getCacheKey("object", objectType, primaryKey);
-          this.store.peekQuery(cacheKey)?.deleteFromStore("loaded",
+          const cacheKey = this.store.cacheKeys.get("object", objectType, primaryKey);
+          this.store.queries.peek(cacheKey)?.deleteFromStore("loaded",
           // this is probably not the best value to use
           batch);
         }

package/build/browser/observable/internal/actions/ActionApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionApplication.js","names":["runOptimisticJob","ACTION_DELAY","process","env","NODE_ENV","ActionApplication","constructor","store","applyAction","action","args","optimisticUpdate","logger","child","methodName","removeOptimisticResult","Array","isArray","debug","results","client","batchApplyAction","$returnEdits","invalidateActionEditResponse","actionResults","delay","default","#invalidateActionEditResponse","deletedObjects","modifiedObjects","addedObjects","editedObjectTypes","type","changes","promisesToWait","list","obj","push","invalidateObject","objectType","primaryKey","batch","cacheKey","cacheKeys","get","queries","peek","deleteFromStore","Promise","all","apiName","invalidateObjectType"],"sources":["ActionApplication.ts"],"sourcesContent":["/*\n * Copyright 2025 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type {\n  ActionDefinition,\n  ActionEditResponse,\n  ActionReturnTypeForOptions,\n} from \"@osdk/api\";\nimport type { ActionSignatureFromDef } from \"../../../actions/applyAction.js\";\nimport { type Changes } from \"../Changes.js\";\nimport type { ObjectCacheKey } from \"../object/ObjectCacheKey.js\";\nimport type { Store } from \"../Store.js\";\nimport { runOptimisticJob } from \"./OptimisticJob.js\";\n\nconst ACTION_DELAY = process.env.NODE_ENV === \"production\" ? 0 : 1000;\n\nexport class ActionApplication {\n  constructor(private store: Store) {}\n\n  applyAction: <Q extends ActionDefinition<any>>(\n    action: Q,\n    args:\n      | Parameters<ActionSignatureFromDef<Q>[\"applyAction\"]>[0]\n      | Array<Parameters<ActionSignatureFromDef<Q>[\"applyAction\"]>[0]>,\n    opts?: Store.ApplyActionOptions,\n  ) => Promise<ActionEditResponse> = async (\n    action,\n    args,\n    { optimisticUpdate } = {},\n  ) => {\n    const logger = process.env.NODE_ENV !== \"production\"\n      ? this.store.logger?.child({ methodName: \"applyAction\" })\n      : this.store.logger;\n    const removeOptimisticResult = runOptimisticJob(\n      this.store,\n      optimisticUpdate,\n    );\n\n    return await (async () => {\n      try {\n        if (Array.isArray(args)) {\n          if (process.env.NODE_ENV !== \"production\") {\n            logger?.debug(\"applying action to multiple args\", args);\n          }\n\n          const results: ActionReturnTypeForOptions<{ $returnEdits: true }> =\n            await this.store\n              .client(action).batchApplyAction(\n                args,\n                { $returnEdits: true },\n              );\n\n          await this.#invalidateActionEditResponse(results);\n\n          return results;\n        }\n\n        // The types for client get confused when we dynamically applyAction so we\n        // have to deal with the `any` here and force cast it to what it should be.\n        // TODO: Update the types so this doesn't happen!\n\n        const actionResults: ActionEditResponse = await this.store.client(\n          action,\n        ).applyAction(args as any, { $returnEdits: true });\n\n        if (process.env.NODE_ENV !== \"production\") {\n          if (ACTION_DELAY > 0) {\n            logger?.debug(\"action done, pausing\", actionResults);\n            const delay = (await import(\"delay\")).default;\n            await delay(ACTION_DELAY);\n            logger?.debug(\"action done, pausing done\");\n          }\n        }\n        await this.#invalidateActionEditResponse(actionResults);\n        return actionResults;\n      } finally {\n        if (process.env.NODE_ENV !== \"production\") {\n          logger?.debug(\n            \"optimistic action complete; remove the results\",\n          );\n        }\n        // make sure this happens even if the action fails\n        await removeOptimisticResult();\n      }\n    })();\n  };\n\n  #invalidateActionEditResponse = async (\n    { deletedObjects, modifiedObjects, addedObjects, editedObjectTypes, type }:\n      ActionEditResponse,\n  ): Promise<void> => {\n    let changes: Changes | undefined;\n    if (type === \"edits\") {\n      const promisesToWait: Promise<any>[] = [];\n\n      for (const list of [deletedObjects, modifiedObjects, addedObjects]) {\n        for (const obj of list ?? []) {\n          promisesToWait.push(\n            this.store.invalidateObject(obj.objectType, obj.primaryKey),\n          );\n        }\n      }\n\n      this.store.batch({}, (batch) => {\n        for (const { objectType, primaryKey } of deletedObjects ?? []) {\n          const cacheKey = this.store.cacheKeys.get<ObjectCacheKey>(\n            \"object\",\n            objectType,\n            primaryKey,\n          );\n          this.store.queries.peek(cacheKey)?.deleteFromStore(\n            \"loaded\", // this is probably not the best value to use\n            batch,\n          );\n        }\n      });\n      await Promise.all(promisesToWait);\n    } else {\n      for (const apiName of editedObjectTypes) {\n        await this.store.invalidateObjectType(apiName as string, changes);\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/{esm/observable/internal → browser/observable/internal/actions}/OptimisticJob.js

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { additionalContext } from "../../Client.js";
-import { createOptimisticId } from "./OptimisticId.js";
+import { additionalContext } from "../../../Client.js";
+import { createOptimisticId } from "../OptimisticId.js";
 export class OptimisticJob {
   #result;
   constructor(store, optimisticId) {
@@ -41,17 +41,26 @@ export class OptimisticJob {
         }, batch => {
           for (const obj of addedObjects) {
             if (obj.status === "fulfilled") {
-              store.getObjectQuery(obj.value.$objectType, obj.value.$primaryKey).writeToStore(obj.value, "loading", batch);
+              store.objects.getQuery({
+                apiName: obj.value.$objectType,
+                pk: obj.value.$primaryKey
+              }).writeToStore(obj.value, "loading", batch);
             } else {
               // TODO FIXME
               throw obj;
             }
           }
           for (const obj of updatedObjects) {
-            store.getObjectQuery(obj.$objectType, obj.$primaryKey).writeToStore(obj, "loading", batch);
+            store.objects.getQuery({
+              apiName: obj.$objectType,
+              pk: obj.$primaryKey
+            }).writeToStore(obj, "loading", batch);
           }
           for (const obj of deletedObjects) {
-            store.getObjectQuery(obj.$objectType, obj.$primaryKey).deleteFromStore("loading", batch);
+            store.objects.getQuery({
+              apiName: obj.$objectType,
+              pk: obj.$primaryKey
+            }).deleteFromStore("loading", batch);
           }
         });
         return batchResult.changes;
@@ -93,7 +102,7 @@ export function runOptimisticJob(store, optimisticUpdate) {
     return optimisticApplicationDone.then(
     // we don't want to leak the result
     () => undefined).finally(() => {
-      store.removeLayer(optimisticId);
+      store.layers.remove(optimisticId);
     });
   };
 }

package/build/browser/observable/internal/actions/OptimisticJob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptimisticJob.js","names":["additionalContext","createOptimisticId","OptimisticJob","result","constructor","store","optimisticId","updatedObjects","addedObjectPromises","deletedObjects","getResult","addedObjects","Promise","allSettled","batchResult","batch","obj","status","objects","getQuery","apiName","value","$objectType","pk","$primaryKey","writeToStore","deleteFromStore","changes","context","updateObject","push","createObject","type","properties","create","client","objectFactory2","$apiName","undefined","then","objs","deleteObject","runOptimisticJob","optimisticUpdate","resolve","job","optimisticApplicationDone","finally","layers","remove"],"sources":["OptimisticJob.ts"],"sourcesContent":["/*\n * Copyright 2025 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { additionalContext } from \"../../../Client.js\";\nimport type { ObjectHolder } from \"../../../object/convertWireToOsdkObjects/ObjectHolder.js\";\nimport type { OptimisticBuilder } from \"../../OptimisticBuilder.js\";\nimport { type Changes } from \"../Changes.js\";\nimport { createOptimisticId, type OptimisticId } from \"../OptimisticId.js\";\nimport type { Store } from \"../Store.js\";\n\nexport class OptimisticJob {\n  context: OptimisticBuilder;\n  getResult: () => Promise<Changes>;\n  #result!: Promise<Changes>;\n\n  constructor(store: Store, optimisticId: OptimisticId) {\n    const updatedObjects: Array<\n      ObjectHolder\n    > = [];\n\n    // due to potentially needing to fetch the object metadata,\n    // the creation of objects needs to be async. In practice, the\n    // metadata is cached.\n    const addedObjectPromises: Array<\n      Promise<ObjectHolder>\n    > = [];\n\n    const deletedObjects: Array<ObjectHolder> = [];\n\n    // TODO, this code needs to be refactored. its weird right now\n    // but the contract for `runOptimisticJob` is good.\n\n    // todo memoize this\n    this.getResult = () => {\n      return this.#result ??= (async () => {\n        const addedObjects = await Promise.allSettled(\n          addedObjectPromises,\n        );\n\n        const { batchResult } = store.batch({ optimisticId }, (batch) => {\n          for (const obj of addedObjects) {\n            if (obj.status === \"fulfilled\") {\n              store.objects.getQuery({\n                apiName: obj.value.$objectType,\n                pk: obj.value.$primaryKey,\n              }).writeToStore(obj.value, \"loading\", batch);\n            } else {\n              // TODO FIXME\n              throw obj;\n            }\n          }\n\n          for (const obj of updatedObjects) {\n            store.objects.getQuery({\n              apiName: obj.$objectType,\n              pk: obj.$primaryKey,\n            }).writeToStore(obj, \"loading\", batch);\n          }\n\n          for (const obj of deletedObjects) {\n            store.objects.getQuery({\n              apiName: obj.$objectType,\n              pk: obj.$primaryKey,\n            }).deleteFromStore(\"loading\", batch);\n          }\n        });\n\n        return batchResult.changes;\n      })();\n    };\n\n    this.context = {\n      updateObject(value) {\n        updatedObjects.push(value as unknown as ObjectHolder<typeof value>);\n        return this;\n      },\n      createObject(type, pk, properties) {\n        const create = store.client[additionalContext].objectFactory2(\n          store.client[additionalContext],\n          [{\n            $primaryKey: pk,\n            $apiName: type.apiName,\n            $objectType: type.apiName,\n            ...properties,\n          }],\n          undefined,\n          {},\n        ).then(objs => {\n          return objs[0];\n        });\n\n        addedObjectPromises.push(create);\n        return this;\n      },\n      deleteObject(value) {\n        deletedObjects.push(value as unknown as ObjectHolder<typeof value>);\n        return this;\n      },\n    };\n  }\n}\n\nexport function runOptimisticJob(\n  store: Store,\n  optimisticUpdate: undefined | ((ctx: OptimisticBuilder) => void),\n): () => Promise<void> {\n  if (!optimisticUpdate) {\n    return () => Promise.resolve();\n  }\n\n  const optimisticId = createOptimisticId();\n  const job = new OptimisticJob(store, optimisticId);\n  optimisticUpdate(job.context);\n  const optimisticApplicationDone = job.getResult();\n\n  return () => {\n    return optimisticApplicationDone.then(\n      // we don't want to leak the result\n      () => undefined,\n    ).finally(() => {\n      store.layers.remove(optimisticId);\n    });\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/browser/observable/internal/base-list/BaseCollectionQuery.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BaseCollectionQuery.js.map

package/build/browser/observable/internal/base-list/BaseCollectionQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCollectionQuery.js","names":[],"sources":["BaseCollectionQuery.ts"],"sourcesContent":["/*\n * Copyright 2025 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { InterfaceHolder } from \"../../../object/convertWireToOsdkObjects/InterfaceHolder.js\";\nimport type { ObjectHolder } from \"../../../object/convertWireToOsdkObjects/ObjectHolder.js\";\nimport type { Status } from \"../../ObservableClient/common.js\";\nimport { type ObjectCacheKey } from \"../object/ObjectCacheKey.js\";\n\n/**\n * Abstract base for ListQuery and SpecificLinkQuery.\n * - Stores object references, not duplicates\n * - Implements shared pagination and reference counting\n * - Template method pattern for collection operations\n */\nexport interface CollectionStorageData {\n  data: ObjectCacheKey[];\n}\n\n/**\n * Base interface for collection-based payloads (lists and links)\n * Contains the common properties shared by all collection payload types\n */\nexport interface BaseCollectionPayload {\n  /**\n   * The resolved collection of objects\n   */\n  resolvedList: Array<ObjectHolder | InterfaceHolder>;\n\n  /**\n   * Whether the data is from an optimistic update\n   */\n  isOptimistic: boolean;\n\n  /**\n   * Function to fetch more items when available\n   */\n  fetchMore: () => Promise<void>;\n\n  /**\n   * Whether there are more items available to fetch\n   */\n  hasMore: boolean;\n\n  /**\n   * Current loading status\n   */\n  status: Status;\n\n  /**\n   * Timestamp of when the data was last updated\n   */\n  lastUpdated: number;\n}\n\n/**\n * Common parameters available for constructing a collection payload\n */\nexport interface CollectionConnectableParams {\n  /**\n   * Array of resolved objects\n   */\n  resolvedData: any[];\n\n  /**\n   * Whether the data is from an optimistic update\n   */\n  isOptimistic: boolean;\n\n  /**\n   * Current loading status\n   */\n  status: Status;\n\n  /**\n   * Timestamp of the last update\n   */\n  lastUpdated: number;\n}\n"],"mappings":"","ignoreList":[]}

package/build/browser/observable/internal/base-list/BaseListQuery.js

@@ -0,0 +1,411 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import deepEqual from "fast-deep-equal";
+import { DEBUG_ONLY__cacheKeysToString } from "../CacheKey.js";
+import { isObjectInstance } from "../isObjectInstance.js";
+import { Query } from "../Query.js";
+import { NoOpSortingStrategy } from "../sorting/SortingStrategy.js";
+import { createCollectionConnectable } from "./createCollectionConnectable.js";
+import { removeDuplicates } from "./removeDuplicates.js";
+
+/**
+ * Base class for collection-based queries (lists and links)
+ * Provides common functionality for working with collections of objects
+ */
+export class BaseListQuery extends Query {
+  /**
+   * The sorting strategy to use for this collection
+   * @protected
+   */
+  sortingStrategy = new NoOpSortingStrategy();
+
+  // Collection-specific behavior is implemented by subclasses
+  /**
+   * Token for the next page of results
+   * @protected
+   */
+
+  /**
+   * Promise tracking an in-progress page fetch
+   * @protected
+   */
+
+  //
+  // Shared Implementations
+  //
+
+  /**
+   * Standard method to update a list of objects
+   * Handles common list update patterns for both ListQuery and SpecificLinkQuery
+   *
+   * @param items Objects or cache keys to add to the list
+   * @param status Status to set for the list
+   * @param batch Batch context to use
+   * @param append Whether to append to the existing list or replace it
+   * @returns The updated entry
+   */
+  _updateList(items, status, batch, append = false) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "updateList"
+      }).debug(`{status: ${status}, append: ${append}}`, JSON.stringify(items, null, 2));
+    }
+    let objectCacheKeys;
+    if (items.length === 0) {
+      objectCacheKeys = [];
+    } else if (isObjectInstance(items[0])) {
+      // Items are object instances, need to store them first
+      objectCacheKeys = this.store.objects.storeOsdkInstances(items, batch);
+    } else {
+      // Items are already cache keys
+      objectCacheKeys = items;
+    }
+    objectCacheKeys = this.#retainReleaseAppend(batch, append, objectCacheKeys);
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, status, batch);
+  }
+
+  /**
+   * Common implementation for writing to store for collection-based queries
+   * @param data The collection data to write to the store
+   * @param status The status to set
+   * @param batch The batch context
+   */
+  writeToStore(data, status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual(data, entry.value)) {
+      // Check if both data AND status are the same
+      if (entry.status === status) {
+        if (process.env.NODE_ENV !== "production") {
+          this.logger?.child({
+            methodName: "writeToStore"
+          }).debug(`Collection data was deep equal and status unchanged (${status}), skipping update`);
+        }
+        // Return the existing entry without writing to avoid unnecessary notifications
+        return entry;
+      }
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Collection data was deep equal, just updating status from ${entry.status} to ${status}`);
+      }
+      // Keep the same value but update status and lastUpdated
+      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);
+    this.registerCacheChanges(batch);
+    return ret;
+  }
+
+  /**
+   * Register changes to the cache based on the specific collection type
+   * Implemented by subclasses to handle specific change registration
+   */
+
+  /**
+   * Common method for managing object reference counting and appending results
+   * Used by collection queries when updating object references
+   *
+   * @param batch The batch context to use
+   * @param append Whether to append to existing objects or replace them
+   * @param objectCacheKeys Array of object cache keys to process
+   * @returns The final array of object cache keys after retain/release/append
+   */
+  #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.cacheKeys.release(objectCacheKey);
+        }
+      }
+      for (const objectCacheKey of objectCacheKeys) {
+        this.store.cacheKeys.retain(objectCacheKey);
+      }
+    }
+    if (append) {
+      objectCacheKeys = [...(existingList?.value?.data ?? []), ...objectCacheKeys];
+    }
+    return objectCacheKeys;
+  }
+  _dispose() {
+    this.store.batch({}, batch => {
+      const entry = batch.read(this.cacheKey);
+      if (entry) {
+        for (const objectCacheKey of entry.value?.data ?? []) {
+          this.store.cacheKeys.release(objectCacheKey);
+        }
+      }
+    });
+  }
+
+  /**
+   * Creates a payload from collection parameters
+   * Default implementation that covers common fields for all collection types
+   * Subclasses may override to add type-specific fields if needed
+   *
+   * @param params Common collection parameters
+   * @returns A typed payload for the specific collection type
+   */
+  createPayload(params) {
+    return {
+      resolvedList: params.resolvedData,
+      isOptimistic: params.isOptimistic,
+      fetchMore: this.fetchMore,
+      hasMore: this.nextPageToken != null,
+      status: params.status,
+      lastUpdated: params.lastUpdated
+    }; // Type assertion needed since we don't know exact subtype
+  }
+
+  /**
+   * Creates a connectable observable for this collection
+   * Common implementation shared by all collection types
+   *
+   * @param subject The subject to connect to
+   * @returns A connectable observable of the collection's payload type
+   */
+  _createConnectable(subject) {
+    return createCollectionConnectable(subject, this.store.subjects, params => this.createPayload(params));
+  }
+
+  /**
+   * @override Reset pagination state before a fetch
+   */
+  _preFetch() {
+    this.nextPageToken = undefined;
+    super._preFetch();
+  }
+
+  /**
+   * Common fetchMore implementation for pagination
+   * Handles pending request management and loading states
+   */
+  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(undefined);
+    }
+    this.store.batch({}, batch => {
+      this.setStatus("loading", batch);
+    });
+    this.pendingFetch = this.fetchPageAndUpdate("loaded", this.abortController?.signal).then(() => void 0).finally(() => {
+      this.pendingPageFetch = undefined;
+    });
+    return this.pendingFetch;
+  };
+
+  /**
+   * Minimum number of results to load initially
+   * May be overridden by subclasses for specific collection types
+   * @protected
+   */
+  minResultsToLoad = 0;
+
+  /**
+   * Common _fetchAndStore implementation for pagination
+   * Uses fetchPageAndUpdate to load the initial set of data
+   * Will load multiple pages if necessary to reach minResultsToLoad
+   */
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).debug("fetching pages");
+    }
+
+    // Keep fetching pages until we have the minimum number of results or no more pages
+    while (true) {
+      const entry = await this.fetchPageAndUpdate("loading", this.abortController?.signal);
+      if (!entry) {
+        // we were aborted
+        return;
+      }
+
+      // Check if we have enough results or no more pages
+      const count = entry.value?.data.length || 0;
+      if (count >= this.minResultsToLoad || this.nextPageToken == null) {
+        break;
+      }
+    }
+    this.store.batch({}, batch => {
+      this.setStatus("loaded", batch);
+    });
+    return Promise.resolve();
+  }
+
+  /**
+   * Template method for fetching a page of data and updating the store
+   * Provides common error handling and abort signal checking
+   *
+   * @param status The status to set for the entry
+   * @param signal Optional AbortSignal for cancellation
+   * @returns A promise that resolves to the updated entry or undefined if aborted
+   */
+  async fetchPageAndUpdate(status, signal) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "fetchPageAndUpdate"
+      }).debug(`Fetching data with status: ${status}`);
+    }
+
+    // Early abort check
+    if (signal?.aborted) {
+      return undefined;
+    }
+    try {
+      // Call the subclass-specific implementation to fetch data
+      const result = await this.fetchPageData(signal);
+
+      // Check for abort again after fetch
+      if (signal?.aborted) {
+        return undefined;
+      }
+
+      // Store the fetched data using batch operations
+      const {
+        retVal
+      } = this.store.batch({}, batch => {
+        const append = this.nextPageToken != null;
+        const finalStatus = result.nextPageToken ? status : "loaded";
+        return this._updateList(this.store.objects.storeOsdkInstances(result.data, batch), finalStatus, batch, append);
+      });
+      return retVal;
+    } catch (error) {
+      // Log any errors that occur
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "fetchPageAndUpdate"
+        }).error("Error fetching data", error);
+      }
+
+      // For unexpected errors, write error status if not aborted
+      if (!signal?.aborted) {
+        const {
+          retVal
+        } = this.store.batch({}, batch => {
+          return this.handleFetchError(error, status, batch);
+        });
+        return retVal;
+      }
+
+      // If aborted, just return undefined
+      return undefined;
+    }
+  }
+
+  /**
+   * Abstract method that subclasses implement for their specific data fetching logic
+   *
+   * @param signal Optional AbortSignal for cancellation
+   * @returns A promise that resolves to the fetched data
+   */
+
+  /**
+   * Handle fetch errors by setting appropriate error state
+   * Default implementation that subclasses can override
+   *
+   * @param error The error that occurred
+   * @param status The intended status if successful
+   * @param batch The batch context to use
+   * @returns The updated entry with error status
+   */
+  handleFetchError(_error, _status, batch) {
+    // Default implementation writes an empty list with error status
+    // Most subclasses should be able to use this
+    return this.writeToStore({
+      data: []
+    }, "error", batch);
+  }
+
+  /**
+   * Sort the collection items using the configured sorting strategy
+   * @param objectCacheKeys - The cache keys to sort
+   * @param batch - The batch context
+   * @returns Sorted array of cache keys
+   */
+  _sortCacheKeys(objectCacheKeys, batch) {
+    return this.sortingStrategy.sortCacheKeys(objectCacheKeys, batch);
+  }
+
+  /**
+   * Unified method for updating collection data in the store
+   * Handles storing, sorting, deduplication, and reference counting
+   *
+   * @param items - Either object cache keys or object instances to update
+   * @param options - Configuration options for the update
+   * @param batch - The batch context to use
+   * @returns The updated entry
+   */
+  updateCollection(items, options, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+        methodName: "updateCollection"
+      }) : this.logger;
+      logger?.debug(`{status: ${options.status}, append: ${options.append}}`, JSON.stringify(items, null, 2));
+    }
+
+    // Step 1: Convert items to object cache keys if needed
+    let objectCacheKeys;
+    if (items.length === 0) {
+      objectCacheKeys = [];
+    } else if (isObjectInstance(items[0])) {
+      // Items are object instances, need to store them first
+      objectCacheKeys = this.store.objects.storeOsdkInstances(items, batch);
+    } else {
+      // Items are already cache keys
+      objectCacheKeys = items;
+    }
+
+    // Step 2: Handle retain/release/append logic
+    objectCacheKeys = this.#retainReleaseAppend(batch, options.append ?? false, objectCacheKeys);
+
+    // Step 3: Sort using the configured sorting strategy
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+
+    // Step 4: Remove duplicates
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+
+    // Step 5: Write to store
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, options.status, batch);
+  }
+}
+//# sourceMappingURL=BaseListQuery.js.map