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

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

@@ -14,21 +14,21 @@
  * limitations under the License.
  */
 
-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 { 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 { createMinimalClient } from "../../createMinimalClient.js";
-import { createObjectSet } from "../../objectSet/createObjectSet.js";
-import { InterfaceDefinitions } from "../../ontology/OntologyProvider.js";
+import { TestLogger } from "../../logger/TestLogger.js";
 import { createOptimisticId } from "./OptimisticId.js";
 import { runOptimisticJob } from "./OptimisticJob.js";
 import { invalidateList, Store } from "./Store.js";
-import { applyCustomMatchers, createClientMockHelper, createDefer, createTestLogger, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.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 = createTestLogger({});
+const logger = new TestLogger();
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -59,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;
@@ -66,23 +102,27 @@ describe(Store, () => {
     let employeesAsServerReturns;
     let mutatedEmployees;
     beforeAll(async () => {
-      apiServer.listen();
-      client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken", {
+      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];
@@ -362,11 +402,11 @@ describe(Store, () => {
         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.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
@@ -382,7 +422,7 @@ describe(Store, () => {
         }));
         const firstLoad = subFn1.next.mock.lastCall?.[0];
         subFn1.next.mockClear();
-        defer(cache.observeObject(Employee, 50030, {
+        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           mode: "force"
         }, subFn2));
         expectSingleObjectCallAndClear(subFn1, likeEmployee50030, "loading");
@@ -409,13 +449,13 @@ describe(Store, () => {
         subFn.complete.mockClear();
         subFn.next.mockClear();
         subFn.error.mockClear();
-        sub = defer(cache.observeObject(Employee, 50030, {
+        sub = defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           mode: "offline"
         }, subFn));
         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
         updateObject(cache, emp);
@@ -437,7 +477,7 @@ describe(Store, () => {
         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
         updateObject(cache, emp.$clone({
@@ -496,7 +536,7 @@ describe(Store, () => {
             status: "loaded"
           });
           await waitForCall(ifaceSub);
-          expectSingleListCallAndClear(ifaceSub, employeesAsServerReturns.filter(o => o.$primaryKey === 50050), {
+          expectSingleListCallAndClear(ifaceSub, employeesAsServerReturns, {
             status: "loaded"
           });
           expectNoMoreCalls(listSub1);
@@ -630,32 +670,91 @@ describe(Store, () => {
   });
   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 error = new Error("A faux error");
-      mockClient.mockFetchPageOnce().reject(error);
       const sub = mockListSubCallback();
       store.observeList({
         type: Employee,
-        where: {},
+        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({
+        fauxFoundry.getDefaultDataStore().registerObject(Todo, {
           $apiName: "Todo",
-          $primaryKey: 0
+          id: 0,
+          text: "og title"
         });
         const todoSubFn = mockSingleSubCallback();
         defer(store.observeObject(Todo, 0, {}, todoSubFn));
@@ -672,22 +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({
-          $primaryKey: 0,
-          $apiName: "Todo",
+        await store.applyAction(editTodo, {
+          id: 0,
           text: "hello there kind sir"
         });
-        await store.applyAction(createOffice, {
-          officeId: "whatever"
-        });
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading"
@@ -700,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({
@@ -723,94 +812,53 @@ 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.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: {
-            ...fauxObject,
-            text: "optimistic"
-          },
-          status: "loading",
-          isOptimistic: true
-        }));
-        todoSubFn.next.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.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: fauxObject,
-          status: "loaded",
-          isOptimistic: false
-        }));
       });
     });
     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 = await createObject(Todo, {
-        $primaryKey: nextPk,
-        $title: "a",
-        id: nextPk,
-        text: "a"
-      });
-      nextPk++;
-      const fauxObjectB = await createObject(Todo, {
-        $primaryKey: nextPk,
-        $title: "b",
-        id: nextPk,
-        text: "b"
-      });
-      nextPk++;
-      const fauxObjectC = await createObject(Todo, {
-        $primaryKey: nextPk,
-        $title: "c",
-        id: nextPk,
-        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 = {
         type: Todo,
@@ -865,14 +913,11 @@ describe(Store, () => {
         expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB, fauxObjectC]);
       });
       it("produces proper results with optimistic updates and successful action", async () => {
-        const optimisticallyMutatedA = await createObject(Todo, {
-          ...fauxObjectA,
+        const optimisticallyMutatedA = fauxObjectA.$clone({
           text: "optimistic"
         });
         const pkForOptimistic = nextPk++;
-        const optimisticallyCreatedObjectD = await createObject(Todo, {
-          "$primaryKey": pkForOptimistic,
-          "$title": "d",
+        const optimisticallyCreatedObjectD = expect.objectContaining({
           "text": "d",
           id: pkForOptimistic
         });
@@ -888,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, {
@@ -933,26 +974,18 @@ describe(Store, () => {
       // I think these are named backwards
       it("produces proper results with optimistic updates and rollback", async () => {
         const pkForOptimistic = nextPk++;
-        const optimisticallyCreatedObjectD = await createObject(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 = await createObject(Todo, {
-          ...fauxObjectA,
+        const optimisticallyMutatedA = fauxObjectA.$clone({
           text: "optimistic"
         });
         testStage("Initial Setup");
 
-        // later we will "create" this object
-        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]
         updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
         await waitForCall(subListUnordered, 1);
@@ -963,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, optimisticallyCreatedObjectD.$primaryKey, {
-              id: optimisticallyCreatedObjectD.$primaryKey,
-              text: "d"
+            b.createObject(Todo, pkForOptimistic, {
+              id: pkForOptimistic,
+              text: "d optimistic"
             });
             b.updateObject(optimisticallyMutatedA);
           }
@@ -996,53 +1043,15 @@ describe(Store, () => {
           isOptimistic: true
         });
         testStage("Resolve Action");
-        const modifiedObjectA = await createObject(Todo, {
-          ...fauxObjectA,
+        const modifiedObjectA = fauxObjectA.$clone({
           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);
-        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);
-        console.log("=====", subListUnordered.next.mock.calls[0][0]);
-        expectSingleListCallAndClear(subListUnordered, [fauxObjectB,
-        // fauxObjectC,
-        modifiedObjectA, createdObjectD], {
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, modifiedObjectA, createdObjectD], {
           isOptimistic: false
         });
         await waitForCall(subListOrdered, 1);