@osdk/client 2.1.0-beta.3 → 2.1.0-beta.31

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

@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { isOk } from "@osdk/api";
-import { $ontologyRid, Employee, FooInterface, Office } from "@osdk/client.test.ontology";
+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 { createClient } from "../createClient.js";
@@ -30,10 +32,13 @@ describe("ObjectSet", () => {
   it("does not allow intersect/union/subtract with different object types", () => {
     const employeeObjectSet = client(Employee);
     const officeObjectSet = client(Office);
+
     // @ts-expect-error
     employeeObjectSet.union(officeObjectSet);
+
     // @ts-expect-error
     employeeObjectSet.subtract(officeObjectSet);
+
     // @ts-expect-error
     employeeObjectSet.intersect(officeObjectSet);
   });
@@ -95,6 +100,7 @@ describe("ObjectSet", () => {
       class: "Red",
       employeeId: 50030,
       employeeStatus: expect.anything(),
+      employeeSensor: expect.anything(),
       fullName: "John Doe",
       office: "NYC",
       startDate: "2019-01-01",
@@ -107,6 +113,7 @@ describe("ObjectSet", () => {
       class: "Blue",
       employeeId: 50031,
       employeeStatus: expect.anything(),
+      employeeSensor: expect.anything(),
       fullName: "Jane Doe",
       office: "SEA",
       startDate: "2012-02-12",
@@ -119,6 +126,7 @@ describe("ObjectSet", () => {
       class: "Red",
       employeeId: 50032,
       employeeStatus: expect.anything(),
+      employeeSensor: expect.anything(),
       fullName: "Jack Smith",
       office: "LON",
       startDate: "2015-05-15",
@@ -130,6 +138,40 @@ describe("ObjectSet", () => {
     expectTypeOf().toMatchTypeOf;
     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");
+    expectTypeOf().toMatchTypeOf;
+    expect(employee.$primaryKey).toBe(stubData.employee1.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", {
+      $select: ["fullName"]
+    });
+    expectTypeOf().toMatchTypeOf;
+    expect(employee.$primaryKey).toBe(stubData.employee2.employeeId);
+  });
+  it("check struct parsing", async () => {
+    const player = await client(BgaoNflPlayer).fetchOne("tkelce");
+    expectTypeOf().toMatchTypeOf;
+    expectTypeOf().toMatchTypeOf;
+    const address1 = player.address.addressLine1;
+    expectTypeOf().toMatchTypeOf;
+    expect(address1).toEqual("15 Muppets Lane");
+    const address2 = player.address?.addressLine2;
+    expectTypeOf().toMatchTypeOf;
+    expect(address2).toEqual("Resort No 4");
+    const city = player.address?.city;
+    expectTypeOf().toMatchTypeOf;
+    expect(city).toEqual("Memphis");
+    const state = player.address?.state;
+    expectTypeOf().toMatchTypeOf;
+    expect(state).toEqual("TN");
+    const zipCode = player.address?.zipCode;
+    expectTypeOf().toMatchTypeOf;
+    expect(zipCode).toEqual(11100);
+    expect(player.$primaryKey).toEqual(stubData.travisPlayer.__primaryKey);
+    expect(player.address).toEqual(stubData.travisPlayer.address);
+  });
   it("allows fetching by PK from a base object set - fetchOneWithErrors", async () => {
     const employeeResult = await client(Employee).fetchOneWithErrors(stubData.employee1.employeeId);
     expectTypeOf().toMatchTypeOf;
@@ -192,34 +234,158 @@ describe("ObjectSet", () => {
       expect(iter).toEqual(2);
     }
   });
-  describe.each(["fetchPage", "fetchPageWithErrors"])("%s", k => {
-    describe("strictNonNull: \"drop\"", () => {
-      describe("includeRid: true", () => {
-        it("drops bad data", async () => {
-          const opts = {
-            $__EXPERIMENTAL_strictNonNull: "drop",
-            $includeRid: true
-          };
-          const result = k === "fetchPage" ? await client(Employee).fetchPage(opts) : (await client(Employee).fetchPageWithErrors(opts)).value;
-          expect(result.data).toHaveLength(3);
-          expectTypeOf(result.data[0]).branded.toEqualTypeOf();
-          expectTypeOf(result.data[0]).branded.toEqualTypeOf();
-        });
-      });
-      describe("includeRid: false", () => {
-        it("drops bad data", async () => {
-          const opts = {
-            $__EXPERIMENTAL_strictNonNull: "drop",
-            $includeRid: false
-          };
-          const result = k === "fetchPage" ? await client(Employee).fetchPage(opts) : (await client(Employee).fetchPageWithErrors(opts)).value;
-          expect(result.data).toHaveLength(3);
-          expectTypeOf(result.data[0]).branded.toEqualTypeOf();
-          expectTypeOf(result.data[0]).branded.toEqualTypeOf();
-          expectTypeOf(result.data[0]).branded.toEqualTypeOf();
-        });
-      });
+  it("allows $in filter with ReadonlyArrays", () => {
+    const objectSet = client(Employee).where({
+      employeeId: {
+        $in: [50030, 50031]
+      }
+    });
+    expect(objectSet).toBeDefined();
+  });
+  it("does not allow arbitrary keys when no properties", () => {
+    client(Employee).where({
+      // @ts-expect-error
+      employeeIdNonExistent: {
+        $in: [50030, 50031]
+      }
+    });
+    client(BarInterface).where({
+      // @ts-expect-error
+      nonExistentProp: ""
+    });
+  });
+  it("type checking containsallterm and containsanyterm", () => {
+    client(Employee).where({
+      $or: [{
+        fullName: {
+          $containsAllTerms: "John Smith"
+        }
+      }, {
+        office: {
+          $containsAllTerms: {
+            term: "NYC DC"
+          }
+        }
+      }, {
+        fullName: {
+          $containsAllTerms: {
+            term: "John Smith",
+            fuzzySearch: false
+          }
+        }
+      }, {
+        // @ts-expect-error
+        fullName: {
+          $containsAllTerms: {
+            fuzzySearch: false
+          }
+        }
+      }]
     });
+    client(Employee).where({
+      $or: [{
+        fullName: {
+          $containsAnyTerm: "John Smith"
+        }
+      }, {
+        office: {
+          $containsAnyTerm: {
+            term: "NYC DC"
+          }
+        }
+      }, {
+        fullName: {
+          $containsAnyTerm: {
+            term: "John Smith",
+            fuzzySearch: false
+          }
+        }
+      }, {
+        // @ts-expect-error
+        fullName: {
+          $containsAnyTerm: {
+            fuzzySearch: false
+          }
+        }
+      }]
+    });
+    client(BarInterface).where({
+      // @ts-expect-error
+      nonExistentProp: ""
+    });
+  });
+  it("type checking struct where clauses", () => {
+    expectTypeOf(client(BgaoNflPlayer).where).toBeCallableWith({
+      $and: [{
+        address: {
+          city: {
+            $eq: "NYC"
+          }
+        }
+      }, {
+        address: {
+          zipCode: {
+            $gte: 55555
+          }
+        }
+      }]
+    });
+    expectTypeOf(client(BgaoNflPlayer).where).toBeCallableWith({
+      address: {
+        addressLine1: {
+          $containsAllTerms: "BLVD"
+        },
+        // @ts-expect-error
+        addressLine2: {
+          $containsAllTermsInOrder: "Apartment Number"
+        }
+      }
+    });
+  });
+  describe.each(["fetchPage", "fetchPageWithErrors"])("%s", k => {
+    // describe("strictNonNull: \"drop\"", () => {
+    //   describe("includeRid: true", () => {
+    //     it("drops bad data", async () => {
+    //       const opts = {
+    //         $__EXPERIMENTAL_strictNonNull: "drop",
+    //         $includeRid: true,
+    //       } as const;
+    //       const result = k === "fetchPage"
+    //         ? await client(Employee).fetchPage(opts)
+    //         : (await client(Employee).fetchPageWithErrors(opts)).value!;
+
+    //       expect(result.data).toHaveLength(3);
+    //       expectTypeOf(result.data[0]).branded.toEqualTypeOf<
+    //         Osdk<Employee, "$rid" | "$all">
+    //       >();
+    //       expectTypeOf(result.data[0]).branded.toEqualTypeOf<
+    //         Employee.OsdkObject<"$rid">
+    //       >();
+    //     });
+    //   });
+
+    //   describe("includeRid: false", () => {
+    //     it("drops bad data", async () => {
+    //       const opts = {
+    //         $__EXPERIMENTAL_strictNonNull: "drop",
+    //         $includeRid: false,
+    //       } as const;
+    //       const result = k === "fetchPage"
+    //         ? await client(Employee).fetchPage(opts)
+    //         : (await client(Employee).fetchPageWithErrors(opts)).value!;
+
+    //       expect(result.data).toHaveLength(3);
+    //       expectTypeOf(result.data[0]).branded.toEqualTypeOf<Osdk<Employee>>();
+    //       expectTypeOf(result.data[0]).branded.toEqualTypeOf<
+    //         Employee.OsdkObject
+    //       >();
+    //       expectTypeOf(result.data[0]).branded.toEqualTypeOf<
+    //         Employee.OsdkObject<never>
+    //       >();
+    //     });
+    //   });
+    // });
+
     describe("strictNonNull: false", () => {
       describe("includeRid: true", () => {
         it("returns bad data", async () => {
@@ -235,8 +401,7 @@ describe("ObjectSet", () => {
       describe("includeRid: false", () => {
         it("returns bad data", async () => {
           const opts = {
-            $__EXPERIMENTAL_strictNonNull: false,
-            includeRid: false
+            $includeRid: false
           };
           const result = k === "fetchPage" ? await client(Employee).fetchPage(opts) : (await client(Employee).fetchPageWithErrors(opts)).value;
           expect(result.data).toHaveLength(4);
@@ -245,17 +410,210 @@ describe("ObjectSet", () => {
       });
     });
   });
-  describe("strictNonNull: \"throw\"", () => {
-    it("throws when getting bad data", () => {
-      expect(() => client(Employee).fetchPage({
-        $__EXPERIMENTAL_strictNonNull: "throw"
-      })).rejects.toThrowErrorMatchingInlineSnapshot(`[Error: Unable to safely convert objects as some non nullable properties are null]`);
+  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(50035);
+      expectTypeOf(objectWithRdp.derivedPropertyName).toEqualTypeOf();
+      expect(objectWithRdp.derivedPropertyName).toBe(1);
+      const objectWithUndefinedRdp = await client(Employee).withProperties({
+        "derivedPropertyName": base => base.pivotTo("lead").selectProperty("employeeId")
+      }).fetchOne(50036);
+      expect(objectWithUndefinedRdp.derivedPropertyName).toBeUndefined();
     });
   });
   describe.each(["fetchOne", "fetchOneWithErrors"])("%s", k => {
     describe("strictNonNull: false", () => {
       describe("includeRid: true", () => {
         it("returns bad data", async () => {
+          // Look at this
           const opts = {
             $__EXPERIMENTAL_strictNonNull: false,
             $includeRid: true
@@ -269,7 +627,7 @@ describe("ObjectSet", () => {
         it("returns bad data", async () => {
           const opts = {
             $__EXPERIMENTAL_strictNonNull: false,
-            includeRid: false
+            $includeRid: false
           };
           const result = k === "fetchOne" ? await client(Employee).fetchOne(50033, opts) : (await client(Employee).fetchOneWithErrors(50033, opts)).value;
           expect(result).not.toBeUndefined();
@@ -278,19 +636,10 @@ describe("ObjectSet", () => {
       });
     });
   });
-  describe("strictNonNull: \"throw\"", () => {
-    it("throws when getting bad data", () => {
-      expect(() => client(Employee).fetchPage({
-        $__EXPERIMENTAL_strictNonNull: "throw"
-      })).rejects.toThrowErrorMatchingInlineSnapshot(`[Error: Unable to safely convert objects as some non nullable properties are null]`);
-    });
-  });
   describe("conversions", () => {
     describe("strictNonNull: false", () => {
       it("returns bad data", async () => {
-        const result = await client(Employee).fetchPage({
-          $__EXPERIMENTAL_strictNonNull: false
-        });
+        const result = await client(Employee).fetchPage({});
         const empNotStrict = result.data[0];
         expectTypeOf(empNotStrict).branded.toEqualTypeOf();
         expectTypeOf(empNotStrict).branded.toEqualTypeOf();
@@ -305,6 +654,11 @@ describe("ObjectSet", () => {
         expectTypeOf().toEqualTypeOf();
         expectTypeOf().toEqualTypeOf();
         expectTypeOf().toEqualTypeOf();
+
+        // We don't have a proper definition that has
+        // a non-null property on an interface so
+        // we cheese it here to be sure the types work
+
         const cheesedFooNotStrict = result.data[0].$as(FooInterface);
         expectTypeOf(cheesedFooNotStrict).branded.toEqualTypeOf();
         cheesedFooNotStrict.fooSpt;