fix(fumadb): mirror aggregate review hardening (#62)

## Summary

Mirrors the review-hardening deltas from upstream
[RhysSullivan#1119](RhysSullivan#1119)
onto `dev`.

`dev` already contains the broader FumaDB aggregate and keyset query
feature, so this PR only carries the remaining drift from the upstream
review loop.

## Changes

- Preserve memory and Drizzle parity for empty composite filters by
compiling empty JSON `or` filters to a constant false SQL predicate.
- Add regression coverage for empty `or` and empty `and` filters across
the aggregate harness.
- Replace nested plugin-storage operator selection with an explicit
typed JSON compare-operator map.
- Document SQLite percentile behavior on the public FumaDB and
plugin-storage stats inputs.

## Intentional Differences From Upstream RhysSullivan#1119

- This PR does not re-add the full aggregate and keyset implementation
because `dev` already has that feature surface.
- This PR does not touch the OpenAPI storage facade mock because `dev`
already has the mock shape needed by the expanded collection facade.
- This PR has no changeset because it only mirrors fixes to an existing
`dev` feature surface.

## Tests

- `bun run bootstrap`
- `bun run --cwd packages/core/fumadb test --
src/query/aggregate.test.ts src/query/table-policy.test.ts`
- `bun run --cwd packages/core/sdk test --
src/plugin-storage-aggregate.test.ts src/plugin-storage.test.ts`
- `bun run --cwd packages/core/fumadb typecheck`
- `bun run --cwd packages/core/sdk typecheck`
- `bun run typecheck`
- `./node_modules/.bin/oxfmt --check
packages/core/fumadb/src/adapters/drizzle/query.ts
packages/core/fumadb/src/query/aggregate.test.ts
packages/core/fumadb/src/query/aggregate.ts
packages/core/sdk/src/executor.ts
packages/core/sdk/src/plugin-storage.ts`

Author: aryasaatvik

packages/core/fumadb/src/adapters/drizzle/query.ts

@@ -362,6 +362,7 @@ export function fromDrizzle(
       );
     }
     if (filter.kind === "or") {
+      if (filter.items.length === 0) return Drizzle.sql`1 = 0`;
       return Drizzle.or(
         ...filter.items.map((item) => buildJsonFilter(jsonColumn, item)),
       );

packages/core/fumadb/src/query/aggregate.test.ts

@@ -128,6 +128,24 @@ const runSuite = (name: string, makeHarness: () => Promise<Harness>) => {
       ).toBe(2);
     });
 
+    it("matches empty composite filter semantics", async () => {
+      const { orm } = harness;
+      expect(
+        await orm.jsonCount("events", {
+          column: "data",
+          where: inT1,
+          filter: { kind: "or", items: [] },
+        }),
+      ).toBe(0);
+      expect(
+        await orm.jsonCount("events", {
+          column: "data",
+          where: inT1,
+          filter: { kind: "and", items: [] },
+        }),
+      ).toBe(4);
+    });
+
     it("jsonGroupCount counts distinct values", async () => {
       const rows = await harness.orm.jsonGroupCount("events", {
         column: "data",

packages/core/fumadb/src/query/aggregate.ts

@@ -91,7 +91,13 @@ export interface JsonTimeBucketRow {
 export interface JsonStatsAdapterOptions extends JsonAdapterBase {
   /** Numeric path the stats are computed over. */
   readonly path: JsonPath;
-  /** Percentile fractions in [0, 1] (e.g. 0.5, 0.95). */
+  /**
+   * Percentile fractions in [0, 1] (e.g. 0.5, 0.95).
+   *
+   * SQLite adapters compute percentiles from all matching numeric values after
+   * projection because SQLite has no native percentile aggregate. Count, min,
+   * and max still run as SQL aggregates.
+   */
   readonly percentiles?: readonly number[];
 }
 
@@ -155,6 +161,13 @@ export interface JsonTimeBucketOptions<TColumns extends Record<string, AnyColumn
 export interface JsonStatsOptions<TColumns extends Record<string, AnyColumn>>
   extends JsonPublicBase<TColumns> {
   readonly path: JsonPath;
+  /**
+   * Percentile fractions in [0, 1] (e.g. 0.5, 0.95).
+   *
+   * SQLite adapters compute percentiles from all matching numeric values after
+   * projection because SQLite has no native percentile aggregate. Count, min,
+   * and max still run as SQL aggregates.
+   */
   readonly percentiles?: readonly number[];
 }
 

packages/core/sdk/src/executor.ts

@@ -7,6 +7,7 @@ import {
   withQueryContext,
   type Condition,
   type ConditionBuilder,
+  type JsonCompareOperator,
   type JsonFilter,
   type JsonGroupCountRow,
   type JsonKeysetCursor,
@@ -1116,6 +1117,17 @@ const isPluginStorageRecord = (value: unknown): value is Readonly<Record<string,
 
 const pluginStorageWhereOperators = ["eq", "in", "gt", "gte", "lt", "lte"] as const;
 
+const pluginStorageJsonCompareOperators = {
+  eq: "=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+} satisfies Record<
+  Exclude<(typeof pluginStorageWhereOperators)[number], "in">,
+  JsonCompareOperator
+>;
+
 const isPluginStorageWhereFilter = (value: unknown): value is Readonly<Record<string, unknown>> =>
   isPluginStorageRecord(value) && pluginStorageWhereOperators.some((operator) => operator in value);
 
@@ -1212,16 +1224,11 @@ const pluginStorageWhereToJsonFilter = (
           });
           continue;
         }
+        if (!(operator in pluginStorageJsonCompareOperators)) continue;
         const compareOperator =
-          operator === "gt"
-            ? ">"
-            : operator === "gte"
-              ? ">="
-              : operator === "lt"
-                ? "<"
-                : operator === "lte"
-                  ? "<="
-                  : "=";
+          pluginStorageJsonCompareOperators[
+            operator as keyof typeof pluginStorageJsonCompareOperators
+          ];
         items.push({
           kind: "compare",
           path,

packages/core/sdk/src/plugin-storage.ts

@@ -225,7 +225,13 @@ export interface PluginStorageStatsInput<
 > extends PluginStorageAggregateFilter<TDefinition> {
   /** Numeric field the stats are computed over. */
   readonly field: PluginStorageCollectionIndexedField<TDefinition>;
-  /** Percentile fractions in [0, 1] (e.g. 0.5, 0.95). */
+  /**
+   * Percentile fractions in [0, 1] (e.g. 0.5, 0.95).
+   *
+   * SQLite-backed storage computes percentiles from all matching numeric values
+   * after projection because SQLite has no native percentile aggregate. Count,
+   * min, and max still run as SQL aggregates.
+   */
   readonly percentiles?: readonly number[];
 }