@silverbulletmd/silverbullet 2.4.1 → 2.5.3

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 select order by desc asc nulls first last group having filter using":
     t.keyword,
 });
 
@@ -131,6 +132,7 @@ function expressionHasFunctionDef(e: LuaExpression): boolean {
             break;
           case "Where":
           case "Select":
+          case "Having":
             if (expressionHasFunctionDef(c.expression)) return true;
             break;
           case "Limit":
@@ -142,11 +144,26 @@ 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;
+          case "GroupBy":
+            for (let j = 0; j < c.expressions.length; j++) {
+              if (expressionHasFunctionDef(c.expressions[j])) return true;
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        expressionHasFunctionDef(e.call) ||
+        expressionHasFunctionDef(e.filter)
+      );
     default:
       return false;
   }
@@ -213,6 +230,7 @@ function exprReferencesNames(e: LuaExpression, names: Set<string>): boolean {
             break;
           case "Where":
           case "Select":
+          case "Having":
             if (exprReferencesNames(c.expression, names)) return true;
             break;
           case "Limit":
@@ -224,11 +242,27 @@ 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;
+          case "GroupBy":
+            for (let j = 0; j < c.expressions.length; j++) {
+              if (exprReferencesNames(c.expressions[j], names)) return true;
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        exprReferencesNames(e.call, names) ||
+        exprReferencesNames(e.filter, names)
+      );
     default:
       return false;
   }
@@ -512,6 +546,7 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
             break;
           case "Where":
           case "Select":
+          case "Having":
             if (exprCapturesNames(c.expression, names)) return true;
             break;
           case "Limit":
@@ -523,11 +558,25 @@ 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;
+          case "GroupBy":
+            for (let j = 0; j < c.expressions.length; j++) {
+              if (exprCapturesNames(c.expressions[j], names)) return true;
             }
             break;
         }
       }
       return false;
+    case "FilteredCall":
+      return (
+        exprCapturesNames(e.call, names) ||
+        exprCapturesNames(e.filter, names)
+      );
     default:
       return false;
   }
@@ -537,7 +586,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) };
 
@@ -765,7 +814,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]) {
@@ -900,7 +949,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
             ? t.children![0].text
             : String(t.type)
         }`,
@@ -995,7 +1044,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!);
@@ -1103,8 +1152,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),
       };
     }
@@ -1190,6 +1240,16 @@ 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}`);
@@ -1240,12 +1300,36 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
       const orderBy: LuaOrderBy[] = [];
       for (const child of t.children!) {
         if (child.type === "OrderBy") {
-          orderBy.push({
+          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(child.children![0], ctx),
-            direction: child.children![1]?.type === "desc" ? "desc" : "asc",
+            expression: parseExpression(kids[0], ctx),
+            direction,
             ctx: context(child, ctx),
-          });
+          };
+          if (nulls) ob.nulls = nulls;
+          if (usingVal !== undefined) ob.using = usingVal;
+          orderBy.push(ob);
         }
       }
       return {
@@ -1261,6 +1345,27 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
         ctx: context(t, ctx),
       };
     }
+    case "GroupByClause": {
+      // children: ckw<"group">, ckw<"by">, exp, ",", exp, ...
+      const expressions: LuaExpression[] = t.children!
+        .filter((c) =>
+          c.type !== undefined && c.type !== "group" && c.type !== "by" &&
+          c.type !== ","
+        )
+        .map((c) => parseExpression(c, ctx));
+      return {
+        type: "GroupBy",
+        expressions,
+        ctx: context(t, ctx),
+      };
+    }
+    case "HavingClause": {
+      return {
+        type: "Having",
+        expression: parseExpression(t.children![1], ctx),
+        ctx: context(t, ctx),
+      };
+    }
     default:
       console.error(t);
       throw new Error(`Unknown query clause type: ${t.type}`);
@@ -1371,7 +1476,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 +1529,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;