expo-sqlite 58.0.2 → 58.0.4

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.4/expo.modules.sqlite-58.0.4.aar.md5

@@ -0,0 +1 @@
+cb8d35229ca9834150b696b80ea0dc28

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

@@ -0,0 +1 @@
+26be23ac048860cb8868d2dd1be563f25a3425d7

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

@@ -0,0 +1 @@
+b45dc027936e3b29de38200d4643d33ea99943b472a2c9ffac3d65daf12d72fa

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

@@ -0,0 +1 @@
+14be708c5a379138cdcbd6df78af8708ae8d6965912c0c98f5b20b93b1c6b5eebf07c31dd448a426dd8046af6d28ef36ccd17b79aa78a1734c65d0d1e82f916c

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

@@ -3,7 +3,7 @@
   "component": {
     "group": "host.exp.exponent",
     "module": "expo.modules.sqlite",
-    "version": "58.0.2",
+    "version": "58.0.4",
     "attributes": {
       "org.gradle.status": "release"
     }
@@ -24,13 +24,13 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.2.aar",
-          "url": "expo.modules.sqlite-58.0.2.aar",
-          "size": 3886612,
-          "sha512": "d9e545a9b113382af6026f7dd1956f28ebc57295de64ef34c760528447fc549cb284d9d1345827e7180eb2372da8907c9dbd02ab7e98a48508f52691b6cc71d6",
-          "sha256": "23ffa7b59f6dd275ce6cc0c35579383d41627aab24a60b5d3e95c29ef95ced14",
-          "sha1": "c834ccd2576e9f9840a32e8fa2bf006bb4a72e53",
-          "md5": "99e5bfc0280d5f75729044efdfbf209b"
+          "name": "expo.modules.sqlite-58.0.4.aar",
+          "url": "expo.modules.sqlite-58.0.4.aar",
+          "size": 3957803,
+          "sha512": "14be708c5a379138cdcbd6df78af8708ae8d6965912c0c98f5b20b93b1c6b5eebf07c31dd448a426dd8046af6d28ef36ccd17b79aa78a1734c65d0d1e82f916c",
+          "sha256": "b45dc027936e3b29de38200d4643d33ea99943b472a2c9ffac3d65daf12d72fa",
+          "sha1": "26be23ac048860cb8868d2dd1be563f25a3425d7",
+          "md5": "cb8d35229ca9834150b696b80ea0dc28"
         }
       ]
     },
@@ -67,13 +67,13 @@
       ],
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.2.aar",
-          "url": "expo.modules.sqlite-58.0.2.aar",
-          "size": 3886612,
-          "sha512": "d9e545a9b113382af6026f7dd1956f28ebc57295de64ef34c760528447fc549cb284d9d1345827e7180eb2372da8907c9dbd02ab7e98a48508f52691b6cc71d6",
-          "sha256": "23ffa7b59f6dd275ce6cc0c35579383d41627aab24a60b5d3e95c29ef95ced14",
-          "sha1": "c834ccd2576e9f9840a32e8fa2bf006bb4a72e53",
-          "md5": "99e5bfc0280d5f75729044efdfbf209b"
+          "name": "expo.modules.sqlite-58.0.4.aar",
+          "url": "expo.modules.sqlite-58.0.4.aar",
+          "size": 3957803,
+          "sha512": "14be708c5a379138cdcbd6df78af8708ae8d6965912c0c98f5b20b93b1c6b5eebf07c31dd448a426dd8046af6d28ef36ccd17b79aa78a1734c65d0d1e82f916c",
+          "sha256": "b45dc027936e3b29de38200d4643d33ea99943b472a2c9ffac3d65daf12d72fa",
+          "sha1": "26be23ac048860cb8868d2dd1be563f25a3425d7",
+          "md5": "cb8d35229ca9834150b696b80ea0dc28"
         }
       ]
     },
@@ -87,8 +87,8 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.2-sources.jar",
-          "url": "expo.modules.sqlite-58.0.2-sources.jar",
+          "name": "expo.modules.sqlite-58.0.4-sources.jar",
+          "url": "expo.modules.sqlite-58.0.4-sources.jar",
           "size": 11541,
           "sha512": "5a1466bf876dedce21b7a2bd7cdcf3dbbced85edf71dda6fd6397ed10b255bde5f2b41b9211949f3313536b283df5490555df92c208ef4dd360022e59d818ed7",
           "sha256": "b918435386059efd25a94569b9008af2977a88deae1ad63c7aaa2df93458dbaf",

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

@@ -0,0 +1 @@
+41f14ba2fe815293a33511fb48d68fac

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

@@ -0,0 +1 @@
+1b355654f3dc1696acfdc2dd297ac39d0620b194

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

@@ -0,0 +1 @@
+e646721271f7c70075329a67dbe43c21160823d6da9294a846c82e3f74bfab83

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

@@ -0,0 +1 @@
+587f8969ed591ca9a21df33adad531c3d1c2527363536981de0eeb5507d4e390ce56fa885b097e77cd3bca057bef097c76a3c031a9abca9546d7454ca4339569

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

@@ -9,7 +9,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>host.exp.exponent</groupId>
   <artifactId>expo.modules.sqlite</artifactId>
-  <version>58.0.2</version>
+  <version>58.0.4</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.4/expo.modules.sqlite-58.0.4.pom.md5

@@ -0,0 +1 @@
+61241d1909003b7db6b102347dd3e845

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

@@ -0,0 +1 @@
+805a0993ca0552fd4f831e157d0ee65996cd9ba0

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

@@ -0,0 +1 @@
+620d75043afdac2da6a0c628894b4aa2f47e5dad28321fa709ad32f7f93f683a

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

@@ -0,0 +1 @@
+c4f03d21028fa724f1223ba44b2ecbe150026d105049685e893b66045a7f8393ebeb06dae38d09baf5ba09bd02e82f7dc8bd882d1f24853b250e196001087b38

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>host.exp.exponent</groupId>
   <artifactId>expo.modules.sqlite</artifactId>
   <versioning>
-    <latest>58.0.2</latest>
-    <release>58.0.2</release>
+    <latest>58.0.4</latest>
+    <release>58.0.4</release>
     <versions>
-      <version>58.0.2</version>
+      <version>58.0.4</version>
     </versions>
-    <lastUpdated>20260914155309</lastUpdated>
+    <lastUpdated>20260921105152</lastUpdated>
   </versioning>
 </metadata>

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/maven-metadata.xml.md5

@@ -1 +1 @@
-bef4130505c35fd51b78b51b902dec37
+2a41da8aea04aa8355d6488c4853814d

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/maven-metadata.xml.sha1

@@ -1 +1 @@
-bff919325bb431025892c2b45e1e0ba1e7f2542c
+419f093be157e329c907c3ca70d864a01966d921