Update docs

Author: aritchie

src/content/docs/release-notes/sqlite-documentdb.mdx

@@ -5,27 +5,26 @@ tableOfContents: true
 
 import RN from '/src/components/ReleaseNote.astro';
 
-## 1.2 - February 24, 2026
-<RN type="feature">Expression-based OrderBy (ascending/descending) on all GetAll, Query, GetAllStream, and QueryStream methods — translates to ORDER BY json_extract SQL</RN>
-<RN type="feature">Scalar aggregates: Max, Min, Sum, Average with optional predicate filters</RN>
-<RN type="feature">Aggregate projections with automatic GROUP BY via Sql.Count(), Sql.Max(), Sql.Min(), Sql.Sum(), Sql.Avg() marker methods</RN>
-<RN type="feature">Collection-level aggregates in projections: Sum, Min, Max, Average on child collections (e.g. o.Lines.Sum(l => l.Quantity))</RN>
-
-## 1.1 - February 23, 2026
-<RN type="feature">SetProperty — update a single scalar JSON field via json_set without deserializing the document. Supports nested paths (e.g. o.ShippingAddress.City)</RN>
-<RN type="feature">RemoveProperty — strip a field from the stored JSON via json_remove. Works on any property type including collections and nested objects</RN>
-<RN type="feature">Both SetProperty and RemoveProperty have reflection-based and AOT-safe overloads, and work inside transactions</RN>
-
-## 1.0 - February 22, 2026
-<RN type="feature">Initial Public Release</RN>
+## 1.0 - February 2026
 <RN type="feature">Schema-free JSON document storage on top of SQLite</RN>
 <RN type="feature">LINQ expression queries translated to json_extract SQL with support for equality, comparisons, logical operators, null checks, string methods, nested properties, and collection queries</RN>
-<RN type="feature">SQL-level projections via json_object for extracting specific fields without full deserialization</RN>
-<RN type="feature">IAsyncEnumerable streaming with GetAllStream and QueryStream</RN>
+<RN type="feature">Fluent query builder (IDocumentQuery) — chain .Where(), .OrderBy(), .OrderByDescending(), .GroupBy(), .Paginate(), .Select() and terminate with .ToList(), .ToAsyncEnumerable(), .Count(), .Any(), .Remove(), .Max(), .Min(), .Sum(), .Average()</RN>
+<RN type="feature">Pagination via .Paginate(offset, take) — translates to SQL LIMIT/OFFSET</RN>
+<RN type="feature">Expression-based ordering — .OrderBy(u => u.Age) and .OrderByDescending(u => u.Name) on the fluent query builder</RN>
+<RN type="feature">SQL-level projections via .Select() using json_object for extracting specific fields without full deserialization</RN>
+<RN type="feature">IAsyncEnumerable streaming via .ToAsyncEnumerable() — yield results one-at-a-time without buffering</RN>
 <RN type="feature">Expression-based JSON indexes for up to 30x faster queries on indexed properties</RN>
-<RN type="feature">Full AOT and trimming support with JsonTypeInfo overloads on every API</RN>
-<RN type="feature">Auto-resolving type info from configured JsonSerializerContext</RN>
+<RN type="feature">Full AOT and trimming support — all JsonTypeInfo parameters are optional and auto-resolve from configured JsonSerializerContext</RN>
+<RN type="feature">Scalar aggregates: .Max(), .Min(), .Sum(), .Average() as terminal methods on the query builder</RN>
+<RN type="feature">Aggregate projections with automatic GROUP BY via Sql.Count(), Sql.Max(), Sql.Min(), Sql.Sum(), Sql.Avg() marker methods</RN>
+<RN type="feature">Collection-level aggregates in projections: Sum, Min, Max, Average on child collections (e.g. o.Lines.Sum(l => l.Quantity))</RN>
+<RN type="feature">JSON Merge Patch (Upsert) — deep-merge partial objects into existing documents via json_patch (RFC 7396)</RN>
+<RN type="feature">SetProperty — update a single scalar JSON field via json_set without deserializing the document. Supports nested paths</RN>
+<RN type="feature">RemoveProperty — strip a field from the stored JSON via json_remove. Works on any property type</RN>
+<RN type="feature">Bulk delete via query builder — .Where(predicate).Remove() returns count of deleted documents</RN>
 <RN type="feature">Transactions with automatic commit/rollback via RunInTransaction</RN>
 <RN type="feature">Dependency injection registration via AddSqliteDocumentStore</RN>
 <RN type="feature">Configurable type name resolution (ShortName or FullName)</RN>
 <RN type="feature">UseReflectionFallback option for strict AOT enforcement</RN>
+<RN type="feature">SQL logging callback via DocumentStoreOptions.Logging</RN>
+<RN type="feature">Raw SQL query and streaming support via store.Query(whereClause) and store.QueryStream(whereClause)</RN>

src/content/docs/sqlite-docdb/aggregates.mdx

@@ -4,16 +4,16 @@ title: Aggregates
 
 ## Scalar Aggregates
 
-Compute a single aggregate value across all documents of a type, or filtered by a predicate. All scalar aggregates are AOT-safe.
+Compute a single aggregate value across documents using terminal methods on the fluent query builder.
 
 ### Max / Min
 
 ```csharp
-var maxAge = await store.Max<User, int>(u => u.Age, ctx.User);
-var minAge = await store.Min<User, int>(u => u.Age, ctx.User);
+var maxAge = await store.Query<User>().Max(u => u.Age);
+var minAge = await store.Query<User>().Min(u => u.Age);
 
 // With predicate filter
-var maxAge = await store.Max<User, int>(u => u.Age < 35, u => u.Age, ctx.User);
+var maxAge = await store.Query<User>().Where(u => u.Age < 35).Max(u => u.Age);
 ```
 
 Generated SQL:
@@ -24,20 +24,19 @@ SELECT MAX(json_extract(Data, '$.age')) FROM documents WHERE TypeName = @typeNam
 ### Sum
 
 ```csharp
-var totalAge = await store.Sum<User, int>(u => u.Age, ctx.User);
-var totalPrice = await store.Sum<Product, decimal>(p => p.Price, ctx.Product);
+var totalAge = await store.Query<User>().Sum(u => u.Age);
 
 // With predicate filter
-var over25 = await store.Sum<User, int>(u => u.Age > 25, u => u.Age, ctx.User);
+var over25 = await store.Query<User>().Where(u => u.Age > 25).Sum(u => u.Age);
 ```
 
 ### Average
 
 ```csharp
-var avgAge = await store.Average<User>(u => u.Age, ctx.User);
+var avgAge = await store.Query<User>().Average(u => u.Age);
 
 // With predicate filter
-var avgAge = await store.Average<User>(u => u.Age > 25, u => u.Age, ctx.User);
+var avgAge = await store.Query<User>().Where(u => u.Age > 25).Average(u => u.Age);
 ```
 
 Returns `double`. Returns `0d` for empty result sets.
@@ -46,7 +45,7 @@ Returns `double`. Returns `0d` for empty result sets.
 
 ## Aggregate Projections (GROUP BY)
 
-Use the `Sql` marker class to build aggregate projections with automatic GROUP BY. Non-aggregate columns are automatically grouped.
+Use the `Sql` marker class to build aggregate projections with automatic GROUP BY via `.Select()`. Non-aggregate columns are automatically grouped.
 
 ### Available Sql Markers
 
@@ -61,14 +60,13 @@ Use the `Sql` marker class to build aggregate projections with automatic GROUP B
 ### Group By with Count
 
 ```csharp
-var results = await store.Aggregate<Order, OrderStats>(
-    o => new OrderStats
+var results = await store.Query<Order>()
+    .Select(o => new OrderStats
     {
         Status = o.Status,            // GROUP BY column
         OrderCount = Sql.Count(),     // COUNT(*)
-    },
-    ctx.Order,
-    ctx.OrderStats);
+    })
+    .ToList();
 // Status = "Shipped", OrderCount = 2
 // Status = "Pending", OrderCount = 1
 ```
@@ -78,50 +76,56 @@ var results = await store.Aggregate<Order, OrderStats>(
 When every column uses a `Sql.*` marker, no GROUP BY is generated — the query returns a single summary row.
 
 ```csharp
-var results = await store.Aggregate<Product, PriceSummary>(
-    p => new PriceSummary
+var results = await store.Query<Product>()
+    .Select(p => new PriceSummary
     {
         TotalCount = Sql.Count(),
         MaxPrice = Sql.Max(p.Price),
         MinPrice = Sql.Min(p.Price),
         SumPrice = Sql.Sum(p.Price),
         AvgPrice = Sql.Avg(p.Price),
-    },
-    ctx.Product,
-    ctx.PriceSummary);
+    })
+    .ToList();
 ```
 
 ### With Predicate Filter
 
 ```csharp
-var results = await store.Aggregate<Order, OrderStats>(
-    o => o.Status == "Shipped",          // WHERE filter
-    o => new OrderStats
+var results = await store.Query<Order>()
+    .Where(o => o.Status == "Shipped")          // WHERE filter
+    .Select(o => new OrderStats
     {
         Status = o.Status,
         OrderCount = Sql.Count(),
-    },
-    ctx.Order,
-    ctx.OrderStats);
+    })
+    .ToList();
+```
+
+### Explicit GroupBy
+
+```csharp
+var results = await store.Query<Order>()
+    .GroupBy(o => o.Status)
+    .Select(o => new OrderStats { Status = o.Status, OrderCount = Sql.Count() })
+    .ToList();
 ```
 
 ---
 
 ## Collection Aggregates in Projections
 
-Aggregate over child collections within a single document using standard LINQ methods in projection expressions.
+Aggregate over child collections within a single document using standard LINQ methods in `.Select()` projection expressions.
 
 ### Sum on Collection
 
 ```csharp
-var results = await store.GetAll<Order, OrderLineAggregates>(
-    o => new OrderLineAggregates
+var results = await store.Query<Order>()
+    .Select(o => new OrderLineAggregates
     {
         Customer = o.CustomerName,
         TotalQty = o.Lines.Sum(l => l.Quantity)
-    },
-    ctx.Order,
-    ctx.OrderLineAggregates);
+    })
+    .ToList();
 ```
 
 Generated SQL:
@@ -135,30 +139,31 @@ SELECT json_object(
 ### Max / Min on Collection
 
 ```csharp
-o => new OrderLineAggregates
-{
-    Customer = o.CustomerName,
-    MaxPrice = o.Lines.Max(l => l.UnitPrice),
-    MinPrice = o.Lines.Min(l => l.UnitPrice)
-}
+var results = await store.Query<Order>()
+    .Select(o => new OrderLineAggregates
+    {
+        Customer = o.CustomerName,
+        MaxPrice = o.Lines.Max(l => l.UnitPrice),
+        MinPrice = o.Lines.Min(l => l.UnitPrice)
+    })
+    .ToList();
 ```
 
 ### Multiple Collection Aggregates
 
 Combine multiple collection aggregates in a single projection:
 
 ```csharp
-var results = await store.Query<Order, OrderLineAggregates>(
-    o => o.CustomerName == "Alice",
-    o => new OrderLineAggregates
+var results = await store.Query<Order>()
+    .Where(o => o.CustomerName == "Alice")
+    .Select(o => new OrderLineAggregates
     {
         Customer = o.CustomerName,
         TotalQty = o.Lines.Sum(l => l.Quantity),
         MaxPrice = o.Lines.Max(l => l.UnitPrice),
         MinPrice = o.Lines.Min(l => l.UnitPrice),
-    },
-    ctx.Order,
-    ctx.OrderLineAggregates);
+    })
+    .ToList();
 ```
 
 ### Collection Aggregate Reference

src/content/docs/sqlite-docdb/aot.mdx

@@ -52,42 +52,37 @@ var store = new SqliteDocumentStore(new DocumentStoreOptions
 });
 ```
 
-## Auto-resolving type info from the context
+## Optional JsonTypeInfo<T> parameters
 
-When a `JsonSerializerContext` is attached to `JsonSerializerOptions`, the reflection-marked overloads (without `JsonTypeInfo<T>`) automatically resolve type info from the configured resolver. You can configure the context once and skip passing `JsonTypeInfo<T>` on every call — while retaining full AOT safety.
+All `JsonTypeInfo<T>` parameters across the entire API are optional (`= null` default). When omitted, type info is automatically resolved from the configured `JsonSerializerOptions.TypeInfoResolver`. You can configure a `JsonSerializerContext` once and skip passing `JsonTypeInfo<T>` on every call — while retaining full AOT safety.
 
-| Without resolver (explicit `JsonTypeInfo<T>`) | With resolver (auto-resolved) |
+| With explicit `JsonTypeInfo<T>` | With auto-resolution (recommended) |
 |---|---|
 | `store.Set(user, ctx.User)` | `store.Set(user)` |
 | `store.Set("id", user, ctx.User)` | `store.Set("id", user)` |
-| `store.Get<User>("id", ctx.User)` | `store.Get<User>("id")` |
-| `store.GetAll<User>(ctx.User)` | `store.GetAll<User>()` |
+| `store.Get("id", ctx.User)` | `store.Get<User>("id")` |
 | `store.Upsert("id", patch, ctx.User)` | `store.Upsert("id", patch)` |
 | `store.SetProperty("id", (User u) => u.Age, 31, ctx.User)` | `store.SetProperty<User>("id", u => u.Age, 31)` |
 | `store.RemoveProperty("id", (User u) => u.Email, ctx.User)` | `store.RemoveProperty<User>("id", u => u.Email)` |
-| `store.Query<User>(sql, ctx.User, parms)` | `store.Query<User>(sql, parms)` |
-| `store.GetAllStream<User>(ctx.User)` | `store.GetAllStream<User>()` |
-| `store.QueryStream<User>(sql, ctx.User, parms)` | `store.QueryStream<User>(sql, parms)` |
+| `store.Query(ctx.User)` | `store.Query<User>()` |
+| `store.Query<User>("sql", ctx.User, parms)` | `store.Query<User>("sql", parameters: parms)` |
+| `store.QueryStream<User>("sql", ctx.User, parms)` | `store.QueryStream<User>("sql", parameters: parms)` |
 
 ```csharp
 // All of these are AOT-safe when ctx.Options is configured
 var id = await store.Set(new User { Name = "Alice", Age = 25 });
 var user = await store.Get<User>(id);
-var all = await store.GetAll<User>();
+var all = await store.Query<User>().ToList();
 await store.Upsert("user-1", new User { Name = "Alice", Age = 30 });
 
 var results = await store.Query<User>(
     "json_extract(Data, '$.age') > @minAge",
-    new { minAge = 30 });
+    parameters: new { minAge = 30 });
 
-await foreach (var u in store.GetAllStream<User>())
+await foreach (var u in store.Query<User>().ToAsyncEnumerable())
     Console.WriteLine(u.Name);
 ```
 
-:::note
-Expression-based queries (`store.Query(u => u.Age > 30, ctx.User)`) and projections always require explicit `JsonTypeInfo<T>` because the LINQ expression visitor needs type metadata to resolve JSON property names. Auto-resolution applies to the 10 methods in the table above.
-:::
-
 ## Disabling reflection fallback
 
 By default (`UseReflectionFallback = true`), if no resolver is configured or the type isn't registered, methods fall back to reflection-based serialization. This preserves backwards compatibility.

src/content/docs/sqlite-docdb/crud.mdx

@@ -6,10 +6,10 @@ title: CRUD Operations
 
 ```csharp
 // Auto-generated GUID key — returns the ID
-var id = await store.Set(new User { Name = "Alice", Age = 25 }, ctx.User);
+var id = await store.Set(new User { Name = "Alice", Age = 25 });
 
 // Explicit key
-await store.Set("user-1", new User { Name = "Alice", Age = 25 }, ctx.User);
+await store.Set("user-1", new User { Name = "Alice", Age = 25 });
 ```
 
 ## Upsert with JSON Merge Patch
@@ -18,12 +18,12 @@ await store.Set("user-1", new User { Name = "Alice", Age = 25 }, ctx.User);
 
 ```csharp
 // Insert a full document
-await store.Set("user-1", new User { Name = "Alice", Age = 25, Email = "alice@test.com" }, ctx.User);
+await store.Set("user-1", new User { Name = "Alice", Age = 25, Email = "alice@test.com" });
 
 // Merge patch — only update Name and Age, preserve Email
-await store.Upsert("user-1", new User { Name = "Alice", Age = 30 }, ctx.User);
+await store.Upsert("user-1", new User { Name = "Alice", Age = 30 });
 
-var user = await store.Get<User>("user-1", ctx.User);
+var user = await store.Get<User>("user-1");
 // user.Name == "Alice", user.Age == 30, user.Email == "alice@test.com" (preserved)
 ```
 
@@ -42,19 +42,19 @@ For true partial updates, use nullable properties in your patch type so that uns
 
 ```csharp
 // Update a scalar field
-await store.SetProperty<User>("user-1", u => u.Age, 31, ctx.User);
+await store.SetProperty<User>("user-1", u => u.Age, 31);
 
 // Update a string field
-await store.SetProperty<User>("user-1", u => u.Email, "newemail@test.com", ctx.User);
+await store.SetProperty<User>("user-1", u => u.Email, "newemail@test.com");
 
 // Set a field to null
-await store.SetProperty<User>("user-1", u => u.Email, null, ctx.User);
+await store.SetProperty<User>("user-1", u => u.Email, null);
 
 // Nested property
-await store.SetProperty<Order>("order-1", o => o.ShippingAddress.City, "Portland", ctx.Order);
+await store.SetProperty<Order>("order-1", o => o.ShippingAddress.City, "Portland");
 
 // Check if document existed
-bool updated = await store.SetProperty<User>("user-1", u => u.Age, 31, ctx.User);
+bool updated = await store.SetProperty<User>("user-1", u => u.Age, 31);
 ```
 
 **How it works:** The expression `u => u.Age` is resolved to the JSON path `$.age` (respecting `[JsonPropertyName]` attributes and naming policies). The SQL executed is:
@@ -73,13 +73,13 @@ WHERE Id = @id AND TypeName = @typeName;
 
 ```csharp
 // Remove a nullable field
-await store.RemoveProperty<User>("user-1", u => u.Email, ctx.User);
+await store.RemoveProperty<User>("user-1", u => u.Email);
 
 // Remove a nested property
-await store.RemoveProperty<Order>("order-1", o => o.ShippingAddress.City, ctx.Order);
+await store.RemoveProperty<Order>("order-1", o => o.ShippingAddress.City);
 
 // Remove a collection property (removes the entire array)
-await store.RemoveProperty<Order>("order-1", o => o.Tags, ctx.Order);
+await store.RemoveProperty<Order>("order-1", o => o.Tags);
 ```
 
 Unlike `SetProperty`, `RemoveProperty` works on any property type — scalar, nested object, or collection — because it simply removes the key from the JSON.
@@ -96,25 +96,31 @@ Unlike `SetProperty`, `RemoveProperty` works on any property type — scalar, ne
 ## Get a document
 
 ```csharp
-var user = await store.Get<User>("user-1", ctx.User);
+var user = await store.Get<User>("user-1");
 ```
 
 ## Get all documents of a type
 
 ```csharp
-var users = await store.GetAll<User>(ctx.User);
+var users = await store.Query<User>().ToList();
 ```
 
 ## Remove a document
 
 ```csharp
 // By ID
 bool deleted = await store.Remove<User>("user-1");
+```
+
+## Remove documents matching a predicate
 
-// By expression — returns number deleted
-int deleted = await store.Remove<User>(u => u.Age < 18, ctx.User);
+```csharp
+// Returns number of deleted rows
+int deleted = await store.Query<User>().Where(u => u.Age < 18).Remove();
 ```
 
+See [Querying](/sqlite-docdb/querying) for more examples of removing with expressions.
+
 ## Clear all documents of a type
 
 ```csharp