@osdk/client 2.1.1 → 2.2.0-beta.10

package/build/esm/objectSet/ObjectSet.test.js

@@ -15,19 +15,21 @@
  */
 
 import { isOk } from "@osdk/api";
-import { __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid } from "@osdk/api/unstable";
-import { $ontologyRid, BarInterface, BgaoNflPlayer, Employee, FooInterface, Office } from "@osdk/client.test.ontology";
-import { apiServer, stubData } from "@osdk/shared.test";
-import { afterAll, beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+import { __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid, __EXPERIMENTAL__NOT_SUPPORTED_YET__fetchPageByRid } from "@osdk/api/unstable";
+import { BarInterface, BgaoNflPlayer, Employee, FooInterface, Office } from "@osdk/client.test.ontology";
+import { LegacyFauxFoundry, startNodeApiServer, stubData } from "@osdk/shared.test";
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { createClient } from "../createClient.js";
 describe("ObjectSet", () => {
   let client;
-  beforeAll(async () => {
-    apiServer.listen();
-    client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken");
-  });
-  afterAll(() => {
-    apiServer.close();
+  beforeAll(() => {
+    const testSetup = startNodeApiServer(new LegacyFauxFoundry(), createClient);
+    ({
+      client
+    } = testSetup);
+    return () => {
+      testSetup.apiServer.close();
+    };
   });
   it("does not allow intersect/union/subtract with different object types", () => {
     const employeeObjectSet = client(Employee);
@@ -46,15 +48,20 @@ describe("ObjectSet", () => {
   it("objects set union", async () => {
     const objectSet = client(Employee);
     const unionedObjectSet = objectSet.union(objectSet);
-    let iter = 0;
     const {
       data: employees
     } = await unionedObjectSet.fetchPage();
+    const pks = new Set();
     for (const emp of employees) {
-      expect(emp.employeeId).toEqual(50030 + iter);
-      iter += 1;
+      pks.add(emp.$primaryKey);
     }
-    expect(iter).toEqual(2);
+    expect(pks.size).toEqual(6);
+    expect(pks.has(stubData.employee1.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee2.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee3.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee4withDerived.employeeId)).toBe(true);
+    expect(pks.has(stubData.employeePassesStrict.__primaryKey)).toBe(true);
+    expect(pks.has(stubData.employee50050.employeeId)).toBe(true);
   });
   it("objects set subtract", async () => {
     const objectSet = client(Employee);
@@ -62,76 +69,44 @@ describe("ObjectSet", () => {
       employeeId: 50030
     });
     const subtractedObjectSet = objectSet.subtract(objectSet2);
-    let iter = 0;
-    const {
-      data: employees
-    } = await subtractedObjectSet.fetchPage();
-    for (const emp of employees) {
-      expect(emp.employeeId).toEqual(50031 + iter);
-      iter += 1;
-    }
-    expect(iter).toEqual(2);
+    const objectSetResults = await objectSet.fetchPage();
+    const objectSet2Results = await objectSet2.fetchPage();
+    const subtractedObjectSetResults = await subtractedObjectSet.fetchPage();
+    expect(objectSet2Results.data).toHaveLength(1);
+    expect(subtractedObjectSetResults.data).toHaveLength(objectSetResults.data.length - objectSet2Results.data.length);
+    expect(subtractedObjectSetResults.data.find(x => x.$primaryKey === 50030)).toBeUndefined();
   });
   it("objects set intersect", async () => {
     const objectSet = client(Employee);
     const intersectedObjectSet = objectSet.intersect(objectSet);
-    let iter = 0;
     const {
       data: employees
     } = await intersectedObjectSet.fetchPage();
+    const pks = new Set();
     for (const emp of employees) {
-      expect(emp.employeeId).toEqual(50032);
-      iter += 1;
+      pks.add(emp.$primaryKey);
     }
-    expect(iter).toEqual(1);
+    expect(pks.size).toEqual(6);
+    expect(pks.has(stubData.employee1.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee2.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee3.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee4withDerived.employeeId)).toBe(true);
+    expect(pks.has(stubData.employeePassesStrict.__primaryKey)).toBe(true);
+    expect(pks.has(stubData.employee50050.employeeId)).toBe(true);
   });
   it("orders objects in ascending order without a filter, and returns all results", async () => {
     const {
       data: employees
-    } = await client(Employee).fetchPage({
+    } = await client(Employee).where({
+      employeeId: {
+        $isNull: false
+      }
+    }).fetchPage({
       $orderBy: {
         "employeeId": "asc"
       }
     });
-    expect(employees).toMatchObject([{
-      $apiName: "Employee",
-      $objectType: "Employee",
-      $primaryKey: 50030,
-      class: "Red",
-      employeeId: 50030,
-      employeeStatus: expect.anything(),
-      employeeSensor: expect.anything(),
-      fullName: "John Doe",
-      office: "NYC",
-      startDate: "2019-01-01",
-      employeeLocation: expect.anything()
-    }, {
-      $apiName: "Employee",
-      $objectType: "Employee",
-      $primaryKey: 50031,
-      $title: "Jane Doe",
-      class: "Blue",
-      employeeId: 50031,
-      employeeStatus: expect.anything(),
-      employeeSensor: expect.anything(),
-      fullName: "Jane Doe",
-      office: "SEA",
-      startDate: "2012-02-12",
-      employeeLocation: expect.anything()
-    }, {
-      $apiName: "Employee",
-      $objectType: "Employee",
-      $primaryKey: 50032,
-      $title: "Jack Smith",
-      class: "Red",
-      employeeId: 50032,
-      employeeStatus: expect.anything(),
-      employeeSensor: expect.anything(),
-      fullName: "Jack Smith",
-      office: "LON",
-      startDate: "2015-05-15",
-      employeeLocation: expect.anything()
-    }]);
+    expect(employees.map(e => e.$primaryKey)).toEqual([50030, 50031, 50032, 50033, 50035, stubData.employee50050.employeeId]);
   });
   it("allows fetching by PK from a base object set - fetchOne", async () => {
     const employee = await client(Employee).fetchOne(stubData.employee1.employeeId);
@@ -139,17 +114,31 @@ describe("ObjectSet", () => {
     expect(employee.$primaryKey).toBe(stubData.employee1.employeeId);
   });
   it("allows fetching by rid with experimental function", async () => {
-    const employee = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid).fetchOneByRid(Employee, "ri.employee.i.look.for");
+    const employee = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid).fetchOneByRid(Employee, stubData.employee1.__rid);
     expectTypeOf().toMatchTypeOf;
     expect(employee.$primaryKey).toBe(stubData.employee1.employeeId);
   });
+  it("allows fetching page of rids with experimental function", async () => {
+    const employees = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchPageByRid).fetchPageByRid(Employee, [stubData.employee1.__rid, stubData.employee2.__rid], {});
+    expectTypeOf().toMatchTypeOf;
+    expect(employees.data[0].$primaryKey).toBe(stubData.employee1.employeeId);
+    expect(employees.data[1].$primaryKey).toBe(stubData.employee2.employeeId);
+  });
   it("allows fetching by rid with experimental function, with select", async () => {
-    const employee = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid).fetchOneByRid(Employee, "ri.employee.i.look.for", {
+    const employee = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchOneByRid).fetchOneByRid(Employee, stubData.employee2.__rid, {
       $select: ["fullName"]
     });
     expectTypeOf().toMatchTypeOf;
     expect(employee.$primaryKey).toBe(stubData.employee2.employeeId);
   });
+  it("allows fetching by rid with experimental function, with select 2", async () => {
+    const employees = await client(__EXPERIMENTAL__NOT_SUPPORTED_YET__fetchPageByRid).fetchPageByRid(Employee, [stubData.employee2.__rid, stubData.employee3.__rid], {
+      $select: ["fullName"]
+    });
+    expectTypeOf().toMatchTypeOf;
+    expect(employees.data[0].$primaryKey).toBe(stubData.employee2.employeeId);
+    expect(employees.data[1].$primaryKey).toBe(stubData.employee3.employeeId);
+  });
   it("check struct parsing", async () => {
     const player = await client(BgaoNflPlayer).fetchOne("tkelce");
     expectTypeOf().toMatchTypeOf;
@@ -223,16 +212,18 @@ describe("ObjectSet", () => {
   it(" object set union works with fetchPageWithErrors", async () => {
     const objectSet = client(Employee);
     const unionedObjectSet = objectSet.union(objectSet);
-    let iter = 0;
     const result = await unionedObjectSet.fetchPageWithErrors();
-    if (isOk(result)) {
-      const employees = result.value.data;
-      for (const emp of employees) {
-        expect(emp.employeeId).toEqual(50030 + iter);
-        iter += 1;
-      }
-      expect(iter).toEqual(2);
+    const pks = new Set();
+    for (const emp of result.value.data) {
+      pks.add(emp.$primaryKey);
     }
+    expect(pks.size).toEqual(6);
+    expect(pks.has(stubData.employee1.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee2.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee3.employeeId)).toBe(true);
+    expect(pks.has(stubData.employee4withDerived.employeeId)).toBe(true);
+    expect(pks.has(stubData.employeePassesStrict.__primaryKey)).toBe(true);
+    expect(pks.has(stubData.employee50050.employeeId)).toBe(true);
   });
   it("allows $in filter with ReadonlyArrays", () => {
     const objectSet = client(Employee).where({
@@ -394,7 +385,7 @@ describe("ObjectSet", () => {
             $includeRid: true
           };
           const result = k === "fetchPage" ? await client(Employee).fetchPage(opts) : (await client(Employee).fetchPageWithErrors(opts)).value;
-          expect(result.data).toHaveLength(4);
+          expect(result.data).toHaveLength(6);
           expectTypeOf(result.data[0]).branded.toEqualTypeOf();
         });
       });
@@ -404,12 +395,254 @@ describe("ObjectSet", () => {
             $includeRid: false
           };
           const result = k === "fetchPage" ? await client(Employee).fetchPage(opts) : (await client(Employee).fetchPageWithErrors(opts)).value;
-          expect(result.data).toHaveLength(4);
+          expect(result.data).toHaveLength(6);
           expectTypeOf(result.data[0]).branded.toEqualTypeOf();
         });
       });
     });
   });
+  describe("Derived Properties Object Set", () => {
+    it("does not allow aggregate or selectProperty before a link type is selected", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base =>
+        // @ts-expect-error
+        base.aggregate("employeeId:exactDistinct")
+      });
+      client(Employee).withProperties({
+        "derivedPropertyName": base =>
+        // @ts-expect-error
+        base.selectProperty("employeeId")
+      });
+    });
+    it("does not allow selectProperty when a many link was selected at any point", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base => {
+          // @ts-expect-error
+          base.pivotTo("peeps").selectProperty("employeeId");
+
+          // @ts-expect-error
+          base.pivotTo("lead").pivotTo("peeps").selectProperty("employeeId");
+          return base.pivotTo("lead").selectProperty("employeeId");
+        }
+      });
+    });
+    it("enforces a return only of correct type", () => {
+      client(Employee).withProperties({
+        // @ts-expect-error
+        "derivedPropertyName": base => {
+          return base.pivotTo("peeps");
+        },
+        // @ts-expect-error
+        "derivedPropertyName2": () => {
+          return {
+            incorrect: "type"
+          };
+        }
+      });
+    });
+
+    // Executed code fails since we're providing bad strings to the function
+    it.fails("correctly narrows types of aggregate function", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base => {
+          // @ts-expect-error
+          base.pivotTo("lead").aggregate("notAProperty:sum");
+
+          // @ts-expect-error
+          base.pivotTo("lead").aggregate(":avg");
+
+          // @ts-expect-error
+          base.pivotTo("lead").aggregate("employeeId:notAnOp");
+
+          // @ts-expect-error
+          base.pivotTo("lead").aggregate("");
+          base.pivotTo("lead").aggregate("employeeId:collectList");
+          return base.pivotTo("lead").aggregate("employeeId:sum");
+        }
+      });
+    });
+
+    // Executed code fails since we're providing bad strings to the function
+    it("correctly narrows types of options for aggregate functions", () => {
+      const objectSet = client(Employee).withProperties({
+        "derivedPropertyName": base => {
+          // @ts-expect-error
+          base.pivotTo("lead").aggregate("employeeId:approximateDistinct", {
+            limit: 1
+          });
+          base.pivotTo("lead").aggregate("employeeId:collectList", {
+            limit: 1
+          });
+          base.pivotTo("lead").aggregate("employeeId:collectSet", {
+            limit: 1
+          });
+          base.pivotTo("lead").aggregate("employeeId:collectList", {
+            // @ts-expect-error
+            percentile: 1
+          });
+          return base.pivotTo("lead").aggregate("employeeId:approximatePercentile", {
+            percentile: 0.5
+          });
+        }
+      });
+      expectTypeOf(objectSet).branded.toEqualTypeOf();
+    });
+    it("correctly narrows types of selectProperty function", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base => {
+          // @ts-expect-error
+          base.pivotTo("lead").selectProperty("notAProperty");
+          return base.pivotTo("lead").selectProperty("employeeStatus");
+        }
+      });
+    });
+    it("propagates derived property type to future object set operations with correct types", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").aggregate("employeeId:sum")
+        // @ts-expect-error
+      }).where({
+        "notAProperty": {
+          "$eq": 3
+        }
+      });
+      const numericAggregationObjectSet = client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").aggregate("employeeId:sum")
+      }).where({
+        "derivedPropertyName": {
+          "$eq": 3
+        }
+      });
+      expectTypeOf(numericAggregationObjectSet).toEqualTypeOf();
+      client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").aggregate("employeeId:collectList")
+      }).where({
+        "derivedPropertyName": {
+          "$isNull": false
+        }
+      })
+      // @ts-expect-error
+      .where({
+        "derivedPropertyName": {
+          "$eq": [1, 2]
+        }
+      });
+      const setAggregationObjectSet = client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").aggregate("fullName:collectSet")
+      });
+      setAggregationObjectSet.where({
+        "derivedPropertyName": {
+          "$isNull": false
+        }
+      });
+      setAggregationObjectSet.where({
+        // @ts-expect-error
+        "derivedPropertyName": {
+          "$eq": [1, 2]
+        }
+      });
+      expectTypeOf(setAggregationObjectSet).toEqualTypeOf();
+      const selectPropertyObjectSet = client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).where({
+        "derivedPropertyName": {
+          "$eq": 3
+        }
+      });
+      expectTypeOf(selectPropertyObjectSet).toEqualTypeOf();
+      client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("startDate")
+      }).where({
+        "derivedPropertyName": {
+          "$eq": "datetimeFilter"
+        }
+      });
+    });
+    it("correctly types multiple property definitions in one clause", () => {
+      const objectSet = client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").aggregate("employeeId:sum"),
+        "derivedPropertyName2": base => base.pivotTo("lead").selectProperty("fullName")
+      }).where({
+        "derivedPropertyName": {
+          "$eq": 3
+        }
+      }).where({
+        "derivedPropertyName2": {
+          "$eq": "name"
+        }
+      });
+      expectTypeOf(objectSet).toEqualTypeOf();
+    });
+    it("ensures other properties are consistently typed", () => {
+      client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).where({
+        "fullName": {
+          "$eq": "A"
+        }
+      });
+      client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).where({
+        "employeeId": {
+          "$eq": 2
+        }
+      });
+    });
+    it("allows fetching derived properties with correctly typed Osdk.Instance types", async () => {
+      const objectWithRdp = await client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).fetchOne(stubData.employee1.employeeId);
+      expectTypeOf(objectWithRdp.derivedPropertyName).toEqualTypeOf();
+      expect(objectWithRdp.derivedPropertyName).toBe(stubData.employee2.__primaryKey);
+      const objectWithUndefinedRdp = await client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).fetchOne(stubData.employee2.employeeId, {
+        $select: ["derivedPropertyName"]
+      });
+      expect(objectWithUndefinedRdp.derivedPropertyName).toBeUndefined();
+    });
+  });
+
+  // Can't run these tests because we can't load by primary key!
+  // describe.each(["fetchOne", "fetchOneWithErrors"] as const)("%s", (k) => {
+  //   describe("strictNonNull: false", () => {
+  //     describe("includeRid: true", () => {
+  //       it("returns bad data", async () => {
+  //         // Look at this
+  //         const opts = {
+  //           $__EXPERIMENTAL_strictNonNull: false,
+  //           $includeRid: true,
+  //         } as const;
+  //         const result = k === "fetchOne"
+  //           ? await client(Employee).fetchOne(50033, opts)
+  //           : (await client(Employee).fetchOneWithErrors(50033, opts)).value!;
+
+  //         expect(result).not.toBeUndefined();
+  //         expectTypeOf(result).branded.toEqualTypeOf<
+  //           Osdk<Employee, "$all" | "$notStrict" | "$rid">
+  //         >();
+  //       });
+  //     });
+
+  //     describe("includeRid: false", () => {
+  //       it("returns bad data", async () => {
+  //         const opts = {
+  //           $__EXPERIMENTAL_strictNonNull: false,
+  //           $includeRid: false,
+  //         } as const;
+  //         const result = k === "fetchOne"
+  //           ? await client(Employee).fetchOne(50033, opts)
+  //           : (await client(Employee).fetchOneWithErrors(50033, opts)).value!;
+
+  //         expect(result).not.toBeUndefined();
+  //         expectTypeOf(result).branded.toEqualTypeOf<
+  //           Osdk<Employee, "$all" | "$notStrict">
+  //         >();
+  //       });
+  //     });
+  //   });
+  // });
+
   describe("conversions", () => {
     describe("strictNonNull: false", () => {
       it("returns bad data", async () => {
@@ -428,6 +661,7 @@ describe("ObjectSet", () => {
         expectTypeOf().toEqualTypeOf();
         expectTypeOf().toEqualTypeOf();
         expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
 
         // We don't have a proper definition that has
         // a non-null property on an interface so