@osdk/client 2.4.2 → 2.5.0-beta.10

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 { runOptimisticJob } from "./actions/OptimisticJob.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,16 +97,214 @@ 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;
+    let cacheKeys;
     let employeesAsServerReturns;
     let mutatedEmployees;
     beforeAll(async () => {
@@ -120,13 +326,14 @@ describe(Store, () => {
     });
     beforeEach(() => {
       cache = new Store(client);
+      cacheKeys = cache.cacheKeys;
       return () => {
         cache = undefined;
       };
     });
     it("basic single object works", async () => {
       const emp = employeesAsServerReturns[0];
-      const cacheKey = cache.getCacheKey("object", "Employee", emp.$primaryKey);
+      const cacheKey = cacheKeys.get("object", "Employee", emp.$primaryKey);
 
       // starts empty
       expect(cache.getValue(cacheKey)?.value).toBeUndefined();
@@ -149,7 +356,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");
@@ -165,7 +374,7 @@ describe(Store, () => {
         }), "loaded");
 
         // remove the optimistic write
-        cache.removeLayer(optimisticId);
+        cache.layers.remove(optimisticId);
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
       });
       it("rolls back to an updated real value", async () => {
@@ -177,12 +386,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));
@@ -223,7 +434,7 @@ describe(Store, () => {
         }, [truthUpdatedEmployee]);
 
         // remove the optimistic write
-        cache.removeLayer(optimisticId);
+        cache.layers.remove(optimisticId);
 
         // see the object observation get updated
         expectSingleObjectCallAndClear(empSubFn, truthUpdatedEmployee, "loaded");
@@ -240,7 +451,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");
@@ -263,7 +476,7 @@ describe(Store, () => {
         expect(subFn.next).not.toHaveBeenCalled();
 
         // remove the optimistic write
-        cache.removeLayer(optimisticId);
+        cache.layers.remove(optimisticId);
         expectSingleObjectCallAndClear(subFn, truthUpdatedEmployee);
         expectNoMoreCalls(subFn);
       });
@@ -276,12 +489,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));
@@ -289,7 +504,7 @@ describe(Store, () => {
           expectSingleListCallAndClear(subListFn, [emp], {
             status: "loaded"
           });
-          const cacheKey = cache.getCacheKey("object", emp.$apiName, emp.$primaryKey);
+          const cacheKey = cacheKeys.get("object", emp.$apiName, emp.$primaryKey);
 
           // Actual test is here, prior to this is setup
           testStage("delete the object");
@@ -316,7 +531,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 +548,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 +559,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 +612,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 +637,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 +672,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 +690,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 +719,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 +767,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 +778,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 +820,7 @@ describe(Store, () => {
             where: {},
             orderBy: {}
           }, mutatedEmployees);
-          defer(cache.observeList({
+          defer(cache.lists.observe({
             type: Employee,
             mode: "force"
           }, listSub1));
@@ -611,19 +838,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 +858,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 +886,9 @@ describe(Store, () => {
             },
             orderBy: {}
           }, mutatedEmployees);
-          vitest.runOnlyPendingTimers();
 
           // original list updates still
+          await waitForCall(listSub1);
           expectSingleListCallAndClear(listSub1, mutatedEmployees);
         });
       });
@@ -677,14 +902,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 +964,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 +994,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 +1037,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 +1082,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",
@@ -855,7 +1098,7 @@ describe(Store, () => {
             isOptimistic: false
           })
         });
-        const object = store.getValue(store.getCacheKey("object", "Todo", 0))?.value;
+        const object = store.getValue(store.cacheKeys.get("object", "Todo", 0))?.value;
         !object ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
 
         // at this point we have an observation properly set up
@@ -915,19 +1158,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]
@@ -1114,7 +1365,7 @@ describe(Store, () => {
         $apiName: "Employee",
         $title: `truth ${i}`
       }));
-      const cacheKeys = baseObjects.map(obj => store.getCacheKey("object", "Employee", obj.$primaryKey));
+      const cacheKeys = baseObjects.map(obj => store.cacheKeys.get("object", "Employee", obj.$primaryKey));
 
       // set the truth
       for (const obj of baseObjects) {
@@ -1149,7 +1400,7 @@ describe(Store, () => {
       }
 
       // remove the first layer
-      store.removeLayer(layerIds[0]);
+      store.layers.remove(layerIds[0]);
 
       // should have truth object 1 and optimistic object 2
       expect(getObject(store, "Employee", 1)).toEqual(expect.objectContaining({
@@ -1160,7 +1411,7 @@ describe(Store, () => {
       }));
 
       // remove the second layer
-      store.removeLayer(layerIds[1]);
+      store.layers.remove(layerIds[1]);
 
       // should have truth objects
       for (const obj of baseObjects) {
@@ -1171,4 +1422,10 @@ describe(Store, () => {
     });
   });
 });
+export function asBsoStub(x) {
+  return {
+    __apiName: x.$apiName,
+    __primaryKey: x.$primaryKey
+  };
+}
 //# sourceMappingURL=Store.test.js.map