@silverbulletmd/silverbullet 2.5.3 → 2.6.1

package/client/space_lua/query_collection.ts

@@ -1,4 +1,5 @@
 import type {
+  LuaAggregateCallExpression,
   LuaBinaryExpression,
   LuaDynamicField,
   LuaExpression,
@@ -25,6 +26,7 @@ import {
   type LuaValue,
   singleResult,
 } from "./runtime.ts";
+import { isSqlNull, LIQ_NULL } from "./liq_null.ts";
 import { evalExpression, luaOp } from "./eval.ts";
 import { asyncMergeSort } from "./util.ts";
 import type { DataStore } from "../data/datastore.ts";
@@ -35,13 +37,10 @@ import type { QueryCollationConfig } from "../../plug-api/types/config.ts";
 import type { KvKey } from "../../plug-api/types/datastore.ts";
 
 import { executeAggregate, getAggregateSpec } from "./aggregates.ts";
+import { Config } from "../config.ts";
 
-// Sentinel value representing SQL NULL in query results.
-export const LIQ_NULL = Symbol.for("silverbullet.sqlNull");
-
-export function isSqlNull(v: any): boolean {
-  return v === LIQ_NULL;
-}
+// Implicit single group map key (aggregates without `group by`)
+const IMPLICIT_GROUP_KEY: unique symbol = Symbol("implicit-group");
 
 // Build environment for post-`group by` clauses. Injects `key` and `group`
 // as top-level variables. Unpacks first group item fields and group-by key
@@ -58,9 +57,8 @@ function buildGroupItemEnv(
   if (item instanceof LuaTable) {
     const keyVal = item.rawGet("key");
     const groupVal = item.rawGet("group");
-    const firstItem = (groupVal instanceof LuaTable)
-      ? groupVal.rawGet(1)
-      : undefined;
+    const firstItem =
+      groupVal instanceof LuaTable ? groupVal.rawGet(1) : undefined;
 
     if (firstItem) {
       for (const k of luaKeys(firstItem)) {
@@ -79,19 +77,32 @@ function buildGroupItemEnv(
       itemEnv.setLocal("group", groupVal);
     }
 
+    // Unpack named fields from multi-key LuaTable keys
     if (keyVal instanceof LuaTable) {
       for (const k of luaKeys(keyVal)) {
         if (typeof k !== "string") continue;
         itemEnv.setLocal(k, luaGet(keyVal, k, sf.astCtx ?? null, sf));
       }
     }
-    // For single-key group by, bind the key name as a local
-    if (
-      !(keyVal instanceof LuaTable) &&
-      groupByNames &&
-      groupByNames.length === 1
-    ) {
-      itemEnv.setLocal(groupByNames[0], keyVal);
+
+    // Bind all `group by` aliases/names to their key values.  For
+    // single key bind the name to the scalar `keyVal`.  For multi-key
+    // bind each name to the field from the key table.
+    if (groupByNames && groupByNames.length > 0) {
+      if (!(keyVal instanceof LuaTable)) {
+        // Bind all names to scalar
+        for (const gbn of groupByNames) {
+          itemEnv.setLocal(gbn, keyVal);
+        }
+      } else {
+        // Ensure every alias is bound even if `luaKeys` missed it
+        for (const gbn of groupByNames) {
+          const v = keyVal.rawGet(gbn);
+          if (v !== undefined) {
+            itemEnv.setLocal(gbn, v);
+          }
+        }
+      }
     }
   }
   return itemEnv;
@@ -141,6 +152,11 @@ export type LuaOrderBy = {
   using?: string | LuaFunctionBody;
 };
 
+export type LuaGroupByEntry = {
+  expr: LuaExpression;
+  alias?: string;
+};
+
 /**
  * Represents a query for a collection
  */
@@ -158,8 +174,8 @@ export type LuaCollectionQuery = {
   offset?: number;
   // Whether to return only distinct values
   distinct?: boolean;
-  // The group by expressions evaluated with Lua
-  groupBy?: LuaExpression[];
+  // The group by entries evaluated with Lua
+  groupBy?: LuaGroupByEntry[];
   // The having expression evaluated with Lua
   having?: LuaExpression;
 };
@@ -169,6 +185,7 @@ export interface LuaQueryCollection {
     query: LuaCollectionQuery,
     env: LuaEnv,
     sf: LuaStackFrame,
+    config?: Config,
   ): Promise<any[]>;
 }
 
@@ -176,15 +193,14 @@ export interface LuaQueryCollection {
  * Implements a query collection for a regular JavaScript array
  */
 export class ArrayQueryCollection<T> implements LuaQueryCollection {
-  constructor(private readonly array: T[]) {
-  }
+  constructor(private readonly array: T[]) {}
   query(
     query: LuaCollectionQuery,
     env: LuaEnv,
     sf: LuaStackFrame,
-    collation?: QueryCollationConfig,
+    config?: Config,
   ): Promise<any[]> {
-    return applyQuery(this.array, query, env, sf, collation);
+    return applyQuery(this.array, query, env, sf, config);
   }
 }
 
@@ -202,46 +218,71 @@ export function toCollection(obj: any): LuaQueryCollection {
   return new ArrayQueryCollection([obj]);
 }
 
-function containsAggregate(expr: LuaExpression): boolean {
+function containsAggregate(expr: LuaExpression, config?: Config): boolean {
   switch (expr.type) {
     case "FilteredCall": {
       const fc = (expr as LuaFilteredCallExpression).call;
-      if (fc.prefix.type === "Variable" && getAggregateSpec(fc.prefix.name)) {
+      if (
+        fc.prefix.type === "Variable" &&
+        getAggregateSpec(fc.prefix.name, config)
+      ) {
+        return true;
+      }
+      return (
+        containsAggregate(fc, config) ||
+        containsAggregate((expr as LuaFilteredCallExpression).filter, config)
+      );
+    }
+    case "AggregateCall": {
+      const ac = expr as LuaAggregateCallExpression;
+      const fc = ac.call;
+      if (
+        fc.prefix.type === "Variable" &&
+        getAggregateSpec(fc.prefix.name, config)
+      ) {
         return true;
       }
-      return containsAggregate(fc) ||
-        containsAggregate((expr as LuaFilteredCallExpression).filter);
+      return containsAggregate(fc, config);
     }
     case "FunctionCall": {
       const fc = expr as LuaFunctionCallExpression;
-      if (fc.prefix.type === "Variable" && getAggregateSpec(fc.prefix.name)) {
+      if (
+        fc.prefix.type === "Variable" &&
+        getAggregateSpec(fc.prefix.name, config)
+      ) {
         return true;
       }
-      return fc.args.some(containsAggregate);
+      return fc.args.some((a) => containsAggregate(a, config));
     }
     case "Binary": {
       const bin = expr as LuaBinaryExpression;
-      return containsAggregate(bin.left) || containsAggregate(bin.right);
+      return (
+        containsAggregate(bin.left, config) ||
+        containsAggregate(bin.right, config)
+      );
     }
     case "Unary": {
       const un = expr as LuaUnaryExpression;
-      return containsAggregate(un.argument);
+      return containsAggregate(un.argument, config);
     }
     case "Parenthesized": {
       const p = expr as LuaParenthesizedExpression;
-      return containsAggregate(p.expression);
+      return containsAggregate(p.expression, config);
     }
     case "TableConstructor":
       return expr.fields.some((f) => {
         switch (f.type) {
           case "PropField":
-            return containsAggregate((f as LuaPropField).value);
+            return containsAggregate((f as LuaPropField).value, config);
           case "DynamicField": {
             const df = f as LuaDynamicField;
-            return containsAggregate(df.key) || containsAggregate(df.value);
+            return (
+              containsAggregate(df.key, config) ||
+              containsAggregate(df.value, config)
+            );
           }
           case "ExpressionField":
-            return containsAggregate((f as LuaExpressionField).value);
+            return containsAggregate((f as LuaExpressionField).value, config);
           default:
             return false;
         }
@@ -251,6 +292,12 @@ function containsAggregate(expr: LuaExpression): boolean {
   }
 }
 
+// Wrap a value for select result tables so that the column key survives
+// in the `LuaTable`
+function selectVal(v: LuaValue): LuaValue {
+  return v === null || v === undefined ? LIQ_NULL : v;
+}
+
 /**
  * Evaluate an expression in aggregate-aware mode.
  *
@@ -265,8 +312,9 @@ export async function evalExpressionWithAggregates(
   groupItems: LuaTable,
   objectVariable: string | undefined,
   outerEnv: LuaEnv,
+  config: Config,
 ): Promise<LuaValue> {
-  if (!containsAggregate(expr)) {
+  if (!containsAggregate(expr, config)) {
     return evalExpression(expr, env, sf);
   }
   const recurse = (e: LuaExpression) =>
@@ -277,6 +325,7 @@ export async function evalExpressionWithAggregates(
       groupItems,
       objectVariable,
       outerEnv,
+      config,
     );
 
   if (expr.type === "FilteredCall") {
@@ -284,18 +333,22 @@ export async function evalExpressionWithAggregates(
     const fc = filtered.call;
     if (fc.prefix.type === "Variable") {
       const name = fc.prefix.name;
-      const spec = getAggregateSpec(name);
+      const spec = getAggregateSpec(name, config);
       if (spec) {
         const valueExpr = fc.args.length > 0 ? fc.args[0] : null;
+        const extraArgExprs = fc.args.length > 1 ? fc.args.slice(1) : [];
         return executeAggregate(
           spec,
           groupItems,
           valueExpr,
+          extraArgExprs,
           objectVariable,
           outerEnv,
           sf,
           evalExpression,
+          config,
           filtered.filter,
+          fc.orderBy,
         );
       }
     }
@@ -307,17 +360,22 @@ export async function evalExpressionWithAggregates(
     const fc = expr as LuaFunctionCallExpression;
     if (fc.prefix.type === "Variable") {
       const name = fc.prefix.name;
-      const spec = getAggregateSpec(name);
+      const spec = getAggregateSpec(name, config);
       if (spec) {
         const valueExpr = fc.args.length > 0 ? fc.args[0] : null;
+        const extraArgExprs = fc.args.length > 1 ? fc.args.slice(1) : [];
         return executeAggregate(
           spec,
           groupItems,
           valueExpr,
+          extraArgExprs,
           objectVariable,
           outerEnv,
           sf,
           evalExpression,
+          config,
+          undefined,
+          fc.orderBy,
         );
       }
     }
@@ -330,20 +388,20 @@ export async function evalExpressionWithAggregates(
         case "PropField": {
           const pf = field as LuaPropField;
           const value = await recurse(pf.value);
-          table.set(pf.key, value, sf);
+          void table.set(pf.key, selectVal(value), sf);
           break;
         }
         case "DynamicField": {
           const df = field as LuaDynamicField;
           const key = await evalExpression(df.key, env, sf);
           const value = await recurse(df.value);
-          table.set(key, value, sf);
+          void table.set(key, selectVal(value), sf);
           break;
         }
         case "ExpressionField": {
           const ef = field as LuaExpressionField;
           const value = await recurse(ef.value);
-          table.rawSetArrayIndex(nextArrayIndex, value);
+          table.rawSetArrayIndex(nextArrayIndex, selectVal(value));
           nextArrayIndex++;
           break;
         }
@@ -365,30 +423,16 @@ export async function evalExpressionWithAggregates(
     }
     const left = singleResult(await recurse(bin.left));
     const right = singleResult(await recurse(bin.right));
-    return luaOp(
-      bin.operator,
-      left,
-      right,
-      undefined,
-      undefined,
-      expr.ctx,
-      sf,
-    );
+    return luaOp(bin.operator, left, right, undefined, undefined, expr.ctx, sf);
   }
   if (expr.type === "Unary") {
     const un = expr as LuaUnaryExpression;
     const arg = singleResult(await recurse(un.argument));
     switch (un.operator) {
       case "-":
-        return typeof arg === "number" ? -arg : luaOp(
-          "-",
-          0,
-          arg,
-          undefined,
-          undefined,
-          expr.ctx,
-          sf,
-        );
+        return typeof arg === "number"
+          ? -arg
+          : luaOp("-", 0, arg, undefined, undefined, expr.ctx, sf);
       case "not":
         return !luaTruthy(arg);
       case "#":
@@ -447,14 +491,11 @@ function normalizeSelectResults(results: any[]): any[] {
     const rebuilt = new LuaTable();
     for (const k of canonicalKeys) {
       const v = item.rawGet(k);
-      rebuilt.rawSet(
-        k,
-        (v === undefined || v === null) ? LIQ_NULL : v,
-      );
+      void rebuilt.rawSet(k, v === undefined || v === null ? LIQ_NULL : v);
     }
     for (const k of luaKeys(item)) {
       if (typeof k !== "string") {
-        rebuilt.rawSet(k, item.rawGet(k));
+        void rebuilt.rawSet(k, item.rawGet(k));
       }
     }
     results[i] = rebuilt;
@@ -487,14 +528,10 @@ async function usingCompare(
   keyIdx: number,
 ): Promise<number> {
   const res = luaTruthy(
-    singleResult(
-      await luaCall(luaCmp, [aVal, bVal], sf.astCtx ?? {}, sf),
-    ),
+    singleResult(await luaCall(luaCmp, [aVal, bVal], sf.astCtx ?? {}, sf)),
   );
   const reverseRes = luaTruthy(
-    singleResult(
-      await luaCall(luaCmp, [bVal, aVal], sf.astCtx ?? {}, sf),
-    ),
+    singleResult(await luaCall(luaCmp, [bVal, aVal], sf.astCtx ?? {}, sf)),
   );
 
   // both true means SWO violation
@@ -526,6 +563,7 @@ async function precomputeSortKeys(
   sf: LuaStackFrame,
   grouped: boolean,
   selectResults: any[] | undefined,
+  config: Config,
 ): Promise<any[][]> {
   const allKeys: any[][] = new Array(results.length);
   for (let i = 0; i < results.length; i++) {
@@ -551,6 +589,7 @@ async function precomputeSortKeys(
           groupTable,
           objectVariable,
           env,
+          config,
         );
       } else {
         keys[j] = await evalExpression(orderBy[j].expr, itemEnv, sf);
@@ -583,8 +622,8 @@ async function sortKeyCompare(
     const bVal = bKeys[idx];
 
     // Handle nulls positioning
-    const aIsNull = aVal === null || aVal === undefined;
-    const bIsNull = bVal === null || bVal === undefined;
+    const aIsNull = aVal === null || aVal === undefined || isSqlNull(aVal);
+    const bIsNull = bVal === null || bVal === undefined || isSqlNull(bVal);
     if (aIsNull || bIsNull) {
       if (aIsNull && bIsNull) continue;
       // Default: nulls last for asc, nulls first for desc
@@ -625,23 +664,35 @@ async function sortKeyCompare(
   return 0;
 }
 
+// Build a select-result table from a non-aggregate select expression
+async function evalSelectExpression(
+  selectExpr: LuaExpression,
+  itemEnv: LuaEnv,
+  sf: LuaStackFrame,
+): Promise<LuaValue> {
+  const result = await evalExpression(selectExpr, itemEnv, sf);
+  if (!(result instanceof LuaTable)) return result;
+  for (const k of luaKeys(result)) {
+    const v = result.rawGet(k);
+    if (v === null || v === undefined) {
+      void result.rawSet(k, LIQ_NULL);
+    }
+  }
+  return result;
+}
+
 export async function applyQuery(
   results: any[],
   query: LuaCollectionQuery,
   env: LuaEnv,
   sf: LuaStackFrame,
-  collation?: QueryCollationConfig,
+  config: Config = new Config(),
 ): Promise<any[]> {
   results = results.slice();
   if (query.where) {
     const filteredResults = [];
     for (const value of results) {
-      const itemEnv = buildItemEnvLocal(
-        query.objectVariable,
-        value,
-        env,
-        sf,
-      );
+      const itemEnv = buildItemEnvLocal(query.objectVariable, value, env, sf);
       if (await evalExpression(query.where, itemEnv, sf)) {
         filteredResults.push(value);
       }
@@ -649,62 +700,72 @@ export async function applyQuery(
     results = filteredResults;
   }
 
+  // Implicit single group
+  if (
+    !query.groupBy &&
+    ((query.select && containsAggregate(query.select, config)) ||
+      (query.having && containsAggregate(query.having, config)))
+  ) {
+    query = { ...query, groupBy: [] };
+  }
+
   const grouped = !!query.groupBy;
 
   // Collect group-by key names for unpacking into the post-group environment.
   let groupByNames: string[] | undefined;
 
   if (query.groupBy) {
-    // Extract bare names from group-by expressions for local binding
-    groupByNames = query.groupBy.map((expr) => {
-      if (expr.type === "Variable") {
-        return expr.name;
-      }
-      if (expr.type === "PropertyAccess") {
-        return expr.property;
-      }
-      return undefined as unknown as string;
-    }).filter(Boolean);
+    // Extract expressions and names from `group by` entries
+    const groupByEntries = query.groupBy;
 
-    const groups = new Map<
-      string,
-      { key: any; items: any[] }
-    >();
-    const groupByExprs = query.groupBy as LuaExpression[];
+    // Derive canonical name (explicit alias first, or from expression)
+    groupByNames = groupByEntries
+      .map((entry) => {
+        if (entry.alias) return entry.alias;
+        if (entry.expr.type === "Variable") return entry.expr.name;
+        if (entry.expr.type === "PropertyAccess") return entry.expr.property;
+        return undefined as unknown as string;
+      })
+      .filter(Boolean);
+
+    const groups = new Map<string | symbol, { key: any; items: any[] }>();
 
     for (const item of results) {
-      const itemEnv = buildItemEnvLocal(
-        query.objectVariable,
-        item,
-        env,
-        sf,
-      );
+      const itemEnv = buildItemEnvLocal(query.objectVariable, item, env, sf);
 
       const keyParts: any[] = [];
       const keyRecord: Record<string, any> = {};
 
-      for (const expr of groupByExprs) {
-        if (expr.type === "Variable") {
-          const v = await evalExpression(expr, itemEnv, sf);
-          keyParts.push(v);
-          keyRecord[expr.name] = v;
-        } else if (expr.type === "PropertyAccess") {
-          const v = await evalExpression(expr, itemEnv, sf);
-          keyParts.push(v);
-          keyRecord[expr.property] = v;
-        } else {
-          const v = await evalExpression(expr, itemEnv, sf);
-          keyParts.push(v);
+      for (let ei = 0; ei < groupByEntries.length; ei++) {
+        const entry = groupByEntries[ei];
+        const v = await evalExpression(entry.expr, itemEnv, sf);
+        keyParts.push(v);
+        // Use alias if provided, or from expression
+        const name =
+          entry.alias ??
+          (entry.expr.type === "Variable" ? entry.expr.name : undefined) ??
+          (entry.expr.type === "PropertyAccess"
+            ? entry.expr.property
+            : undefined);
+        if (name) {
+          keyRecord[name] = v;
         }
       }
 
-      const compositeKey = keyParts.length === 1
-        ? generateKey(keyParts[0])
-        : JSON.stringify(keyParts.map(generateKey));
+      // Implicit single group uses a symbol key
+      const compositeKey: string | symbol =
+        keyParts.length === 0
+          ? IMPLICIT_GROUP_KEY
+          : keyParts.length === 1
+            ? generateKey(keyParts[0])
+            : JSON.stringify(keyParts.map(generateKey));
       let entry = groups.get(compositeKey);
       if (!entry) {
         let keyVal: any;
-        if (keyParts.length === 1) {
+        if (keyParts.length === 0) {
+          // Implicit single group — key is `nil`
+          keyVal = null;
+        } else if (keyParts.length === 1) {
           keyVal = keyParts[0];
         } else {
           const kt = new LuaTable();
@@ -714,7 +775,7 @@ export async function applyQuery(
           }
           // Additionally set named fields for Variable/PropertyAccess exprs
           for (const name in keyRecord) {
-            kt.rawSet(name, keyRecord[name]);
+            void kt.rawSet(name, keyRecord[name]);
           }
           keyVal = kt;
         }
@@ -734,15 +795,14 @@ export async function applyQuery(
         const item = items[i];
         groupTable.rawSetArrayIndex(
           i + 1,
-          (item instanceof LuaTable || typeof item !== "object" ||
-              item === null)
+          item instanceof LuaTable || typeof item !== "object" || item === null
             ? item
             : jsToLuaValue(item),
         );
       }
       const row = new LuaTable();
-      row.rawSet("key", key);
-      row.rawSet("group", groupTable);
+      void row.rawSet("key", key);
+      void row.rawSet("group", groupTable);
       results.push(row);
     }
   }
@@ -767,14 +827,10 @@ export async function applyQuery(
           groupTable,
           query.objectVariable,
           env,
+          config,
         );
       } else {
-        const itemEnv = buildItemEnvLocal(
-          query.objectVariable,
-          value,
-          env,
-          sf,
-        );
+        const itemEnv = buildItemEnvLocal(query.objectVariable, value, env, sf);
         condResult = await evalExpression(query.having, itemEnv, sf);
       }
       if (condResult) {
@@ -785,28 +841,27 @@ export async function applyQuery(
   }
 
   const mkEnv = grouped
-    ? (
-      ov: string | undefined,
-      item: any,
-      e: LuaEnv,
-      s: LuaStackFrame,
-    ) => buildGroupItemEnv(ov, groupByNames, item, e, s)
+    ? (ov: string | undefined, item: any, e: LuaEnv, s: LuaStackFrame) =>
+        buildGroupItemEnv(ov, groupByNames, item, e, s)
     : buildItemEnvLocal;
 
   let selectResults: any[] | undefined;
 
+  // Pre-compute select for grouped + ordered queries
   if (grouped && query.select && query.orderBy) {
+    const selectExpr = query.select;
     selectResults = [];
     for (const item of results) {
       const itemEnv = mkEnv(query.objectVariable, item, env, sf);
       const groupTable = (item as LuaTable).rawGet("group");
       const selected = await evalExpressionWithAggregates(
-        query.select,
+        selectExpr,
         itemEnv,
         sf,
         groupTable,
         query.objectVariable,
         env,
+        config,
       );
       selectResults.push(selected);
     }
@@ -814,10 +869,7 @@ export async function applyQuery(
   }
 
   if (query.orderBy) {
-    if (collation === undefined) {
-      const config = globalThis.client.config;
-      collation = config.get("queryCollation", {});
-    }
+    const collation = config.get<QueryCollationConfig>("queryCollation", {});
     const collator = Intl.Collator(collation?.locale, collation?.options);
 
     const resolvedUsing: (LuaValue | null)[] = [];
@@ -837,6 +889,7 @@ export async function applyQuery(
       sf,
       grouped,
       selectResults,
+      config,
     );
 
     // Tag each result with its original index for stable sorting
@@ -855,7 +908,8 @@ export async function applyQuery(
         resolvedUsing,
         violated,
         sf,
-      ));
+      ),
+    );
 
     // Check for SWO violations in comparators
     for (let i = 0; i < violated.length; i++) {
@@ -884,6 +938,7 @@ export async function applyQuery(
   }
 
   if (query.select) {
+    const selectExpr = query.select;
     if (selectResults) {
       results = selectResults;
     } else {
@@ -894,16 +949,17 @@ export async function applyQuery(
           const groupTable = (item as LuaTable).rawGet("group");
           newResult.push(
             await evalExpressionWithAggregates(
-              query.select,
+              selectExpr,
               itemEnv,
               sf,
               groupTable,
               query.objectVariable,
               env,
+              config,
             ),
           );
         } else {
-          newResult.push(await evalExpression(query.select, itemEnv, sf));
+          newResult.push(await evalSelectExpression(query.select, itemEnv, sf));
         }
       }
       results = newResult;
@@ -942,17 +998,16 @@ export async function queryLua<T = any>(
   env: LuaEnv,
   sf: LuaStackFrame = LuaStackFrame.lostFrame,
   enricher?: (key: KvKey, item: any) => any,
+  config?: Config,
 ): Promise<T[]> {
   const results: T[] = [];
-  for await (
-    let { key, value } of kv.query({ prefix })
-  ) {
+  for await (let { key, value } of kv.query({ prefix })) {
     if (enricher) {
       value = enricher(key, value);
     }
     results.push(value);
   }
-  return applyQuery(results, query, env, sf);
+  return applyQuery(results, query, env, sf, config);
 }
 
 function generateKey(value: any) {
@@ -979,8 +1034,8 @@ function luaTableToJSWithNulls(
         isSqlNull(v)
           ? "__SQL_NULL__"
           : v instanceof LuaTable
-          ? luaTableToJSWithNulls(v, sf)
-          : v,
+            ? luaTableToJSWithNulls(v, sf)
+            : v,
       );
     }
     return arr;
@@ -991,8 +1046,8 @@ function luaTableToJSWithNulls(
     obj[key] = isSqlNull(v)
       ? "__SQL_NULL__"
       : v instanceof LuaTable
-      ? luaTableToJSWithNulls(v, sf)
-      : v;
+        ? luaTableToJSWithNulls(v, sf)
+        : v;
   }
   return obj;
 }
@@ -1006,7 +1061,16 @@ export class DataStoreQueryCollection implements LuaQueryCollection {
     query: LuaCollectionQuery,
     env: LuaEnv,
     sf: LuaStackFrame,
+    config?: Config,
   ): Promise<any[]> {
-    return queryLua(this.dataStore.kv, this.prefix, query, env, sf);
+    return queryLua(
+      this.dataStore.kv,
+      this.prefix,
+      query,
+      env,
+      sf,
+      undefined,
+      config,
+    );
   }
 }