@osdk/client 2.5.0-beta.1 → 2.5.0-beta.3

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

@@ -14,21 +14,29 @@
  * limitations under the License.
  */
 
-import { editTodo, Employee, FooInterface, Todo } from "@osdk/client.test.ontology";
+import { editTodo, Employee, FooInterface, Office, Todo } from "@osdk/client.test.ontology";
 import { FauxFoundry, ontologies, startNodeApiServer, stubData, TypeHelpers } from "@osdk/shared.test";
 import chalk from "chalk";
+import { inspect } from "node:util";
 import invariant from "tiny-invariant";
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, vitest } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { ActionValidationError } from "../../actions/ActionValidationError.js";
 import { createClient } from "../../createClient.js";
 import { TestLogger } from "../../logger/TestLogger.js";
 import { createOptimisticId } from "./OptimisticId.js";
 import { runOptimisticJob } from "./OptimisticJob.js";
-import { invalidateList, Store } from "./Store.js";
-import { applyCustomMatchers, createClientMockHelper, createDefer, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
+import { Store } from "./Store.js";
+import { applyCustomMatchers, createClientMockHelper, createDefer, expectNoMoreCalls, expectSingleLinkCallAndClear, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
+import { invalidateList } from "./testUtils/invalidateList.js";
+import { expectStandardObserveLink } from "./testUtils/observeLink/expectStandardObserveLink.js";
+import { expectStandardObserveObject } from "./testUtils/observeObject/expectStandardObserveObject.js";
 const JOHN_DOE_ID = 50030;
 const defer = createDefer();
-const logger = new TestLogger();
+const logger = new TestLogger({}, {
+  level: "debug"
+});
+inspect.defaultOptions.depth = 9;
+inspect.defaultOptions.colors = true;
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -75,10 +83,10 @@ function setupOntology(fauxFoundry) {
 }
 function setupSomeEmployees(fauxFoundry) {
   const dataStore = fauxFoundry.getDefaultDataStore();
-  dataStore.registerObject(Employee, {
+  const emp1 = dataStore.registerObject(Employee, {
     employeeId: 1
   });
-  dataStore.registerObject(Employee, {
+  const emp2 = dataStore.registerObject(Employee, {
     employeeId: 2
   });
   dataStore.registerObject(Employee, {
@@ -89,13 +97,210 @@ function setupSomeEmployees(fauxFoundry) {
     $apiName: "Employee",
     employeeId: 4
   });
-  dataStore.registerObject(Employee, {
+  const johnDoe = dataStore.registerObject(Employee, {
     $apiName: "Employee",
     employeeId: JOHN_DOE_ID,
     fullName: "John Doe"
   });
+  dataStore.registerLink(emp1, "peeps", johnDoe, "lead");
+
+  // Create offices
+  const office1 = dataStore.registerObject(Office, {
+    officeId: "101",
+    name: "Office 1"
+  });
+  const office2 = dataStore.registerObject(Office, {
+    officeId: "102",
+    name: "Office 2"
+  });
+
+  // Link employees to offices (Employee->Office: officeLink, Office->Employee: occupants)
+  dataStore.registerLink(emp1, "officeLink", office1, "occupants");
+  dataStore.registerLink(emp2, "officeLink", office2, "occupants");
 }
 describe(Store, () => {
+  describe("observeLinks", () => {
+    let client;
+    let cache;
+    let fauxFoundry;
+    beforeAll(async () => {
+      // Set up the mock environment and client
+      const testSetup = startNodeApiServer(new FauxFoundry("https://stack.palantir.com/"), createClient, {
+        logger
+      });
+      ({
+        client,
+        fauxFoundry
+      } = testSetup);
+
+      // Use the existing setup function that adds Employee objects
+      setupOntology(fauxFoundry);
+      setupSomeEmployees(fauxFoundry);
+      return () => {
+        testSetup.apiServer.close();
+      };
+    });
+    beforeEach(() => {
+      cache = new Store(client);
+      return () => {
+        cache = undefined;
+      };
+    });
+    const objectLikeJohnDoe = expect.objectContaining({
+      $apiName: "Employee",
+      $primaryKey: JOHN_DOE_ID
+    });
+    expect.objectContaining({
+      $apiName: "Employee",
+      $primaryKey: 2
+    });
+    it("removing link updates", async () => {
+      const {
+        payload: emp1Payload,
+        subFn
+      } = await expectStandardObserveObject({
+        cache,
+        type: Employee,
+        primaryKey: 1
+      });
+      const emp1 = emp1Payload?.object;
+      !emp1 ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+
+      // Set up mock callback for observing links
+      const {
+        payload,
+        linkSubFn
+      } = await expectStandardObserveLink({
+        store: cache,
+        srcObject: emp1,
+        srcLinkName: "peeps",
+        targetType: Employee,
+        expected: [objectLikeJohnDoe]
+      });
+
+      // Unregister the link "in the backend"
+      fauxFoundry.getDefaultDataStore().unregisterLink(asBsoStub(emp1), "peeps", {
+        __apiName: "Employee",
+        __primaryKey: JOHN_DOE_ID
+      }, "lead");
+      testStage("Observing Employee 1's peeps");
+
+      // Invalidate the employee cache
+      const invalidateEmployeePromise = cache.invalidateObjectType("Employee", undefined);
+      await waitForCall(linkSubFn);
+      // Initially go to an invalidated loading state
+      expectSingleLinkCallAndClear(linkSubFn, [objectLikeJohnDoe], {
+        status: "loading"
+      });
+      await invalidateEmployeePromise;
+
+      // Should have no peeps now
+      expectSingleLinkCallAndClear(linkSubFn, [], {
+        status: "loaded"
+      });
+    });
+    it("invalidating Employee type only invalidates links, not Office objects", async () => {
+      // Get an Office object that has Employee occupants
+      const {
+        payload: office1Payload,
+        subFn: officeSubFn
+      } = await expectStandardObserveObject({
+        cache,
+        type: Office,
+        primaryKey: "101"
+      });
+      const office1 = office1Payload?.object;
+      !office1 ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+      expect(await office1.$link.occupants.fetchPage()).toMatchInlineSnapshot(`
+        {
+          "data": [
+            {
+              "$apiName": "Employee",
+              "$objectSpecifier": "Employee:1",
+              "$objectType": "Employee",
+              "$primaryKey": 1,
+              "$title": undefined,
+              "employeeId": 1,
+              "office": "101",
+            },
+          ],
+          "nextPageToken": undefined,
+          "totalCount": undefined,
+        }
+      `);
+      testStage("Observing Employee 1");
+
+      // Get an Employee object linked to the office
+      const {
+        payload: emp1Payload,
+        subFn: empSubFn
+      } = await expectStandardObserveObject({
+        cache,
+        type: Employee,
+        primaryKey: 1
+      });
+      const emp1 = emp1Payload?.object;
+      !emp1 ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+      testStage("Observing Office 101's occupants");
+
+      // Set up observation of occupants link
+      const {
+        linkSubFn: occupantsLinkSubFn
+      } = await expectStandardObserveLink({
+        store: cache,
+        srcObject: office1,
+        srcLinkName: "occupants",
+        targetType: Employee,
+        expected: [expect.objectContaining({
+          $primaryKey: 1
+        })]
+      });
+
+      // Clear any initial calls
+      officeSubFn.next.mockClear();
+      empSubFn.next.mockClear();
+      occupantsLinkSubFn.next.mockClear();
+      testStage("Invalidating Employee object type");
+
+      // Invalidate the Employee object type
+      // This should cause:
+      //  - any object query for Employee to be invalidated
+      //  - any object list query for Employee to be invalidated
+      //  - any link queries where the source is an Employee to be invalidated
+      //  - any link queries where the target is an Employee to be invalidated
+      const invalidateEmployeePromise = cache.invalidateObjectType(Employee, undefined);
+
+      // The link should be invalidated (loading state)
+      await waitForCall(occupantsLinkSubFn, 1);
+      expectSingleLinkCallAndClear(occupantsLinkSubFn, [emp1], {
+        status: "loading"
+      });
+
+      // The employee should be invalidated (loading state)
+      await waitForCall(empSubFn, 1);
+      expectSingleObjectCallAndClear(empSubFn, emp1, "loading");
+
+      // The link should be revalidated (loaded state)
+      await waitForCall(occupantsLinkSubFn, 1);
+      expectSingleLinkCallAndClear(occupantsLinkSubFn, [emp1], {
+        status: "loaded"
+      });
+
+      // the Employee object should also be invalidated (loading state)
+      await waitForCall(empSubFn, 1);
+      expectSingleObjectCallAndClear(empSubFn, emp1, "loaded");
+
+      // The Office object should NOT have any calls
+      // This is the key verification - no calls should be made to the office subscription
+      expect(officeSubFn.next).not.toHaveBeenCalled();
+      await invalidateEmployeePromise;
+
+      // ensure at the end of invalidation there are no new calls
+      expect(occupantsLinkSubFn.next).not.toHaveBeenCalled();
+      expect(empSubFn.next).not.toHaveBeenCalled();
+      expect(officeSubFn.next).not.toHaveBeenCalled();
+    });
+  });
   describe("with mock server", () => {
     let client;
     let cache;
@@ -149,7 +354,9 @@ describe(Store, () => {
         updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
@@ -177,12 +384,14 @@ describe(Store, () => {
         }, employeesAsServerReturns);
         const emp = employeesAsServerReturns[0];
         const empSubFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, empSubFn));
         expectSingleObjectCallAndClear(empSubFn, emp, "loaded");
         const listSubFn = mockListSubCallback();
-        defer(cache.observeList({
+        defer(cache.lists.observe({
           type: Employee,
           mode: "offline"
         }, listSubFn));
@@ -240,7 +449,9 @@ describe(Store, () => {
         updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
@@ -276,12 +487,14 @@ describe(Store, () => {
             orderBy: {}
           }, [emp]);
           const subFn = mockSingleSubCallback();
-          defer(cache.observeObject(Employee, emp.$primaryKey, {
+          defer(cache.objects.observe({
+            apiName: Employee,
+            pk: emp.$primaryKey,
             mode: "offline"
           }, subFn));
           expectSingleObjectCallAndClear(subFn, emp);
           const subListFn = mockListSubCallback();
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             mode: "offline"
           }, subListFn));
@@ -316,7 +529,9 @@ describe(Store, () => {
         });
         updateObject(cache, staleEmp);
         const subFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, staleEmp, "loaded");
@@ -331,12 +546,6 @@ describe(Store, () => {
       });
     });
     describe(".invalidateList", () => {
-      beforeEach(() => {
-        vi.useFakeTimers({});
-      });
-      afterEach(() => {
-        vi.useRealTimers();
-      });
       it("triggers an update", async () => {
         const emp = employeesAsServerReturns[0];
         const staleEmp = emp.$clone({
@@ -348,12 +557,14 @@ describe(Store, () => {
           orderBy: {}
         }, [staleEmp]);
         const subFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
-        defer(cache.observeList({
+        defer(cache.lists.observe({
           type: Employee,
           mode: "offline"
         }, subListFn));
@@ -399,12 +610,14 @@ describe(Store, () => {
           orderBy: {}
         }, [staleEmp]);
         const subFn = mockSingleSubCallback();
-        defer(cache.observeObject(Employee, emp.$primaryKey, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: emp.$primaryKey,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
-        defer(cache.observeList({
+        defer(cache.lists.observe({
           type: Employee,
           where: {},
           orderBy: {},
@@ -422,8 +635,19 @@ describe(Store, () => {
         });
         await waitForCall(subListFn, 1);
         expectSingleListCallAndClear(subListFn, employeesAsServerReturns);
-        await waitForCall(subFn, 1);
-        expectSingleObjectCallAndClear(subFn, emp, "loaded");
+        testStage("Check invalidation call for single sub");
+        await waitForCall(subFn, 2);
+        // First call is for loading state
+        expect(subFn.next).toHaveBeenNthCalledWith(1, objectPayloadContaining({
+          status: "loading",
+          object: staleEmp
+        }));
+        // Second call is for loaded state with fresh data
+        expect(subFn.next).toHaveBeenNthCalledWith(2, objectPayloadContaining({
+          status: "loaded",
+          object: emp
+        }));
+        subFn.next.mockClear();
 
         // we don't need this value to control the test but we want to make sure we don't have
         // any unhandled exceptions upon test completion
@@ -446,7 +670,9 @@ describe(Store, () => {
         fullName: "John Doe"
       });
       it("fetches and updates twice", async () => {
-        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: JOHN_DOE_ID,
           mode: "force"
         }, subFn1));
         expect(subFn1.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
@@ -462,7 +688,9 @@ describe(Store, () => {
         }));
         const firstLoad = subFn1.next.mock.lastCall?.[0];
         subFn1.next.mockClear();
-        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
+        defer(cache.objects.observe({
+          apiName: Employee,
+          pk: JOHN_DOE_ID,
           mode: "force"
         }, subFn2));
         expectSingleObjectCallAndClear(subFn1, likeEmployee50030, "loading");
@@ -489,7 +717,9 @@ describe(Store, () => {
         subFn.complete.mockClear();
         subFn.next.mockClear();
         subFn.error.mockClear();
-        sub = defer(cache.observeObject(Employee, JOHN_DOE_ID, {
+        sub = defer(cache.objects.observe({
+          apiName: Employee,
+          pk: JOHN_DOE_ID,
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, undefined, "init");
@@ -535,11 +765,10 @@ describe(Store, () => {
         }));
       });
     });
-    describe(".observeList", () => {
+    describe(".lists.observe", () => {
       const listSub1 = mockListSubCallback();
       const ifaceSub = mockListSubCallback();
       beforeEach(() => {
-        vi.useFakeTimers({});
         vi.mocked(listSub1.next).mockReset();
         vi.mocked(listSub1.error).mockReset();
         vi.mocked(listSub1.complete).mockReset();
@@ -547,22 +776,18 @@ describe(Store, () => {
         vi.mocked(ifaceSub.error).mockReset();
         vi.mocked(ifaceSub.complete).mockReset();
       });
-      afterEach(() => {
-        vi.useRealTimers();
-      });
       describe("mode=force", () => {
         it("initial load", async () => {
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             orderBy: {},
             mode: "force"
           }, listSub1));
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: FooInterface,
             orderBy: {},
             mode: "force"
           }, ifaceSub));
-          vitest.runOnlyPendingTimers();
           await waitForCall(listSub1);
           await waitForCall(ifaceSub);
           expectSingleListCallAndClear(listSub1, [], {
@@ -593,7 +818,7 @@ describe(Store, () => {
             where: {},
             orderBy: {}
           }, mutatedEmployees);
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             mode: "force"
           }, listSub1));
@@ -611,19 +836,18 @@ describe(Store, () => {
       });
       describe("mode = offline", () => {
         it("updates with list updates", async () => {
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             where: {},
             orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1.next).toHaveBeenCalledTimes(0);
           updateList(cache, {
             type: Employee,
             where: {},
             orderBy: {}
           }, employeesAsServerReturns);
-          vitest.runOnlyPendingTimers();
+          await waitForCall(listSub1);
           expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // list is just now one object
@@ -632,23 +856,22 @@ describe(Store, () => {
             where: {},
             orderBy: {}
           }, [employeesAsServerReturns[0]]);
-          vitest.runOnlyPendingTimers();
+          await waitForCall(listSub1);
           expectSingleListCallAndClear(listSub1, [employeesAsServerReturns[0]]);
         });
         it("updates with different list updates", async () => {
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             where: {},
             orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1.next).toHaveBeenCalledTimes(0);
           updateList(cache, {
             type: Employee,
             where: {},
             orderBy: {}
           }, employeesAsServerReturns);
-          vitest.runOnlyPendingTimers();
+          await waitForCall(listSub1);
           expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // new where === different list
@@ -661,9 +884,9 @@ describe(Store, () => {
             },
             orderBy: {}
           }, mutatedEmployees);
-          vitest.runOnlyPendingTimers();
 
           // original list updates still
+          await waitForCall(listSub1);
           expectSingleListCallAndClear(listSub1, mutatedEmployees);
         });
       });
@@ -677,14 +900,13 @@ describe(Store, () => {
       });
       it("works in the solo case", async () => {
         const listSub = mockListSubCallback();
-        defer(cache.observeList({
+        defer(cache.lists.observe({
           type: Employee,
           where: {},
           orderBy: {},
           mode: "force",
           pageSize: 1
         }, listSub));
-        expect(listSub.next).not.toHaveBeenCalled();
         await waitForCall(listSub, 1);
         expectSingleListCallAndClear(listSub, [], {
           status: "loading"
@@ -740,15 +962,22 @@ describe(Store, () => {
 
       // ignores unhandled rejection, like one we will get from fire-and-forget metadata call
       process.on("unhandledRejection", () => {});
-      store.observeList({
+      store.lists.observe({
         type: {
           apiName: "notReal",
           type: "object"
         },
         orderBy: {}
       }, sub);
-      await waitForCall(sub.error, 1);
-      expect(sub.error).toHaveBeenCalled();
+      await waitForCall(sub.next);
+
+      // initial loading state
+      expect(sub.next).toHaveBeenCalledOnce();
+      expectSingleListCallAndClear(sub, [], {
+        status: "loading"
+      });
+      await waitForCall(sub.error);
+      expect(sub.error).toHaveBeenCalledOnce();
       expect(sub.next).not.toHaveBeenCalled();
     });
     describe("batching", () => {
@@ -763,8 +992,14 @@ describe(Store, () => {
         });
         const a = mockSingleSubCallback();
         const b = mockSingleSubCallback();
-        defer(store.observeObject(Employee, 0, {}, a));
-        defer(store.observeObject(Employee, 1, {}, b));
+        defer(store.objects.observe({
+          apiName: Employee,
+          pk: 0
+        }, a));
+        defer(store.objects.observe({
+          apiName: Employee,
+          pk: 1
+        }, b));
         await a.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -800,7 +1035,10 @@ describe(Store, () => {
           text: "og title"
         });
         const todoSubFn = mockSingleSubCallback();
-        defer(store.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.objects.observe({
+          apiName: Todo,
+          pk: 0
+        }, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -842,7 +1080,10 @@ describe(Store, () => {
           text: "does not matter"
         });
         const todoSubFn = mockSingleSubCallback();
-        defer(store.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.objects.observe({
+          apiName: Todo,
+          pk: 0
+        }, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -915,19 +1156,27 @@ describe(Store, () => {
           text: "asc"
         }
       };
-      const subListUnordered = mockListSubCallback();
-      const subListOrdered = mockListSubCallback();
-      beforeEach(() => {
-        defer(store.observeList({
+      let subListUnordered = mockListSubCallback();
+      let subListOrdered = mockListSubCallback();
+      beforeEach(async () => {
+        subListUnordered = mockListSubCallback();
+        subListOrdered = mockListSubCallback();
+        defer(store.lists.observe({
           ...noWhereNoOrderBy,
           mode: "offline"
         }, subListUnordered));
-        expect(subListUnordered.next).toHaveBeenCalledTimes(0);
-        defer(store.observeList({
+        await waitForCall(subListUnordered);
+        expectSingleListCallAndClear(subListUnordered, [], {
+          status: "init"
+        });
+        defer(store.lists.observe({
           ...noWhereOrderByText,
           mode: "offline"
         }, subListOrdered));
-        expect(subListOrdered.next).toHaveBeenCalledTimes(0);
+        await waitForCall(subListOrdered);
+        expectSingleListCallAndClear(subListOrdered, [], {
+          status: "init"
+        });
       });
       it("invalidates the correct lists", async () => {
         // for whatever reason, the first list is loaded as [B, A]
@@ -1171,4 +1420,10 @@ describe(Store, () => {
     });
   });
 });
+export function asBsoStub(x) {
+  return {
+    __apiName: x.$apiName,
+    __primaryKey: x.$primaryKey
+  };
+}
 //# sourceMappingURL=Store.test.js.map