fix: Null handling improvements (#161)

chrispader · web-flow · commit a292f5a31286 · 2025-04-14T17:18:05.000+02:00
* refactor: move null handling code

* fix: execute always replacing null values

* refactor: simplify null handling in execute

* feat: implement null handling for executeBatch

* chore: update nitrogen specs

* fix: use null handling function

* update pods

* chore: remove Xcode 16.2 Swift hotfix

* Update Podfile.lock

* fix: update c++ batch code

* chore: release 9.1.8
diff --git a/example/ios/Podfile b/example/ios/Podfile
@@ -37,7 +37,6 @@ target 'NitroSQLiteExample' do
 
     installer.pods_project.targets.each do |target|
       target.build_configurations.each do |config|
-        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET[sdk=iphonesimulator*]'] = '16.6'
         config.build_settings['DEAD_CODE_STRIPPING'] = 'YES'
       end
     end
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
@@ -1614,7 +1614,7 @@ PODS:
     - React-logger (= 0.78.0)
     - React-perflogger (= 0.78.0)
     - React-utils (= 0.78.0)
-  - RNNitroSQLite (9.1.7):
+  - RNNitroSQLite (9.1.8):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -1973,11 +1973,11 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: f2e81d80afd71a8058589e19d8a134243fa53f17
   ReactCodegen: 335c73d9eb04d93d9b2350157ed52a6a9ad05e1e
   ReactCommon: c8fdbc582b98a07daf201cd95c1da75dd029f3ee
-  RNNitroSQLite: 6f4b16233d10ca5da070d1b8012107d561c60d5b
+  RNNitroSQLite: ffd6b8298153f00d8a57d11464a93bd5bf52d012
   RNScreens: 77f93ec55b749c49549b447527ebf78e990125f3
   SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
   Yoga: be02ca501b03c79d7027a6bbbd0a8db985034f11
 
-PODFILE CHECKSUM: 60941c02e965706ce3073b8e6f186a204a7b6e73
+PODFILE CHECKSUM: 94e2eb7d622b44feacdd64fd57969a1205a734ae
 
 COCOAPODS: 1.15.2
diff --git a/example/package.json b/example/package.json
@@ -24,7 +24,7 @@
     "react": "19.0.0",
     "react-native": "0.78.0",
     "react-native-nitro-modules": "0.24.1",
-    "react-native-nitro-sqlite": "9.1.7",
+    "react-native-nitro-sqlite": "9.1.8",
     "react-native-safe-area-context": "^5.2.0",
     "react-native-screens": "^4.9.1",
     "reflect-metadata": "^0.1.13",
diff --git a/package/cpp/specs/HybridNitroSQLite.cpp b/package/cpp/specs/HybridNitroSQLite.cpp
@@ -66,15 +66,15 @@ std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> HybridNit
   });
 };
 
-BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& batchParams) {
+BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& batchParams) {
   const auto commands = batchParamsToCommands(batchParams);
 
   auto result = sqliteExecuteBatch(dbName, commands);
   return BatchQueryResult(result.rowsAffected);
 };
 
 std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(const std::string& dbName,
-                                                                                const std::vector<BatchQueryCommand>& batchParams) {
+                                                                                const std::vector<NativeBatchQueryCommand>& batchParams) {
   return Promise<BatchQueryResult>::async([=, this]() -> BatchQueryResult {
     auto result = executeBatch(dbName, batchParams);
     return result;
diff --git a/package/cpp/specs/HybridNitroSQLite.hpp b/package/cpp/specs/HybridNitroSQLite.hpp
@@ -32,8 +32,8 @@ class HybridNitroSQLite : public HybridNitroSQLiteSpec {
   
   std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
   
-  BatchQueryResult executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
-  std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
+  BatchQueryResult executeBatch(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& commands) override;
+  std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& commands) override;
   
   FileLoadResult loadFile(const std::string& dbName, const std::string& location) override;
   std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) override;
diff --git a/package/cpp/sqliteExecuteBatch.cpp b/package/cpp/sqliteExecuteBatch.cpp
@@ -8,7 +8,7 @@
 
 namespace margelo::rnnitrosqlite {
 
-std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryCommand>& batchParams) {
+std::vector<BatchQuery> batchParamsToCommands(const std::vector<NativeBatchQueryCommand>& batchParams) {
   auto commands = std::vector<BatchQuery>();
 
   for (auto& command : batchParams) {
diff --git a/package/cpp/sqliteExecuteBatch.hpp b/package/cpp/sqliteExecuteBatch.hpp
@@ -3,7 +3,7 @@
  */
 #pragma once
 
-#include "BatchQueryCommand.hpp"
+#include "NativeBatchQueryCommand.hpp"
 #include "types.hpp"
 
 using namespace facebook;
@@ -20,7 +20,7 @@ struct BatchQuery {
  * Local Helper method to translate JSI objects BatchQuery datastructure
  * MUST be called in the JavaScript Thread
  */
-std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryCommand>& batchParams);
+std::vector<BatchQuery> batchParamsToCommands(const std::vector<NativeBatchQueryCommand>& batchParams);
 
 /**
  * Execute a batch of commands in a exclusive transaction
diff --git a/package/nitrogen/generated/shared/c++/HybridNitroSQLiteSpec.hpp b/package/nitrogen/generated/shared/c++/HybridNitroSQLiteSpec.hpp
diff --git a/package/nitrogen/generated/shared/c++/NativeBatchQueryCommand.hpp b/package/nitrogen/generated/shared/c++/NativeBatchQueryCommand.hpp
diff --git a/package/package.json b/package/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-sqlite",
-  "version": "9.1.7",
+  "version": "9.1.8",
   "description": "Fast SQLite library for React Native built using Nitro Modules",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index",
diff --git a/package/src/index.ts b/package/src/index.ts
@@ -2,8 +2,8 @@ import { transaction } from './operations/transaction'
 import { HybridNitroSQLite } from './nitro'
 import { open } from './operations/session'
 import { execute, executeAsync } from './operations/execute'
-import { SQLiteNullValue } from './types'
 import { init } from './OnLoad'
+import { executeBatch, executeBatchAsync } from './operations/executeBatch'
 export type * from './types'
 export { typeORMDriver } from './typeORM'
 
@@ -19,24 +19,14 @@ export const NitroSQLite = {
   transaction,
   execute,
   executeAsync,
+  executeBatch,
+  executeBatchAsync,
 }
 
 export { open } from './operations/session'
-
-let ENABLE_SIMPLE_NULL_HANDLING = false
-export function enableSimpleNullHandling(
-  shouldEnableSimpleNullHandling = true
-) {
-  ENABLE_SIMPLE_NULL_HANDLING = shouldEnableSimpleNullHandling
-}
-export function isSimpleNullHandlingEnabled() {
-  return ENABLE_SIMPLE_NULL_HANDLING
-}
-
-export const NITRO_SQLITE_NULL: SQLiteNullValue = { isNitroSQLiteNull: true }
-export function isNitroSQLiteNull(value: any): value is SQLiteNullValue {
-  if (typeof value === 'object' && 'isNitroSQLiteNull' in value) {
-    return true
-  }
-  return false
-}
+export {
+  isNitroSQLiteNull,
+  NITRO_SQLITE_NULL,
+  isSimpleNullHandlingEnabled,
+  enableSimpleNullHandling,
+} from './nullHandling'
diff --git a/package/src/nullHandling.ts b/package/src/nullHandling.ts
@@ -0,0 +1,31 @@
+import { SQLiteNullValue, SQLiteValue } from './types'
+import { SQLiteQueryParamItem } from './types'
+
+let ENABLE_SIMPLE_NULL_HANDLING = false
+
+export function enableSimpleNullHandling(
+  shouldEnableSimpleNullHandling = true
+) {
+  ENABLE_SIMPLE_NULL_HANDLING = shouldEnableSimpleNullHandling
+}
+
+export function isSimpleNullHandlingEnabled() {
+  return ENABLE_SIMPLE_NULL_HANDLING
+}
+
+export const NITRO_SQLITE_NULL: SQLiteNullValue = { isNitroSQLiteNull: true }
+export function isNitroSQLiteNull(value: any): value is SQLiteNullValue {
+  if (typeof value === 'object' && 'isNitroSQLiteNull' in value) {
+    return true
+  }
+  return false
+}
+
+export function replaceWithNativeNullValue(
+  value: SQLiteQueryParamItem
+): SQLiteValue {
+  if (value === undefined || value === null) {
+    return NITRO_SQLITE_NULL
+  }
+  return value
+}
diff --git a/package/src/operations/execute.ts b/package/src/operations/execute.ts
@@ -1,9 +1,6 @@
-import {
-  NITRO_SQLITE_NULL,
-  isNitroSQLiteNull,
-  isSimpleNullHandlingEnabled,
-} from '..'
+import { isNitroSQLiteNull, isSimpleNullHandlingEnabled } from '../nullHandling'
 import { HybridNitroSQLite } from '../nitro'
+import { replaceWithNativeNullValue } from '../nullHandling'
 import type { NativeQueryResult } from '../specs/NativeQueryResult.nitro'
 import type {
   QueryResult,
@@ -17,10 +14,14 @@ export function execute<Row extends QueryResultRow = never>(
   query: string,
   params?: SQLiteQueryParams
 ): QueryResult<Row> {
+  const transformedParams = isSimpleNullHandlingEnabled()
+    ? toNativeQueryParams(params)
+    : (params as NativeSQLiteQueryParams)
+
   const nativeResult = HybridNitroSQLite.execute(
     dbName,
     query,
-    toNativeQueryParams(params)
+    transformedParams
   )
   const result = buildJsQueryResult<Row>(nativeResult)
   return result
@@ -47,12 +48,7 @@ export async function executeAsync<Row extends QueryResultRow = never>(
 function toNativeQueryParams(
   params: SQLiteQueryParams | undefined
 ): NativeSQLiteQueryParams | undefined {
-  return params?.map((param) => {
-    if (param === undefined || param === null) {
-      return NITRO_SQLITE_NULL
-    }
-    return param
-  })
+  return params?.map((param) => replaceWithNativeNullValue(param))
 }
 
 function buildJsQueryResult<Row extends QueryResultRow = never>({
diff --git a/package/src/operations/executeBatch.ts b/package/src/operations/executeBatch.ts
@@ -0,0 +1,56 @@
+import {
+  isSimpleNullHandlingEnabled,
+  replaceWithNativeNullValue,
+} from '../nullHandling'
+import { HybridNitroSQLite } from '../nitro'
+import type {
+  NativeSQLiteQueryParams,
+  BatchQueryResult,
+  BatchQueryCommand,
+  NativeBatchQueryCommand,
+} from '../types'
+
+export function executeBatch(
+  dbName: string,
+  commands: BatchQueryCommand[]
+): BatchQueryResult {
+  const transformedCommands = isSimpleNullHandlingEnabled()
+    ? toNativeBatchQueryCommands(commands)
+    : (commands as NativeBatchQueryCommand[])
+
+  const result = HybridNitroSQLite.executeBatch(dbName, transformedCommands)
+  return result
+}
+
+export async function executeBatchAsync(
+  dbName: string,
+  commands: BatchQueryCommand[]
+): Promise<BatchQueryResult> {
+  const transformedCommands = isSimpleNullHandlingEnabled()
+    ? toNativeBatchQueryCommands(commands)
+    : (commands as NativeBatchQueryCommand[])
+
+  const result = await HybridNitroSQLite.executeBatchAsync(
+    dbName,
+    transformedCommands
+  )
+  return result
+}
+
+function toNativeBatchQueryCommands(
+  commands: BatchQueryCommand[]
+): NativeBatchQueryCommand[] {
+  return commands.map((command) => {
+    const transformedParams = command.params?.map((param) => {
+      if (Array.isArray(param)) {
+        return param.map((p) => replaceWithNativeNullValue(p))
+      }
+      return replaceWithNativeNullValue(param)
+    }) as NativeSQLiteQueryParams | NativeSQLiteQueryParams[]
+
+    return {
+      query: command.query,
+      params: transformedParams,
+    }
+  })
+}
diff --git a/package/src/operations/session.ts b/package/src/operations/session.ts
@@ -10,6 +10,7 @@ import type {
   QueryResultRow,
 } from '../types'
 import { execute, executeAsync } from './execute'
+import { executeBatch, executeBatchAsync } from './executeBatch'
 
 export function open(
   options: NitroSQLiteConnectionOptions
@@ -33,9 +34,9 @@ export function open(
       params?: SQLiteQueryParams
     ): Promise<QueryResult<Row>> => executeAsync(options.name, query, params),
     executeBatch: (commands: BatchQueryCommand[]) =>
-      HybridNitroSQLite.executeBatch(options.name, commands),
+      executeBatch(options.name, commands),
     executeBatchAsync: (commands: BatchQueryCommand[]) =>
-      HybridNitroSQLite.executeBatchAsync(options.name, commands),
+      executeBatchAsync(options.name, commands),
     loadFile: (location: string) =>
       HybridNitroSQLite.loadFile(options.name, location),
     loadFileAsync: (location: string) =>
diff --git a/package/src/specs/NitroSQLite.nitro.ts b/package/src/specs/NitroSQLite.nitro.ts
diff --git a/package/src/types.ts b/package/src/types.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "react-native-nitro-sqlite",`
`3`		`- "version": "9.1.7",`
	`3`	`+ "version": "9.1.8",`
`4`	`4`	`"description": "Fast SQLite library for React Native built using Nitro Modules",`
`5`	`5`	`"source": "./src/index.ts",`
`6`	`6`	`"main": "./lib/commonjs/index",`