Use given cardinality in select expression (#1043)

Previously, if you made a select expression with a constant or coalescing
expression, we always calculated the cardinality of a object key based on the
pointer's cardinality, rather than allowing you to return something assignable
to that cardinality. This change will check if the assignment is possible, and
override the cardinality when converting the query builder expression to a TS
type.

integration-tests/lts/bench.ts

@@ -225,6 +225,13 @@ bench("select: with offset", () => {
   return {} as typeof query;
 }).types([8891, "instantiations"]);
 
+bench("select: with pointer override", () => {
+  const query = e.select(e.Hero, (h) => ({
+    height: e.decimal("10.0"),
+  }));
+  return {} as typeof query;
+}).types([2160, "instantiations"]);
+
 bench("params select", () => {
   const query = e.params({ name: e.str }, (params) =>
     e.select(e.Hero, (hero) => ({

integration-tests/lts/select.test.ts

@@ -1170,6 +1170,61 @@ SELECT __scope_0_defaultPerson {
     assert.equal(res4, 1);
   });
 
+  test("overriding pointers", async () => {
+    const q = e.select(e.Hero, () => ({
+      height: e.decimal("10.0"),
+    }));
+    type Height = $infer<typeof q.__element__.__shape__.height>;
+    type Q = $infer<typeof q>;
+    tc.assert<
+      tc.IsExact<
+        Q,
+        {
+          height: Height;
+        }[]
+      >
+    >(true);
+
+    await assert.rejects(
+      async () =>
+        e
+          // @ts-expect-error cannot assign multi cardinality if point is single
+          .select(e.Hero, () => ({
+            height: e.set(e.decimal("10.0"), e.decimal("11.0")),
+          }))
+          .run(client),
+      (err) => {
+        if (
+          err &&
+          typeof err === "object" &&
+          "message" in err &&
+          typeof err.message === "string"
+        ) {
+          assert.match(err.message, /possibly more than one element returned/);
+          return true;
+        } else {
+          assert.fail("Expected error to be an object with a message");
+        }
+      },
+    );
+  });
+
+  test("coalescing pointers", () => {
+    const q = e.select(e.Hero, (h) => ({
+      height: e.op(h.height, "??", e.decimal("10.0")),
+    }));
+    type Height = $infer<typeof q.__element__.__shape__.height>;
+    type Q = $infer<typeof q>;
+    tc.assert<
+      tc.IsExact<
+        Q,
+        {
+          height: Height;
+        }[]
+      >
+    >(true);
+  });
+
   test("nested matching scopes", async () => {
     const q = e.select(e.Hero, (h) => ({
       name: h.name,

packages/generate/src/syntax/typesystem.ts

@@ -372,10 +372,16 @@ export type computeObjectShape<
                 ShapeEl
               > | null
             : never
-          : [k] extends [keyof Pointers]
-            ? shapeElementToTs<Pointers[k], Shape[k]>
-            : Shape[k] extends TypeSet
-              ? setToTsType<Shape[k]>
+          : Shape[k] extends TypeSet
+            ? [k] extends [keyof Pointers]
+              ? Shape[k]["__cardinality__"] extends cardutil.assignable<
+                  Pointers[k]["cardinality"]
+                >
+                ? setToTsType<Shape[k]>
+                : never
+              : setToTsType<Shape[k]>
+            : [k] extends [keyof Pointers]
+              ? shapeElementToTs<Pointers[k], Shape[k]>
               : never;
       }
 >;