Merge pull request #10 from amarjanica/feature/import-export

add import and export

Author: amarjanica

app/settings.tsx

@@ -1,14 +1,16 @@
-import React from 'react';
+import React, { useContext } from 'react';
 import { View, Text, StyleSheet, Button } from 'react-native';
 import { useAppDispatch } from '@/store';
 import Header from '@/Header';
 import globalStyles from '@/globalStyles';
 import { clearData } from '@/store/globalReset';
 import { useDataContext } from '@/data/DataContext';
+import { SQLiteContext } from '@/data/SQLiteProvider';
 
 const SettingsPage = () => {
   const dispatch = useAppDispatch();
   const { opsClient } = useDataContext();
+  const dbCtx = useContext(SQLiteContext);
 
   return (
     <View style={globalStyles.root}>
@@ -24,6 +26,19 @@ const SettingsPage = () => {
             dispatch(clearData({ opsClient }));
           }}
         />
+        <Button
+          title="Import"
+          onPress={async () => {
+            await opsClient.restore();
+            await dbCtx.reload();
+          }}
+        />
+        <Button
+          title="Export"
+          onPress={async () => {
+            await opsClient.backup('testbackup.sqlite');
+          }}
+        />
       </View>
     </View>
   );

package-lock.json

@@ -22,7 +22,6 @@
     "eslint-plugin-prettier": "^5.2.1",
     "expo": "^51.0.34",
     "expo-constants": "~16.0.2",
-    "expo-dev-client": "~4.0.29",
     "expo-linking": "~6.3.1",
     "expo-router": "~3.5.23",
     "expo-sqlite": "~14.0.6",
@@ -40,9 +39,9 @@
     "redux-devtools-expo-dev-plugin": "^0.2.1",
     "semver": "^7.6.3",
     "sql.js": "^1.12.0",
-    "@expo/vector-icons": "^14.0.3",
-    "expo-document-picker": "~12.0.2",
+    "expo-dev-client": "~4.0.29",
     "expo-file-system": "~17.0.1",
+    "expo-document-picker": "~12.0.2",
     "expo-sharing": "~12.0.1"
   },
   "devDependencies": {

package.json

@@ -1,5 +1,5 @@
 import { OpsClient } from '@/clients/types';
-import { SQLiteDatabase } from '@/data/sqliteDatabase';
+import { backupDatabase, restoreDatabase, SQLiteDatabase } from '@/data/sqliteDatabase';
 
 class SQLiteOpsClient implements OpsClient {
   constructor(private db: SQLiteDatabase) {}
@@ -8,11 +8,11 @@ class SQLiteOpsClient implements OpsClient {
     await this.db.execAsync(`
 DELETE FROM task;`);
   }
-  async backup(): Promise<void> {
-    throw new Error('Method not implemented.');
+  async backup(backupName: string): Promise<void> {
+    await backupDatabase(this.db, backupName);
   }
   async restore(): Promise<void> {
-    throw new Error('Method not implemented.');
+    await restoreDatabase(this.db);
   }
 }
 

src/clients/SQLiteOpsClient.ts

@@ -13,6 +13,6 @@ export interface TaskClient {
  */
 export interface OpsClient {
   clear(): Promise<void>;
-  backup(): Promise<void>;
+  backup(backupName: string): Promise<void>;
   restore(): Promise<void>;
 }

src/clients/types.ts

@@ -1 +1 @@
-export const dbName = 'test.db';
+export const dbName = 'test.sqlite';

src/config.ts

@@ -2,7 +2,7 @@ import React, { createContext, useEffect, useState } from 'react';
 import logger from '@/logger';
 import { SQLiteDatabase, openDatabaseAsync } from '@/data/sqliteDatabase';
 
-const SQLiteContext = createContext<SQLiteDatabase | null>(null);
+export const SQLiteContext = createContext<{ db: SQLiteDatabase; reload: () => Promise<void> } | null>(null);
 function SQLiteProvider({
   databaseName,
   children,
@@ -17,28 +17,26 @@ function SQLiteProvider({
   const [error, setError] = useState<Error | null>(null);
   const isMounting = React.useRef(true);
   const isRunning = React.useRef(false); // New flag to track if the setup is still running
+  const setup = React.useCallback(async () => {
+    if (!isMounting.current || isRunning.current) return;
 
-  useEffect(() => {
-    const setup = async () => {
-      if (!isMounting.current || isRunning.current) return;
-
-      isMounting.current = false;
-      isRunning.current = true;
-      try {
-        const _db = await openDatabaseAsync(databaseName, undefined);
-        await onInit(_db);
-        logger.log(`Mounted sqlite provider`);
-        setDb(_db);
-        setLoading(false);
-      } catch (e: any) {
-        setError(e);
-      } finally {
-        isRunning.current = false; // Mark setup as complete
-      }
-    };
+    isMounting.current = false;
+    isRunning.current = true;
+    try {
+      const _db = await openDatabaseAsync(databaseName, undefined);
+      await onInit(_db);
+      logger.log(`Mounted sqlite provider`);
+      setDb(_db);
+      setLoading(false);
+    } catch (e: any) {
+      setError(e);
+    } finally {
+      isRunning.current = false; // Mark setup as complete
+    }
+  }, []);
 
+  useEffect(() => {
     void setup();
-
     return () => {
       isMounting.current = true;
     };
@@ -51,7 +49,21 @@ function SQLiteProvider({
 
   const isFullyLoaded = !loading && !!db;
 
-  return isFullyLoaded && <SQLiteContext.Provider value={db}>{children}</SQLiteContext.Provider>;
+  return (
+    isFullyLoaded && (
+      <SQLiteContext.Provider
+        value={{
+          db,
+          reload: async () => {
+            isMounting.current = true;
+            isRunning.current = false;
+            await setup();
+          },
+        }}>
+        {children}
+      </SQLiteContext.Provider>
+    )
+  );
 }
 
 export default SQLiteProvider;

src/data/SQLiteProvider.tsx

@@ -17,6 +17,9 @@ export async function loadFromIndexedDB(dbName: string): Promise<Uint8Array | nu
 }
 export async function saveToIndexedDB(db: Database, dbName: string) {
   const dbData = db.export();
+  await saveToIndexedDBBA(dbData, dbName);
+}
+export async function saveToIndexedDBBA(dbData: Uint8Array, dbName: string) {
   const idb = await idbPromise;
   await idb.put(STORE_NAME, dbData, dbName);
 }

src/data/indexedDatabase.ts

@@ -1 +1,56 @@
-export { openDatabaseAsync, SQLiteDatabase } from 'expo-sqlite';
+import { openDatabaseAsync, SQLiteDatabase } from 'expo-sqlite';
+import * as FileSystem from 'expo-file-system';
+import * as Sharing from 'expo-sharing';
+import * as DocumentPicker from 'expo-document-picker';
+import logger from '@/logger';
+
+export const backupDatabase = async (db: SQLiteDatabase, backupName: string) => {
+  try {
+    await db.execAsync('PRAGMA wal_checkpoint(FULL)');
+    const appPath = FileSystem.documentDirectory;
+    const dbPath = `${appPath}/SQLite/${db.databaseName}`;
+    const backupPath = `${appPath}/SQLite/${backupName}`;
+
+    await FileSystem.copyAsync({
+      from: dbPath,
+      to: backupPath,
+    });
+
+    await Sharing.shareAsync(backupPath, { mimeType: 'application/x-sqlite3' });
+    await FileSystem.deleteAsync(backupPath, { idempotent: true });
+  } catch (err) {
+    logger.error('Failed to backup', err);
+  }
+};
+
+export const restoreDatabase = async (db: SQLiteDatabase) => {
+  try {
+    const appPath = FileSystem.documentDirectory;
+    const result = await DocumentPicker.getDocumentAsync({
+      type: '*/*',
+      copyToCacheDirectory: true,
+      multiple: false,
+    });
+    if (result.canceled) {
+      return;
+    }
+    const backupPath = result.assets[0].uri;
+    if (!(await FileSystem.getInfoAsync(backupPath)).exists) {
+      return;
+    }
+    await db.execAsync('PRAGMA wal_checkpoint(FULL)');
+    await db.closeAsync();
+    const dbPath = `${appPath}/SQLite/${db.databaseName}`;
+    await FileSystem.deleteAsync(`${dbPath}-wal`, { idempotent: true });
+    await FileSystem.deleteAsync(`${dbPath}-shm`, { idempotent: true });
+
+    await FileSystem.copyAsync({
+      to: dbPath,
+      from: backupPath,
+    });
+  } catch (err) {
+    logger.error('Failed to backup', err);
+  }
+};
+
+export { openDatabaseAsync, SQLiteDatabase };

src/data/sqliteDatabase.ts

@@ -1,6 +1,10 @@
 import { BindParams } from 'sql.js';
 import initSqlJs from 'sql.js';
-import { loadFromIndexedDB, saveToIndexedDB } from '@/data/indexedDatabase';
+import { loadFromIndexedDB, saveToIndexedDB, saveToIndexedDBBA } from '@/data/indexedDatabase';
+import * as FileSystem from 'expo-file-system';
+import * as Sharing from 'expo-sharing';
+import logger from '@/logger';
+import * as DocumentPicker from 'expo-document-picker';
 export type SQLiteDatabase = any;
 const sqlPromise = initSqlJs({
   locateFile: (file) => `https://sql.js.org/dist/${file}`,
@@ -60,5 +64,72 @@ export async function openDatabaseAsync(databaseName: string, options?: any): Pr
     closeAsync: async () => {
       db.close();
     },
+    export: () => {
+      return db.export();
+    },
+    import: async (data: Uint8Array) => {
+      await saveToIndexedDBBA(data, databaseName);
+    },
   };
 }
+
+export const backupDatabase = async (db: SQLiteDatabase, backupName: string) => {
+  try {
+    const fileContent = await db.export();
+    const blob = new Blob([fileContent], { type: 'application/x-sqlite3' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = backupName;
+    link.click();
+    URL.revokeObjectURL(url);
+  } catch (err) {
+    logger.error('Failed to backup', err);
+  }
+};
+
+export const restoreDatabase = async (db: SQLiteDatabase) => {
+  try {
+    const input = document.createElement('input');
+    input.type = 'file';
+    input.accept = '*/*';
+
+    return new Promise<void>((resolve, reject) => {
+      input.onchange = async (event: any) => {
+        const file = event.target.files[0];
+        if (!file) {
+          resolve(undefined);
+          return;
+        }
+
+        const reader = new FileReader();
+        reader.onload = async (e) => {
+          try {
+            const fileContent = e.target?.result as ArrayBuffer | null;
+            if (!fileContent) {
+              reject('Corrupted file!');
+              return;
+            }
+
+            const uint8Array = new Uint8Array(fileContent);
+            // @ts-ignore
+            await db.import(uint8Array);
+            resolve(undefined);
+          } catch (error) {
+            reject(error?.message || 'Unknown error!');
+          }
+        };
+
+        reader.onerror = () => {
+          reject('Error reading the file!');
+        };
+
+        reader.readAsArrayBuffer(file);
+      };
+
+      input.click();
+    });
+  } catch (err) {
+    logger.error('Failed to backup', err);
+  }
+};