@osdk/client 2.2.0-beta.7 → 2.2.0-beta.9

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

@@ -14,16 +14,21 @@
  * limitations under the License.
  */
 
-import { $ontologyRid, createOffice, Employee, Todo } from "@osdk/client.test.ontology";
-import { apiServer } from "@osdk/shared.test";
+import { $ontologyRid, createOffice, Employee, FooInterface, Todo } from "@osdk/client.test.ontology";
+import { wireObjectTypeFullMetadataToSdkObjectMetadata } from "@osdk/generator-converters";
+import { apiServer, stubData } from "@osdk/shared.test";
 import chalk from "chalk";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, vitest } from "vitest";
 import { createClient } from "../../createClient.js";
+import { createMinimalClient } from "../../createMinimalClient.js";
+import { createObjectSet } from "../../objectSet/createObjectSet.js";
+import { InterfaceDefinitions } from "../../ontology/OntologyProvider.js";
 import { createOptimisticId } from "./OptimisticId.js";
 import { runOptimisticJob } from "./OptimisticJob.js";
-import { Store } from "./Store.js";
-import { applyCustomMatchers, createClientMockHelper, createDefer, createTestLogger, expectSingleListCallAndClear, expectSingleObjectCallAndClear, listPayloadContaining, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, waitForCall } from "./testUtils.js";
+import { invalidateList, Store } from "./Store.js";
+import { applyCustomMatchers, createClientMockHelper, createDefer, createTestLogger, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
 const defer = createDefer();
+const logger = createTestLogger({});
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -63,7 +68,7 @@ describe(Store, () => {
     beforeAll(async () => {
       apiServer.listen();
       client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken", {
-        logger: createTestLogger({})
+        logger
       });
       employeesAsServerReturns = (await client(Employee).fetchPage()).data;
       mutatedEmployees = [employeesAsServerReturns[0], employeesAsServerReturns[1].$clone({
@@ -81,26 +86,27 @@ describe(Store, () => {
     });
     it("basic single object works", async () => {
       const emp = employeesAsServerReturns[0];
+      const cacheKey = cache.getCacheKey("object", "Employee", emp.$primaryKey);
 
       // starts empty
-      expect(cache.getObject(Employee, emp.$primaryKey)).toBeUndefined();
-      const result = cache.updateObject(Employee, emp);
+      expect(cache.getValue(cacheKey)?.value).toBeUndefined();
+      const result = updateObject(cache, emp);
       expect(emp).toBe(result);
 
       // getting the object now matches the result
-      expect(cache.getObject(Employee, emp.$primaryKey)).toEqual(result);
-      const updatedEmpFromCache = cache.updateObject(Employee, emp.$clone({
+      expect(cache.getValue(cacheKey)?.value).toEqual(result);
+      const updatedEmpFromCache = updateObject(cache, emp.$clone({
         fullName: "new name"
       }));
       expect(updatedEmpFromCache).not.toBe(emp);
 
       // getting it again is the updated object
-      expect(cache.getObject(Employee, emp.$primaryKey)).toEqual(updatedEmpFromCache);
+      expect(cache.getValue(cacheKey)?.value).toEqual(updatedEmpFromCache);
     });
     describe("optimistic updates", () => {
       it("rolls back objects", async () => {
         const emp = employeesAsServerReturns[0];
-        cache.updateObject(Employee, emp); // pre-seed the cache with the "real" value
+        updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
@@ -109,7 +115,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
         const optimisticId = createOptimisticId();
         // update with an optimistic write
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name"
         }), {
           optimisticId
@@ -124,8 +130,8 @@ describe(Store, () => {
       });
       it("rolls back to an updated real value", async () => {
         // pre-seed the cache with the "real" value
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, employeesAsServerReturns);
@@ -137,7 +143,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(empSubFn, emp, "loaded");
         const listSubFn = mockListSubCallback();
         defer(cache.observeList({
-          objectType: Employee,
+          type: Employee,
           mode: "offline"
         }, listSubFn));
         await waitForCall(listSubFn, 1);
@@ -147,10 +153,10 @@ describe(Store, () => {
         });
         const optimisticId = createOptimisticId();
         testStage("optimistic update");
-        expect(listSubFn).not.toHaveBeenCalled();
+        expect(listSubFn.next).not.toHaveBeenCalled();
 
         // update with an optimistic write
-        cache.updateObject(Employee, optimisticEmployee, {
+        updateObject(cache, optimisticEmployee, {
           optimisticId
         });
         testStage("after optimistic update");
@@ -170,8 +176,8 @@ describe(Store, () => {
           fullName: "real update"
         });
         testStage("write real update");
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [truthUpdatedEmployee]);
@@ -188,47 +194,38 @@ describe(Store, () => {
           status: "loaded",
           isOptimistic: false
         });
-        vi.useRealTimers();
       });
       it("rolls back to an updated real value via list", async () => {
         const emp = employeesAsServerReturns[0];
-        cache.updateObject(Employee, emp); // pre-seed the cache with the "real" value
+        updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp,
-          status: "loaded"
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
         const optimisticEmployee = emp.$clone({
           fullName: "new name"
         });
 
         // update with an optimistic write
         const optimisticId = createOptimisticId();
-        cache.updateObject(Employee, optimisticEmployee, {
+        updateObject(cache, optimisticEmployee, {
           optimisticId
         });
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: optimisticEmployee
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, optimisticEmployee);
         const truthUpdatedEmployee = emp.$clone({
           fullName: "real update"
         });
-        cache.updateObject(Employee, truthUpdatedEmployee);
+        updateObject(cache, truthUpdatedEmployee);
 
         // we shouldn't expect an update because the top layer has a value
-        expect(subFn).not.toHaveBeenCalled();
+        expect(subFn.next).not.toHaveBeenCalled();
 
         // remove the optimistic write
         cache.removeLayer(optimisticId);
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: truthUpdatedEmployee
-        }));
+        expectSingleObjectCallAndClear(subFn, truthUpdatedEmployee);
+        expectNoMoreCalls(subFn);
       });
     });
     describe(".invalidateObject", () => {
@@ -237,29 +234,20 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateObject(Employee, staleEmp);
+        updateObject(cache, staleEmp);
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: staleEmp,
-          status: "loaded"
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, staleEmp, "loaded");
 
         // invalidate
         void cache.invalidateObject(Employee, staleEmp.$primaryKey);
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: staleEmp,
-          status: "loading"
-        }));
-        subFn.mockClear();
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp
-        }));
+        await waitForCall(subFn);
+        expectSingleObjectCallAndClear(subFn, staleEmp, "loading");
+        await waitForCall(subFn);
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
+        expectNoMoreCalls(subFn);
       });
     });
     describe(".invalidateList", () => {
@@ -274,8 +262,8 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [staleEmp]);
@@ -286,7 +274,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
         defer(cache.observeList({
-          objectType: Employee,
+          type: Employee,
           mode: "offline"
         }, subListFn));
         await waitForCall(subListFn, 1);
@@ -294,8 +282,8 @@ describe(Store, () => {
           status: "loaded"
         });
         testStage("invalidate");
-        cache.invalidateList({
-          objectType: Employee
+        const invalidateListPromise = invalidateList(cache, {
+          type: Employee
         });
         testStage("check invalidate");
         await waitForCall(subListFn, 1);
@@ -308,6 +296,9 @@ describe(Store, () => {
         });
         await waitForCall(subFn, 1);
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
+
+        // don't leave promises dangling
+        await invalidateListPromise;
       });
     });
     describe(".invalidateObjectType", () => {
@@ -322,8 +313,8 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [staleEmp]);
@@ -334,7 +325,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
         defer(cache.observeList({
-          objectType: Employee,
+          type: Employee,
           where: {},
           orderBy: {},
           mode: "offline"
@@ -346,21 +337,13 @@ describe(Store, () => {
         testStage("invalidate");
         const pInvalidateComplete = cache.invalidateObjectType(Employee, undefined);
         await waitForCall(subListFn, 1);
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: [staleEmp],
+        expectSingleListCallAndClear(subListFn, [staleEmp], {
           status: "loading"
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loaded",
-          object: emp
-        }));
+        });
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, employeesAsServerReturns);
+        await waitForCall(subFn, 1);
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
 
         // 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
@@ -371,8 +354,12 @@ describe(Store, () => {
       const subFn1 = mockSingleSubCallback();
       const subFn2 = mockSingleSubCallback();
       beforeEach(async () => {
-        subFn1.mockClear();
-        subFn2.mockClear();
+        subFn1.complete.mockClear();
+        subFn1.next.mockClear();
+        subFn1.error.mockClear();
+        subFn2.complete.mockClear();
+        subFn2.next.mockClear();
+        subFn2.error.mockClear();
       });
       const likeEmployee50030 = expect.objectContaining({
         $primaryKey: 50030,
@@ -382,42 +369,36 @@ describe(Store, () => {
         defer(cache.observeObject(Employee, 50030, {
           mode: "force"
         }, subFn1));
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(subFn1.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           status: "loading",
           object: undefined,
           isOptimistic: false
         }));
-        subFn1.mockClear();
-        await vi.waitFor(() => expect(subFn1).toHaveBeenCalled());
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        subFn1.next.mockClear();
+        await waitForCall(subFn1);
+        expect(subFn1.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: likeEmployee50030,
           isOptimistic: false
         }));
-        const firstLoad = subFn1.mock.lastCall?.[0];
-        subFn1.mockClear();
+        const firstLoad = subFn1.next.mock.lastCall?.[0];
+        subFn1.next.mockClear();
         defer(cache.observeObject(Employee, 50030, {
           mode: "force"
         }, subFn2));
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loading"
-        }));
-        subFn1.mockClear();
+        expectSingleObjectCallAndClear(subFn1, likeEmployee50030, "loading");
 
         // should be the earlier results
-        expect(subFn2).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loading"
-        }));
-        subFn2.mockClear();
+        expectSingleObjectCallAndClear(subFn2, likeEmployee50030, "loading");
 
         // both will be updated
         for (const s of [subFn1, subFn2]) {
           // wait for the result to come in
-          await vi.waitFor(() => expect(s).toHaveBeenCalled());
-          expect(s).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+          await waitForCall(s, 1);
+          expect(s.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
             ...firstLoad,
             lastUpdated: expect.toBeGreaterThan(firstLoad.lastUpdated)
           }));
-          s.mockClear();
+          s.next.mockClear();
         }
       });
     });
@@ -425,68 +406,66 @@ describe(Store, () => {
       const subFn = mockSingleSubCallback();
       let sub;
       beforeEach(() => {
-        subFn.mockClear();
+        subFn.complete.mockClear();
+        subFn.next.mockClear();
+        subFn.error.mockClear();
         sub = defer(cache.observeObject(Employee, 50030, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "init",
-          object: undefined
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, undefined, "init");
       });
       it("does basic observation and unsubscribe", async () => {
         const emp = employeesAsServerReturns[0];
 
         // force an update
-        cache.updateObject(Employee, emp);
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp
-        }));
-        subFn.mockClear();
+        updateObject(cache, emp);
+        expectSingleObjectCallAndClear(subFn, emp);
 
         // force again
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name"
         }));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: expect.objectContaining({
-            fullName: "new name"
-          })
+        expectSingleObjectCallAndClear(subFn, emp.$clone({
+          fullName: "new name"
         }));
-        subFn.mockClear();
         sub.unsubscribe();
 
         // force again but no subscription update
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name 2"
         }));
-        expect(subFn).not.toHaveBeenCalled();
+        expect(subFn.next).not.toHaveBeenCalled();
       });
       it("observes with list update", async () => {
         const emp = employeesAsServerReturns[0];
 
         // force an update
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "not the name"
         }));
-        expect(subFn).toHaveBeenCalledTimes(1);
-        cache.updateList({
-          objectType: Employee,
+        expect(subFn.next).toHaveBeenCalledTimes(1);
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, employeesAsServerReturns);
-        expect(subFn).toHaveBeenCalledTimes(2);
-        expect(subFn.mock.calls[1][0]).toEqual(objectPayloadContaining({
+        expect(subFn.next).toHaveBeenCalledTimes(2);
+        expect(subFn.next.mock.calls[1][0]).toEqual(objectPayloadContaining({
           object: emp
         }));
       });
     });
     describe(".observeList", () => {
       const listSub1 = mockListSubCallback();
+      const ifaceSub = mockListSubCallback();
       beforeEach(() => {
         vi.useFakeTimers({});
-        listSub1.mockReset();
+        vi.mocked(listSub1.next).mockReset();
+        vi.mocked(listSub1.error).mockReset();
+        vi.mocked(listSub1.complete).mockReset();
+        vi.mocked(ifaceSub.next).mockReset();
+        vi.mocked(ifaceSub.error).mockReset();
+        vi.mocked(ifaceSub.complete).mockReset();
       });
       afterEach(() => {
         vi.useRealTimers();
@@ -494,102 +473,107 @@ describe(Store, () => {
       describe("mode=force", () => {
         it("initial load", async () => {
           defer(cache.observeList({
-            objectType: Employee,
-            where: {},
+            type: Employee,
             orderBy: {},
             mode: "force"
           }, listSub1));
+          defer(cache.observeList({
+            type: FooInterface,
+            orderBy: {},
+            mode: "force"
+          }, ifaceSub));
           vitest.runOnlyPendingTimers();
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            status: "loading",
-            resolvedList: []
-          }));
-          listSub1.mockClear();
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns,
+          await waitForCall(listSub1);
+          await waitForCall(ifaceSub);
+          expectSingleListCallAndClear(listSub1, [], {
+            status: "loading"
+          });
+          expectSingleListCallAndClear(ifaceSub, [], {
+            status: "loading"
+          });
+          await waitForCall(listSub1);
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns, {
             status: "loaded"
-          }));
+          });
+          await waitForCall(ifaceSub);
+          expectSingleListCallAndClear(ifaceSub, employeesAsServerReturns.filter(o => o.$primaryKey === 50050), {
+            status: "loaded"
+          });
+          expectNoMoreCalls(listSub1);
+          expectNoMoreCalls(ifaceSub);
+          expect(listSub1.next).not.toHaveBeenCalled();
+          expect(listSub1.error).not.toHaveBeenCalled();
+          expect(ifaceSub.next).not.toHaveBeenCalled();
+          expect(ifaceSub.error).not.toHaveBeenCalled();
         });
         it("subsequent load", async () => {
           // Pre-seed with data the server doesn't return
-          cache.updateList({
-            objectType: Employee,
+          updateList(cache, {
+            type: Employee,
             where: {},
             orderBy: {}
           }, mutatedEmployees);
           defer(cache.observeList({
-            objectType: Employee,
+            type: Employee,
             mode: "force"
           }, listSub1));
           await waitForCall(listSub1, 1);
-          const firstLoad = listSub1.mock.calls[0][0];
+          const firstLoad = listSub1.next.mock.calls[0][0];
           expectSingleListCallAndClear(listSub1, mutatedEmployees, {
             status: "loading"
           });
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns,
+          await waitForCall(listSub1, 1);
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns, {
             status: "loaded",
             lastUpdated: expect.toBeGreaterThan(firstLoad.lastUpdated)
-          }));
-          listSub1.mockClear();
+          });
         });
       });
       describe("mode = offline", () => {
         it("updates with list updates", async () => {
           defer(cache.observeList({
-            objectType: Employee,
+            type: Employee,
             where: {},
             orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1).toHaveBeenCalledTimes(0);
-          cache.updateList({
-            objectType: Employee,
+          expect(listSub1.next).toHaveBeenCalledTimes(0);
+          updateList(cache, {
+            type: Employee,
             where: {},
             orderBy: {}
           }, employeesAsServerReturns);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns
-          }));
-          listSub1.mockClear();
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // list is just now one object
-          cache.updateList({
-            objectType: Employee,
+          updateList(cache, {
+            type: Employee,
             where: {},
             orderBy: {}
           }, [employeesAsServerReturns[0]]);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: [employeesAsServerReturns[0]]
-          }));
+          expectSingleListCallAndClear(listSub1, [employeesAsServerReturns[0]]);
         });
         it("updates with different list updates", async () => {
           defer(cache.observeList({
-            objectType: Employee,
+            type: Employee,
             where: {},
             orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1).toHaveBeenCalledTimes(0);
-          cache.updateList({
-            objectType: Employee,
+          expect(listSub1.next).toHaveBeenCalledTimes(0);
+          updateList(cache, {
+            type: Employee,
             where: {},
             orderBy: {}
           }, employeesAsServerReturns);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns
-          }));
-          listSub1.mockClear();
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // new where === different list
-          cache.updateList({
-            objectType: Employee,
+          updateList(cache, {
+            type: Employee,
             where: {
               employeeId: {
                 $gt: 0
@@ -600,9 +584,7 @@ describe(Store, () => {
           vitest.runOnlyPendingTimers();
 
           // original list updates still
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: mutatedEmployees
-          }));
+          expectSingleListCallAndClear(listSub1, mutatedEmployees);
         });
       });
     });
@@ -616,39 +598,33 @@ describe(Store, () => {
       it("works in the solo case", async () => {
         const listSub = mockListSubCallback();
         defer(cache.observeList({
-          objectType: Employee,
+          type: Employee,
           where: {},
           orderBy: {},
           mode: "force",
           pageSize: 1
         }, listSub));
-        expect(listSub).not.toHaveBeenCalled();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalled());
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
+        expect(listSub.next).not.toHaveBeenCalled();
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, [], {
           status: "loading"
-        }));
-        listSub.mockClear();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalled());
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 1),
-          status: "loaded"
-        }));
+        });
+        await waitForCall(listSub, 1);
         const {
           fetchMore
-        } = listSub.mock.calls[0][0];
-        listSub.mockClear();
+        } = listSub.next.mock.calls[0][0];
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 1), {
+          status: "loaded"
+        });
         void fetchMore();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalledTimes(1));
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 1),
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 1), {
           status: "loading"
-        }));
-        listSub.mockClear();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalledTimes(1));
-        expect(listSub).toHaveBeenCalledWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 2),
+        });
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 2), {
           status: "loaded"
-        }));
+        });
       });
     });
   });
@@ -661,11 +637,25 @@ describe(Store, () => {
       client = mockClient.client;
       store = new Store(client);
     });
+    it("properly fires error handler for a list", async () => {
+      const error = new Error("A faux error");
+      mockClient.mockFetchPageOnce().reject(error);
+      const sub = mockListSubCallback();
+      store.observeList({
+        type: Employee,
+        where: {},
+        orderBy: {}
+      }, sub);
+      await waitForCall(sub.error, 1);
+      expect(sub.error).toHaveBeenCalled();
+      expect(sub.next).not.toHaveBeenCalled();
+    });
     describe("actions", () => {
       it("properly invalidates objects", async () => {
         // after the below `observeObject`, the cache will need to load from the server
         mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo"
+          $apiName: "Todo",
+          $primaryKey: 0
         });
         const todoSubFn = mockSingleSubCallback();
         defer(store.observeObject(Todo, 0, {}, todoSubFn));
@@ -690,15 +680,14 @@ describe(Store, () => {
         });
 
         // after we apply the action, the object is invalidated and gets re-requested
-
         mockClient.mockFetchOneOnce().resolve({
+          $primaryKey: 0,
           $apiName: "Todo",
           text: "hello there kind sir"
         });
-        const actionPromise = store.applyAction(createOffice, {
+        await store.applyAction(createOffice, {
           officeId: "whatever"
         });
-        await actionPromise;
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading"
@@ -748,7 +737,7 @@ describe(Store, () => {
           }
         });
         await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(todoSubFn.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: {
             ...fauxObject,
             text: "optimistic"
@@ -756,7 +745,7 @@ describe(Store, () => {
           status: "loading",
           isOptimistic: true
         }));
-        todoSubFn.mockClear();
+        todoSubFn.next.mockClear();
 
         // let the action error out
         applyActionResult.reject("an error thrown");
@@ -764,43 +753,72 @@ describe(Store, () => {
 
         // back to the original object
         await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(todoSubFn.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: fauxObject,
           status: "loaded",
           isOptimistic: false
         }));
       });
     });
-    describe("orderBy", () => {
+    describe("orderBy", async () => {
+      const ontologyProvider = {
+        getObjectDefinition: async () => {
+          return {
+            ...wireObjectTypeFullMetadataToSdkObjectMetadata(stubData.todoWithLinkTypes, true),
+            [InterfaceDefinitions]: {}
+          };
+        },
+        getActionDefinition() {
+          throw new Error("not implemented");
+        },
+        getInterfaceDefinition() {
+          throw new Error("not implemented");
+        },
+        getQueryDefinition() {
+          throw new Error("not implemented");
+        }
+      };
+      const minimalClient = createMinimalClient({
+        ontologyRid: "ri.whatever"
+      }, "https://localhost:8080", () => Promise.resolve("token"), {
+        logger
+      }, fetch, createObjectSet, () => () => ontologyProvider);
+      async function createObject(type, x) {
+        return (await minimalClient.objectFactory2(minimalClient, [{
+          ...x,
+          $apiName: type.apiName,
+          $objectType: type.apiName,
+          $objectSpecifier: `${type.apiName}:${x.$primaryKey}`
+        }], undefined))[0];
+      }
       let nextPk = 0;
-      const fauxObjectA = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
+      const fauxObjectA = await createObject(Todo, {
+        $primaryKey: nextPk,
         $title: "a",
+        id: nextPk,
         text: "a"
-      };
-      const fauxObjectB = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
+      });
+      nextPk++;
+      const fauxObjectB = await createObject(Todo, {
+        $primaryKey: nextPk,
         $title: "b",
+        id: nextPk,
         text: "b"
-      };
-      const fauxObjectC = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
+      });
+      nextPk++;
+      const fauxObjectC = await createObject(Todo, {
+        $primaryKey: nextPk,
         $title: "c",
+        id: nextPk,
         text: "c"
-      };
+      });
       const noWhereNoOrderBy = {
-        objectType: Todo,
+        type: Todo,
         where: {},
         orderBy: {}
       };
       const noWhereOrderByText = {
-        objectType: Todo,
+        type: Todo,
         where: {},
         orderBy: {
           text: "asc"
@@ -813,16 +831,16 @@ describe(Store, () => {
           ...noWhereNoOrderBy,
           mode: "offline"
         }, subListUnordered));
-        expect(subListUnordered).toHaveBeenCalledTimes(0);
+        expect(subListUnordered.next).toHaveBeenCalledTimes(0);
         defer(store.observeList({
           ...noWhereOrderByText,
           mode: "offline"
         }, subListOrdered));
-        expect(subListOrdered).toHaveBeenCalledTimes(0);
+        expect(subListOrdered.next).toHaveBeenCalledTimes(0);
       });
       it("invalidates the correct lists", async () => {
         // for whatever reason, the first list is loaded as [B, A]
-        store.updateList(noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
         await waitForCall(subListUnordered, 1);
         expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
 
@@ -833,8 +851,8 @@ describe(Store, () => {
 
         // For whatever reason, object B is no longer in the first set (use your imagination)
         // but we have added a C before A. So the first list is [C, A]
-        store.updateList({
-          objectType: Todo,
+        updateList(store, {
+          type: Todo,
           where: {},
           orderBy: {}
         }, [fauxObjectC, fauxObjectA]);
@@ -847,22 +865,20 @@ describe(Store, () => {
         expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB, fauxObjectC]);
       });
       it("produces proper results with optimistic updates and successful action", async () => {
-        const optimisticallyMutatedA = {
+        const optimisticallyMutatedA = await createObject(Todo, {
           ...fauxObjectA,
           text: "optimistic"
-        };
+        });
         const pkForOptimistic = nextPk++;
-        const optimisticallyCreatedObjectD = {
-          "$apiName": "Todo",
-          "$objectType": "Todo",
+        const optimisticallyCreatedObjectD = await createObject(Todo, {
           "$primaryKey": pkForOptimistic,
           "$title": "d",
           "text": "d",
           id: pkForOptimistic
-        };
+        });
 
         // for whatever reason, the first list is loaded as [B, A]
-        store.updateList(noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
         await waitForCall(subListUnordered, 1);
         expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
 
@@ -917,32 +933,28 @@ describe(Store, () => {
       // I think these are named backwards
       it("produces proper results with optimistic updates and rollback", async () => {
         const pkForOptimistic = nextPk++;
-        const optimisticallyCreatedObjectD = {
-          "$apiName": "Todo",
-          "$objectType": "Todo",
+        const optimisticallyCreatedObjectD = await createObject(Todo, {
           "$primaryKey": pkForOptimistic,
           "$title": "d",
           "text": "d",
           id: pkForOptimistic
-        };
-        const optimisticallyMutatedA = {
+        });
+        const optimisticallyMutatedA = await createObject(Todo, {
           ...fauxObjectA,
           text: "optimistic"
-        };
+        });
         testStage("Initial Setup");
 
         // later we will "create" this object
-        const createdObjectD = {
-          "$apiName": "Todo",
-          "$objectType": "Todo",
+        const createdObjectD = await createObject(Todo, {
           "$primaryKey": 9000,
           "$title": "d prime",
           "text": "d prime",
           id: 9000
-        };
+        });
 
         // for whatever reason, the first list is loaded as [B, A]
-        store.updateList(noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
         await waitForCall(subListUnordered, 1);
         expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
 
@@ -961,8 +973,8 @@ describe(Store, () => {
           officeId: "5"
         }, {
           optimisticUpdate: b => {
-            b.createObject(Todo, pkForOptimistic, {
-              id: pkForOptimistic,
+            b.createObject(Todo, optimisticallyCreatedObjectD.$primaryKey, {
+              id: optimisticallyCreatedObjectD.$primaryKey,
               text: "d"
             });
             b.updateObject(optimisticallyMutatedA);
@@ -978,16 +990,20 @@ describe(Store, () => {
           isOptimistic: true
         });
 
-        // the second list is now [A, B, optimistic]
+        // the second list is now [B, optimistic, optimistic a]
         await waitForCall(subListOrdered, 1);
         expectSingleListCallAndClear(subListOrdered, [fauxObjectB, optimisticallyCreatedObjectD, optimisticallyMutatedA], {
           isOptimistic: true
         });
         testStage("Resolve Action");
-        const modifiedObjectA = {
+        const modifiedObjectA = await createObject(Todo, {
           ...fauxObjectA,
           text: "a prime"
-        };
+        });
+
+        // console.log("winner?", modifiedObjectA.$as);
+        // // throw "hi";
+        // console.log("winner2?", modifiedObjectA.$as("Todo").$as);
 
         // The action will complete and then revalidate in order...
         mockClient.mockFetchOneOnce(modifiedObjectA.$primaryKey).resolve(modifiedObjectA);
@@ -1023,6 +1039,7 @@ describe(Store, () => {
 
         await actionPromise;
         await waitForCall(subListUnordered, 1);
+        console.log("=====", subListUnordered.next.mock.calls[0][0]);
         expectSingleListCallAndClear(subListUnordered, [fauxObjectB,
         // fauxObjectC,
         modifiedObjectA, createdObjectD], {
@@ -1049,12 +1066,12 @@ describe(Store, () => {
 
       // set the truth
       for (const obj of baseObjects) {
-        store.updateObject("Employee", obj);
+        updateObject(store, obj);
       }
 
       // expect the truth
       for (const obj of baseObjects) {
-        expect(store.getObject("Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
           $title: `truth ${obj.$primaryKey}`
         }));
       }
@@ -1074,7 +1091,7 @@ describe(Store, () => {
 
       // expect the optimistic values
       for (let i = 0; i < 2; i++) {
-        expect(store.getObject("Employee", baseObjects[i].$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", baseObjects[i].$primaryKey)).toEqual(expect.objectContaining({
           $title: `optimistic ${baseObjects[i].$primaryKey}`
         }));
       }
@@ -1083,10 +1100,10 @@ describe(Store, () => {
       store.removeLayer(layerIds[0]);
 
       // should have truth object 1 and optimistic object 2
-      expect(store.getObject("Employee", 1)).toEqual(expect.objectContaining({
+      expect(getObject(store, "Employee", 1)).toEqual(expect.objectContaining({
         $title: "truth 1"
       }));
-      expect(store.getObject("Employee", 2)).toEqual(expect.objectContaining({
+      expect(getObject(store, "Employee", 2)).toEqual(expect.objectContaining({
         $title: "optimistic 2"
       }));
 
@@ -1095,7 +1112,7 @@ describe(Store, () => {
 
       // should have truth objects
       for (const obj of baseObjects) {
-        expect(store.getObject("Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
           $title: `truth ${obj.$primaryKey}`
         }));
       }