@silverbulletmd/silverbullet 2.4.2 → 2.5.3

package/client/space_lua/aggregates.ts

@@ -0,0 +1,209 @@
+/**
+ * Aggregate function definitions and execution for LIQ.
+ *
+ * Built-in aggregates (sum, count, min, max, avg, array_agg) are
+ * implemented in TypeScript for speed.  Users can override any builtin
+ * via `aggregate.define` or `aggregate.update`.
+ *
+ * Builtins implement ILuaFunction via plain objects rather than
+ * LuaBuiltinFunction instances.  This avoids ES module TDZ issues:
+ * `class` exports are not available during circular module init,
+ * but `interface`/`type` imports are.
+ */
+
+import type { ILuaFunction, LuaStackFrame } from "./runtime.ts";
+import {
+  luaCall,
+  type LuaEnv,
+  LuaTable,
+  luaTruthy,
+  type LuaValue,
+} from "./runtime.ts";
+import type { LuaExpression } from "./ast.ts";
+import { buildItemEnv } from "./query_env.ts";
+
+export interface AggregateSpec {
+  name: string;
+  description?: string;
+  initialize: LuaValue; // ILuaFunction
+  iterate: LuaValue; // ILuaFunction
+  finish?: LuaValue; // ILuaFunction | undefined
+}
+
+// Helper to build an ILuaFunction from a plain function.  Equivalent to
+// LuaBuiltinFunction but without referencing the class.
+function aggFn(
+  fn: (sf: LuaStackFrame, ...args: LuaValue[]) => LuaValue,
+): ILuaFunction {
+  return {
+    call(sf: LuaStackFrame, ...args: LuaValue[]) {
+      return fn(sf, ...args);
+    },
+    asString() {
+      return "<builtin aggregate>";
+    },
+  };
+}
+
+// Built-in aggregate specs
+const builtinAggregates: Record<string, AggregateSpec> = {
+  sum: {
+    name: "sum",
+    description: "Sum of numeric values",
+    initialize: aggFn((_sf) => 0),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      if (value === null || value === undefined) return state;
+      return (state as number) + (value as number);
+    }),
+  },
+  count: {
+    name: "count",
+    description: "Count of values; count() with no argument counts all rows",
+    initialize: aggFn((_sf) => 0),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      if (value === null || value === undefined) return state;
+      return (state as number) + 1;
+    }),
+  },
+  min: {
+    name: "min",
+    description: "Minimum value",
+    initialize: aggFn((_sf) => null),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      if (value === null || value === undefined) return state;
+      if (state === null || value < state) return value;
+      return state;
+    }),
+  },
+  max: {
+    name: "max",
+    description: "Maximum value",
+    initialize: aggFn((_sf) => null),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      if (value === null || value === undefined) return state;
+      if (state === null || value > state) return value;
+      return state;
+    }),
+  },
+  avg: {
+    name: "avg",
+    description: "Average of numeric values",
+    initialize: aggFn((_sf) => ({ sum: 0, count: 0 })),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      if (value === null || value === undefined) return state;
+      state.sum += value as number;
+      state.count += 1;
+      return state;
+    }),
+    finish: aggFn((_sf, state: any) => {
+      if (state.count === 0) return null;
+      return state.sum / state.count;
+    }),
+  },
+  array_agg: {
+    name: "array_agg",
+    description: "Collect values into an array",
+    initialize: aggFn((_sf) => new LuaTable()),
+    iterate: aggFn((_sf, state: any, value: any) => {
+      (state as LuaTable).rawSetArrayIndex(
+        (state as LuaTable).length + 1,
+        value,
+      );
+      return state;
+    }),
+  },
+};
+
+const noCtx = {};
+
+function buildAggCtx(name: string): LuaTable {
+  const ctx = new LuaTable();
+  ctx.rawSet("name", name);
+  const clientConfig = globalThis.client?.config;
+  const aggConfig = clientConfig
+    ? clientConfig.get(`aggregateConfig.${name}`, {})
+    : {};
+  ctx.rawSet("config", aggConfig);
+  return ctx;
+}
+
+export function getAggregateSpec(name: string): AggregateSpec | null {
+  const clientConfig = globalThis.client?.config;
+  if (clientConfig) {
+    const spec: any = clientConfig.get(`aggregates.${name}`, null);
+    if (spec) {
+      let candidate: AggregateSpec | null = null;
+      if (spec instanceof LuaTable) {
+        const init = spec.rawGet("initialize");
+        const iter = spec.rawGet("iterate");
+        if (init && iter) {
+          candidate = {
+            name: spec.rawGet("name") ?? name,
+            description: spec.rawGet("description"),
+            initialize: init,
+            iterate: iter,
+            finish: spec.rawGet("finish"),
+          };
+        }
+      } else if (spec.initialize && spec.iterate) {
+        candidate = spec as AggregateSpec;
+      }
+      if (candidate) return candidate;
+    }
+  }
+  return builtinAggregates[name] ?? null;
+}
+
+/**
+ * Execute an aggregate function over a group of items.
+ */
+export async function executeAggregate(
+  spec: AggregateSpec,
+  items: LuaTable,
+  valueExpr: LuaExpression | null,
+  objectVariable: string | undefined,
+  env: LuaEnv,
+  sf: LuaStackFrame,
+  evalExprFn: (
+    e: LuaExpression,
+    env: LuaEnv,
+    sf: LuaStackFrame,
+  ) => Promise<LuaValue> | LuaValue,
+  filterExpr?: LuaExpression,
+): Promise<LuaValue> {
+  const ctx = buildAggCtx(spec.name);
+
+  // Initialize
+  let state = await luaCall(spec.initialize, [ctx], noCtx, sf);
+
+  // Iterate
+  const len = items.length;
+  for (let i = 1; i <= len; i++) {
+    const item = items.rawGet(i);
+
+    // Filter
+    if (filterExpr) {
+      const filterEnv = buildItemEnv(objectVariable, item, env, sf);
+      const filterResult = await evalExprFn(filterExpr, filterEnv, sf);
+      if (!luaTruthy(filterResult)) {
+        continue;
+      }
+    }
+
+    let value: LuaValue;
+    if (valueExpr === null) {
+      value = item;
+    } else {
+      const itemEnv = buildItemEnv(objectVariable, item, env, sf);
+      value = await evalExprFn(valueExpr, itemEnv, sf);
+    }
+    state = await luaCall(spec.iterate, [state, value, ctx], noCtx, sf);
+  }
+
+  // Finish
+  if (spec.finish) {
+    state = await luaCall(spec.finish, [state, ctx], noCtx, sf);
+  }
+
+  return state;
+}

package/client/space_lua/ast.ts

@@ -175,7 +175,8 @@ export type LuaExpression =
   | LuaUnaryExpression
   | LuaTableConstructor
   | LuaFunctionDefinition
-  | LuaQueryExpression;
+  | LuaQueryExpression
+  | LuaFilteredCallExpression;
 
 export type LuaNilLiteral = {
   type: "Nil";
@@ -281,6 +282,13 @@ export type LuaFunctionDefinition = {
   body: LuaFunctionBody;
 } & ASTContext;
 
+// Aggregate with per-row filter
+export type LuaFilteredCallExpression = {
+  type: "FilteredCall";
+  call: LuaFunctionCallExpression;
+  filter: LuaExpression;
+} & ASTContext;
+
 // Query stuff
 export type LuaQueryExpression = {
   type: "Query";
@@ -292,7 +300,9 @@ export type LuaQueryClause =
   | LuaWhereClause
   | LuaLimitClause
   | LuaOrderByClause
-  | LuaSelectClause;
+  | LuaSelectClause
+  | LuaGroupByClause
+  | LuaHavingClause;
 
 export type LuaFromClause = {
   type: "From";
@@ -320,9 +330,21 @@ export type LuaOrderBy = {
   type: "Order";
   expression: LuaExpression;
   direction: "asc" | "desc";
+  nulls?: "first" | "last";
+  using?: string | LuaFunctionBody;
 } & ASTContext;
 
 export type LuaSelectClause = {
   type: "Select";
   expression: LuaExpression;
 } & ASTContext;
+
+export type LuaGroupByClause = {
+  type: "GroupBy";
+  expressions: LuaExpression[];
+} & ASTContext;
+
+export type LuaHavingClause = {
+  type: "Having";
+  expression: LuaExpression;
+} & ASTContext;

package/client/space_lua/eval.ts

@@ -19,6 +19,7 @@ import {
   luaEnsureCloseStack,
   LuaEnv,
   luaEquals,
+  luaFormatNumber,
   LuaFunction,
   luaGet,
   luaIndexValue,
@@ -37,10 +38,7 @@ import {
   luaValueToJS,
   singleResult,
 } from "./runtime.ts";
-import {
-  ArrayQueryCollection,
-  type LuaCollectionQuery,
-} from "./query_collection.ts";
+import { type LuaCollectionQuery, toCollection } from "./query_collection.ts";
 import {
   coerceNumericPair,
   coerceToNumber,
@@ -178,17 +176,6 @@ function blockMetaOrThrow(
   }
 }
 
-// Queryable guard to avoid `(collection as any).query` usage
-type Queryable = {
-  query: (
-    q: LuaCollectionQuery,
-    env: LuaEnv,
-    sf: LuaStackFrame,
-  ) => Promise<any>;
-};
-function isQueryable(x: unknown): x is Queryable {
-  return !!x && typeof (x as any).query === "function";
-}
 
 function arithVerbFromOperator(op: string): string | null {
   switch (op) {
@@ -250,7 +237,7 @@ function arithCoercionErrorOrThrow(
   throw e;
 }
 
-function luaOp(
+export function luaOp(
   op: string,
   left: any,
   right: any,
@@ -333,10 +320,10 @@ function luaOp(
             return v as string;
           }
           if (typeof v === "number") {
-            return String(v);
+            return luaFormatNumber(v);
           }
           if (isTaggedFloat(v)) {
-            return String(v.value);
+            return luaFormatNumber(v.value, "float");
           }
           const t = luaTypeName(v);
           throw new LuaRuntimeError(
@@ -853,22 +840,35 @@ export function evalExpression(
                 sf.withCtx(q.ctx),
               );
             }
-            if (collection instanceof LuaTable && collection.empty()) {
-              // Make sure we're converting an empty result to an array to "query"
-              collection = [];
-            } else {
-              collection = luaValueToJS(collection, sf);
-            }
-            // Check if collection is a queryable collection
-            if (!isQueryable(collection)) {
-              if (!Array.isArray(collection)) {
-                throw new LuaRuntimeError(
-                  "Collection does not support query",
-                  sf.withCtx(q.ctx),
-                );
+
+            // If already a queryable collection (e.g. DataStoreQueryCollection),
+            // use directly - skip all LuaTable/JS conversion.
+            if (
+              typeof collection === "object" &&
+              collection !== null &&
+              "query" in collection &&
+              typeof (collection as any).query === "function"
+            ) {
+              // Already queryable, use as-is
+            } else if (collection instanceof LuaTable && collection.empty()) {
+              // Empty table → empty array
+              collection = toCollection([]);
+            } else if (collection instanceof LuaTable) {
+              if (collection.length > 0) {
+                // Array-like table: extract array items, keep as LuaTables
+                const arr: any[] = [];
+                for (let i = 1; i <= collection.length; i++) {
+                  arr.push(collection.rawGet(i));
+                }
+                collection = toCollection(arr);
+              } else {
+                // Record-like table (no array part): treat as singleton
+                collection = toCollection([collection]);
               }
-              collection = new ArrayQueryCollection(collection);
+            } else {
+              collection = toCollection(luaValueToJS(collection, sf));
             }
+
             // Build up query object
             const query: LuaCollectionQuery = {
               objectVariable,
@@ -886,6 +886,8 @@ export function evalExpression(
                   query.orderBy = clause.orderBy.map((o) => ({
                     expr: o.expression,
                     desc: o.direction === "desc",
+                    nulls: o.nulls,
+                    using: o.using,
                   }));
                   break;
                 }
@@ -906,12 +908,19 @@ export function evalExpression(
                   }
                   break;
                 }
+                case "GroupBy": {
+                  query.groupBy = clause.expressions;
+                  break;
+                }
+                case "Having": {
+                  query.having = clause.expression;
+                  break;
+                }
               }
             }
 
-            return (collection as Queryable).query(query, env, sf).then(
-              jsToLuaValue,
-            );
+            // Always use the possibly-wrapped collection
+            return (collection as any).query(query, env, sf).then(jsToLuaValue);
           },
         );
       }
@@ -1410,9 +1419,9 @@ function evalExpressions(
 }
 
 type EvalBlockResult =
-  | void
+  | undefined
   | ControlSignal
-  | Promise<void | ControlSignal>;
+  | Promise<undefined | ControlSignal>;
 
 function runStatementsNoGoto(
   stmts: LuaStatement[],
@@ -1420,10 +1429,10 @@ function runStatementsNoGoto(
   sf: LuaStackFrame,
   returnOnReturn: boolean,
   startIdx: number,
-): void | ControlSignal | Promise<void | ControlSignal> {
+): undefined | ControlSignal | Promise<undefined | ControlSignal> {
   const processFrom = (
     idx: number,
-  ): void | ControlSignal | Promise<void | ControlSignal> => {
+  ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
     for (let i = idx; i < stmts.length; i++) {
       const result = evalStatement(
         stmts[i],
@@ -1621,7 +1630,7 @@ export function evalStatement(
   env: LuaEnv,
   sf: LuaStackFrame,
   returnOnReturn = false,
-): void | ControlSignal | Promise<void | ControlSignal> {
+): undefined | ControlSignal | Promise<undefined | ControlSignal> {
   switch (s.type) {
     case "Assignment": {
       const a = asAssignment(s);
@@ -1773,7 +1782,7 @@ export function evalStatement(
         return rpThen(rp, onValue) as any;
       };
 
-      return runFrom(0);
+      return runFrom(0) as undefined | Promise<undefined>;
     }
     case "Semicolon": {
       return;
@@ -1826,9 +1835,9 @@ export function evalStatement(
       const runFrom = (
         i: number,
       ):
-        | void
+        | undefined
         | ControlSignal
-        | Promise<void | ControlSignal> => {
+        | Promise<undefined | ControlSignal> => {
         if (i >= conds.length) {
           if (iff.elseBlock) {
             return evalStatement(iff.elseBlock, env, sf, returnOnReturn);
@@ -1855,7 +1864,7 @@ export function evalStatement(
     case "While": {
       const w = asWhile(s);
 
-      const runAsync = async (): Promise<void | ControlSignal> => {
+      const runAsync = async (): Promise<undefined | ControlSignal> => {
         while (true) {
           const c = await evalExpression(w.condition, env, sf);
           if (!luaTruthy(c)) {
@@ -1880,7 +1889,6 @@ export function evalStatement(
             if (!luaTruthy(cv)) {
               return;
             }
-            try {
               const r = evalStatement(w.block, env, sf, returnOnReturn);
               if (isPromise(r)) {
                 return (r as Promise<any>).then((res) => {
@@ -1900,9 +1908,6 @@ export function evalStatement(
                 return r;
               }
               return runAsync();
-            } catch (e: any) {
-              throw e;
-            }
           });
         }
         if (!luaTruthy(c)) {
@@ -1932,7 +1937,7 @@ export function evalStatement(
     case "Repeat": {
       const r = asRepeat(s);
 
-      const runAsync = async (): Promise<void | ControlSignal> => {
+      const runAsync = async (): Promise<undefined | ControlSignal> => {
         while (true) {
           const rr = evalStatement(r.block, env, sf, returnOnReturn);
           const res = isPromise(rr) ? await rr : rr;
@@ -2101,7 +2106,7 @@ export function evalStatement(
           loopEnv: LuaEnv,
           i: number,
           loopType: NumericType,
-        ): void | ControlSignal | Promise<void | ControlSignal> => {
+        ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
           loopEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
           return evalStatement(fr.block, loopEnv, sf, returnOnReturn);
         }
@@ -2109,7 +2114,7 @@ export function evalStatement(
           _loopEnv: LuaEnv,
           i: number,
           loopType: NumericType,
-        ): void | ControlSignal | Promise<void | ControlSignal> => {
+        ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
           const localEnv = new LuaEnv(env);
           localEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
           return evalStatement(fr.block, localEnv, sf, returnOnReturn);
@@ -2148,9 +2153,9 @@ export function evalStatement(
         step: number,
         loopType: NumericType,
       ):
-        | void
+        | undefined
         | ControlSignal
-        | Promise<void | ControlSignal> => {
+        | Promise<undefined | ControlSignal> => {
         if (step === 0) {
           throw new LuaRuntimeError("'for' step is zero", sf.withCtx(fr.ctx));
         }

package/client/space_lua/labels.ts

@@ -122,7 +122,7 @@ function resolveFunction(root: LuaBlock): FunctionMeta {
 
     while (searchBlock) {
       const meta = blockMeta.get(searchBlock);
-      if (meta && meta.labels.has(target)) {
+      if (meta?.labels.has(target)) {
         labelIndex = meta.labels.get(target);
         labelDefBlock = searchBlock;
         break;