Add minimal support for 4.x

integration-tests/lts/primitives.test.ts

@@ -66,7 +66,7 @@ describe("primitives", () => {
     );
     assert.equal(
       e.std.range(upperRange).toEdgeQL(),
-      `std::range(<std::int64>{}, 8, inc_lower := true, inc_upper := false)`
+      `std::range(<std::int64>{}, 8, inc_lower := false, inc_upper := false)`
     );
     assert.equal(
       e.std.range(dateRange).toEdgeQL(),

integration-tests/lts/select.test.ts

@@ -310,14 +310,15 @@ describe("select", () => {
   test("* in polymorphic", async () => {
     const q = e.select(e.Person, () => ({
       ...e.is(e.Hero, e.Hero["*"]),
+      name: true,
     }));
 
     // 'id' is filtered out since it is not valid in a polymorphic expr
     tc.assert<
       tc.IsExact<
         $infer<typeof q>,
         {
-          name: string | null;
+          name: string;
           height: string | null;
           number_of_movies: number | null;
           secret_identity: string | null;

integration-tests/nightly/dbschema/default.esdl

@@ -1,3 +1,5 @@
 module default {
-
+  type WithMultiRange {
+    required ranges: multirange<std::int32>;
+  };
 }

integration-tests/nightly/dbschema/migrations/00001.edgeql

@@ -0,0 +1,7 @@
+CREATE MIGRATION m1rlwpc5ikrkb7cvylhbcntglvnanm524yb6si5xlcjk6gd2lczugq
+    ONTO initial
+{
+  CREATE TYPE default::WithMultiRange {
+      CREATE REQUIRED PROPERTY ranges: multirange<std::int32>;
+  };
+};

integration-tests/nightly/multirange.test.ts

@@ -0,0 +1,45 @@
+import type { Client, MultiRange } from "edgedb";
+import e from "./dbschema/edgeql-js";
+import { setupTests, tc, teardownTests } from "./setupTeardown";
+
+import type { WithMultiRange } from "./dbschema/interfaces";
+
+interface BaseObject {
+  id: string;
+}
+interface test_WithMultiRange extends BaseObject {
+  ranges: MultiRange<number>;
+}
+
+describe("multirange", () => {
+  let client: Client;
+  beforeAll(async () => {
+    const setup = await setupTests();
+    ({ client } = setup);
+  });
+
+  afterAll(async () => {
+    await teardownTests(client);
+  }, 10_000);
+
+  test("check generated interfaces", () => {
+    tc.assert<tc.IsExact<WithMultiRange, test_WithMultiRange>>(true);
+  });
+
+  test("inferred return type + literal encoding", async () => {
+    const query = e.select(e.WithMultiRange, () => ({
+      ranges: true,
+    }));
+
+    const result = await query.run(client);
+
+    tc.assert<
+      tc.IsExact<
+        typeof result,
+        {
+          ranges: MultiRange<number>;
+        }[]
+      >
+    >(true);
+  });
+});

integration-tests/nightly/setupTeardown.ts

@@ -17,6 +17,7 @@ export async function setupTests() {
 async function cleanupData(client: Client) {
   await client.execute(`
 # Delete any user-defined objects here
+delete WithMultiRange;
 `);
 }
 

packages/driver/genErrors.js → packages/driver/genErrors.mjs

@@ -16,11 +16,11 @@
  * limitations under the License.
  */
 
-const fs = require("fs");
-const path = require("path");
-
-const getStdin = require("get-stdin");
-const prettier = require("prettier");
+import { fileURLToPath, URL } from "url";
+import fs from "node:fs";
+import path from "node:path";
+import getStdin from "get-stdin";
+import prettier from "prettier";
 
 class Buffer {
   constructor() {
@@ -39,6 +39,8 @@ class Buffer {
     return this.buf.join("\n");
   }
 }
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = new URL("", import.meta.url).pathname;
 
 (async () => {
   const prettierOptions = (await prettier.resolveConfig(__dirname)) ?? {};

packages/driver/package.json

@@ -43,7 +43,7 @@
     "test": "npx --node-options='--experimental-fetch' jest --detectOpenHandles",
     "lint": "tslint 'packages/*/src/**/*.ts'",
     "format": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "gen-errors": "edb gen-errors-json --client | node genErrors.js",
+    "gen-errors": "edb gen-errors-json --client | node genErrors.mjs",
     "watch": "nodemon -e js,ts,tsx --ignore dist -x ",
     "dev": "yarn tsc --project tsconfig.json --incremental && yarn build:deno"
   }

packages/driver/src/codecs/array.ts

@@ -16,10 +16,11 @@
  * limitations under the License.
  */
 
-import { ICodec, Codec, ScalarCodec, uuid, CodecKind } from "./ifaces";
+import type { ICodec, uuid, CodecKind } from "./ifaces";
+import { Codec, ScalarCodec } from "./ifaces";
 import { WriteBuffer, ReadBuffer } from "../primitives/buffer";
 import { TupleCodec } from "./tuple";
-import { RangeCodec } from "./range";
+import { MultiRangeCodec, RangeCodec } from "./range";
 import { InvalidArgumentError, ProtocolError } from "../errors";
 import { NamedTupleCodec } from "./namedtuple";
 
@@ -39,7 +40,8 @@ export class ArrayCodec extends Codec implements ICodec {
         this.subCodec instanceof ScalarCodec ||
         this.subCodec instanceof TupleCodec ||
         this.subCodec instanceof NamedTupleCodec ||
-        this.subCodec instanceof RangeCodec
+        this.subCodec instanceof RangeCodec ||
+        this.subCodec instanceof MultiRangeCodec
       )
     ) {
       throw new InvalidArgumentError(
@@ -48,7 +50,9 @@ export class ArrayCodec extends Codec implements ICodec {
     }
 
     if (!Array.isArray(obj) && !isTypedArray(obj)) {
-      throw new InvalidArgumentError("an array was expected");
+      throw new InvalidArgumentError(
+        `an array was expected (got type ${obj.constructor.name})`
+      );
     }
 
     const subCodec = this.subCodec;

packages/driver/src/codecs/consts.ts

@@ -24,6 +24,7 @@ export const INVALID_CODEC_ID = "ffffffffffffffffffffffffffffffff";
 export const KNOWN_TYPES = new Map<uuid, string>([
   ["00000000000000000000000000000001", "anytype"],
   ["00000000000000000000000000000002", "anytuple"],
+  ["00000000000000000000000000000003", "anyobject"],
   ["000000000000000000000000000000f0", "std"],
   ["000000000000000000000000000000ff", "empty-tuple"],
   ["00000000000000000000000000000100", "std::uuid"],

packages/driver/src/codecs/ifaces.ts

@@ -29,7 +29,8 @@ export type CodecKind =
   | "set"
   | "scalar"
   | "sparse_object"
-  | "range";
+  | "range"
+  | "multirange";
 
 export interface ICodec {
   readonly tid: uuid;