bugfixes

Author: aritchie

src/Shiny.DocumentDb.Aspire.Client/DocumentStoreClientExtensions.cs

@@ -129,7 +129,7 @@ static DocumentProviderKind ResolveProvider(IConfiguration configuration, string
         if (!Enum.TryParse<DocumentProviderKind>(raw, ignoreCase: true, out var kind))
             throw new InvalidOperationException(
                 $"DocumentDb provider discriminator '{raw}' for store '{name}' is not a recognized DocumentProviderKind " +
-                "(Sqlite, Postgres, SqlServer, MySql).");
+                "(Sqlite, Postgres, CockroachDb, SqlServer, MySql, MariaDb).");
 
         return kind;
     }

src/Shiny.DocumentDb.Diagnostics/OperationTracker.cs

@@ -63,6 +63,14 @@ public async IAsyncEnumerable<T> TrackStream<T>(string op, string collection, IA
                     if (!await enumerator.MoveNextAsync().ConfigureAwait(false))
                         break;
                 }
+                catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                {
+                    // The consumer stopped enumerating by cancelling the token — normal termination, not an
+                    // error. Record it as "cancelled" so it isn't counted against the error rate.
+                    faulted = true;
+                    metrics.Record(system, op, collection, Stopwatch.GetElapsedTime(start), "cancelled", null, count, storeName);
+                    throw;
+                }
                 catch (Exception ex)
                 {
                     faulted = true;

src/Shiny.DocumentDb.Generators/GeneratedMetadata.cs

@@ -110,6 +110,18 @@ void Register(ITypeSymbol t, Location loc)
                 return;
             }
 
+            // Any collection other than List<T>/T[] (Dictionary, HashSet, ObservableCollection, custom
+            // IEnumerable-backed types). These have a public parameterless ctor so IsPlainObject would accept
+            // them, but walking them as objects yields no settable properties → they silently serialize as an
+            // empty {} and lose every entry. STJ serializes them as arrays/objects, which the Generated
+            // resolver doesn't model, so reject with a clear diagnostic.
+            if (t is INamedTypeSymbol coll && !coll.IsAbstract && ImplementsIEnumerable(coll))
+            {
+                diagnostics.Add(new DiagInfo(Diagnostics.UnsupportedGeneratedType, loc, full,
+                    "collection types other than List<T> and T[] (e.g. Dictionary, HashSet, ObservableCollection) are not supported by DocumentSerialization.Generated — use List<T>/array, or a different DocumentSerialization mode (Reflection/JsonContext/Auto)"));
+                return;
+            }
+
             // plain object
             if (t is INamedTypeSymbol obj && IsPlainObject(obj))
             {
@@ -134,6 +146,13 @@ void Register(ITypeSymbol t, Location loc)
                 continue;
             }
 
+            // Flag public properties STJ would persist but the Generated resolver can't set (init-only or a
+            // non-public setter) — they would be silently dropped on round-trip. Pure get-only (computed)
+            // properties are intentionally not flagged.
+            foreach (var dropped in DroppedSerializableProperties(obj))
+                diagnostics.Add(new DiagInfo(Diagnostics.UnsupportedGeneratedType, location, full,
+                    $"property '{dropped}' has an init-only or non-public setter — DocumentSerialization.Generated cannot round-trip it (it would be silently dropped); give it a public setter, mark it [JsonIgnore], or use a non-Generated DocumentSerialization mode"));
+
             var props = new List<MetaProp>();
             foreach (var member in EnumerateProperties(obj))
             {
@@ -188,6 +207,46 @@ void Register(ITypeSymbol t, Location loc)
         }
     }
 
+    static bool ImplementsIEnumerable(ITypeSymbol t)
+    {
+        if (t.SpecialType == SpecialType.System_String)
+            return false;
+        foreach (var i in t.AllInterfaces)
+            if (i.SpecialType == SpecialType.System_Collections_IEnumerable
+                || i.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
+                return true;
+        return false;
+    }
+
+    static IEnumerable<string> DroppedSerializableProperties(INamedTypeSymbol type)
+    {
+        var seen = new HashSet<string>();
+        for (var t = type; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
+        {
+            foreach (var m in t.GetMembers())
+            {
+                if (m is not IPropertySymbol p || p.IsStatic || p.IsIndexer)
+                    continue;
+                if (p.DeclaredAccessibility != Accessibility.Public)
+                    continue;
+                if (p.GetMethod is not { DeclaredAccessibility: Accessibility.Public })
+                    continue;
+                if (!seen.Add(p.Name))
+                    continue;
+                if (p.SetMethod == null)
+                    continue; // pure get-only (computed) — not a round-trip data-loss case
+                if (p.SetMethod.DeclaredAccessibility == Accessibility.Public && !p.SetMethod.IsInitOnly)
+                    continue; // properly settable — handled normally
+                var isIgnored = false;
+                foreach (var a in p.GetAttributes())
+                    if (a.AttributeClass?.ToDisplayString() == JsonIgnore) { isIgnored = true; break; }
+                if (isIgnored)
+                    continue;
+                yield return p.Name;
+            }
+        }
+    }
+
     static bool IsPlainObject(INamedTypeSymbol t)
     {
         if (t.TypeKind != TypeKind.Class && t.TypeKind != TypeKind.Struct)

src/Shiny.DocumentDb.IndexedDb/wwwroot/shiny-indexeddb.js

@@ -48,32 +48,33 @@ export async function get(storeName, key) {
 export async function put(storeName, recordJson) {
     const record = JSON.parse(recordJson);
     return new Promise((resolve, reject) => {
+        // Resolve on tx.oncomplete (commit), not request.onsuccess — IndexedDB reports commit-time failures
+        // (QuotaExceededError, constraint/abort) after the request succeeds, so resolving on the request would
+        // be a false-positive success with the write silently rolled back.
         const tx = db.transaction(storeName, 'readwrite');
-        const store = tx.objectStore(storeName);
-        const request = store.put(record);
-
-        request.onsuccess = () => resolve();
-        request.onerror = () => reject(new Error(`Put failed: ${request.error}`));
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(new Error(`Put failed: ${tx.error}`));
+        tx.onabort = () => reject(new Error(`Put aborted: ${tx.error}`));
+        tx.objectStore(storeName).put(record);
     });
 }
 
 export async function remove(storeName, key) {
     return new Promise((resolve, reject) => {
         const tx = db.transaction(storeName, 'readwrite');
         const store = tx.objectStore(storeName);
-
-        // Check if exists first
+        let existed = false;
         const getReq = store.get(key);
         getReq.onsuccess = () => {
-            if (!getReq.result) {
-                resolve(false);
-                return;
+            if (getReq.result) {
+                existed = true;
+                store.delete(key);
             }
-            const delReq = store.delete(key);
-            delReq.onsuccess = () => resolve(true);
-            delReq.onerror = () => reject(new Error(`Delete failed: ${delReq.error}`));
         };
-        getReq.onerror = () => reject(new Error(`Get failed: ${getReq.error}`));
+        // Report the outcome only once the transaction commits (so an abort surfaces as a failure).
+        tx.oncomplete = () => resolve(existed);
+        tx.onerror = () => reject(new Error(`Delete failed: ${tx.error}`));
+        tx.onabort = () => reject(new Error(`Delete aborted: ${tx.error}`));
     });
 }
 
@@ -108,25 +109,18 @@ export async function clearByTypeName(storeName, typeName) {
         const tx = db.transaction(storeName, 'readwrite');
         const store = tx.objectStore(storeName);
         const index = store.index('typeName');
+        let deleted = 0;
         const request = index.getAllKeys(typeName);
-
         request.onsuccess = () => {
-            const keys = request.result;
-            let deleted = 0;
-            if (keys.length === 0) {
-                resolve(0);
-                return;
-            }
-            for (const key of keys) {
-                const delReq = store.delete(key);
-                delReq.onsuccess = () => {
-                    deleted++;
-                    if (deleted === keys.length) resolve(deleted);
-                };
-                delReq.onerror = () => reject(new Error(`Delete failed: ${delReq.error}`));
+            for (const key of request.result) {
+                store.delete(key);
+                deleted++;
             }
         };
-        request.onerror = () => reject(new Error(`GetAllKeys failed: ${request.error}`));
+        // Resolve the count only once the whole batch commits.
+        tx.oncomplete = () => resolve(deleted);
+        tx.onerror = () => reject(new Error(`Clear failed: ${tx.error}`));
+        tx.onabort = () => reject(new Error(`Clear aborted: ${tx.error}`));
     });
 }
 

src/Shiny.DocumentDb.MongoDb/MongoDbDocumentStore.cs

@@ -860,7 +860,9 @@ public async Task<IReadOnlyList<VectorResult<T>>> NearestVectors<T>(
                     { "path", $"{MongoFields.Data}.{mapping.JsonPath}" },
                     { "queryVector", qv },
                     { "numCandidates", numCandidates },
-                    { "limit", k },
+                    // When a user predicate is post-applied, fetch a wider slice so the post-filter doesn't
+                    // truncate below k; results are trimmed to k after filtering.
+                    { "limit", filter != null ? numCandidates : k },
                     { "filter", filterDoc }
                 }
             }
@@ -906,6 +908,9 @@ public async Task<IReadOnlyList<VectorResult<T>>> NearestVectors<T>(
             var score = row.TryGetValue("score", out var sv) && sv.IsNumeric ? (float)sv.ToDouble() : float.NaN;
             results.Add(new VectorResult<T> { Document = doc, Score = score });
         }
+        // Trim the widened, post-filtered candidate set back to the requested k (rows are nearest-first).
+        if (filter != null && results.Count > k)
+            results = results.GetRange(0, k);
         return results;
     }
 

src/Shiny.DocumentDb.MySql/MySqlDatabaseProvider.cs

@@ -213,6 +213,11 @@ public string BuildBatchSkipExistingSql(string tableName, int batchSize)
         return sb.ToString();
     }
 
+    // MySQL/MariaDB treat backslash as a string-literal escape, so `ESCAPE '\'` would be a malformed literal —
+    // and LIKE already uses '\' as its default escape character, so no explicit ESCAPE clause is needed. The
+    // inherited EscapeLikePattern (which backslash-escapes %/_/\) lines up with that default.
+    public string LikeEscapeClause => "";
+
     // virtual: MariaDB rejects CAST(... AS JSON) and overrides these to use JSON_COMPACT instead.
     public virtual string BuildSetPropertySql(string tableName) => $"""
         UPDATE `{tableName}`

src/Shiny.DocumentDb.OData/FilterExpressionBuilder.cs

@@ -91,21 +91,36 @@ static Expression BuildBinary(ODataFilterNode node, ParameterExpression paramete
     static (Expression Left, Expression Right) BuildComparisonOperands(
         ODataFilterNode leftNode, ODataFilterNode rightNode, ParameterExpression parameter, JsonTypeInfo typeInfo)
     {
+        var leftIsNull = IsNullConstant(leftNode);
+        var rightIsNull = IsNullConstant(rightNode);
+
+        // Handle a null operand BEFORE binding the other side to its inferred type — building
+        // Expression.Constant(null, typeof(int)) for a non-nullable value-type property throws, so the member
+        // side must be made null-comparable (boxed to object) first.
+        if (rightIsNull && !leftIsNull)
+        {
+            var member = BuildValue(leftNode, parameter, typeInfo, InferType(leftNode, parameter, typeInfo));
+            var (m, n) = MakeNullComparable(member);
+            return (m, n);
+        }
+        if (leftIsNull && !rightIsNull)
+        {
+            var member = BuildValue(rightNode, parameter, typeInfo, InferType(rightNode, parameter, typeInfo));
+            var (m, n) = MakeNullComparable(member);
+            return (n, m);
+        }
+        if (leftIsNull && rightIsNull)
+        {
+            var nul = Expression.Constant(null, typeof(object));
+            return (nul, nul);
+        }
+
         var targetType = InferType(leftNode, parameter, typeInfo)
                          ?? InferType(rightNode, parameter, typeInfo);
-
         var left = BuildValue(leftNode, parameter, typeInfo, targetType);
         var right = BuildValue(rightNode, parameter, typeInfo, left.Type);
-
         if (left.Type != right.Type)
-        {
-            if (IsNullConstant(rightNode))
-                (left, right) = MakeNullComparable(left);
-            else if (IsNullConstant(leftNode))
-                (right, left) = MakeNullComparable(right);
-            else
-                right = Expression.Convert(right, left.Type);
-        }
+            right = Expression.Convert(right, left.Type);
         return (left, right);
     }
 

src/Shiny.DocumentDb.Orleans/DocumentDbGrainStorage.cs

@@ -81,7 +81,19 @@ public static void ConfigureGrainState(DocumentStoreOptions options, string tabl
         options.MapVersionProperty<GrainStateRecord>(x => x.Version);
     }
 
-    static string MakeId(string stateName, GrainId grainId) => $"{stateName}|{grainId}";
+    // GrainId.ToString() renders as "{grainType}/{key}" — the '/' (and '\', '?', '#') are reserved characters
+    // in a Cosmos DB item id, breaking the point-read on ReadStateAsync. Percent-encode them (and '%' first,
+    // to keep the encoding unambiguous) so the composite id is valid on Cosmos and unchanged in meaning on the
+    // relational/Mongo providers.
+    static string MakeId(string stateName, GrainId grainId)
+        => $"{stateName}|{SanitizeId(grainId.ToString())}";
+
+    static string SanitizeId(string s) => s
+        .Replace("%", "%25")
+        .Replace("/", "%2F")
+        .Replace("\\", "%5C")
+        .Replace("?", "%3F")
+        .Replace("#", "%23");
 
     static int ParseEtag(string etag) => int.Parse(etag, CultureInfo.InvariantCulture);
 

src/Shiny.DocumentDb.PostgreSql/PostgreSqlDatabaseProvider.cs

@@ -532,7 +532,10 @@ protected static string VecTable(string tableName, string typeName)
         VectorDistance.Cosine => "vector_cosine_ops",
         VectorDistance.Euclidean => "vector_l2_ops",
         VectorDistance.DotProduct => "vector_ip_ops",
-        VectorDistance.Hamming => "bit_hamming_ops",
+        // pgvector's Hamming distance requires a bit(n) column, but embeddings are stored as vector(n) — so
+        // Hamming can't be expressed here. Reject it cleanly rather than emit DDL that fails on the server.
+        VectorDistance.Hamming => throw new NotSupportedException(
+            "pgvector Hamming distance requires a bit(n) column; float embeddings stored as vector(n) support Cosine, Euclidean and DotProduct only."),
         _ => throw new ArgumentOutOfRangeException(nameof(metric), metric, null)
     };
 
@@ -541,7 +544,8 @@ protected static string VecTable(string tableName, string typeName)
         VectorDistance.Cosine => "<=>",
         VectorDistance.Euclidean => "<->",
         VectorDistance.DotProduct => "<#>",
-        VectorDistance.Hamming => "<+>",
+        VectorDistance.Hamming => throw new NotSupportedException(
+            "pgvector Hamming distance requires a bit(n) column; float embeddings support Cosine, Euclidean and DotProduct only."),
         _ => throw new ArgumentOutOfRangeException(nameof(metric), metric, null)
     };
 

src/Shiny.DocumentDb.SqlServer/SqlServerDatabaseProvider.cs

@@ -366,6 +366,10 @@ ELSE IF EXISTS (SELECT * FROM sys.computed_columns WHERE name = 'cc_{indexName}'
     public string BuildListJsonIndexesSql(string tableName, string prefix)
         => $"SELECT name FROM sys.indexes WHERE object_id = OBJECT_ID('{tableName}') AND name LIKE @prefix;";
 
+    // SQL Server LIKE treats '[' as a character-class metacharacter in addition to % and _, so escape it too.
+    public string EscapeLikePattern(string literal)
+        => literal.Replace("\\", "\\\\").Replace("%", "\\%").Replace("_", "\\_").Replace("[", "\\[");
+
     public string JsonExtract(string column, string jsonPath)
         => $"JSON_VALUE({column}, '$.{jsonPath}')";