Updated uuid dependency and updated uuid import to work in react native

Author: Christiaan Landman

package.json

@@ -49,7 +49,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.26.2",
     "@types/lodash": "^4.14.200",
-    "@types/uuid": "3.4.0",
+    "@types/uuid": "^9.0.1",
     "react": "18.2.0",
     "react-native": "0.71.0",
     "react-native-builder-bob": "^0.18.2",
@@ -82,6 +82,6 @@
   },
   "dependencies": {
     "lodash": "^4.17.21",
-    "uuid": "3.4.0"
+    "uuid": "^9.0.1"
   }
 }

src/setup-open.ts

@@ -9,10 +9,10 @@ import {
   UpdateCallback,
   SQLBatchTuple,
   OpenOptions,
-  QueryResult
+  QueryResult,
 } from './types';
 
-import uuid from 'uuid';
+import { v4 } from 'uuid';
 import _ from 'lodash';
 import { enhanceQueryResult } from './utils';
 import { DBListenerManagerInternal } from './DBListenerManager';
@@ -25,7 +25,7 @@ type LockCallbackRecord = {
 
 enum TransactionFinalizer {
   COMMIT = 'commit',
-  ROLLBACK = 'rollback'
+  ROLLBACK = 'rollback',
 }
 
 const DEFAULT_READ_CONNECTIONS = 4;
@@ -49,7 +49,10 @@ function closeContextLock(dbName: string, id: ContextLockID) {
  * @param lockId
  * @returns
  */
-global.onLockContextIsAvailable = async (dbName: string, lockId: ContextLockID) => {
+global.onLockContextIsAvailable = async (
+  dbName: string,
+  lockId: ContextLockID
+) => {
   // Don't hold C++ bridge side up waiting to complete
   setImmediate(async () => {
     try {
@@ -61,10 +64,15 @@ global.onLockContextIsAvailable = async (dbName: string, lockId: ContextLockID)
         // @ts-expect-error This is not part of the public interface, but is used internally
         _contextId: lockId,
         execute: async (sql: string, args?: any[]) => {
-          const result = await proxy.executeInContext(dbName, lockId, sql, args);
+          const result = await proxy.executeInContext(
+            dbName,
+            lockId,
+            sql,
+            args
+          );
           enhanceQueryResult(result);
           return result;
-        }
+        },
       });
     } catch (ex) {
       console.error(ex);
@@ -87,11 +95,15 @@ export function setupOpen(QuickSQLite: ISQLite) {
      * By default opens DB in WAL mode with 4 Read connections and a single
      * write connection
      */
-    open: (dbName: string, options: OpenOptions = {}): QuickSQLiteConnection => {
+    open: (
+      dbName: string,
+      options: OpenOptions = {}
+    ): QuickSQLiteConnection => {
       // Opens the connection
       QuickSQLite.open(dbName, {
         ...options,
-        numReadConnections: options?.numReadConnections ?? DEFAULT_READ_CONNECTIONS
+        numReadConnections:
+          options?.numReadConnections ?? DEFAULT_READ_CONNECTIONS,
       });
 
       const listenerManager = new DBListenerManagerInternal({ dbName });
@@ -106,7 +118,7 @@ export function setupOpen(QuickSQLite: ISQLite) {
         options?: LockOptions,
         hooks?: LockHooks
       ): Promise<T> => {
-        const id = uuid.v4(); // TODO maybe do this in C++
+        const id = v4(); // TODO maybe do this in C++
         // Wrap the callback in a promise that will resolve to the callback result
         return new Promise<T>((resolve, reject) => {
           // Add callback to the queue for timing
@@ -117,14 +129,14 @@ export function setupOpen(QuickSQLite: ISQLite) {
                 const res = await callback(context);
 
                 closeContextLock(dbName, id);
-                resolve(res)
+                resolve(res);
               } catch (ex) {
                 closeContextLock(dbName, id);
-                reject(ex)
+                reject(ex);
               } finally {
-                hooks?.lockReleased?.()
+                hooks?.lockReleased?.();
               }
-            }
+            },
           } as LockCallbackRecord);
 
           try {
@@ -145,15 +157,20 @@ export function setupOpen(QuickSQLite: ISQLite) {
         });
       };
 
-      const readLock = <T>(callback: (context: LockContext) => Promise<T>, options?: LockOptions): Promise<T> =>
-        requestLock(ConcurrentLockType.READ, callback, options);
+      const readLock = <T>(
+        callback: (context: LockContext) => Promise<T>,
+        options?: LockOptions
+      ): Promise<T> => requestLock(ConcurrentLockType.READ, callback, options);
 
-      const writeLock = <T>(callback: (context: LockContext) => Promise<T>, options?: LockOptions): Promise<T> =>
+      const writeLock = <T>(
+        callback: (context: LockContext) => Promise<T>,
+        options?: LockOptions
+      ): Promise<T> =>
         requestLock(ConcurrentLockType.WRITE, callback, options, {
           lockReleased: async () => {
             // flush updates once a write lock has been released
             listenerManager.flushUpdates();
-          }
+          },
         });
 
       const wrapTransaction = async <T>(
@@ -174,17 +191,23 @@ export function setupOpen(QuickSQLite: ISQLite) {
             return action();
           };
 
-        const commit = finalizedStatement(async () => context.execute('COMMIT'));
+        const commit = finalizedStatement(async () =>
+          context.execute('COMMIT')
+        );
 
-        const rollback = finalizedStatement(async () => context.execute('ROLLBACK'));
+        const rollback = finalizedStatement(async () =>
+          context.execute('ROLLBACK')
+        );
 
         const wrapExecute =
           <T>(
             method: (sql: string, params?: any[]) => Promise<QueryResult>
           ): ((sql: string, params?: any[]) => Promise<QueryResult>) =>
           async (sql: string, params?: any[]) => {
             if (finalized) {
-              throw new Error(`Cannot execute in transaction after it has been finalized with commit/rollback.`);
+              throw new Error(
+                `Cannot execute in transaction after it has been finalized with commit/rollback.`
+              );
             }
             return method(sql, params);
           };
@@ -194,7 +217,7 @@ export function setupOpen(QuickSQLite: ISQLite) {
             ...context,
             commit,
             rollback,
-            execute: wrapExecute(context.execute)
+            execute: wrapExecute(context.execute),
           });
           switch (defaultFinalizer) {
             case TransactionFinalizer.COMMIT:
@@ -214,26 +237,45 @@ export function setupOpen(QuickSQLite: ISQLite) {
       // Return the concurrent connection object
       return {
         close: () => QuickSQLite.close(dbName),
-        execute: (sql: string, args?: any[]) => writeLock((context) => context.execute(sql, args)),
+        execute: (sql: string, args?: any[]) =>
+          writeLock((context) => context.execute(sql, args)),
         readLock,
-        readTransaction: async <T>(callback: (context: TransactionContext) => Promise<T>, options?: LockOptions) =>
-          readLock((context) => wrapTransaction(context, callback)),
+        readTransaction: async <T>(
+          callback: (context: TransactionContext) => Promise<T>,
+          options?: LockOptions
+        ) => readLock((context) => wrapTransaction(context, callback)),
         writeLock,
-        writeTransaction: async <T>(callback: (context: TransactionContext) => Promise<T>, options?: LockOptions) =>
-          writeLock((context) => wrapTransaction(context, callback, TransactionFinalizer.COMMIT), options),
+        writeTransaction: async <T>(
+          callback: (context: TransactionContext) => Promise<T>,
+          options?: LockOptions
+        ) =>
+          writeLock(
+            (context) =>
+              wrapTransaction(context, callback, TransactionFinalizer.COMMIT),
+            options
+          ),
         delete: () => QuickSQLite.delete(dbName, options?.location),
         executeBatch: (commands: SQLBatchTuple[]) =>
-          writeLock((context) => QuickSQLite.executeBatch(dbName, commands, (context as any)._contextId)),
+          writeLock((context) =>
+            QuickSQLite.executeBatch(
+              dbName,
+              commands,
+              (context as any)._contextId
+            )
+          ),
         attach: (dbNameToAttach: string, alias: string, location?: string) =>
           QuickSQLite.attach(dbName, dbNameToAttach, alias, location),
         detach: (alias: string) => QuickSQLite.detach(dbName, alias),
         loadFile: (location: string) =>
-          writeLock((context) => QuickSQLite.loadFile(dbName, location, (context as any)._contextId)),
+          writeLock((context) =>
+            QuickSQLite.loadFile(dbName, location, (context as any)._contextId)
+          ),
         listenerManager,
         registerUpdateHook: (callback: UpdateCallback) =>
           listenerManager.registerListener({ rawTableChange: callback }),
-        registerTablesChangedHook: (callback) => listenerManager.registerListener({ tablesUpdated: callback })
+        registerTablesChangedHook: (callback) =>
+          listenerManager.registerListener({ tablesUpdated: callback }),
       };
-    }
+    },
   };
 }

tests/package.json

@@ -33,7 +33,7 @@
     "tailwindcss": "^3.2.4",
     "typeorm": "^0.3.11",
     "util": "^0.12.5",
-    "uuid": "3.4.0"
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@babel/core": "^7.20.0",