@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/space_lua/parse.ts

@@ -4,6 +4,7 @@ import {
   cleanTree,
   type ParseTree,
 } from "@silverbulletmd/silverbullet/lib/tree";
+// @ts-expect-error - Local generated JavaScript file without type definitions
 import { parser } from "./parse-lua.js";
 import { styleTags, tags as t } from "@lezer/highlight";
 import { indentNodeProp, LRLanguage } from "@codemirror/language";
@@ -35,7 +36,7 @@ const luaStyleTags = styleTags({
   CompareOp: t.operator,
   "true false": t.bool,
   Comment: t.lineComment,
-  "return break goto do end while repeat until function local if then else elseif in for nil or and not query from where limit select order by desc":
+  "return break goto do end while repeat until function local if then else elseif in for nil or and not query from where limit offset select order by desc asc nulls first last group having filter using":
     t.keyword,
 });
 
@@ -51,10 +52,7 @@ const customIndent = indentNodeProp.add({
 export const luaLanguage = LRLanguage.define({
   name: "space-lua",
   parser: parser.configure({
-    props: [
-      luaStyleTags,
-      customIndent,
-    ],
+    props: [luaStyleTags, customIndent],
   }),
   languageData: {
     commentTokens: { line: "--", block: { open: "--[[", close: "--]]" } },
@@ -96,8 +94,9 @@ function expressionHasFunctionDef(e: LuaExpression): boolean {
       }
       return false;
     case "Binary":
-      return expressionHasFunctionDef(e.left) ||
-        expressionHasFunctionDef(e.right);
+      return (
+        expressionHasFunctionDef(e.left) || expressionHasFunctionDef(e.right)
+      );
     case "Unary":
       return expressionHasFunctionDef(e.argument);
     case "Parenthesized":
@@ -118,8 +117,9 @@ function expressionHasFunctionDef(e: LuaExpression): boolean {
       }
       return false;
     case "TableAccess":
-      return expressionHasFunctionDef(e.object) ||
-        expressionHasFunctionDef(e.key);
+      return (
+        expressionHasFunctionDef(e.object) || expressionHasFunctionDef(e.key)
+      );
     case "PropertyAccess":
       return expressionHasFunctionDef(e.object);
     case "Query":
@@ -127,10 +127,23 @@ function expressionHasFunctionDef(e: LuaExpression): boolean {
         const c = e.clauses[i];
         switch (c.type) {
           case "From":
-            if (expressionHasFunctionDef(c.expression)) return true;
+          case "Select":
+          case "GroupBy":
+            for (const f of c.fields) {
+              switch (f.type) {
+                case "DynamicField":
+                  if (expressionHasFunctionDef(f.key)) return true;
+                  if (expressionHasFunctionDef(f.value)) return true;
+                  break;
+                case "PropField":
+                case "ExpressionField":
+                  if (expressionHasFunctionDef(f.value)) return true;
+                  break;
+              }
+            }
             break;
           case "Where":
-          case "Select":
+          case "Having":
             if (expressionHasFunctionDef(c.expression)) return true;
             break;
           case "Limit":
@@ -142,11 +155,30 @@ function expressionHasFunctionDef(e: LuaExpression): boolean {
               if (expressionHasFunctionDef(c.orderBy[j].expression)) {
                 return true;
               }
+              if (
+                c.orderBy[j].using &&
+                typeof c.orderBy[j].using !== "string"
+              ) {
+                return true;
+              }
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        expressionHasFunctionDef(e.call) || expressionHasFunctionDef(e.filter)
+      );
+    case "AggregateCall":
+      return (
+        expressionHasFunctionDef((e as any).call) ||
+        ((e as any).orderBy as LuaOrderBy[]).some(
+          (ob) =>
+            expressionHasFunctionDef(ob.expression) ||
+            (ob.using && typeof ob.using !== "string"),
+        )
+      );
     default:
       return false;
   }
@@ -170,8 +202,10 @@ function exprReferencesNames(e: LuaExpression, names: Set<string>): boolean {
     case "Variable":
       return names.has(e.name);
     case "Binary":
-      return exprReferencesNames(e.left, names) ||
-        exprReferencesNames(e.right, names);
+      return (
+        exprReferencesNames(e.left, names) ||
+        exprReferencesNames(e.right, names)
+      );
     case "Unary":
       return exprReferencesNames(e.argument, names);
     case "Parenthesized":
@@ -183,8 +217,10 @@ function exprReferencesNames(e: LuaExpression, names: Set<string>): boolean {
       }
       return false;
     case "TableAccess":
-      return exprReferencesNames(e.object, names) ||
-        exprReferencesNames(e.key, names);
+      return (
+        exprReferencesNames(e.object, names) ||
+        exprReferencesNames(e.key, names)
+      );
     case "PropertyAccess":
       return exprReferencesNames(e.object, names);
     case "TableConstructor":
@@ -209,10 +245,23 @@ function exprReferencesNames(e: LuaExpression, names: Set<string>): boolean {
         const c = e.clauses[i];
         switch (c.type) {
           case "From":
-            if (exprReferencesNames(c.expression, names)) return true;
+          case "Select":
+          case "GroupBy":
+            for (const f of c.fields) {
+              switch (f.type) {
+                case "DynamicField":
+                  if (exprReferencesNames(f.key, names)) return true;
+                  if (exprReferencesNames(f.value, names)) return true;
+                  break;
+                case "PropField":
+                case "ExpressionField":
+                  if (exprReferencesNames(f.value, names)) return true;
+                  break;
+              }
+            }
             break;
           case "Where":
-          case "Select":
+          case "Having":
             if (exprReferencesNames(c.expression, names)) return true;
             break;
           case "Limit":
@@ -224,11 +273,31 @@ function exprReferencesNames(e: LuaExpression, names: Set<string>): boolean {
               if (exprReferencesNames(c.orderBy[j].expression, names)) {
                 return true;
               }
+              if (
+                typeof c.orderBy[j].using === "string" &&
+                names.has(c.orderBy[j].using as string)
+              ) {
+                return true;
+              }
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        exprReferencesNames(e.call, names) ||
+        exprReferencesNames(e.filter, names)
+      );
+    case "AggregateCall": {
+      const ac = e as any;
+      if (exprReferencesNames(ac.call, names)) return true;
+      for (const ob of ac.orderBy as LuaOrderBy[]) {
+        if (exprReferencesNames(ob.expression, names)) return true;
+        if (typeof ob.using === "string" && names.has(ob.using)) return true;
+      }
+      return false;
+    }
     default:
       return false;
   }
@@ -241,8 +310,10 @@ function lvalueReferencesNames(lv: LuaLValue, names: Set<string>): boolean {
     case "PropertyAccess":
       return exprReferencesNames(lv.object as LuaExpression, names);
     case "TableAccess":
-      return exprReferencesNames(lv.object as LuaExpression, names) ||
-        exprReferencesNames(lv.key, names);
+      return (
+        exprReferencesNames(lv.object as LuaExpression, names) ||
+        exprReferencesNames(lv.key, names)
+      );
   }
 }
 
@@ -375,10 +446,7 @@ function blockCapturesNames(block: LuaBlock, names: Set<string>): boolean {
   return false;
 }
 
-function statementCapturesNames(
-  s: LuaStatement,
-  names: Set<string>,
-): boolean {
+function statementCapturesNames(s: LuaStatement, names: Set<string>): boolean {
   switch (s.type) {
     case "Local": {
       const exprs = (s as any).expressions as LuaExpression[] | undefined;
@@ -471,8 +539,9 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
     case "FunctionDefinition":
       return functionBodyCapturesNames(e.body, names);
     case "Binary":
-      return exprCapturesNames(e.left, names) ||
-        exprCapturesNames(e.right, names);
+      return (
+        exprCapturesNames(e.left, names) || exprCapturesNames(e.right, names)
+      );
     case "Unary":
       return exprCapturesNames(e.argument, names);
     case "Parenthesized":
@@ -484,8 +553,9 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
       }
       return false;
     case "TableAccess":
-      return exprCapturesNames(e.object, names) ||
-        exprCapturesNames(e.key, names);
+      return (
+        exprCapturesNames(e.object, names) || exprCapturesNames(e.key, names)
+      );
     case "PropertyAccess":
       return exprCapturesNames(e.object, names);
     case "TableConstructor":
@@ -508,10 +578,23 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
         const c = e.clauses[i];
         switch (c.type) {
           case "From":
-            if (exprCapturesNames(c.expression, names)) return true;
+          case "Select":
+          case "GroupBy":
+            for (const f of c.fields) {
+              switch (f.type) {
+                case "DynamicField":
+                  if (exprCapturesNames(f.key, names)) return true;
+                  if (exprCapturesNames(f.value, names)) return true;
+                  break;
+                case "PropField":
+                case "ExpressionField":
+                  if (exprCapturesNames(f.value, names)) return true;
+                  break;
+              }
+            }
             break;
           case "Where":
-          case "Select":
+          case "Having":
             if (exprCapturesNames(c.expression, names)) return true;
             break;
           case "Limit":
@@ -523,11 +606,31 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
               if (exprCapturesNames(c.orderBy[j].expression, names)) {
                 return true;
               }
+              const u = c.orderBy[j].using;
+              if (u && typeof u !== "string") {
+                if (functionBodyCapturesNames(u, names)) return true;
+              }
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        exprCapturesNames(e.call, names) || exprCapturesNames(e.filter, names)
+      );
+    case "AggregateCall": {
+      const ac = e as any;
+      if (exprCapturesNames(ac.call, names)) return true;
+      for (const ob of ac.orderBy as LuaOrderBy[]) {
+        if (exprCapturesNames(ob.expression, names)) return true;
+        const u = ob.using;
+        if (u && typeof u !== "string") {
+          if (functionBodyCapturesNames(u, names)) return true;
+        }
+      }
+      return false;
+    }
     default:
       return false;
   }
@@ -537,7 +640,7 @@ function parseBlock(t: ParseTree, ctx: ASTCtx): LuaBlock {
   if (t.type !== "Block") {
     throw new Error(`Expected Block, got ${t.type}`);
   }
-  const stmtNodes = t.children!.filter((c) => c && c.type);
+  const stmtNodes = t.children!.filter((c) => c?.type);
   const statements = stmtNodes.map((s) => parseStatement(s, ctx));
   const block: LuaBlock = { type: "Block", statements, ctx: context(t, ctx) };
 
@@ -595,7 +698,8 @@ function parseBlock(t: ParseTree, ctx: ASTCtx): LuaBlock {
       case "FunctionCallStatement": {
         if (!hasFunctionDef) {
           const call = (s as any).call as LuaFunctionCallExpression;
-          hasFunctionDef = expressionHasFunctionDef(call.prefix) ||
+          hasFunctionDef =
+            expressionHasFunctionDef(call.prefix) ||
             expressionsHaveFunctionDef(call.args);
         }
         break;
@@ -662,7 +766,8 @@ function parseBlock(t: ParseTree, ctx: ASTCtx): LuaBlock {
         hasCloseHere = hasCloseHere || !!child.hasCloseHere;
         hasFunctionDef = hasFunctionDef || !!child.hasFunctionDef;
         if (!hasFunctionDef) {
-          hasFunctionDef = expressionHasFunctionDef((s as any).start) ||
+          hasFunctionDef =
+            expressionHasFunctionDef((s as any).start) ||
             expressionHasFunctionDef((s as any).end) ||
             ((s as any).step
               ? expressionHasFunctionDef((s as any).step)
@@ -765,7 +870,7 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
         from?: number;
         to?: number;
       }[] = [];
-      let elseBlock: LuaBlock | undefined = undefined;
+      let elseBlock: LuaBlock | undefined;
       for (let i = 0; i < t.children!.length; i += 4) {
         const child = t.children![i];
         if (!child || !child.children || !child.children[0]) {
@@ -855,8 +960,8 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
     case "Assign":
       return {
         type: "Assignment",
-        variables: t.children![0].children!
-          .filter((c) => c.type && c.type !== ",")
+        variables: t
+          .children![0].children!.filter((c) => c.type && c.type !== ",")
           .map((lvalue) => parseLValue(lvalue, ctx)),
         expressions: parseExpList(t.children![2], ctx),
         ctx: context(t, ctx),
@@ -900,9 +1005,7 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
       console.error(t);
       throw new Error(
         `Unknown statement type: ${
-          t.children![0] && t.children![0].text
-            ? t.children![0].text
-            : String(t.type)
+          t.children![0]?.text ? t.children![0].text : String(t.type)
         }`,
       );
   }
@@ -913,28 +1016,44 @@ function parseFunctionCall(
   ctx: ASTCtx,
 ): LuaFunctionCallExpression {
   if (t.children![1] && t.children![1].type === ":") {
-    return {
+    const { args, aggOrderBy } = parseFunctionArgsWithOrderBy(
+      t.children!.slice(3),
+      ctx,
+    );
+    const result: LuaFunctionCallExpression = {
       type: "FunctionCall",
       prefix: parsePrefixExpression(t.children![0], ctx),
       name: t.children![2].children![0].text!,
-      args: parseFunctionArgs(t.children!.slice(3), ctx),
+      args,
       ctx: context(t, ctx),
     };
+    if (aggOrderBy) {
+      (result as any).orderBy = aggOrderBy;
+    }
+    return result;
   }
-  return {
+  const { args, aggOrderBy } = parseFunctionArgsWithOrderBy(
+    t.children!.slice(1),
+    ctx,
+  );
+  const result: LuaFunctionCallExpression = {
     type: "FunctionCall",
     prefix: parsePrefixExpression(t.children![0], ctx),
-    args: parseFunctionArgs(t.children!.slice(1), ctx),
+    args,
     ctx: context(t, ctx),
   };
+  if (aggOrderBy) {
+    (result as any).orderBy = aggOrderBy;
+  }
+  return result;
 }
 
 function parseAttNames(t: ParseTree, ctx: ASTCtx): LuaAttName[] {
   if (t.type !== "AttNameList") {
     throw new Error(`Expected AttNameList, got ${t.type}`);
   }
-  return t.children!
-    .filter((c) => c.type && c.type !== ",")
+  return t
+    .children!.filter((c) => c.type && c.type !== ",")
     .map((att) => parseAttName(att, ctx));
 }
 
@@ -995,7 +1114,7 @@ function parseFunctionName(t: ParseTree, ctx: ASTCtx): LuaFunctionName {
     throw new Error(`Expected FunctionName, got ${t.type}`);
   }
   const propNames: string[] = [];
-  let colonName: string | undefined = undefined;
+  let colonName: string | undefined;
   for (let i = 0; i < t.children!.length; i += 2) {
     const prop = t.children![i];
     propNames.push(prop.children![0].text!);
@@ -1016,8 +1135,8 @@ function parseNameList(t: ParseTree): string[] {
   if (t.type !== "NameList") {
     throw new Error(`Expected NameList, got ${t.type}`);
   }
-  return t.children!
-    .filter((c) => c.type === "Name")
+  return t
+    .children!.filter((c) => c.type === "Name")
     .map((c) => c.children![0].text!);
 }
 
@@ -1025,8 +1144,8 @@ function parseExpList(t: ParseTree, ctx: ASTCtx): LuaExpression[] {
   if (t.type !== "ExpList") {
     throw new Error(`Expected ExpList, got ${t.type}`);
   }
-  return t.children!
-    .filter((c) => c.type && c.type !== ",")
+  return t
+    .children!.filter((c) => c.type && c.type !== ",")
     .map((e) => parseExpression(e, ctx));
 }
 
@@ -1045,44 +1164,46 @@ function parseString(s: string): string {
     }
     return text;
   }
-  return s.slice(1, -1).replace(
-    /\\(x[0-9a-fA-F]{2}|u\{[0-9a-fA-F]+\}|[abfnrtv\\'"n])/g,
-    (match, capture) => {
-      switch (capture) {
-        case "a":
-          return "\x07"; // Bell
-        case "b":
-          return "\b"; // Backspace
-        case "f":
-          return "\f"; // Form feed
-        case "n":
-          return "\n"; // Newline
-        case "r":
-          return "\r"; // Carriage return
-        case "t":
-          return "\t"; // Horizontal tab
-        case "v":
-          return "\v"; // Vertical tab
-        case "\\":
-          return "\\"; // Backslash
-        case '"':
-          return '"'; // Double quote
-        case "'":
-          return "'"; // Single quote
-        default:
-          // Handle hexadecimal \x00
-          if (capture.startsWith("x")) {
-            return String.fromCharCode(parseInt(capture.slice(1), 16));
-          }
-          // Handle unicode \u{XXXX}
-          if (capture.startsWith("u{")) {
-            const codePoint = parseInt(capture.slice(2, -1), 16);
-            return String.fromCodePoint(codePoint);
-          }
-          return match; // return the original match if nothing fits
-      }
-    },
-  );
+  return s
+    .slice(1, -1)
+    .replace(
+      /\\(x[0-9a-fA-F]{2}|u\{[0-9a-fA-F]+\}|[abfnrtv\\'"n])/g,
+      (match, capture) => {
+        switch (capture) {
+          case "a":
+            return "\x07"; // Bell
+          case "b":
+            return "\b"; // Backspace
+          case "f":
+            return "\f"; // Form feed
+          case "n":
+            return "\n"; // Newline
+          case "r":
+            return "\r"; // Carriage return
+          case "t":
+            return "\t"; // Horizontal tab
+          case "v":
+            return "\v"; // Vertical tab
+          case "\\":
+            return "\\"; // Backslash
+          case '"':
+            return '"'; // Double quote
+          case "'":
+            return "'"; // Single quote
+          default:
+            // Handle hexadecimal \x00
+            if (capture.startsWith("x")) {
+              return String.fromCharCode(parseInt(capture.slice(1), 16));
+            }
+            // Handle unicode \u{XXXX}
+            if (capture.startsWith("u{")) {
+              const codePoint = parseInt(capture.slice(2, -1), 16);
+              return String.fromCodePoint(codePoint);
+            }
+            return match; // return the original match if nothing fits
+        }
+      },
+    );
 }
 
 function parseExpression(t: ParseTree, ctx: ASTCtx): LuaExpression {
@@ -1103,8 +1224,9 @@ function parseExpression(t: ParseTree, ctx: ASTCtx): LuaExpression {
       return {
         type: "Number",
         // Use the integer parser fox 0x literals
+        // biome-ignore lint/correctness/useParseIntRadix: hex strings need auto-detect radix
         value: text.includes("x") ? parseInt(text) : parseFloat(text),
-        numericType: /[\.eEpP]/.test(text) ? "float" : "int",
+        numericType: /[.eEpP]/.test(text) ? "float" : "int",
         ctx: context(t, ctx),
       };
     }
@@ -1174,10 +1296,10 @@ function parseExpression(t: ParseTree, ctx: ASTCtx): LuaExpression {
     case "TableConstructor":
       return {
         type: "TableConstructor",
-        fields: t.children!
-          .slice(1, -1)
+        fields: t
+          .children!.slice(1, -1)
           .filter((c) =>
-            ["FieldExp", "FieldProp", "FieldDynamic"].includes(c.type!)
+            ["FieldExp", "FieldProp", "FieldDynamic"].includes(c.type!),
           )
           .map((tf) => parseTableField(tf, ctx)),
         ctx: context(t, ctx),
@@ -1190,12 +1312,36 @@ function parseExpression(t: ParseTree, ctx: ASTCtx): LuaExpression {
         clauses: t.children!.slice(2, -1).map((c) => parseQueryClause(c, ctx)),
         ctx: context(t, ctx),
       };
+    case "FilteredCall": {
+      const call = parseFunctionCall(t.children![0], ctx);
+      const filterExpr = parseExpression(t.children![4], ctx);
+      return {
+        type: "FilteredCall",
+        call,
+        filter: filterExpr,
+        ctx: context(t, ctx),
+      };
+    }
     default:
       console.error(t);
       throw new Error(`Unknown expression type: ${t.type}`);
   }
 }
 
+function parseFieldList(t: ParseTree, ctx: ASTCtx): LuaTableField[] {
+  if (t.type !== "FieldList") {
+    throw new Error(`Expected FieldList, got ${t.type}`);
+  }
+  return t
+    .children!.filter(
+      (c) =>
+        c.type === "FieldExp" ||
+        c.type === "FieldProp" ||
+        c.type === "FieldDynamic",
+    )
+    .map((c) => parseTableField(c, ctx));
+}
+
 function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
   if (t.type !== "QueryClause") {
     throw new Error(`Expected QueryClause, got ${t.type}`);
@@ -1203,18 +1349,14 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
   t = t.children![0];
   switch (t.type) {
     case "FromClause": {
-      if (t.children!.length === 4) {
-        // From clause with a name
-        return {
-          type: "From",
-          name: t.children![1].children![0].text!,
-          expression: parseExpression(t.children![3], ctx),
-          ctx: context(t, ctx),
-        };
+      // children: ckw<"from">, FieldList
+      const fieldListNode = t.children!.find((c) => c.type === "FieldList");
+      if (!fieldListNode) {
+        throw new Error("FromClause missing FieldList");
       }
       return {
         type: "From",
-        expression: parseExpression(t.children![1], ctx),
+        fields: parseFieldList(fieldListNode, ctx),
         ctx: context(t, ctx),
       };
     }
@@ -1236,16 +1378,18 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
         ctx: context(t, ctx),
       };
     }
+    case "OffsetClause": {
+      return {
+        type: "Offset",
+        offset: parseExpression(t.children![1], ctx),
+        ctx: context(t, ctx),
+      };
+    }
     case "OrderByClause": {
       const orderBy: LuaOrderBy[] = [];
       for (const child of t.children!) {
         if (child.type === "OrderBy") {
-          orderBy.push({
-            type: "Order",
-            expression: parseExpression(child.children![0], ctx),
-            direction: child.children![1]?.type === "desc" ? "desc" : "asc",
-            ctx: context(child, ctx),
-          });
+          orderBy.push(parseOrderByNode(child, ctx));
         }
       }
       return {
@@ -1255,8 +1399,32 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
       };
     }
     case "SelectClause": {
+      // children: ckw<"select">, FieldList
+      const fieldListNode = t.children!.find((c) => c.type === "FieldList");
+      if (!fieldListNode) {
+        throw new Error("SelectClause missing FieldList");
+      }
       return {
         type: "Select",
+        fields: parseFieldList(fieldListNode, ctx),
+        ctx: context(t, ctx),
+      };
+    }
+    case "GroupByClause": {
+      // children: ckw<"group">, ckw<"by">, FieldList
+      const fieldListNode = t.children!.find((c) => c.type === "FieldList");
+      if (!fieldListNode) {
+        throw new Error("GroupByClause missing FieldList");
+      }
+      return {
+        type: "GroupBy",
+        fields: parseFieldList(fieldListNode, ctx),
+        ctx: context(t, ctx),
+      };
+    }
+    case "HavingClause": {
+      return {
+        type: "Having",
         expression: parseExpression(t.children![1], ctx),
         ctx: context(t, ctx),
       };
@@ -1267,10 +1435,70 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
   }
 }
 
-function parseFunctionArgs(ts: ParseTree[], ctx: ASTCtx): LuaExpression[] {
-  return ts
-    .filter((t) => t.type && ![",", "(", ")"].includes(t.type))
-    .map((e) => parseExpression(e, ctx));
+// Parse a single OrderBy node (shared by query OrderByClause and AggOrderBy)
+function parseOrderByNode(child: ParseTree, ctx: ASTCtx): LuaOrderBy {
+  const kids = child.children!;
+  let direction: "asc" | "desc" = "asc";
+  let nulls: "first" | "last" | undefined;
+  let usingVal: string | LuaFunctionBody | undefined;
+  for (let i = 1; i < kids.length; i++) {
+    const typ = kids[i].type;
+    if (typ === "desc") direction = "desc";
+    else if (typ === "asc") direction = "asc";
+    else if (typ === "first") nulls = "first";
+    else if (typ === "last") nulls = "last";
+    else if (typ === "using") {
+      const next = kids[i + 1];
+      if (next.type === "function") {
+        usingVal = parseFunctionBody(kids[i + 2], ctx);
+        i += 2;
+      } else {
+        usingVal = next.children![0].text!;
+        i++;
+      }
+    }
+  }
+  const ob: LuaOrderBy = {
+    type: "Order",
+    expression: parseExpression(kids[0], ctx),
+    direction,
+    ctx: context(child, ctx),
+  };
+  if (nulls) ob.nulls = nulls;
+  if (usingVal !== undefined) ob.using = usingVal;
+  return ob;
+}
+
+// Parse an AggOrderBy node into LuaOrderBy[]
+function parseAggOrderBy(t: ParseTree, ctx: ASTCtx): LuaOrderBy[] {
+  if (t.type !== "AggOrderBy") {
+    throw new Error(`Expected AggOrderBy, got ${t.type}`);
+  }
+  const orderBy: LuaOrderBy[] = [];
+  for (const child of t.children!) {
+    if (child.type === "OrderBy") {
+      orderBy.push(parseOrderByNode(child, ctx));
+    }
+  }
+  return orderBy;
+}
+
+// Parse function args, extracting AggOrderBy if present inside funcParams
+function parseFunctionArgsWithOrderBy(
+  ts: ParseTree[],
+  ctx: ASTCtx,
+): { args: LuaExpression[]; aggOrderBy?: LuaOrderBy[] } {
+  let aggOrderBy: LuaOrderBy[] | undefined;
+  const args: LuaExpression[] = [];
+  for (const t of ts) {
+    if (!t.type || [",", "(", ")"].includes(t.type)) continue;
+    if (t.type === "AggOrderBy") {
+      aggOrderBy = parseAggOrderBy(t, ctx);
+    } else {
+      args.push(parseExpression(t, ctx));
+    }
+  }
+  return { args, aggOrderBy };
 }
 
 function parseFunctionBody(t: ParseTree, ctx: ASTCtx): LuaFunctionBody {
@@ -1279,8 +1507,10 @@ function parseFunctionBody(t: ParseTree, ctx: ASTCtx): LuaFunctionBody {
   }
   return {
     type: "FunctionBody",
-    parameters: t.children![1].children!
-      .filter((c) => c.type && ["Name", "Ellipsis"].includes(c.type))
+    parameters: t
+      .children![1].children!.filter(
+        (c) => c.type && ["Name", "Ellipsis"].includes(c.type),
+      )
       .map((c) => c.children![0].text!),
     block: parseBlock(t.children![3], ctx),
     ctx: context(t, ctx),
@@ -1371,7 +1601,7 @@ export function stripLuaComments(s: string): string {
       if (s[j] === "[") {
         // Found long string start
         const openBracket = s.substring(i, j + 1);
-        const closeBracket = "]" + "=".repeat(equalsCount) + "]";
+        const closeBracket = `]${"=".repeat(equalsCount)}]`;
         result += openBracket;
         i = j + 1;
 
@@ -1424,7 +1654,7 @@ export function stripLuaComments(s: string): string {
         }
         if (s[j] === "[") {
           // Found long comment start
-          const closeBracket = "]" + "=".repeat(equalsCount) + "]";
+          const closeBracket = `]${"=".repeat(equalsCount)}]`;
           // Replace opening bracket with spaces
           result += " ".repeat(j - i + 1);
           i = j + 1;
@@ -1468,9 +1698,7 @@ export function parse(s: string, ctx: ASTCtx = {}): LuaBlock {
     if (e && typeof e === "object" && "astCtx" in e) {
       throw new LuaRuntimeError(
         e.message,
-        LuaStackFrame.lostFrame.withCtx(
-          (e as any).astCtx as ASTCtx,
-        ),
+        LuaStackFrame.lostFrame.withCtx((e as any).astCtx as ASTCtx),
       );
     }
     throw e;
@@ -1514,9 +1742,7 @@ function luaUnexpectedSymbolMessage(src: string, from: number): string {
 /**
  * Helper function to parse a Lua expression string
  */
-export function parseExpressionString(
-  expr: string,
-): LuaExpression {
+export function parseExpressionString(expr: string): LuaExpression {
   const parsedLua = parse(`_(${expr})`) as LuaBlock;
   return (parsedLua.statements[0] as LuaFunctionCallStatement).call.args[0];
 }