react-native-nitro-sqlite 9.1.2 → 9.1.4

package/src/index.ts

@@ -3,8 +3,8 @@ import { HybridNitroSQLite } from './nitro'
 import { open } from './operations/session'
 import NitroSQLiteOnLoad from './specs/NativeNitroSQLiteOnLoad'
 import { execute, executeAsync } from './operations/execute'
-
-export * from './types'
+import { SQLiteNullValue } from './types'
+export type * from './types'
 export { typeORMDriver } from './typeORM'
 
 export const onInitialized = new Promise<void>((resolve) => {
@@ -25,3 +25,21 @@ export const NitroSQLite = {
 }
 
 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
+}

package/src/operations/execute.ts

@@ -1,37 +1,79 @@
+import {
+  NITRO_SQLITE_NULL,
+  isNitroSQLiteNull,
+  isSimpleNullHandlingEnabled,
+} from '..'
 import { HybridNitroSQLite } from '../nitro'
 import type { NativeQueryResult } from '../specs/NativeQueryResult.nitro'
-import type { QueryResult, SQLiteItem, SQLiteQueryParams } from '../types'
+import type {
+  QueryResult,
+  NativeSQLiteQueryParams,
+  SQLiteQueryParams,
+  QueryResultRow,
+} from '../types'
 
-export function execute<Data extends SQLiteItem = never>(
+export function execute<Row extends QueryResultRow = never>(
   dbName: string,
   query: string,
   params?: SQLiteQueryParams
-): QueryResult<Data> {
-  const nativeResult = HybridNitroSQLite.execute(dbName, query, params)
-  const result = buildJsQueryResult<Data>(nativeResult)
+): QueryResult<Row> {
+  const nativeResult = HybridNitroSQLite.execute(
+    dbName,
+    query,
+    toNativeQueryParams(params)
+  )
+  const result = buildJsQueryResult<Row>(nativeResult)
   return result
 }
 
-export async function executeAsync<Data extends SQLiteItem = never>(
+export async function executeAsync<Row extends QueryResultRow = never>(
   dbName: string,
   query: string,
   params?: SQLiteQueryParams
-): Promise<QueryResult<Data>> {
+): Promise<QueryResult<Row>> {
+  const transformedParams = isSimpleNullHandlingEnabled()
+    ? toNativeQueryParams(params)
+    : (params as NativeSQLiteQueryParams)
+
   const nativeResult = await HybridNitroSQLite.executeAsync(
     dbName,
     query,
-    params
+    transformedParams
   )
-  const result = buildJsQueryResult<Data>(nativeResult)
+  const result = buildJsQueryResult<Row>(nativeResult)
   return result
 }
 
-function buildJsQueryResult<Data extends SQLiteItem = never>({
+function toNativeQueryParams(
+  params: SQLiteQueryParams | undefined
+): NativeSQLiteQueryParams | undefined {
+  return params?.map((param) => {
+    if (param === undefined || param === null) {
+      return NITRO_SQLITE_NULL
+    }
+    return param
+  })
+}
+
+function buildJsQueryResult<Row extends QueryResultRow = never>({
   insertId,
   rowsAffected,
   results,
-}: NativeQueryResult): QueryResult<Data> {
-  const data = results as Data[]
+}: NativeQueryResult): QueryResult<Row> {
+  let data: Row[] = results as Row[]
+
+  if (isSimpleNullHandlingEnabled()) {
+    data = results.map((row) =>
+      Object.fromEntries(
+        Object.entries(row).map(([key, value]) => {
+          if (isNitroSQLiteNull(value)) {
+            return [key, null]
+          }
+          return [key, value]
+        })
+      )
+    ) as Row[]
+  }
 
   return {
     insertId,

package/src/operations/session.ts

@@ -5,9 +5,9 @@ import type {
   NitroSQLiteConnection,
   NitroSQLiteConnectionOptions,
   QueryResult,
-  SQLiteItem,
-  SQLiteQueryParams,
   Transaction,
+  SQLiteQueryParams,
+  QueryResultRow,
 } from '../types'
 import { execute, executeAsync } from './execute'
 
@@ -24,14 +24,14 @@ export function open(
     detach: (alias: string) => HybridNitroSQLite.detach(options.name, alias),
     transaction: (fn: (tx: Transaction) => Promise<void> | void) =>
       transaction(options.name, fn),
-    execute: <Data extends SQLiteItem = never>(
+    execute: <Row extends QueryResultRow = never>(
       query: string,
       params?: SQLiteQueryParams
-    ): QueryResult<Data> => execute(options.name, query, params),
-    executeAsync: <Data extends SQLiteItem = never>(
+    ): QueryResult<Row> => execute(options.name, query, params),
+    executeAsync: <Row extends QueryResultRow = never>(
       query: string,
       params?: SQLiteQueryParams
-    ): Promise<QueryResult<Data>> => executeAsync(options.name, query, params),
+    ): Promise<QueryResult<Row>> => executeAsync(options.name, query, params),
     executeBatch: (commands: BatchQueryCommand[]) =>
       HybridNitroSQLite.executeBatch(options.name, commands),
     executeBatchAsync: (commands: BatchQueryCommand[]) =>

package/src/operations/transaction.ts

@@ -1,9 +1,9 @@
 import { locks, HybridNitroSQLite } from '../nitro'
 import type {
   QueryResult,
-  SQLiteItem,
-  SQLiteQueryParams,
   Transaction,
+  SQLiteQueryParams,
+  QueryResultRow,
 } from '../types'
 import { execute, executeAsync } from './execute'
 
@@ -30,7 +30,7 @@ export const transaction = (
   let isFinalized = false
 
   // Local transaction context object implementation
-  const executeOnTransaction = <Data extends SQLiteItem = never>(
+  const executeOnTransaction = <Data extends QueryResultRow = never>(
     query: string,
     params?: SQLiteQueryParams
   ): QueryResult<Data> => {
@@ -42,7 +42,7 @@ export const transaction = (
     return execute(dbName, query, params)
   }
 
-  const executeAsyncOnTransaction = <Data extends SQLiteItem = never>(
+  const executeAsyncOnTransaction = <Data extends QueryResultRow = never>(
     query: string,
     params?: SQLiteQueryParams
   ): Promise<QueryResult<Data>> => {

package/src/specs/NativeQueryResult.nitro.ts

@@ -17,7 +17,7 @@ export interface NativeQueryResult
   readonly insertId?: number
 
   /** Query results */
-  readonly results: SQLiteQueryResults
+  readonly results: NativeSQLiteQueryResults
   /** Table metadata */
   readonly metadata?: Record<string, SQLiteQueryColumnMetadata>
 }
@@ -30,7 +30,7 @@ export interface NativeQueryResult
 // TODO: Investigate why this doesn't work with nitrogen
 // export type SQLiteQueryResultRow = Record<string, SQLiteValue>
 // export type SQLiteQueryResults = SQLiteQueryResultRow[]
-export type SQLiteQueryResults = Record<string, SQLiteValue>[]
+export type NativeSQLiteQueryResults = Record<string, SQLiteValue>[]
 
 // TODO: Investigate why this doesn't work with nitrogen
 // export type SQLiteQueryTableMetadata = Record<string, SQLiteQueryColumnMetadata>

package/src/specs/NitroSQLite.nitro.ts

@@ -3,7 +3,7 @@ import type {
   BatchQueryResult,
   FileLoadResult,
   BatchQueryCommand,
-  SQLiteQueryParams,
+  NativeSQLiteQueryParams,
 } from '../types'
 import type { NativeQueryResult } from './NativeQueryResult.nitro'
 
@@ -22,12 +22,12 @@ export interface NitroSQLite
   execute(
     dbName: string,
     query: string,
-    params?: SQLiteQueryParams
+    params?: NativeSQLiteQueryParams
   ): NativeQueryResult
   executeAsync(
     dbName: string,
     query: string,
-    params?: SQLiteQueryParams
+    params?: NativeSQLiteQueryParams
   ): Promise<NativeQueryResult>
   executeBatch(dbName: string, commands: BatchQueryCommand[]): BatchQueryResult
   executeBatchAsync(

package/src/typeORM.ts

@@ -7,14 +7,14 @@
 
 import type {
   QueryResult,
-  SQLiteItem,
-  SQLiteQueryParams,
   Transaction,
+  SQLiteQueryParams,
+  QueryResultRow,
 } from './types'
 import * as Operations from './operations/session'
 
 interface TypeOrmNitroSQLiteConnection {
-  executeSql: <RowData extends SQLiteItem = never>(
+  executeSql: <RowData extends QueryResultRow = never>(
     sql: string,
     params: SQLiteQueryParams | undefined,
     okExecute: (res: QueryResult<RowData>) => void,
@@ -48,7 +48,7 @@ export const typeORMDriver = {
       const db = Operations.open(options)
 
       const connection: TypeOrmNitroSQLiteConnection = {
-        executeSql: async <RowData extends SQLiteItem = never>(
+        executeSql: async <RowData extends QueryResultRow = never>(
           sql: string,
           params: SQLiteQueryParams | undefined,
           okExecute: (res: QueryResult<RowData>) => void,

package/src/types.ts

@@ -26,41 +26,52 @@ export enum ColumnType {
   NULL_VALUE,
 }
 
+// Passing null/undefined in array types is not possible, so we us a special struct as a workaround.
+export type SQLiteNullValue = {
+  isNitroSQLiteNull: true
+}
+export type SQLiteValue =
+  | boolean
+  | number
+  | string
+  | ArrayBuffer
+  | SQLiteNullValue
+export type NativeSQLiteQueryParams = SQLiteValue[]
+
 /**
  * Represents a value that can be stored in a SQLite database
  */
-export type SQLiteValue = boolean | number | string | ArrayBuffer | undefined
+export type SQLiteQueryParamItem = SQLiteValue | null | undefined
+export type SQLiteQueryParams = SQLiteQueryParamItem[]
 
-export type SQLiteItem = Record<string, SQLiteValue>
-
-export interface QueryResult<RowData extends SQLiteItem = SQLiteItem> {
+export type QueryResultRowItem = SQLiteValue | undefined
+export type QueryResultRow = Record<string, QueryResultRowItem>
+export interface QueryResult<Row extends QueryResultRow = QueryResultRow> {
   readonly insertId?: number
   readonly rowsAffected: number
 
   readonly rows?: {
     /** Raw array with all dataset */
-    _array: RowData[]
+    _array: Row[]
     /** The lengh of the dataset */
     length: number
     /** A convenience function to acess the index based the row object
      * @param idx the row index
      * @returns the row structure identified by column names
      */
-    item: (idx: number) => RowData | undefined
+    item: (idx: number) => Row | undefined
   }
 }
 
-export type SQLiteQueryParams = SQLiteValue[]
-
-export type ExecuteQuery = <RowData extends SQLiteItem = SQLiteItem>(
+export type ExecuteQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
   params?: SQLiteQueryParams
-) => QueryResult<RowData>
+) => QueryResult<Row>
 
-export type ExecuteAsyncQuery = <RowData extends SQLiteItem = SQLiteItem>(
+export type ExecuteAsyncQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
   params?: SQLiteQueryParams
-) => Promise<QueryResult<RowData>>
+) => Promise<QueryResult<Row>>
 
 export interface Transaction {
   commit(): QueryResult

package/nitrogen/generated/android/RNNitroSQLiteOnLoad.kt

@@ -1 +0,0 @@
-