expo-sqlite 58.0.3 → 58.0.5

package/ios/SQLiteOptions.swift

@@ -2,21 +2,9 @@
 
 import ExpoModulesCore
 
-struct OpenDatabaseOptions: Record, Equatable {
-  @Field
+@Record
+struct OpenDatabaseOptions: Equatable {
   var enableChangeListener: Bool = false
-
-  @Field
   var useNewConnection: Bool = false
-
-  @Field
   var finalizeUnusedStatementsBeforeClosing: Bool = true
-
-  // MARK: - Equatable
-
-  static func == (lhs: OpenDatabaseOptions, rhs: OpenDatabaseOptions) -> Bool {
-    return lhs.enableChangeListener == rhs.enableChangeListener &&
-      lhs.useNewConnection == rhs.useNewConnection &&
-      lhs.finalizeUnusedStatementsBeforeClosing == rhs.finalizeUnusedStatementsBeforeClosing
-  }
 }

package/ios/Tests/NativeDatabaseTests.swift

@@ -0,0 +1,105 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Testing
+
+@testable import ExpoSQLite
+
+/// Exercises the connection members that `NativeDatabase` exposes to JavaScript, against an in-memory
+/// database opened through the C API.
+@Suite("NativeDatabase")
+@JavaScriptActor
+final class NativeDatabaseTests {
+  private let database: NativeDatabase
+
+  init() throws {
+    var pointer: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &pointer) == SQLITE_OK)
+    database = NativeDatabase(pointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+  }
+
+  deinit {
+    exsqlite3_close(database.pointer)
+  }
+
+  @Test
+  func `exec runs the given statements`() throws {
+    try database.execSync(source: "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL); INSERT INTO test (id) VALUES (1);")
+    let statement = NativeStatement()
+    try database.prepareSync(statement: statement, source: "SELECT COUNT(*) FROM test")
+    #expect(exsqlite3_step(statement.pointer) == SQLITE_ROW)
+    #expect(exsqlite3_column_int(statement.pointer, 0) == 1)
+    exsqlite3_finalize(statement.pointer)
+  }
+
+  @Test
+  func `exec surfaces SQLite errors`() {
+    #expect(throws: SQLiteErrorException.self) {
+      try database.execSync(source: "NOT VALID SQL")
+    }
+  }
+
+  @Test
+  func `prepare rejects a finalized statement`() throws {
+    let statement = NativeStatement()
+    statement.isFinalized = true
+    #expect(throws: AccessClosedResourceException.self) {
+      try database.prepareSync(statement: statement, source: "SELECT 1")
+    }
+  }
+
+  @Test
+  func `reports whether a transaction is open`() throws {
+    #expect(try database.isInTransactionSync() == false)
+    try database.execSync(source: "BEGIN")
+    #expect(try database.isInTransactionSync() == true)
+    try database.execSync(source: "COMMIT")
+    #expect(try database.isInTransactionSync() == false)
+  }
+
+  @Test
+  func `serialize returns the database file image`() throws {
+    try database.execSync(source: "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL)")
+    let data = try database.serializeSync(databaseName: "main")
+    #expect(String(decoding: data.prefix(15), as: UTF8.self) == "SQLite format 3")
+  }
+
+  @Test
+  func `creates a session bound to the database`() throws {
+    try database.execSync(source: "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL)")
+    let session = NativeSession()
+    try database.createSessionSync(session: session, dbName: "main")
+    #expect(session.pointer != nil)
+    exsqlite3session_delete(session.pointer)
+  }
+
+  @Test
+  func `loading a missing extension throws`() {
+    #expect(throws: SQLiteErrorException.self) {
+      try database.loadExtensionSync(libPath: "/nonexistent/extension", entryPoint: nil)
+    }
+  }
+
+  @Test
+  func `throws when the database is closed`() throws {
+    database.isClosed = true
+    #expect(throws: AccessClosedResourceException.self) {
+      try database.execSync(source: "SELECT 1")
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try database.isInTransactionSync()
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try database.serializeSync(databaseName: "main")
+    }
+    database.isClosed = false
+  }
+
+  @Test
+  func `async members run the same operations`() async throws {
+    try await database.execAsync(source: "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL)")
+    #expect(try await database.isInTransactionAsync() == false)
+    let data = try await database.serializeAsync(databaseName: "main")
+    #expect(data.count > 0)
+  }
+}

package/ios/Tests/NativeSessionTests.swift

@@ -0,0 +1,102 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Testing
+
+@testable import ExpoSQLite
+
+/// Exercises the session members that `NativeSession` exposes to JavaScript, against an in-memory
+/// database. The session itself is created through the C API so the tests stay independent of the
+/// database members.
+@Suite("NativeSession")
+@JavaScriptActor
+final class NativeSessionTests {
+  private let database: NativeDatabase
+  private let session = NativeSession()
+
+  init() throws {
+    var pointer: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &pointer) == SQLITE_OK)
+    database = NativeDatabase(pointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+    let setup = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL);"
+    #expect(exsqlite3_exec(database.pointer, setup, nil, nil, nil) == SQLITE_OK)
+    #expect(exsqlite3session_create(database.pointer, "main", &session.pointer) == SQLITE_OK)
+  }
+
+  deinit {
+    exsqlite3_close(database.pointer)
+  }
+
+  private func execute(_ sql: String) {
+    #expect(exsqlite3_exec(database.pointer, sql, nil, nil, nil) == SQLITE_OK)
+  }
+
+  private func rowCount() -> Int32 {
+    var statement: OpaquePointer?
+    #expect(exsqlite3_prepare_v2(database.pointer, "SELECT COUNT(*) FROM test", -1, &statement, nil) == SQLITE_OK)
+    defer {
+      exsqlite3_finalize(statement)
+    }
+    #expect(exsqlite3_step(statement) == SQLITE_ROW)
+    return exsqlite3_column_int(statement, 0)
+  }
+
+  @Test
+  func `records attached table changes into a changeset`() throws {
+    try session.attachSync(database: database, table: "test")
+    execute("INSERT INTO test (id, value) VALUES (1, 'one')")
+    let changeset = try session.createChangesetSync(database: database)
+    #expect(changeset.byteLength > 0)
+  }
+
+  @Test
+  func `records nothing while the session is disabled`() throws {
+    try session.attachSync(database: database, table: nil)
+    try session.enableSync(database: database, enabled: false)
+    execute("INSERT INTO test (id, value) VALUES (1, 'one')")
+    let changeset = try session.createChangesetSync(database: database)
+    #expect(changeset.byteLength == 0)
+  }
+
+  @Test
+  func `applying the inverted changeset reverts the recorded changes`() throws {
+    try session.attachSync(database: database, table: nil)
+    execute("INSERT INTO test (id, value) VALUES (1, 'one')")
+    #expect(rowCount() == 1)
+    let inverted = try session.createInvertedChangesetSync(database: database)
+    try session.applyChangesetSync(database: database, changeset: inverted)
+    #expect(rowCount() == 0)
+  }
+
+  @Test
+  func `inverting a changeset twice yields the original`() throws {
+    try session.attachSync(database: database, table: nil)
+    execute("INSERT INTO test (id, value) VALUES (1, 'one')")
+    let changeset = try session.createChangesetSync(database: database)
+    let inverted = try session.invertChangesetSync(database: database, changeset: changeset)
+    let restored = try session.invertChangesetSync(database: database, changeset: inverted)
+    #expect(restored.byteLength == changeset.byteLength)
+    #expect(inverted.byteLength == changeset.byteLength)
+  }
+
+  @Test
+  func `throws when the database is closed`() throws {
+    database.isClosed = true
+    #expect(throws: AccessClosedResourceException.self) {
+      try session.attachSync(database: database, table: nil)
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try session.createChangesetSync(database: database)
+    }
+    database.isClosed = false
+  }
+
+  @Test
+  func `async members run the same operations`() async throws {
+    try await session.attachAsync(database: database, table: nil)
+    execute("INSERT INTO test (id, value) VALUES (1, 'one')")
+    let changeset = try await session.createChangesetAsync(database: database)
+    #expect(changeset.byteLength > 0)
+    try await session.closeAsync(database: database)
+  }
+}

package/ios/Tests/NativeStatementTests.swift

@@ -0,0 +1,90 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Testing
+
+@testable import ExpoSQLite
+
+/// Exercises the statement members that `NativeStatement` exposes to JavaScript, against an in-memory
+/// database. Statements are prepared through the C API so the tests stay independent of the database
+/// members.
+@Suite("NativeStatement")
+@JavaScriptActor
+final class NativeStatementTests {
+  private let database: NativeDatabase
+
+  init() throws {
+    var pointer: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &pointer) == SQLITE_OK)
+    database = NativeDatabase(pointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+    let setup = """
+      CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL);
+      INSERT INTO test (id, value) VALUES (1, 'one');
+      INSERT INTO test (id, value) VALUES (2, 'two');
+      """
+    #expect(exsqlite3_exec(database.pointer, setup, nil, nil, nil) == SQLITE_OK)
+  }
+
+  deinit {
+    exsqlite3_close(database.pointer)
+  }
+
+  private func prepare(_ source: String) -> NativeStatement {
+    let statement = NativeStatement()
+    #expect(exsqlite3_prepare_v2(database.pointer, source, -1, &statement.pointer, nil) == SQLITE_OK)
+    return statement
+  }
+
+  @Test
+  func `returns the column names of a prepared statement`() throws {
+    let statement = prepare("SELECT id, value AS label FROM test")
+    #expect(try statement.getColumnNamesSync() == ["id", "label"])
+  }
+
+  @Test
+  func `reset rewinds a stepped statement to its first row`() throws {
+    let statement = prepare("SELECT id FROM test ORDER BY id")
+    #expect(exsqlite3_step(statement.pointer) == SQLITE_ROW)
+    #expect(exsqlite3_step(statement.pointer) == SQLITE_ROW)
+    #expect(exsqlite3_column_int(statement.pointer, 0) == 2)
+    try statement.resetSync(database: database)
+    #expect(exsqlite3_step(statement.pointer) == SQLITE_ROW)
+    #expect(exsqlite3_column_int(statement.pointer, 0) == 1)
+  }
+
+  @Test
+  func `finalize marks the statement finalized and rejects further use`() throws {
+    let statement = prepare("SELECT id FROM test")
+    try statement.finalizeSync(database: database)
+    #expect(statement.isFinalized)
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.getColumnNamesSync()
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.resetSync(database: database)
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.finalizeSync(database: database)
+    }
+  }
+
+  @Test
+  func `throws when the database is closed`() throws {
+    let statement = prepare("SELECT id FROM test")
+    database.isClosed = true
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.resetSync(database: database)
+    }
+    database.isClosed = false
+    exsqlite3_finalize(statement.pointer)
+  }
+
+  @Test
+  func `async members run the same operations`() async throws {
+    let statement = prepare("SELECT id, value FROM test")
+    #expect(try await statement.getColumnNamesAsync() == ["id", "value"])
+    try await statement.resetAsync(database: database)
+    try await statement.finalizeAsync(database: database)
+    #expect(statement.isFinalized)
+  }
+}

package/ios/Tests/OpenDatabaseOptionsTests.swift

@@ -0,0 +1,44 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Testing
+
+@testable import ExpoSQLite
+
+@Suite("OpenDatabaseOptions")
+struct OpenDatabaseOptionsTests {
+  private let appContext = AppContext()
+
+  @Test
+  func `decodes every option to its default from an empty dictionary`() throws {
+    let options = try OpenDatabaseOptions.from(dictionary: [:], appContext: appContext)
+    #expect(options.enableChangeListener == false)
+    #expect(options.useNewConnection == false)
+    #expect(options.finalizeUnusedStatementsBeforeClosing == true)
+  }
+
+  @Test
+  func `decodes the provided options and keeps the rest at their defaults`() throws {
+    let options = try OpenDatabaseOptions.from(
+      dictionary: ["useNewConnection": true, "finalizeUnusedStatementsBeforeClosing": false],
+      appContext: appContext
+    )
+    #expect(options.enableChangeListener == false)
+    #expect(options.useNewConnection == true)
+    #expect(options.finalizeUnusedStatementsBeforeClosing == false)
+  }
+
+  /// The module reuses a cached database only when its options equal the requested ones, so equality
+  /// has to look at every option.
+  @Test
+  func `compares equal only when every option matches`() throws {
+    let defaults = try OpenDatabaseOptions.from(dictionary: [:], appContext: appContext)
+    let sameDefaults = try OpenDatabaseOptions.from(dictionary: [:], appContext: appContext)
+    let newConnection = try OpenDatabaseOptions.from(
+      dictionary: ["useNewConnection": true],
+      appContext: appContext
+    )
+    #expect(defaults == sameDefaults)
+    #expect(defaults != newConnection)
+  }
+}

package/ios/Tests/SQLiteModuleTests.swift

@@ -0,0 +1,116 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Testing
+
+@testable import ExpoSQLite
+
+/// Exercises the module-level surface: the constants JavaScript reads, the change-event payload shape
+/// and the listener bookkeeping behind the update hook.
+@Suite("SQLiteModule")
+@JavaScriptActor
+struct SQLiteModuleTests {
+  private let appContext = AppContext()
+  private let module: SQLiteModule
+
+  init() {
+    module = SQLiteModule(appContext: appContext)
+  }
+
+  @Test
+  func `default database directory is the SQLite folder of the app's documents`() {
+    #if os(tvOS)
+    let baseDirectory = appContext.config.cacheDirectory
+    #else
+    let baseDirectory = appContext.config.documentDirectory
+    #endif
+    let expected = baseDirectory?.appendingPathComponent("SQLite").standardized.path
+    #expect(module.defaultDatabaseDirectory == expected)
+    #expect(module.defaultDatabaseDirectory?.hasSuffix("/SQLite") == true)
+  }
+
+  @Test
+  func `bundles no extensions unless the build enables them`() {
+    #if WITH_SQLITE_VEC
+    #expect(module.bundledExtensions.keys.sorted() == ["sqlite-vec"])
+    #else
+    #expect(module.bundledExtensions.isEmpty)
+    #endif
+  }
+
+  @Test
+  func `tracks whether JavaScript listens for database changes`() {
+    #expect(module.hasListeners == false)
+    module.didStartListening(event: "onDatabaseChange")
+    #expect(module.hasListeners == true)
+    module.didStopListening(event: "onDatabaseChange")
+    #expect(module.hasListeners == false)
+  }
+
+  @Test
+  func `database change event carries the fields JavaScript reads`() {
+    let event = DatabaseChangeEvent(
+      databaseName: "main",
+      databaseFilePath: "/tmp/test.db",
+      tableName: "test",
+      rowId: 3,
+      typeId: .insert
+    )
+    let dictionary = event.toDictionary(appContext: appContext)
+    #expect(dictionary.keys.sorted() == ["databaseFilePath", "databaseName", "rowId", "tableName", "typeId"])
+    #expect(dictionary["databaseName"] as? String == "main")
+    #expect(dictionary["tableName"] as? String == "test")
+  }
+
+  @Test
+  func `ensuring the in-memory database path needs no file system`() throws {
+    try module.ensureDatabasePathExistsSync(databasePath: ":memory:")
+  }
+
+  @Test
+  func `ensuring a file database path creates its directory`() throws {
+    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    defer {
+      try? FileManager.default.removeItem(at: directory)
+    }
+    try module.ensureDatabasePathExistsSync(databasePath: directory.appendingPathComponent("test.db").path)
+    #expect(FileManager.default.fileExists(atPath: directory.path))
+  }
+
+  @Test
+  func `deleting the in-memory database does nothing`() throws {
+    try module.deleteDatabaseSync(databasePath: ":memory:")
+  }
+
+  @Test
+  func `backs up one database into another`() throws {
+    var sourcePointer: OpaquePointer?
+    var destinationPointer: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &sourcePointer) == SQLITE_OK)
+    #expect(exsqlite3_open(":memory:", &destinationPointer) == SQLITE_OK)
+    defer {
+      exsqlite3_close(sourcePointer)
+      exsqlite3_close(destinationPointer)
+    }
+    let source = NativeDatabase(sourcePointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+    let destination = NativeDatabase(destinationPointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+    try source.execSync(source: "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL); INSERT INTO test (id) VALUES (7);")
+    try module.backupDatabaseSync(
+      destDatabase: destination,
+      destDatabaseName: "main",
+      sourceDatabase: source,
+      sourceDatabaseName: "main"
+    )
+    let statement = NativeStatement()
+    try destination.prepareSync(statement: statement, source: "SELECT id FROM test")
+    #expect(exsqlite3_step(statement.pointer) == SQLITE_ROW)
+    #expect(exsqlite3_column_int(statement.pointer, 0) == 7)
+    exsqlite3_finalize(statement.pointer)
+  }
+
+  @Test
+  func `async members run the same operations`() async throws {
+    try await module.ensureDatabasePathExistsAsync(databasePath: ":memory:")
+    try await module.deleteDatabaseAsync(databasePath: ":memory:")
+  }
+}

package/ios/Tests/StatementLockTests.swift

@@ -37,28 +37,24 @@ final class StatementLockTests {
   /// call, which is what the module takes. The row read belongs to whichever caller bound the
   /// statement last, so callers assert only that a value the table holds comes back.
   private func runAndReadFirstRow(of statement: NativeStatement, id: Int32) -> String? {
-    statement.lock.wait()
-    defer {
-      statement.lock.signal()
-    }
-    exsqlite3_reset(statement.pointer)
-    exsqlite3_clear_bindings(statement.pointer)
-    exsqlite3_bind_int(statement.pointer, 1, id)
-    guard exsqlite3_step(statement.pointer) == SQLITE_ROW,
-      let text = exsqlite3_column_text(statement.pointer, 0)
-    else {
-      return nil
+    return statement.lock.withLock { _ -> String? in
+      exsqlite3_reset(statement.pointer)
+      exsqlite3_clear_bindings(statement.pointer)
+      exsqlite3_bind_int(statement.pointer, 1, id)
+      guard exsqlite3_step(statement.pointer) == SQLITE_ROW,
+        let text = exsqlite3_column_text(statement.pointer, 0)
+      else {
+        return nil
+      }
+      return String(cString: text)
     }
-    return String(cString: text)
   }
 
   /// Drains the cursor in its own critical section, the way `getAll` does.
   private func drain(_ statement: NativeStatement) {
-    statement.lock.wait()
-    defer {
-      statement.lock.signal()
+    statement.lock.withLock { _ in
+      while exsqlite3_step(statement.pointer) == SQLITE_ROW {}
     }
-    while exsqlite3_step(statement.pointer) == SQLITE_ROW {}
   }
 
   @Test

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5-sources.jar.md5

@@ -0,0 +1 @@
+d1da3a6df8335c04eb1b803a0b4e73cf

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5-sources.jar.sha1

@@ -0,0 +1 @@
+1d398068a3b652c5a9392d4115c9b8258adc42ef

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5-sources.jar.sha256

@@ -0,0 +1 @@
+a4b537cf4b334950fc82e5d251599ed7b3bc6d5c2410a3fdca38b81650fe27c2

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5-sources.jar.sha512

@@ -0,0 +1 @@
+7584658ab5c9dd4f06e3445b056b83007c6fc6162cdda3b3df67bb9b7ec45e17d686903a37feae801ee8b966ed1bd36de9386d739c783bbaec65391dbaa6dc65

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.aar.md5

@@ -0,0 +1 @@
+d952f01aa0c2b9341bd46b742afea2f3

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.aar.sha1

@@ -0,0 +1 @@
+124eae424bb185c8a6c6f9ad3d808337ffa285c1

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.aar.sha256

@@ -0,0 +1 @@
+66e4488bd02141346b04a8bc40fd3880143470b69d1f12b2897b6ab9e90650e9

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.aar.sha512

@@ -0,0 +1 @@
+01dbc41973b2ebae1772a5edc24e2e80ebbc3fef8f43a49a0c6d525d06af00dc2cf46c5e104387a2f59f252b632756f7c0e4dc05f231c91ec43676df88ef56f1

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/{58.0.3/expo.modules.sqlite-58.0.3.module → 58.0.5/expo.modules.sqlite-58.0.5.module}

@@ -3,7 +3,7 @@
   "component": {
     "group": "host.exp.exponent",
     "module": "expo.modules.sqlite",
-    "version": "58.0.3",
+    "version": "58.0.5",
     "attributes": {
       "org.gradle.status": "release"
     }
@@ -24,13 +24,13 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.3.aar",
-          "url": "expo.modules.sqlite-58.0.3.aar",
-          "size": 3917278,
-          "sha512": "9d898cd2f3d55175001fc2c66d17ee9d259c6ace495411036ff1d98682c5c9d078a7b2b50f148a020aee999220559b14c7d65ee85936e78193d1115b25c7858f",
-          "sha256": "05e385243213988f3c9106a638466997f7f056a960ecce28a1ac9329036d4131",
-          "sha1": "0092ab287a53ce82ac9e583c98d842776f76ba90",
-          "md5": "04194e6a36f69d2cbfaea2df26829fc0"
+          "name": "expo.modules.sqlite-58.0.5.aar",
+          "url": "expo.modules.sqlite-58.0.5.aar",
+          "size": 3960770,
+          "sha512": "01dbc41973b2ebae1772a5edc24e2e80ebbc3fef8f43a49a0c6d525d06af00dc2cf46c5e104387a2f59f252b632756f7c0e4dc05f231c91ec43676df88ef56f1",
+          "sha256": "66e4488bd02141346b04a8bc40fd3880143470b69d1f12b2897b6ab9e90650e9",
+          "sha1": "124eae424bb185c8a6c6f9ad3d808337ffa285c1",
+          "md5": "d952f01aa0c2b9341bd46b742afea2f3"
         }
       ]
     },
@@ -67,13 +67,13 @@
       ],
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.3.aar",
-          "url": "expo.modules.sqlite-58.0.3.aar",
-          "size": 3917278,
-          "sha512": "9d898cd2f3d55175001fc2c66d17ee9d259c6ace495411036ff1d98682c5c9d078a7b2b50f148a020aee999220559b14c7d65ee85936e78193d1115b25c7858f",
-          "sha256": "05e385243213988f3c9106a638466997f7f056a960ecce28a1ac9329036d4131",
-          "sha1": "0092ab287a53ce82ac9e583c98d842776f76ba90",
-          "md5": "04194e6a36f69d2cbfaea2df26829fc0"
+          "name": "expo.modules.sqlite-58.0.5.aar",
+          "url": "expo.modules.sqlite-58.0.5.aar",
+          "size": 3960770,
+          "sha512": "01dbc41973b2ebae1772a5edc24e2e80ebbc3fef8f43a49a0c6d525d06af00dc2cf46c5e104387a2f59f252b632756f7c0e4dc05f231c91ec43676df88ef56f1",
+          "sha256": "66e4488bd02141346b04a8bc40fd3880143470b69d1f12b2897b6ab9e90650e9",
+          "sha1": "124eae424bb185c8a6c6f9ad3d808337ffa285c1",
+          "md5": "d952f01aa0c2b9341bd46b742afea2f3"
         }
       ]
     },
@@ -87,13 +87,13 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.3-sources.jar",
-          "url": "expo.modules.sqlite-58.0.3-sources.jar",
-          "size": 11541,
-          "sha512": "5a1466bf876dedce21b7a2bd7cdcf3dbbced85edf71dda6fd6397ed10b255bde5f2b41b9211949f3313536b283df5490555df92c208ef4dd360022e59d818ed7",
-          "sha256": "b918435386059efd25a94569b9008af2977a88deae1ad63c7aaa2df93458dbaf",
-          "sha1": "cf1f89d9298ee8b3ea9e33352111f4b433048ad0",
-          "md5": "4634b21e5b7390ea947d091651ed41d1"
+          "name": "expo.modules.sqlite-58.0.5-sources.jar",
+          "url": "expo.modules.sqlite-58.0.5-sources.jar",
+          "size": 11821,
+          "sha512": "7584658ab5c9dd4f06e3445b056b83007c6fc6162cdda3b3df67bb9b7ec45e17d686903a37feae801ee8b966ed1bd36de9386d739c783bbaec65391dbaa6dc65",
+          "sha256": "a4b537cf4b334950fc82e5d251599ed7b3bc6d5c2410a3fdca38b81650fe27c2",
+          "sha1": "1d398068a3b652c5a9392d4115c9b8258adc42ef",
+          "md5": "d1da3a6df8335c04eb1b803a0b4e73cf"
         }
       ]
     }

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.module.md5

@@ -0,0 +1 @@
+b6efef6843b4fa61a8d1f40c4910690d

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.module.sha1

@@ -0,0 +1 @@
+60ad740877eca94d63b7b76ba884548c0aa16bfb

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.module.sha256

@@ -0,0 +1 @@
+cd23116e9f8be7c62603e3188ddb813233ddaf66d4b1ab327f41ae292024a4c8

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.module.sha512

@@ -0,0 +1 @@
+1700e8bbc63eeba715ef62bb3952693a53ff74e42e8c8874f51dd4d9f02c279580d9a9519fcecef8e406ef6f147f747f49a009fe1b2f69aab151365c19ea90f7

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/{58.0.3/expo.modules.sqlite-58.0.3.pom → 58.0.5/expo.modules.sqlite-58.0.5.pom}

@@ -9,7 +9,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>host.exp.exponent</groupId>
   <artifactId>expo.modules.sqlite</artifactId>
-  <version>58.0.3</version>
+  <version>58.0.5</version>
   <packaging>aar</packaging>
   <name>expo.modules.sqlite</name>
   <url>https://github.com/expo/expo</url>

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.pom.md5

@@ -0,0 +1 @@
+5a46bfa5e5be04918c17d1da3c8be451

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.pom.sha1

@@ -0,0 +1 @@
+af61ea4b8233c59e7c5ea1be94c40ae27e7b3738

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.pom.sha256

@@ -0,0 +1 @@
+364039a6932bba44f279f495ee31277a7c9d187c9e41d7330fbea6c00766a1b5

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.5/expo.modules.sqlite-58.0.5.pom.sha512

@@ -0,0 +1 @@
+f8f3349769ba490cfc7b5cad49b149f0cda78ac09efe72e433b2a8a26a46fd27765fa28aa8ed2e7649578ed5a4df908d01f826858b4c019694ef9c206eb6f807