@vailix/mask 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @vailix/mask
 
+## 0.2.2
+
+### Patch Changes
+
+- 4b6a9d5: fix: ensure database is closed before deletion on key mismatch and add missing internal types
+
 ## 0.2.1
 
 ### Patch Changes

package/dist/index.js

@@ -775,35 +775,54 @@ var import_expo_sqlite2 = require("expo-sqlite");
 var import_drizzle_orm2 = require("drizzle-orm");
 var DB_NAME = "vailix.db";
 async function initializeDatabase(masterKey) {
+  const result = await tryOpenEncryptedDatabase(masterKey);
+  if (result.success) {
+    return result.db;
+  }
+  console.warn("Database key mismatch, recreating fresh database");
+  if (result.expo) {
+    result.expo.closeSync();
+  }
+  (0, import_expo_sqlite2.deleteDatabaseSync)(DB_NAME);
+  const retryResult = await tryOpenEncryptedDatabase(masterKey);
+  if (!retryResult.success) {
+    if (retryResult.expo) {
+      retryResult.expo.closeSync();
+    }
+    throw retryResult.error;
+  }
+  return retryResult.db;
+}
+async function tryOpenEncryptedDatabase(masterKey) {
+  let expo = null;
   try {
-    return await openEncryptedDatabase(masterKey);
+    expo = (0, import_expo_sqlite2.openDatabaseSync)(DB_NAME);
+    const db = (0, import_expo_sqlite.drizzle)(expo);
+    if (!/^[0-9a-f]+$/i.test(masterKey)) {
+      throw new Error("Invalid master key format");
+    }
+    await db.run(import_drizzle_orm2.sql.raw(`PRAGMA key = '${masterKey}'`));
+    await db.run(import_drizzle_orm2.sql`SELECT 1`);
+    await db.run(import_drizzle_orm2.sql`
+            CREATE TABLE IF NOT EXISTS scanned_events (
+                id TEXT PRIMARY KEY,
+                rpi TEXT NOT NULL,
+                metadata_key TEXT NOT NULL,
+                timestamp INTEGER NOT NULL
+            )
+        `);
+    await db.run(import_drizzle_orm2.sql`
+            CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
+        `);
+    return { success: true, db, expo };
   } catch (error) {
-    console.warn("Database key mismatch, recreating fresh database");
-    (0, import_expo_sqlite2.deleteDatabaseSync)(DB_NAME);
-    return await openEncryptedDatabase(masterKey);
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error)),
+      expo
+    };
   }
 }
-async function openEncryptedDatabase(masterKey) {
-  const expo = (0, import_expo_sqlite2.openDatabaseSync)(DB_NAME);
-  const db = (0, import_expo_sqlite.drizzle)(expo);
-  if (!/^[0-9a-f]+$/i.test(masterKey)) {
-    throw new Error("Invalid master key format");
-  }
-  await db.run(import_drizzle_orm2.sql.raw(`PRAGMA key = '${masterKey}'`));
-  await db.run(import_drizzle_orm2.sql`SELECT 1`);
-  await db.run(import_drizzle_orm2.sql`
-    CREATE TABLE IF NOT EXISTS scanned_events (
-      id TEXT PRIMARY KEY,
-      rpi TEXT NOT NULL,
-      metadata_key TEXT NOT NULL,
-      timestamp INTEGER NOT NULL
-    )
-  `);
-  await db.run(import_drizzle_orm2.sql`
-    CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
-  `);
-  return db;
-}
 
 // src/index.ts
 var VailixSDK = class _VailixSDK {

package/dist/index.mjs

@@ -739,35 +739,54 @@ import { openDatabaseSync, deleteDatabaseSync } from "expo-sqlite";
 import { sql } from "drizzle-orm";
 var DB_NAME = "vailix.db";
 async function initializeDatabase(masterKey) {
+  const result = await tryOpenEncryptedDatabase(masterKey);
+  if (result.success) {
+    return result.db;
+  }
+  console.warn("Database key mismatch, recreating fresh database");
+  if (result.expo) {
+    result.expo.closeSync();
+  }
+  deleteDatabaseSync(DB_NAME);
+  const retryResult = await tryOpenEncryptedDatabase(masterKey);
+  if (!retryResult.success) {
+    if (retryResult.expo) {
+      retryResult.expo.closeSync();
+    }
+    throw retryResult.error;
+  }
+  return retryResult.db;
+}
+async function tryOpenEncryptedDatabase(masterKey) {
+  let expo = null;
   try {
-    return await openEncryptedDatabase(masterKey);
+    expo = openDatabaseSync(DB_NAME);
+    const db = drizzle(expo);
+    if (!/^[0-9a-f]+$/i.test(masterKey)) {
+      throw new Error("Invalid master key format");
+    }
+    await db.run(sql.raw(`PRAGMA key = '${masterKey}'`));
+    await db.run(sql`SELECT 1`);
+    await db.run(sql`
+            CREATE TABLE IF NOT EXISTS scanned_events (
+                id TEXT PRIMARY KEY,
+                rpi TEXT NOT NULL,
+                metadata_key TEXT NOT NULL,
+                timestamp INTEGER NOT NULL
+            )
+        `);
+    await db.run(sql`
+            CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
+        `);
+    return { success: true, db, expo };
   } catch (error) {
-    console.warn("Database key mismatch, recreating fresh database");
-    deleteDatabaseSync(DB_NAME);
-    return await openEncryptedDatabase(masterKey);
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error)),
+      expo
+    };
   }
 }
-async function openEncryptedDatabase(masterKey) {
-  const expo = openDatabaseSync(DB_NAME);
-  const db = drizzle(expo);
-  if (!/^[0-9a-f]+$/i.test(masterKey)) {
-    throw new Error("Invalid master key format");
-  }
-  await db.run(sql.raw(`PRAGMA key = '${masterKey}'`));
-  await db.run(sql`SELECT 1`);
-  await db.run(sql`
-    CREATE TABLE IF NOT EXISTS scanned_events (
-      id TEXT PRIMARY KEY,
-      rpi TEXT NOT NULL,
-      metadata_key TEXT NOT NULL,
-      timestamp INTEGER NOT NULL
-    )
-  `);
-  await db.run(sql`
-    CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
-  `);
-  return db;
-}
 
 // src/index.ts
 var VailixSDK = class _VailixSDK {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vailix/mask",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Privacy-preserving proximity tracing SDK for React Native & Expo",
   "author": "Gil Eyni",
   "keywords": [

package/src/ble.ts

@@ -21,6 +21,50 @@ const DEFAULT_PROXIMITY_THRESHOLD = -70;
 
 import { generateDisplayName } from './utils';
 
+// ============================================================================
+// Internal Types (not exported - implementation details)
+// ============================================================================
+
+/**
+ * Internal representation of a nearby user with additional fields for BLE management.
+ * The public NearbyUser type hides these implementation details.
+ */
+interface InternalNearbyUser {
+    id: string;
+    displayName: string;
+    rssi: number;
+    discoveredAt: number;
+    paired: boolean;
+    hasIncomingRequest: boolean;
+    pairedAt?: number;
+    /** First 8 bytes (16 hex chars) of RPI from advertisement */
+    rpiPrefix: string;
+    /** Full RPI (received via GATT exchange) */
+    fullRpi?: string;
+    /** Metadata key (received via GATT exchange) */
+    metadataKey?: string;
+}
+
+/**
+ * Pending incoming pair request (explicit consent mode).
+ * Holds data in memory until user accepts.
+ */
+interface PendingPairRequest {
+    fullRpi: string;
+    metadataKey: string;
+    receivedAt: number;
+}
+
+/**
+ * Configuration options for BleService constructor.
+ */
+interface BleServiceConfig {
+    discoveryTimeoutMs?: number;
+    proximityThreshold?: number;
+    autoAccept?: boolean;
+    serviceUUID?: string;
+}
+
 /**
  * Extract RPI prefix from advertisement manufacturer data or service data.
  */

package/src/db.ts

@@ -1,5 +1,5 @@
 import { drizzle } from 'drizzle-orm/expo-sqlite';
-import { openDatabaseSync, deleteDatabaseSync } from 'expo-sqlite';
+import { openDatabaseSync, deleteDatabaseSync, type SQLiteDatabase } from 'expo-sqlite';
 import { sql } from 'drizzle-orm';
 import type { VailixDB } from './types';
 
@@ -13,45 +13,83 @@ const DB_NAME = 'vailix.db';
  * @param masterKey The user's master key, used to derive encryption password
  */
 export async function initializeDatabase(masterKey: string): Promise<VailixDB> {
-    try {
-        return await openEncryptedDatabase(masterKey);
-    } catch (error) {
-        // Key mismatch: "file is not a database" or similar SQLCipher error
-        // This happens when DB was restored from backup but key is different
-        console.warn('Database key mismatch, recreating fresh database');
-        deleteDatabaseSync(DB_NAME);
-        return await openEncryptedDatabase(masterKey);
+    const result = await tryOpenEncryptedDatabase(masterKey);
+    
+    if (result.success) {
+        return result.db;
+    }
+    
+    // Key mismatch: "file is not a database" or similar SQLCipher error
+    // This happens when DB was restored from backup but key is different
+    console.warn('Database key mismatch, recreating fresh database');
+    
+    // Close the connection before deletion (required by SQLite)
+    if (result.expo) {
+        result.expo.closeSync();
+    }
+    
+    deleteDatabaseSync(DB_NAME);
+    
+    // Retry - if this fails, let it throw (unrecoverable error)
+    const retryResult = await tryOpenEncryptedDatabase(masterKey);
+    if (!retryResult.success) {
+        if (retryResult.expo) {
+            retryResult.expo.closeSync();
+        }
+        throw retryResult.error;
     }
+    
+    return retryResult.db;
 }
 
-async function openEncryptedDatabase(masterKey: string): Promise<VailixDB> {
-    const expo = openDatabaseSync(DB_NAME);
-    const db = drizzle(expo);
+type OpenResult = 
+    | { success: true; db: VailixDB; expo: SQLiteDatabase }
+    | { success: false; error: Error; expo: SQLiteDatabase | null };
 
-    // Enable SQLCipher encryption using master key as password
-    // This encrypts the entire database at rest (AES-256)
-    // Validate key is hex to prevent SQL injection
-    if (!/^[0-9a-f]+$/i.test(masterKey)) {
-        throw new Error('Invalid master key format');
+/**
+ * Attempt to open and configure the encrypted database.
+ * Returns a result object that includes the raw expo connection for cleanup.
+ */
+async function tryOpenEncryptedDatabase(masterKey: string): Promise<OpenResult> {
+    let expo: SQLiteDatabase | null = null;
+    
+    try {
+        expo = openDatabaseSync(DB_NAME);
+        const db = drizzle(expo);
+
+        // Validate key is hex to prevent SQL injection
+        if (!/^[0-9a-f]+$/i.test(masterKey)) {
+            throw new Error('Invalid master key format');
+        }
+        
+        // Enable SQLCipher encryption using master key as password
+        // This encrypts the entire database at rest (AES-256)
+        await db.run(sql.raw(`PRAGMA key = '${masterKey}'`));
+
+        // Verify key works by attempting a read operation
+        // SQLCipher will throw if key is wrong
+        await db.run(sql`SELECT 1`);
+
+        // Create schema
+        await db.run(sql`
+            CREATE TABLE IF NOT EXISTS scanned_events (
+                id TEXT PRIMARY KEY,
+                rpi TEXT NOT NULL,
+                metadata_key TEXT NOT NULL,
+                timestamp INTEGER NOT NULL
+            )
+        `);
+
+        await db.run(sql`
+            CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
+        `);
+
+        return { success: true, db, expo };
+    } catch (error) {
+        return { 
+            success: false, 
+            error: error instanceof Error ? error : new Error(String(error)),
+            expo 
+        };
     }
-    await db.run(sql.raw(`PRAGMA key = '${masterKey}'`));
-
-    // Verify key works by attempting a read operation
-    // SQLCipher will throw if key is wrong
-    await db.run(sql`SELECT 1`);
-
-    await db.run(sql`
-    CREATE TABLE IF NOT EXISTS scanned_events (
-      id TEXT PRIMARY KEY,
-      rpi TEXT NOT NULL,
-      metadata_key TEXT NOT NULL,
-      timestamp INTEGER NOT NULL
-    )
-  `);
-
-    await db.run(sql`
-    CREATE INDEX IF NOT EXISTS rpi_idx ON scanned_events(rpi)
-  `);
-
-    return db;
 }