Merge pull request #288 from orlandos-nl/jw-upsert-success-check-fix-7.0

upsert-success check fails (also adds typesafe index building to Meow)

Sources/Meow/Indexes.swift

@@ -0,0 +1,32 @@
+import MongoKitten
+
+public func SortedIndex<M, T>(
+    named name: String,
+    field: QuerySubject<M, T>,
+    order: Sorting.Order = .ascending
+) -> _MongoIndex {
+    SortedIndex(named: name, field: field.path.string, order: order)
+}
+
+public func UniqueIndex<M, T>(
+    named name: String,
+    field: QuerySubject<M, T>,
+    order: Sorting.Order = .ascending
+) -> _MongoIndex {
+    UniqueIndex(named: name, field: field.path.string, order: order)
+}
+
+public func TTLIndex<M, T>(
+    named name: String,
+    field: QuerySubject<M, T>,
+    expireAfterSeconds seconds: Int
+) -> _MongoIndex {
+    TTLIndex(named: name, field: field.path.string, expireAfterSeconds: seconds)
+}
+
+public func TextScoreIndex<M, T>(
+    named name: String,
+    field: QuerySubject<M, T>
+) -> _MongoIndex {
+    TextScoreIndex(named: name, field: field.path.string)
+}

Sources/Meow/MeowCollection.swift

@@ -143,3 +143,10 @@ extension MeowCollection where M: MutableModel & ReadableModel {
         return try await self.deleteAll(where: filter.makeDocument(), writeConcern: writeConcern)
     }
 }
+
+extension MeowCollection where M: KeyPathQueryable {
+    public func buildIndexes(@MongoIndexBuilder build: (QueryMatcher<M>) -> _MongoIndexes) async throws {
+        let matcher = QueryMatcher<M>()
+        try await self.raw.createIndexes(build(matcher).indexes)
+    }
+}

Sources/Meow/Model.swift

@@ -153,7 +153,7 @@ extension MutableModel {
     public func save(in database: MeowDatabase) async throws -> MeowOperationResult {
         let reply = try await database.collection(for: Self.self).upsert(self)
         return MeowOperationResult(
-            success: reply.updatedCount == 1,
+            success: reply.updatedCount == 1 || reply.upserted != nil,
             n: reply.updatedCount,
             writeErrors: reply.writeErrors
         )

Sources/MongoKitten/CollectionHelpers/Collection+Indexes.swift

@@ -57,6 +57,10 @@ extension MongoCollection {
             transaction: nil
         ).decode(MongoIndex.self)
     }
+
+    public func buildIndexes(@MongoIndexBuilder build: () -> _MongoIndexes) async throws {
+        return try await createIndexes(build().indexes)
+    }
 }
 
 public struct MongoIndex: Decodable {

Sources/MongoKitten/IndexBuilder.swift

@@ -33,7 +33,7 @@ public struct MongoIndexBuilder {
 }
 
 public struct _MongoIndexes {
-    internal var indexes: [CreateIndexes.Index]
+    public private(set) var indexes: [CreateIndexes.Index]
 }
 
 public struct _MongoIndex {

Tests/MeowTests/MeowTests.swift

@@ -96,5 +96,31 @@ class MeowTests: XCTestCase {
         XCTAssertEqual(User.resolveFieldPath(\User.$password), ["password"])
         XCTAssertEqual(User.resolveFieldPath(\User.$profile.$firstName), ["profile", "firstName"])
     }
+
+    func testMigration() async throws {
+        try await meow.migrate("Unique Email", on: User.self) { migrator in
+            migrator.add { users in
+                try await users.buildIndexes { user in
+                    UniqueIndex(named: "unique-email", field: user.$email)
+                }
+            }
+        }
+
+        let myEmail = "joannis@orlandos.nl"
+
+        let user1 = User(email: myEmail, password: "test1")
+        let user2 = User(email: myEmail, password: "test2")
+
+        let saveResult1 = try await user1.save(in: meow)
+        XCTAssertTrue(saveResult1.success)
+        let saveResult2 = try await user2.save(in: meow)
+        XCTAssertFalse(saveResult2.success)
+
+        let count = try await meow[User.self].count { user in
+            user.$email == myEmail
+        }
+
+        XCTAssertEqual(count, 1)
+    }
 }
 #endif

Tests/MongoKittenTests/CRUDTests.swift

@@ -477,7 +477,7 @@ class CrudTests : XCTestCase {
         XCTAssertEqual(updatedAccount.name, "updated")
     }
 
-    func testIndexe () async throws {
+    func testIndexes () async throws {
         try await testBulkCreateDummyAccounts()
         let schema = mongo[DummyAccount.collectionName]
 
@@ -488,4 +488,25 @@ class CrudTests : XCTestCase {
         XCTAssertEqual(result[0].name, "_id_")
         XCTAssertEqual(result[1].name, "nameIndex")
     }
+
+    func testIndexBuilder() async throws {
+        let schema = mongo[DummyAccount.collectionName]
+
+        try await schema.buildIndexes {
+            UniqueIndex(named: "unique-name", field: "name")
+        }
+
+        let dummyAccount1 = DummyAccount(name: "Dum", password: "test1", age: 1337)
+        let dummyAccount2 = DummyAccount(name: "Dum", password: "test2", age: 1338)
+
+        let result1 = try await schema.insertEncoded(dummyAccount1)
+        XCTAssertEqual(result1.insertCount, 1)
+
+        let result2 = try await schema.insertEncoded(dummyAccount2)
+        XCTAssertEqual(result2.insertCount, 0)
+
+        let count = try await schema.count()
+
+        XCTAssertEqual(count, 1)
+    }
 }