@osdk/client 2.0.0-beta.13 → 2.0.0-beta.15

package/build/browser/internal/conversions/modernToLegacyWhereClause.js

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DistanceUnitMapping } from "@osdk/api";
+import invariant from "tiny-invariant";
+/** @internal */
+export function modernToLegacyWhereClause(whereClause) {
+  if ("$and" in whereClause) {
+    return {
+      type: "and",
+      value: whereClause.$and.map(modernToLegacyWhereClause)
+    };
+  } else if ("$or" in whereClause) {
+    return {
+      type: "or",
+      value: whereClause.$or.map(modernToLegacyWhereClause)
+    };
+  } else if ("$not" in whereClause) {
+    return {
+      type: "not",
+      value: modernToLegacyWhereClause(whereClause.$not)
+    };
+  }
+  const parts = Object.entries(whereClause);
+  if (parts.length === 1) {
+    return handleWherePair(parts[0]);
+  }
+  return {
+    type: "and",
+    value: parts.map(handleWherePair)
+  };
+}
+function makeGeoFilterBbox(field, bbox, filterType) {
+  return {
+    type: filterType === "$within" ? "withinBoundingBox" : "intersectsBoundingBox",
+    field,
+    value: {
+      topLeft: {
+        type: "Point",
+        coordinates: [bbox[0], bbox[3]]
+      },
+      bottomRight: {
+        type: "Point",
+        coordinates: [bbox[2], bbox[1]]
+      }
+    }
+  };
+}
+function makeGeoFilterPolygon(field, coordinates, filterType) {
+  return {
+    type: filterType,
+    field,
+    value: {
+      type: "Polygon",
+      coordinates
+    }
+  };
+}
+function handleWherePair([field, filter]) {
+  !(filter != null) ? invariant(false, "Defined key values are only allowed when they are not undefined.") : void 0;
+  if (typeof filter === "string" || typeof filter === "number" || typeof filter === "boolean") {
+    return {
+      type: "eq",
+      field,
+      value: filter
+    };
+  }
+  const keysOfFilter = Object.keys(filter);
+  // If any of the keys start with `$` then they must be the only one.
+  // e.g. `where({ name: { $eq: "foo", $ne: "bar" } })` is invalid currently
+  const hasDollarSign = keysOfFilter.some(key => key.startsWith("$"));
+  !(!hasDollarSign || keysOfFilter.length === 1) ? invariant(false, "WhereClause Filter with multiple clauses isn't allowed") : void 0;
+  if (!hasDollarSign) {
+    // Future case for structs
+    throw new Error(`Unsupported filter. Did you forget to use a $-prefixed filter? (${JSON.stringify(filter)})`);
+  }
+  const firstKey = keysOfFilter[0];
+  !(filter[firstKey] != null) ? invariant(false) : void 0;
+  if (firstKey === "$ne") {
+    return {
+      type: "not",
+      value: {
+        type: "eq",
+        field,
+        value: filter[firstKey]
+      }
+    };
+  }
+  if (firstKey === "$within") {
+    const withinBody = filter[firstKey];
+    if (Array.isArray(withinBody)) {
+      return makeGeoFilterBbox(field, withinBody, firstKey);
+    } else if ("$bbox" in withinBody && withinBody.$bbox != null) {
+      return makeGeoFilterBbox(field, withinBody.$bbox, firstKey);
+    } else if ("$distance" in withinBody && "$of" in withinBody && withinBody.$distance != null && withinBody.$of != null) {
+      return {
+        type: "withinDistanceOf",
+        field,
+        value: {
+          center: Array.isArray(withinBody.$of) ? {
+            type: "Point",
+            coordinates: withinBody.$of
+          } : withinBody.$of,
+          distance: {
+            value: withinBody.$distance[0],
+            unit: DistanceUnitMapping[withinBody.$distance[1]]
+          }
+        }
+      };
+    } else {
+      const coordinates = "$polygon" in withinBody ? withinBody.$polygon : withinBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "withinPolygon");
+    }
+  }
+  if (firstKey === "$intersects") {
+    const intersectsBody = filter[firstKey];
+    if (Array.isArray(intersectsBody)) {
+      return makeGeoFilterBbox(field, intersectsBody, firstKey);
+    } else if ("$bbox" in intersectsBody && intersectsBody.$bbox != null) {
+      return makeGeoFilterBbox(field, intersectsBody.$bbox, firstKey);
+    } else {
+      const coordinates = "$polygon" in intersectsBody ? intersectsBody.$polygon : intersectsBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "intersectsPolygon");
+    }
+  }
+  return {
+    type: firstKey.substring(1),
+    field,
+    value: filter[firstKey]
+  };
+}
+//# sourceMappingURL=modernToLegacyWhereClause.js.map

package/build/browser/internal/conversions/modernToLegacyWhereClause.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modernToLegacyWhereClause.js","names":["DistanceUnitMapping","invariant","modernToLegacyWhereClause","whereClause","type","value","$and","map","$or","$not","parts","Object","entries","length","handleWherePair","makeGeoFilterBbox","field","bbox","filterType","topLeft","coordinates","bottomRight","makeGeoFilterPolygon","filter","keysOfFilter","keys","hasDollarSign","some","key","startsWith","Error","JSON","stringify","firstKey","withinBody","Array","isArray","$bbox","$distance","$of","center","distance","unit","$polygon","intersectsBody","substring"],"sources":["modernToLegacyWhereClause.js"],"sourcesContent":["/*\n * Copyright 2023 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DistanceUnitMapping } from \"@osdk/api\";\nimport invariant from \"tiny-invariant\";\n/** @internal */\nexport function modernToLegacyWhereClause(whereClause) {\n    if (\"$and\" in whereClause) {\n        return {\n            type: \"and\",\n            value: whereClause.$and.map(modernToLegacyWhereClause),\n        };\n    }\n    else if (\"$or\" in whereClause) {\n        return {\n            type: \"or\",\n            value: whereClause.$or.map(modernToLegacyWhereClause),\n        };\n    }\n    else if (\"$not\" in whereClause) {\n        return {\n            type: \"not\",\n            value: modernToLegacyWhereClause(whereClause.$not),\n        };\n    }\n    const parts = Object.entries(whereClause);\n    if (parts.length === 1) {\n        return handleWherePair(parts[0]);\n    }\n    return {\n        type: \"and\",\n        value: parts.map(handleWherePair),\n    };\n}\nfunction makeGeoFilterBbox(field, bbox, filterType) {\n    return {\n        type: filterType === \"$within\"\n            ? \"withinBoundingBox\"\n            : \"intersectsBoundingBox\",\n        field,\n        value: {\n            topLeft: {\n                type: \"Point\",\n                coordinates: [bbox[0], bbox[3]],\n            },\n            bottomRight: {\n                type: \"Point\",\n                coordinates: [bbox[2], bbox[1]],\n            },\n        },\n    };\n}\nfunction makeGeoFilterPolygon(field, coordinates, filterType) {\n    return {\n        type: filterType,\n        field,\n        value: {\n            type: \"Polygon\",\n            coordinates,\n        },\n    };\n}\nfunction handleWherePair([field, filter]) {\n    invariant(filter != null, \"Defined key values are only allowed when they are not undefined.\");\n    if (typeof filter === \"string\" || typeof filter === \"number\"\n        || typeof filter === \"boolean\") {\n        return {\n            type: \"eq\",\n            field,\n            value: filter,\n        };\n    }\n    const keysOfFilter = Object.keys(filter);\n    // If any of the keys start with `$` then they must be the only one.\n    // e.g. `where({ name: { $eq: \"foo\", $ne: \"bar\" } })` is invalid currently\n    const hasDollarSign = keysOfFilter.some((key) => key.startsWith(\"$\"));\n    invariant(!hasDollarSign\n        || keysOfFilter.length === 1, \"WhereClause Filter with multiple clauses isn't allowed\");\n    if (!hasDollarSign) {\n        // Future case for structs\n        throw new Error(`Unsupported filter. Did you forget to use a $-prefixed filter? (${JSON.stringify(filter)})`);\n    }\n    const firstKey = keysOfFilter[0];\n    invariant(filter[firstKey] != null);\n    if (firstKey === \"$ne\") {\n        return {\n            type: \"not\",\n            value: {\n                type: \"eq\",\n                field,\n                value: filter[firstKey],\n            },\n        };\n    }\n    if (firstKey === \"$within\") {\n        const withinBody = filter[firstKey];\n        if (Array.isArray(withinBody)) {\n            return makeGeoFilterBbox(field, withinBody, firstKey);\n        }\n        else if (\"$bbox\" in withinBody && withinBody.$bbox != null) {\n            return makeGeoFilterBbox(field, withinBody.$bbox, firstKey);\n        }\n        else if ((\"$distance\" in withinBody && \"$of\" in withinBody)\n            && withinBody.$distance != null\n            && withinBody.$of != null) {\n            return {\n                type: \"withinDistanceOf\",\n                field,\n                value: {\n                    center: Array.isArray(withinBody.$of)\n                        ? {\n                            type: \"Point\",\n                            coordinates: withinBody.$of,\n                        }\n                        : withinBody.$of,\n                    distance: {\n                        value: withinBody.$distance[0],\n                        unit: DistanceUnitMapping[withinBody.$distance[1]],\n                    },\n                },\n            };\n        }\n        else {\n            const coordinates = (\"$polygon\" in withinBody)\n                ? withinBody.$polygon\n                : withinBody.coordinates;\n            return makeGeoFilterPolygon(field, coordinates, \"withinPolygon\");\n        }\n    }\n    if (firstKey === \"$intersects\") {\n        const intersectsBody = filter[firstKey];\n        if (Array.isArray(intersectsBody)) {\n            return makeGeoFilterBbox(field, intersectsBody, firstKey);\n        }\n        else if (\"$bbox\" in intersectsBody && intersectsBody.$bbox != null) {\n            return makeGeoFilterBbox(field, intersectsBody.$bbox, firstKey);\n        }\n        else {\n            const coordinates = (\"$polygon\" in intersectsBody)\n                ? intersectsBody.$polygon\n                : intersectsBody.coordinates;\n            return makeGeoFilterPolygon(field, coordinates, \"intersectsPolygon\");\n        }\n    }\n    return {\n        type: firstKey.substring(1),\n        field,\n        value: filter[firstKey],\n    };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/browser/internal/conversions/modernToLegacyWhereClause.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=modernToLegacyWhereClause.test.d.ts.map

package/build/browser/internal/conversions/modernToLegacyWhereClause.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modernToLegacyWhereClause.test.d.ts","sourceRoot":"","sources":["../../../../src/internal/conversions/modernToLegacyWhereClause.test.ts"],"names":[],"mappings":""}

package/build/browser/internal/conversions/modernToLegacyWhereClause.test.js

@@ -0,0 +1,486 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { expectType } from "ts-expect";
+import { describe, expect, it } from "vitest";
+import { modernToLegacyWhereClause } from "./modernToLegacyWhereClause.js";
+describe(modernToLegacyWhereClause, () => {
+  describe("single checks", () => {
+    describe("$within", () => {
+      it("properly generates bbox shortcut", async () => {
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: [-5, 5, -10, 10]
+          }
+        })).toMatchInlineSnapshot(`
+          {
+            "field": "geoPoint",
+            "type": "withinBoundingBox",
+            "value": {
+              "bottomRight": {
+                "coordinates": [
+                  -10,
+                  5,
+                ],
+                "type": "Point",
+              },
+              "topLeft": {
+                "coordinates": [
+                  -5,
+                  10,
+                ],
+                "type": "Point",
+              },
+            },
+          }
+        `);
+      });
+      it("properly generates bbox long form", async () => {
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: {
+              $bbox: [-5, 5, -10, 10]
+            }
+          }
+        })).toMatchInlineSnapshot(`
+          {
+            "field": "geoPoint",
+            "type": "withinBoundingBox",
+            "value": {
+              "bottomRight": {
+                "coordinates": [
+                  -10,
+                  5,
+                ],
+                "type": "Point",
+              },
+              "topLeft": {
+                "coordinates": [
+                  -5,
+                  10,
+                ],
+                "type": "Point",
+              },
+            },
+          }
+        `);
+      });
+      it("properly generates within radius", async () => {
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: {
+              $distance: [5, "km"],
+              $of: [-5, 5]
+            }
+          }
+        })).toMatchInlineSnapshot(`
+        {
+          "field": "geoPoint",
+          "type": "withinDistanceOf",
+          "value": {
+            "center": {
+              "coordinates": [
+                -5,
+                5,
+              ],
+              "type": "Point",
+            },
+            "distance": {
+              "unit": "KILOMETERS",
+              "value": 5,
+            },
+          },
+        }
+      `);
+      });
+      it("properly generates within radius of geopoint", async () => {
+        // suppose you loaded an object with a geopoint field
+        // and you want to find all objects within 5 km of that point
+
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: {
+              $distance: [5, "km"],
+              $of: {
+                type: "Point",
+                coordinates: [-5, 5]
+              }
+            }
+          }
+        })).toMatchInlineSnapshot(`
+        {
+          "field": "geoPoint",
+          "type": "withinDistanceOf",
+          "value": {
+            "center": {
+              "coordinates": [
+                -5,
+                5,
+              ],
+              "type": "Point",
+            },
+            "distance": {
+              "unit": "KILOMETERS",
+              "value": 5,
+            },
+          },
+        }
+      `);
+      });
+      it("properly generates within polygon", async () => {
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: {
+              $polygon: [[[0, 1], [3, 2], [0, 1]]]
+            }
+          }
+        })).toMatchInlineSnapshot(`
+          {
+            "field": "geoPoint",
+            "type": "withinPolygon",
+            "value": {
+              "coordinates": [
+                [
+                  [
+                    0,
+                    1,
+                  ],
+                  [
+                    3,
+                    2,
+                  ],
+                  [
+                    0,
+                    1,
+                  ],
+                ],
+              ],
+              "type": "Polygon",
+            },
+          }
+        `);
+      });
+      it("properly generates within polygon geojson", async () => {
+        expect(modernToLegacyWhereClause({
+          geoPoint: {
+            $within: {
+              type: "Polygon",
+              coordinates: [[[0, 1], [3, 2], [0, 1]]]
+            }
+          }
+        })).toMatchInlineSnapshot(`
+          {
+            "field": "geoPoint",
+            "type": "withinPolygon",
+            "value": {
+              "coordinates": [
+                [
+                  [
+                    0,
+                    1,
+                  ],
+                  [
+                    3,
+                    2,
+                  ],
+                  [
+                    0,
+                    1,
+                  ],
+                ],
+              ],
+              "type": "Polygon",
+            },
+          }
+        `);
+      });
+      it("check types", async () => {
+        expectType({
+          geoPoint: {
+            $within: [-5, 5, -10, 10]
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              $distance: [2, "centimeter"],
+              $of: [2, 2]
+            }
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              $polygon: [[[0, 1], [3, 2], [0, 1]]]
+            }
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              type: "Polygon",
+              coordinates: [[[0, 1], [3, 2], [0, 1]]]
+            }
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              $bbox: [-5, 5, -10, 10]
+            }
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              $bbox: [-5, 5, -10, 10],
+              // @ts-expect-error
+              $distance: [2, "centimeter"],
+              // @ts-expect-error
+              $of: [2, 2]
+            }
+          }
+        });
+        expectType({
+          geoPoint: {
+            $within: {
+              $polygon: [[[0, 1], [3, 2], [0, 1]]],
+              // @ts-expect-error
+              $bbox: [2, 2, 2, 2]
+            }
+          }
+        });
+      });
+      describe("$intersects", () => {
+        it("properly generates bbox shortcut", async () => {
+          expect(modernToLegacyWhereClause({
+            geoShape: {
+              $intersects: [-5, 5, -10, 10]
+            }
+          })).toMatchInlineSnapshot(`
+        {
+          "field": "geoShape",
+          "type": "intersectsBoundingBox",
+          "value": {
+            "bottomRight": {
+              "coordinates": [
+                -10,
+                5,
+              ],
+              "type": "Point",
+            },
+            "topLeft": {
+              "coordinates": [
+                -5,
+                10,
+              ],
+              "type": "Point",
+            },
+          },
+        }
+      `);
+        });
+        it("properly generates bbox long form", async () => {
+          expect(modernToLegacyWhereClause({
+            geoShape: {
+              $intersects: {
+                $bbox: [-5, 5, -10, 10]
+              }
+            }
+          })).toMatchInlineSnapshot(`
+          {
+            "field": "geoShape",
+            "type": "intersectsBoundingBox",
+            "value": {
+              "bottomRight": {
+                "coordinates": [
+                  -10,
+                  5,
+                ],
+                "type": "Point",
+              },
+              "topLeft": {
+                "coordinates": [
+                  -5,
+                  10,
+                ],
+                "type": "Point",
+              },
+            },
+          }
+        `);
+        });
+        it("properly generates intersects polygon", async () => {
+          expect(modernToLegacyWhereClause({
+            geoShape: {
+              $intersects: {
+                $polygon: [[[0, 1], [3, 2], [0, 1]]]
+              }
+            }
+          })).toMatchInlineSnapshot(`
+            {
+              "field": "geoShape",
+              "type": "intersectsPolygon",
+              "value": {
+                "coordinates": [
+                  [
+                    [
+                      0,
+                      1,
+                    ],
+                    [
+                      3,
+                      2,
+                    ],
+                    [
+                      0,
+                      1,
+                    ],
+                  ],
+                ],
+                "type": "Polygon",
+              },
+            }
+          `);
+        });
+        it("properly generates within polygon geojson", async () => {
+          expect(modernToLegacyWhereClause({
+            geoShape: {
+              $intersects: {
+                type: "Polygon",
+                coordinates: [[[0, 1], [3, 2], [0, 1]]]
+              }
+            }
+          })).toMatchInlineSnapshot(`
+            {
+              "field": "geoShape",
+              "type": "intersectsPolygon",
+              "value": {
+                "coordinates": [
+                  [
+                    [
+                      0,
+                      1,
+                    ],
+                    [
+                      3,
+                      2,
+                    ],
+                    [
+                      0,
+                      1,
+                    ],
+                  ],
+                ],
+                "type": "Polygon",
+              },
+            }
+          `);
+        });
+      });
+      it("inverts ne short hand properly", () => {
+        expect(modernToLegacyWhereClause({
+          integer: {
+            $ne: 5
+          }
+        })).toMatchInlineSnapshot(`
+        {
+          "type": "not",
+          "value": {
+            "field": "integer",
+            "type": "eq",
+            "value": 5,
+          },
+        }
+      `);
+      });
+    });
+    describe("multiple checks", () => {
+      it("properly handles multiple simple where checks", () => {
+        expect(modernToLegacyWhereClause({
+          decimal: 5,
+          integer: 10
+        })).toMatchInlineSnapshot(`
+        {
+          "type": "and",
+          "value": [
+            {
+              "field": "decimal",
+              "type": "eq",
+              "value": 5,
+            },
+            {
+              "field": "integer",
+              "type": "eq",
+              "value": 10,
+            },
+          ],
+        }
+      `);
+      });
+      it("properly handles $and", () => {
+        expect(modernToLegacyWhereClause({
+          $and: [{
+            decimal: 5
+          }, {
+            integer: 10
+          }]
+        })).toMatchInlineSnapshot(`
+          {
+            "type": "and",
+            "value": [
+              {
+                "field": "decimal",
+                "type": "eq",
+                "value": 5,
+              },
+              {
+                "field": "integer",
+                "type": "eq",
+                "value": 10,
+              },
+            ],
+          }
+        `);
+      });
+      it("properly handles $or", () => {
+        expect(modernToLegacyWhereClause({
+          $or: [{
+            decimal: 5
+          }, {
+            integer: 10
+          }]
+        })).toMatchInlineSnapshot(`
+            {
+              "type": "or",
+              "value": [
+                {
+                  "field": "decimal",
+                  "type": "eq",
+                  "value": 5,
+                },
+                {
+                  "field": "integer",
+                  "type": "eq",
+                  "value": 10,
+                },
+              ],
+            }
+          `);
+      });
+    });
+  });
+});
+//# sourceMappingURL=modernToLegacyWhereClause.test.js.map