Fix QueryFilter IN/NOT_IN serialization to preserve type information (#192)

The IN and NOT_IN filters were stripping type metadata from list items,
causing CloudKit Web Services to reject queries with HTTP 400 errors.

Changes:
- Fix FilterBuilder to use CustomFieldValuePayload preserving types
- Re-enable GUID queries in CelestraCloud ArticleSyncService
- Optimize ArticleCloudKitService to combine filters at query time
- Update tests to reflect server-side filtering behavior

All tests passing: MistKit (311/311), CelestraCloud (115/115)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: leogdion

Examples/CelestraCloud/Sources/CelestraCloudKit/Services/ArticleCloudKitService.swift

@@ -110,24 +110,22 @@ public struct ArticleCloudKitService: Sendable {
     _ guids: [String],
     feedRecordName: String?
   ) async throws(CloudKitError) -> [Article] {
-    // CloudKit Web Services has issues with combining .in() with other filters.
-    // Current approach: Use .in() ONLY for GUID filtering (single filter, no combinations).
-    // Feed filtering is done in-memory (line 135-136) to avoid the .in() + filter issue.
-    //
-    // Known limitation: Cannot efficiently query by both GUID and feedRecordName in one query.
-    // This is acceptable because GUID queries are typically small batches (<150 items).
-    //
-    // Alternative considered: Multiple single-GUID queries would be significantly slower
-    // and hit rate limits faster. The in-memory filter is the pragmatic solution.
-    let filters: [QueryFilter] = [.in("guid", guids.map { FieldValue.string($0) })]
+    // Query articles by GUID using the IN filter.
+    // Now that issue #192 is fixed, we can combine .in() with other filters.
+    // If feedRecordName is specified, we filter at query time for efficiency.
+    var filters: [QueryFilter] = [.in("guid", guids.map { FieldValue.string($0) })]
+    if let feedName = feedRecordName {
+      filters.append(.equals("feedRecordName", FieldValue.string(feedName)))
+    }
+
     let records = try await recordOperator.queryRecords(
       recordType: "Article",
       filters: filters,
       sortBy: nil,
       limit: 200,
       desiredKeys: nil
     )
-    let articles = records.compactMap { record in
+    return records.compactMap { record in
       do {
         return try Article(from: record)
       } catch {
@@ -137,12 +135,6 @@ public struct ArticleCloudKitService: Sendable {
         return nil
       }
     }
-
-    // Filter by feedRecordName in-memory if specified
-    if let feedName = feedRecordName {
-      return articles.filter { $0.feedRecordName == feedName }
-    }
-    return articles
   }
 
   // MARK: - Create Operations

Examples/CelestraCloud/Sources/CelestraCloudKit/Services/ArticleSyncService.swift

@@ -72,14 +72,11 @@ public struct ArticleSyncService: Sendable {
     feedRecordName: String
   ) async throws(CloudKitError) -> ArticleSyncResult {
     // 1. Query existing articles by GUID
-    // TEMPORARY: Skip GUID query due to CloudKit Web Services .in() operator issue
-    // TODO: Fix query or implement alternative deduplication strategy
-    let existingArticles: [Article] = []
-    // let guids = items.map(\.guid)
-    // let existingArticles = try await articleService.queryArticlesByGUIDs(
-    //   guids,
-    //   feedRecordName: feedRecordName
-    // )
+    let guids = items.map(\.guid)
+    let existingArticles = try await articleService.queryArticlesByGUIDs(
+      guids,
+      feedRecordName: feedRecordName
+    )
 
     // 2. Categorize into new vs modified (pure function)
     let categorization = categorizer.categorize(

Examples/CelestraCloud/Tests/CelestraCloudTests/Services/ArticleCloudKitService+Query.swift

@@ -114,27 +114,25 @@ extension ArticleCloudKitService {
       let mock = MockCloudKitRecordOperator()
       let service = CelestraCloudKit.ArticleCloudKitService(recordOperator: mock)
 
-      // Mock returns 2 articles: one matching feed, one not
+      // Now that issue #192 is fixed, feedRecordName filter is applied at query time.
+      // Mock returns only the matching article (CloudKit would filter server-side).
       let matchingFields = createArticleRecordFields(guid: "guid-1")
-      let nonMatchingFields = createArticleRecordFields(guid: "guid-2")
-        .merging(["feedRecordName": .string("other-feed")]) { _, new in new }
 
       mock.queryRecordsResult = .success([
-        createMockRecordInfo(recordName: "article-1", fields: matchingFields),
-        createMockRecordInfo(recordName: "article-2", fields: nonMatchingFields)
+        createMockRecordInfo(recordName: "article-1", fields: matchingFields)
       ])
 
       let result = try await service.queryArticlesByGUIDs(
         ["guid-1", "guid-2"],
         feedRecordName: "feed-123"
       )
 
-      // Verify CloudKit query behavior
+      // Verify CloudKit query combines filters
       #expect(mock.queryCalls.count == 1)
-      // Should have 1 filter (GUID only), feedRecordName filtered in-memory
-      #expect(mock.queryCalls[0].filters?.count == 1)
+      // Should have 2 filters: IN for GUID + EQUALS for feedRecordName
+      #expect(mock.queryCalls[0].filters?.count == 2)
 
-      // Verify in-memory filtering works
+      // Verify filtering at query time works correctly
       #expect(result.count == 1)  // Only matching article returned
       #expect(result[0].guid == "guid-1")
       #expect(result[0].feedRecordName == "feed-123")