@osdk/client 2.2.0-beta.8 → 2.3.0-beta.1

package/build/esm/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 { editTodo, Employee, FooInterface, Todo } from "@osdk/client.test.ontology";
+import { ActionTypeBuilder, FauxFoundry, ontologies, startNodeApiServer, stubData } from "@osdk/shared.test";
 import chalk from "chalk";
+import invariant from "tiny-invariant";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, vitest } 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 { 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, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
+const JOHN_DOE_ID = 50030;
 const defer = createDefer();
+const logger = new TestLogger();
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -54,6 +59,42 @@ function testStage(s) {
   console.log(chalk.bgYellow(`Test Stage: ${s}`));
 }
 applyCustomMatchers();
+function setupOntology(fauxFoundry) {
+  const fauxOntology = fauxFoundry.getDefaultOntology();
+  ontologies.addEmployeeOntology(fauxOntology);
+  fauxFoundry.getDefaultOntology().registerObjectType(stubData.todoWithLinkTypes);
+  fauxFoundry.getDefaultOntology().registerActionType(stubData.editTodo.actionTypeV2, (b, payload) => {
+    const {
+      id,
+      ...other
+    } = payload.parameters;
+    b.modifyObject(Todo.apiName, id, {
+      ...other
+    });
+  });
+}
+function setupSomeEmployees(fauxFoundry) {
+  const dataStore = fauxFoundry.getDefaultDataStore();
+  dataStore.registerObject(Employee, {
+    employeeId: 1
+  });
+  dataStore.registerObject(Employee, {
+    employeeId: 2
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: 3
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: 4
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: JOHN_DOE_ID,
+    fullName: "John Doe"
+  });
+}
 describe(Store, () => {
   describe("with mock server", () => {
     let client;
@@ -61,46 +102,51 @@ describe(Store, () => {
     let employeesAsServerReturns;
     let mutatedEmployees;
     beforeAll(async () => {
-      apiServer.listen();
-      client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken", {
-        logger: createTestLogger({})
+      const testSetup = startNodeApiServer(new FauxFoundry("https://stack.palantir.com/"), createClient, {
+        logger
       });
+      ({
+        client
+      } = testSetup);
+      setupOntology(testSetup.fauxFoundry);
+      setupSomeEmployees(testSetup.fauxFoundry);
       employeesAsServerReturns = (await client(Employee).fetchPage()).data;
       mutatedEmployees = [employeesAsServerReturns[0], employeesAsServerReturns[1].$clone({
         fullName: "foo"
       }), ...employeesAsServerReturns.slice(2)];
-    });
-    afterAll(() => {
-      apiServer.close();
+      return () => {
+        testSetup.apiServer.close();
+      };
     });
     beforeEach(() => {
       cache = new Store(client);
-    });
-    afterEach(() => {
-      cache = undefined;
+      return () => {
+        cache = undefined;
+      };
     });
     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 +155,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 +170,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 +183,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 +193,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 +216,8 @@ describe(Store, () => {
           fullName: "real update"
         });
         testStage("write real update");
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [truthUpdatedEmployee]);
@@ -188,47 +234,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 +274,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 +302,8 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [staleEmp]);
@@ -286,7 +314,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 +322,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 +336,9 @@ describe(Store, () => {
         });
         await waitForCall(subFn, 1);
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
+
+        // don't leave promises dangling
+        await invalidateListPromise;
       });
     });
     describe(".invalidateObjectType", () => {
@@ -322,8 +353,8 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList({
-          objectType: Employee,
+        updateList(cache, {
+          type: Employee,
           where: {},
           orderBy: {}
         }, [staleEmp]);
@@ -334,7 +365,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
         defer(cache.observeList({
-          objectType: Employee,
+          type: Employee,
           where: {},
           orderBy: {},
           mode: "offline"
@@ -346,21 +377,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,53 +394,51 @@ 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,
+        $primaryKey: JOHN_DOE_ID,
         fullName: "John Doe"
       });
       it("fetches and updates twice", async () => {
-        defer(cache.observeObject(Employee, 50030, {
+        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           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();
-        defer(cache.observeObject(Employee, 50030, {
+        const firstLoad = subFn1.next.mock.lastCall?.[0];
+        subFn1.next.mockClear();
+        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           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 +446,66 @@ describe(Store, () => {
       const subFn = mockSingleSubCallback();
       let sub;
       beforeEach(() => {
-        subFn.mockClear();
-        sub = defer(cache.observeObject(Employee, 50030, {
+        subFn.complete.mockClear();
+        subFn.next.mockClear();
+        subFn.error.mockClear();
+        sub = defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           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];
+        const emp = employeesAsServerReturns.find(x => x.$primaryKey === JOHN_DOE_ID);
 
         // 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];
+        const emp = employeesAsServerReturns.find(x => x.$primaryKey === JOHN_DOE_ID);
 
         // 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 +513,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, {
+            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 +624,7 @@ describe(Store, () => {
           vitest.runOnlyPendingTimers();
 
           // original list updates still
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: mutatedEmployees
-          }));
+          expectSingleListCallAndClear(listSub1, mutatedEmployees);
         });
       });
     });
@@ -616,56 +638,123 @@ 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"
-        }));
+        });
       });
     });
   });
   describe("with mock client", () => {
     let client;
-    let mockClient;
+    let apiServer;
+    let fauxFoundry;
     let store;
+    beforeAll(async () => {
+      const testSetup = startNodeApiServer(new FauxFoundry("https://stack.palantir.com/", undefined, {
+        logger
+      }), createClient, {
+        logger
+      });
+      ({
+        client,
+        apiServer,
+        fauxFoundry
+      } = testSetup);
+      setupOntology(testSetup.fauxFoundry);
+      return () => {
+        testSetup.apiServer.close();
+      };
+    });
+    beforeEach(() => {
+      apiServer.resetHandlers();
+    });
     beforeEach(async () => {
-      mockClient = createClientMockHelper();
-      client = mockClient.client;
       store = new Store(client);
     });
+    it("properly fires error handler for a list", async () => {
+      const sub = mockListSubCallback();
+      store.observeList({
+        type: Employee,
+        where: {
+          aBadPropertyThatDoesNotExist: "aBadValue"
+        },
+        orderBy: {}
+      }, sub);
+      await waitForCall(sub.error, 1);
+      expect(sub.error).toHaveBeenCalled();
+      expect(sub.next).not.toHaveBeenCalled();
+    });
+    describe("batching", () => {
+      it("groups requests for single objects", async () => {
+        fauxFoundry.getDefaultDataStore().registerObject(Employee, {
+          $apiName: "Employee",
+          employeeId: 0
+        });
+        fauxFoundry.getDefaultDataStore().registerObject(Employee, {
+          $apiName: "Employee",
+          employeeId: 1
+        });
+        const a = mockSingleSubCallback();
+        const b = mockSingleSubCallback();
+        defer(store.observeObject(Employee, 0, {}, a));
+        defer(store.observeObject(Employee, 1, {}, b));
+        await a.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: undefined
+          }),
+          loaded: objectPayloadContaining({
+            object: expect.objectContaining({
+              $primaryKey: 0
+            })
+          })
+        });
+        await b.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: undefined
+          }),
+          loaded: objectPayloadContaining({
+            object: expect.objectContaining({
+              $primaryKey: 1
+            })
+          })
+        });
+      });
+    });
     describe("actions", () => {
+      beforeEach(() => {
+        fauxFoundry.getDefaultDataStore().clear();
+      });
       it("properly invalidates objects", async () => {
-        // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo"
+        fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+          $apiName: "Todo",
+          id: 0,
+          text: "og title"
         });
         const todoSubFn = mockSingleSubCallback();
         defer(store.observeObject(Todo, 0, {}, todoSubFn));
@@ -682,23 +771,10 @@ describe(Store, () => {
         });
 
         // at this point we have an observation properly set up
-        mockClient.mockApplyActionOnce().resolve({
-          addedObjects: [{
-            objectType: "Todo",
-            primaryKey: 0
-          }]
-        });
-
-        // after we apply the action, the object is invalidated and gets re-requested
-
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo",
+        await store.applyAction(editTodo, {
+          id: 0,
           text: "hello there kind sir"
         });
-        const actionPromise = store.applyAction(createOffice, {
-          officeId: "whatever"
-        });
-        await actionPromise;
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading"
@@ -711,15 +787,17 @@ describe(Store, () => {
         });
       });
       it("rolls back optimistic updates on error", async () => {
-        const fauxObject = {
-          $apiName: "Todo",
-          $objectType: "Todo",
-          $primaryKey: 0,
-          $title: "does not matter"
-        };
+        const fauxObject = expect.objectContaining({
+          id: 0,
+          text: "does not matter"
+        });
 
-        // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve(fauxObject);
+        // set the object in the "backend"
+        fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+          $apiName: "Todo",
+          id: 0,
+          text: "does not matter"
+        });
         const todoSubFn = mockSingleSubCallback();
         defer(store.observeObject(Todo, 0, {}, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
@@ -734,73 +812,61 @@ describe(Store, () => {
             isOptimistic: false
           })
         });
+        const object = store.getValue(store.getCacheKey("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
-        const applyActionResult = mockClient.mockApplyActionOnce();
-        const actionPromise = store.applyAction(createOffice, {
-          officeId: "whatever"
+        await expect(store.applyAction(editTodo, {
+          id: "not an id that exists"
         }, {
           optimisticUpdate: ctx => {
-            ctx.updateObject({
-              ...fauxObject,
+            ctx.updateObject(object.$clone({
               text: "optimistic"
-            });
+            }));
           }
+        })).rejects.toThrow(ActionValidationError);
+        await waitForCall(todoSubFn, 2);
+        await todoSubFn.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: expect.objectContaining({
+              id: 0,
+              text: "optimistic"
+            }),
+            isOptimistic: true
+          }),
+          loaded: objectPayloadContaining({
+            object: fauxObject,
+            status: "loaded",
+            isOptimistic: false
+          })
         });
-        await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: {
-            ...fauxObject,
-            text: "optimistic"
-          },
-          status: "loading",
-          isOptimistic: true
-        }));
-        todoSubFn.mockClear();
-
-        // let the action error out
-        applyActionResult.reject("an error thrown");
-        await expect(actionPromise).rejects.toThrow("an error thrown");
-
-        // back to the original object
-        await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: fauxObject,
-          status: "loaded",
-          isOptimistic: false
-        }));
       });
     });
-    describe("orderBy", () => {
+    describe("orderBy", async () => {
       let nextPk = 0;
-      const fauxObjectA = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
-        $title: "a",
-        text: "a"
-      };
-      const fauxObjectB = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
-        $title: "b",
-        text: "b"
-      };
-      const fauxObjectC = {
-        $apiName: "Todo",
-        $objectType: "Todo",
-        $primaryKey: nextPk++,
-        $title: "c",
-        text: "c"
-      };
+      let fauxObjectA;
+      let fauxObjectB;
+      let fauxObjectC;
+      beforeAll(async () => {
+        fauxFoundry.getDefaultDataStore().clear();
+        [fauxObjectA, fauxObjectB, fauxObjectC] = await Promise.all(["a", "b", "c"].map(text => {
+          const id = nextPk++;
+          fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+            $apiName: "Todo",
+            id,
+            text
+          });
+          return client(Todo).fetchOne(id);
+        }));
+      });
       const noWhereNoOrderBy = {
-        objectType: Todo,
+        type: Todo,
         where: {},
         orderBy: {}
       };
       const noWhereOrderByText = {
-        objectType: Todo,
+        type: Todo,
         where: {},
         orderBy: {
           text: "asc"
@@ -813,16 +879,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 +899,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 +913,17 @@ describe(Store, () => {
         expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB, fauxObjectC]);
       });
       it("produces proper results with optimistic updates and successful action", async () => {
-        const optimisticallyMutatedA = {
-          ...fauxObjectA,
+        const optimisticallyMutatedA = fauxObjectA.$clone({
           text: "optimistic"
-        };
+        });
         const pkForOptimistic = nextPk++;
-        const optimisticallyCreatedObjectD = {
-          "$apiName": "Todo",
-          "$objectType": "Todo",
-          "$primaryKey": pkForOptimistic,
-          "$title": "d",
+        const optimisticallyCreatedObjectD = expect.objectContaining({
           "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]);
 
@@ -872,10 +933,6 @@ describe(Store, () => {
         expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB]);
         testStage("Start");
 
-        // the optimistic job will call createObject which triggers the `objectFactory2` of the
-        // cache context.
-        mockClient.mockObjectFactory2Once().resolve([optimisticallyCreatedObjectD]);
-
         // Perform something optimistic.
         const removeOptimisticResult = runOptimisticJob(store, b => {
           b.createObject(Todo, pkForOptimistic, {
@@ -917,32 +974,20 @@ 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 = expect.objectContaining({
           "$primaryKey": pkForOptimistic,
-          "$title": "d",
-          "text": "d",
+          "$title": undefined,
+          // FIXME once this is calculated by optimistic then this needs to be the right value
+          "text": "d optimistic",
           id: pkForOptimistic
-        };
-        const optimisticallyMutatedA = {
-          ...fauxObjectA,
+        });
+        const optimisticallyMutatedA = fauxObjectA.$clone({
           text: "optimistic"
-        };
+        });
         testStage("Initial Setup");
 
-        // later we will "create" this object
-        const createdObjectD = {
-          "$apiName": "Todo",
-          "$objectType": "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]);
 
@@ -951,19 +996,33 @@ describe(Store, () => {
         expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB]);
         testStage("Optimistic Creation");
 
+        // create the weirdest action ever. It always creates a Todo with
+        // a new primary key and the text "d" and updates A
+        const {
+          actionDefinition: crazyAction,
+          actionTypeV2: crazyActionTypeV2
+        } = new ActionTypeBuilder("asdf").addParameter("foo", "string").build();
+        fauxFoundry.getDefaultOntology().registerActionType(crazyActionTypeV2, batch => {
+          const idForD = nextPk++;
+          batch.addObject(Todo.apiName, idForD, {
+            id: idForD,
+            text: "d"
+          });
+          batch.modifyObject(fauxObjectA.$apiName, fauxObjectA.$primaryKey, {
+            text: "a prime",
+            $title: "a prime" // FIXME we shouldn't have to set this, it can be calculated
+          });
+        });
+
         // the optimistic job will call createObject which triggers the `objectFactory2` of the
         // cache context.
 
-        mockClient.mockObjectFactory2Once().resolve([optimisticallyCreatedObjectD]);
-        const mockedApplyAction = mockClient.mockApplyActionOnce();
-        testStage("Apply Action");
-        const actionPromise = store.applyAction(createOffice, {
-          officeId: "5"
-        }, {
+        // Perform something optimistic.
+        const pActionResult = store.applyAction(crazyAction, {}, {
           optimisticUpdate: b => {
             b.createObject(Todo, pkForOptimistic, {
               id: pkForOptimistic,
-              text: "d"
+              text: "d optimistic"
             });
             b.updateObject(optimisticallyMutatedA);
           }
@@ -978,54 +1037,21 @@ 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 = {
-          ...fauxObjectA,
+        const modifiedObjectA = fauxObjectA.$clone({
           text: "a prime"
-        };
-
-        // The action will complete and then revalidate in order...
-        mockClient.mockFetchOneOnce(modifiedObjectA.$primaryKey).resolve(modifiedObjectA);
-        mockClient.mockFetchOneOnce(createdObjectD.$primaryKey).resolve(createdObjectD);
-
-        // this order matters!
-        // but now we don't need them because we just update lists instead of revalidate when we can
-        // const plainList = mockClient.mockFetchPageOnce<Todo>();
-        // const orderedList = mockClient.mockFetchPageOnce<Todo>();
-
-        mockedApplyAction.resolve({
-          addedObjects: [{
-            objectType: "Todo",
-            primaryKey: createdObjectD.id
-          }],
-          modifiedObjects: [{
-            objectType: "Todo",
-            primaryKey: fauxObjectA.$primaryKey
-          }]
         });
-
-        // plainList.resolve({
-        //   nextPageToken: undefined,
-        //   totalCount: "4",
-        //   data: [fauxObjectB, fauxObjectC, modifiedObjectA, createdObjectD],
-        // });
-
-        // orderedList.resolve({
-        //   nextPageToken: undefined,
-        //   totalCount: "4",
-        //   data: [modifiedObjectA, fauxObjectC, createdObjectD],
-        // });
-
-        await actionPromise;
+        const pkForD = (await pActionResult).addedObjects?.[0].primaryKey;
+        !(typeof pkForD === "number") ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+        // load this without the cache for comparisons
+        const createdObjectD = await client(Todo).fetchOne(pkForD);
         await waitForCall(subListUnordered, 1);
-        expectSingleListCallAndClear(subListUnordered, [fauxObjectB,
-        // fauxObjectC,
-        modifiedObjectA, createdObjectD], {
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, modifiedObjectA, createdObjectD], {
           isOptimistic: false
         });
         await waitForCall(subListOrdered, 1);
@@ -1049,12 +1075,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 +1100,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 +1109,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 +1121,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}`
         }));
       }