feat: Support multiple separate order bys.

packages/orm/src/EntityFilter.ts

@@ -7,7 +7,7 @@ import { ColumnCondition, RawCondition } from "./QueryParser";
 export type FilterAndSettings<T extends Entity> = {
   where: FilterWithAlias<T>;
   conditions?: ExpressionFilter;
-  orderBy?: OrderOf<T>;
+  orderBy?: OrderOf<T> | OrderOf<T>[];
   limit?: number;
   offset?: number;
   softDeletes?: "exclude" | "include";

packages/orm/src/EntityManager.ts

@@ -88,7 +88,7 @@ export interface EntityConstructor<T> {
 /** Options for the auto-batchable `em.find` queries, i.e. limit & offset aren't allowed. */
 export interface FindFilterOptions<T extends Entity> {
   conditions?: ExpressionFilter;
-  orderBy?: OrderOf<T>;
+  orderBy?: OrderOf<T> | OrderOf<T>[];
   softDeletes?: "include" | "exclude";
 }
 

packages/orm/src/QueryParser.ts

@@ -377,13 +377,10 @@ export function parseFindQuery(
     }
   }
 
-  function addOrderBy(meta: EntityMetadata, alias: string, orderBy: any): void {
-    // Assume only one key
+  function addOrderBy(meta: EntityMetadata, alias: string, orderBy: Record<string, any>): void {
     const entries = Object.entries(orderBy);
-    if (entries.length === 0) {
-      return;
-    }
-    Object.entries(orderBy).forEach(([key, value]) => {
+    if (entries.length === 0) return;
+    for (const [key, value] of entries) {
       const field = meta.allFields[key] ?? fail(`${key} not found on ${meta.tableName}`);
       if (field.kind === "primitive" || field.kind === "primaryKey" || field.kind === "enum") {
         const column = field.serde.columns[0];
@@ -415,7 +412,7 @@ export function parseFindQuery(
       } else {
         throw new Error(`Unsupported field ${key}`);
       }
-    });
+    }
   }
 
   // always add the main table
@@ -443,7 +440,11 @@ export function parseFindQuery(
   }
 
   if (orderBy) {
-    addOrderBy(meta, alias, orderBy);
+    if (Array.isArray(orderBy)) {
+      for (const ob of orderBy) addOrderBy(meta, alias, ob);
+    } else {
+      addOrderBy(meta, alias, orderBy);
+    }
   }
   maybeAddOrderBy(query, meta, alias);
 

packages/tests/integration/src/EntityManager.queries.test.ts

@@ -1490,6 +1490,35 @@ describe("EntityManager.queries", () => {
     });
   });
 
+  it("can order by multiple m2os as an array", async () => {
+    await insertPublisher({ id: 1, name: "p1" });
+    await insertPublisher({ id: 2, name: "p2" });
+    await insertAuthor({ first_name: "a1", publisher_id: 2 });
+    await insertAuthor({ first_name: "a2", publisher_id: 1 });
+
+    const em = newEntityManager();
+    const orderBy1 = { currentDraftBook: { title: "ASC" } } satisfies AuthorOrder;
+    const orderBy2 = { publisher: { name: "ASC" } } satisfies AuthorOrder;
+    const authors = await em.find(Author, {}, { orderBy: [orderBy2, orderBy1] });
+    expect(authors.length).toEqual(2);
+    expect(authors[0].firstName).toEqual("a2");
+    expect(authors[1].firstName).toEqual("a1");
+
+    expect(parseFindQuery(am, {}, { ...opts, orderBy: [orderBy2, orderBy1] })).toEqual({
+      selects: [`a.*`],
+      tables: [
+        { alias: "a", table: "authors", join: "primary" },
+        { alias: "p", table: "publishers", join: "outer", col1: "a.publisher_id", col2: "p.id", distinct: false },
+        { alias: "b", table: "books", join: "outer", col1: "a.current_draft_book_id", col2: "b.id", distinct: false },
+      ],
+      orderBys: [
+        { alias: "p", column: "name", order: "ASC" },
+        { alias: "b", column: "title", order: "ASC" },
+        { alias: "a", column: "id", order: "ASC" },
+      ],
+    });
+  });
+
   it("can order by joined string asc", async () => {
     await insertPublisher({ name: "pB" });
     await insertPublisher({ id: 2, name: "pA" });