chore(zero): Change AST for orderBy (#1975)

This changes the AST for orderBy to:

```ts
type Ordering = readonly (readonly [Selector, Direction])[];
```

This is in preparation for supporting things like

```ts
q.orderBy('modified', 'desc').orderBy('id', 'asc');
```

or written as SQL:

```sql
ORDER BY modified DESC, id ASC
```

This PR does not change any semantics

packages/zero-cache/src/services/view-syncer/queries.pg-test.ts

@@ -76,11 +76,8 @@ describe('view-syncer/queries', () => {
         [['parent', 'owner'], 'parent_owner'],
       ],
       orderBy: [
-        [
-          ['issues', 'id'],
-          ['issues', 'title'],
-        ],
-        'desc',
+        [['issues', 'id'], 'desc'],
+        [['issues', 'title'], 'desc'],
       ],
       table: 'issues',
       joins: [
@@ -575,11 +572,8 @@ describe('view-syncer/queries', () => {
         [['parent', 'owner'], 'parent_owner'],
       ],
       orderBy: [
-        [
-          ['issues', 'id'],
-          ['issues', 'title'],
-        ],
-        'desc',
+        [['issues', 'id'], 'desc'],
+        [['issues', 'title'], 'desc'],
       ],
       table: 'issues',
       joins: [

packages/zero-cache/src/zql/deaggregation.test.ts

@@ -46,7 +46,7 @@ describe('zql/deaggregation', () => {
           },
         ],
         groupBy: [['issues', 'id']],
-        orderBy: [[['issues', 'modified']], 'desc'],
+        orderBy: [[['issues', 'modified'], 'desc']],
       },
       original: `
       SELECT 

packages/zero-cache/src/zql/deaggregation.ts

@@ -147,12 +147,12 @@ function getSupportedGroupByTable(
   });
 
   if (orderBy) {
-    orderBy[0].forEach(s => {
+    for (const [selector] of orderBy) {
       assert(
-        s[0] === groupByTable,
-        `ORDER BY ${s} does not match GROUP BY table ${groupByTable}`,
+        selector[0] === groupByTable,
+        `ORDER BY ${selector} does not match GROUP BY table ${groupByTable}`,
       );
-    });
+    }
   }
 
   assertAllWheresAgainst(groupByTable, where);

packages/zero-cache/src/zql/expansion.test.ts

@@ -87,11 +87,8 @@ describe('zql/expansion', () => {
           ),
         ),
         orderBy: [
-          [
-            ['issues', 'date'],
-            ['issues', 'priority'],
-          ],
-          'asc',
+          [['issues', 'date'], 'asc'],
+          [['issues', 'priority'], 'asc'],
         ],
       },
       original: `
@@ -142,11 +139,8 @@ describe('zql/expansion', () => {
               ),
             ),
             orderBy: [
-              [
-                ['issues', 'date'],
-                ['issues', 'priority'],
-              ],
-              'asc',
+              [['issues', 'date'], 'asc'],
+              [['issues', 'priority'], 'asc'],
             ],
           },
         },
@@ -214,7 +208,7 @@ describe('zql/expansion', () => {
             ],
           },
         ],
-        orderBy: [[['owner', 'level']], 'asc'],
+        orderBy: [[['owner', 'level'], 'asc']],
       },
       original: `
       SELECT 
@@ -283,11 +277,8 @@ describe('zql/expansion', () => {
               ),
             ),
             orderBy: [
-              [
-                ['issues', 'date'],
-                ['issues', 'priority'],
-              ],
-              'asc',
+              [['issues', 'date'], 'asc'],
+              [['issues', 'priority'], 'asc'],
             ],
           },
         },
@@ -465,7 +456,7 @@ describe('zql/expansion', () => {
             ],
           },
         ],
-        orderBy: [[['owner', 'awesomeness']], 'desc'],
+        orderBy: [[['owner', 'awesomeness'], 'desc']],
       },
       original: `
       SELECT 

packages/zero-cache/src/zql/expansion.ts

@@ -1,4 +1,9 @@
-import type {AST, Condition, Selector} from '@rocicorp/zql/src/zql/ast/ast.js';
+import type {
+  AST,
+  Condition,
+  Ordering,
+  Selector,
+} from '@rocicorp/zql/src/zql/ast/ast.js';
 import {assert} from 'shared/src/asserts.js';
 import type {ServerAST, SubQuery} from './server-ast.js';
 
@@ -235,6 +240,9 @@ export function expandSubqueries(
     const [from] = selector;
     selectors.get(from)?.push(selector) ?? selectors.set(from, [selector]);
   };
+  const addOrderBySelector = (orderingElement: Ordering[number]) =>
+    addSelector(orderingElement[0]);
+
   const selected = new Set<string>();
   // Add all referenced fields / selectors.
   select?.forEach(([selector, alias]) => {
@@ -246,7 +254,7 @@ export function expandSubqueries(
   getWhereColumns(where, []).forEach(selector => addSelector(selector));
   joins?.forEach(({on}) => on.forEach(part => addSelector(part)));
   groupBy?.forEach(grouping => addSelector(grouping));
-  orderBy?.[0].forEach(ordering => addSelector(ordering));
+  orderBy?.forEach(addOrderBySelector);
   aggregate?.forEach(agg => {
     if (agg.field !== undefined) {
       addSelector(agg.field);
@@ -384,6 +392,11 @@ export function reAliasAndBubbleSelections(
       : [from, newCol];
   };
 
+  const renameSelectorsInOrderingElement = ([
+    selector,
+    dir,
+  ]: Ordering[number]): Ordering[number] => [renameSelector(selector), dir];
+
   // Return a modified AST with all selectors realiased (SELECT, ON, GROUP BY, ORDER BY),
   // and bubble up all selected aliases to the `exports` Map.
   const exported = new Set<string>();
@@ -416,6 +429,6 @@ export function reAliasAndBubbleSelections(
       on: [renameSelector(join.on[0]), renameSelector(join.on[1])],
     })),
     groupBy: groupBy?.map(renameSelector),
-    orderBy: orderBy ? [orderBy[0].map(renameSelector), orderBy[1]] : undefined,
+    orderBy: orderBy?.map(renameSelectorsInOrderingElement),
   };
 }

packages/zero-cache/src/zql/invalidation.test.ts

@@ -227,7 +227,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
         schema: 'zero',
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
       },
       filters: [
         {
@@ -258,7 +258,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
             schema: 'zero',
             table: 'foo',
             select: [[['foo', 'id'], 'id']],
-            orderBy: [[['foo', 'id']], 'asc'],
+            orderBy: [[['foo', 'id'], 'asc']],
           },
           alias: 'foo',
         },
@@ -288,7 +288,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
         aggregate: [
           {aggregate: 'min', field: ['foo', 'priority'], alias: 'ignored'},
         ],
-        orderBy: [[['foo', 'ignored']], 'asc'],
+        orderBy: [[['foo', 'ignored'], 'asc']],
       },
       filters: [
         {
@@ -313,7 +313,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         aggregate: [{aggregate: 'count', alias: 'ignored'}],
-        orderBy: [[['foo', 'ignored']], 'asc'],
+        orderBy: [[['foo', 'ignored'], 'asc']],
       },
       filters: [
         {
@@ -336,7 +336,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: and(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['foo', 'bar'], '=', 2),
@@ -367,7 +367,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: and(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['join.alias', 'baz'], '=', 3), // Ignored
@@ -399,7 +399,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: or(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['foo', 'bar'], '=', 2),
@@ -456,7 +456,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: or(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['foo', 'bar'], '=', 2),
@@ -500,7 +500,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: or(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['foo', 'foo'], '=', 'baz'),
@@ -543,7 +543,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: and(
           or(cond(['foo', 'a'], '=', 1), cond(['foo', 'b'], '=', 2)),
           or(cond(['foo', 'c'], '=', 3), cond(['foo', 'd'], '=', 4)),
@@ -665,7 +665,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: and(
           or(cond(['foo', 'foo'], '=', 'bar'), cond(['foo', 'bar'], '=', 1)),
           or(cond(['foo', 'bar'], '=', 2), cond(['foo', 'do'], '=', 'foo')),
@@ -702,7 +702,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
       ast: {
         table: 'foo',
         select: [[['foo', 'id'], 'id']],
-        orderBy: [[['foo', 'id']], 'asc'],
+        orderBy: [[['foo', 'id'], 'asc']],
         where: and(
           cond(['foo', 'foo'], '=', 'bar'),
           cond(['foo', 'bar'], '=', 2),
@@ -718,7 +718,7 @@ describe('zql/invalidation hashes filters and hashes', () => {
         {
           table: 'foo',
           select: [[['foo', 'id'], 'id']],
-          orderBy: [[['foo', 'id']], 'asc'],
+          orderBy: [[['foo', 'id'], 'asc']],
           where: and(
             or(cond(['foo', 'a'], '=', 1), cond(['foo', 'b'], '=', 2)),
             or(cond(['foo', 'c'], '=', 3), cond(['foo', 'd'], '=', 4)),