feat: add null support in JS and update types

chrispader · chrispader · commit 8de04df98fca · 2025-02-15T14:34:34.000+01:00
diff --git a/package/src/index.ts b/package/src/index.ts
@@ -3,10 +3,12 @@ import { HybridNitroSQLite } from './nitro'
 import { open } from './operations/session'
 import NitroSQLiteOnLoad from './specs/NativeNitroSQLiteOnLoad'
 import { execute, executeAsync } from './operations/execute'
-
-export * from './types'
+import { NativeSqliteNullValue } from './types'
+export type * from './types'
 export { typeORMDriver } from './typeORM'
 
+export const NITRO_SQLITE_NULL: NativeSqliteNullValue = { isNull: true }
+
 export const onInitialized = new Promise<void>((resolve) => {
   NitroSQLiteOnLoad.onReactApplicationContextReady(resolve)
 })
diff --git a/package/src/operations/execute.ts b/package/src/operations/execute.ts
@@ -1,37 +1,67 @@
+import { NITRO_SQLITE_NULL } 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<Data extends QueryResultRow = never>(
   dbName: string,
   query: string,
   params?: SQLiteQueryParams
 ): QueryResult<Data> {
-  const nativeResult = HybridNitroSQLite.execute(dbName, query, params)
+  const nativeResult = HybridNitroSQLite.execute(
+    dbName,
+    query,
+    toNativeQueryParams(params)
+  )
   const result = buildJsQueryResult<Data>(nativeResult)
   return result
 }
 
-export async function executeAsync<Data extends SQLiteItem = never>(
+export async function executeAsync<Data extends QueryResultRow = never>(
   dbName: string,
   query: string,
   params?: SQLiteQueryParams
 ): Promise<QueryResult<Data>> {
   const nativeResult = await HybridNitroSQLite.executeAsync(
     dbName,
     query,
-    params
+    toNativeQueryParams(params)
   )
   const result = buildJsQueryResult<Data>(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<Data extends QueryResultRow = never>({
   insertId,
   rowsAffected,
   results,
 }: NativeQueryResult): QueryResult<Data> {
-  const data = results as Data[]
+  const data = results.map((row) =>
+    Object.fromEntries(
+      Object.entries(row).map(([key, value]) => {
+        if (value === NITRO_SQLITE_NULL) {
+          return [key, undefined]
+        }
+        return [key, value]
+      })
+    )
+  ) as Data[]
 
   return {
     insertId,
diff --git a/package/src/operations/session.ts b/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,11 +24,11 @@ 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: <Data extends QueryResultRow = never>(
       query: string,
       params?: SQLiteQueryParams
     ): QueryResult<Data> => execute(options.name, query, params),
-    executeAsync: <Data extends SQLiteItem = never>(
+    executeAsync: <Data extends QueryResultRow = never>(
       query: string,
       params?: SQLiteQueryParams
     ): Promise<QueryResult<Data>> => executeAsync(options.name, query, params),
diff --git a/package/src/operations/transaction.ts b/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>> => {
diff --git a/package/src/specs/NativeQueryResult.nitro.ts b/package/src/specs/NativeQueryResult.nitro.ts
@@ -1,5 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules'
-import type { ColumnType, SQLiteValue } from '../types'
+import type { ColumnType, NativeSQLiteValue } from '../types'
 
 /**
  * Object returned by SQL Query executions {
@@ -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, NativeSQLiteValue>[]
 
 // TODO: Investigate why this doesn't work with nitrogen
 // export type SQLiteQueryTableMetadata = Record<string, SQLiteQueryColumnMetadata>
diff --git a/package/src/specs/NitroSQLite.nitro.ts b/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(
diff --git a/package/src/typeORM.ts b/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,
diff --git a/package/src/types.ts b/package/src/types.ts
@@ -26,14 +26,24 @@ export enum ColumnType {
   NULL_VALUE,
 }
 
+export type BaseSQLiteValue = boolean | number | string | ArrayBuffer
+
+// Passing null/undefined in array types is not possible, so we us a special struct as a workaround.
+export type NativeSqliteNullValue = {
+  isNull: true
+}
+export type NativeSQLiteValue = BaseSQLiteValue | NativeSqliteNullValue
+export type NativeSQLiteQueryParams = NativeSQLiteValue[]
+
 /**
  * Represents a value that can be stored in a SQLite database
  */
-export type SQLiteValue = boolean | number | string | ArrayBuffer | undefined
-
-export type SQLiteItem = Record<string, SQLiteValue>
+export type SQLiteValue = BaseSQLiteValue | null | undefined
+export type SQLiteQueryParams = SQLiteValue[]
 
-export interface QueryResult<RowData extends SQLiteItem = SQLiteItem> {
+export type QueryResultItem = BaseSQLiteValue | undefined
+export type QueryResultRow = Record<string, QueryResultItem>
+export interface QueryResult<RowData extends QueryResultRow = QueryResultRow> {
   readonly insertId?: number
   readonly rowsAffected: number
 
@@ -50,14 +60,14 @@ export interface QueryResult<RowData extends SQLiteItem = SQLiteItem> {
   }
 }
 
-export type SQLiteQueryParams = SQLiteValue[]
-
-export type ExecuteQuery = <RowData extends SQLiteItem = SQLiteItem>(
+export type ExecuteQuery = <RowData extends QueryResultRow = QueryResultRow>(
   query: string,
   params?: SQLiteQueryParams
 ) => QueryResult<RowData>
 
-export type ExecuteAsyncQuery = <RowData extends SQLiteItem = SQLiteItem>(
+export type ExecuteAsyncQuery = <
+  RowData extends QueryResultRow = QueryResultRow,
+>(
   query: string,
   params?: SQLiteQueryParams
 ) => Promise<QueryResult<RowData>>
