feat(js-module): create AsyncStorageError handle throw it

Author: krizzu

packages/async-storage/src/AsyncStorageError.ts

@@ -0,0 +1,103 @@
+export class AsyncStorageError extends Error {
+  private constructor(
+    public errorMessage: string,
+    public type: AsyncStorageError.Type
+  ) {
+    super(errorMessage);
+    this.name = this.constructor.name;
+  }
+
+  static nativeError(e: any): AsyncStorageError {
+    const error = getNativeError(e);
+    if (!error) {
+      return new AsyncStorageError(
+        e?.message ?? `Unknown error ${e}`,
+        AsyncStorageError.Type.UnknownError
+      );
+    }
+
+    let errorType: AsyncStorageError.Type = AsyncStorageError.Type.UnknownError;
+
+    switch (error.type) {
+      case "SqliteException":
+        errorType = AsyncStorageError.Type.SqliteStorageError;
+        break;
+      case "OtherException":
+        errorType = AsyncStorageError.Type.OtherStorageError;
+        break;
+    }
+
+    return new AsyncStorageError(error.message, errorType);
+  }
+
+  static jsError(
+    error: string,
+    type: AsyncStorageError.Type
+  ): AsyncStorageError {
+    return new AsyncStorageError(error, type);
+  }
+}
+
+export namespace AsyncStorageError {
+  export enum Type {
+    /**
+     * Related to RN Native module itself, ex. not initialized or null at app boot
+     */
+    NativeModuleError = "NativeModuleError",
+
+    /**
+     * Error thrown from Sqlite itself
+     * https://www.sqlite.org/rescode.html
+     */
+    SqliteStorageError = "SqliteStorageError",
+
+    /**
+     * Other errors related to Native Shared Storage
+     * ex. Storage could not be initialized
+     */
+    OtherStorageError = "OtherStorageError",
+
+    /**
+     * Catch-all case, where we can't really tell what went wrong
+     */
+    UnknownError = "UnknownError",
+  }
+}
+
+// Native module reject promises with special code
+function isNativeError(e: any): e is PotentialNativeError {
+  return "message" in e && "code" in e && e?.code === "AsyncStorageError";
+}
+
+function getNativeError(e: any): AsyncStorageNativeError | null {
+  if (!isNativeError(e)) {
+    return null;
+  }
+
+  let errorType = e.userInfo ? e.userInfo["type"] : null;
+
+  if (errorType === "SqliteException") {
+    return {
+      type: "SqliteException",
+      message: e.message,
+    };
+  } else if (errorType === "OtherException") {
+    return {
+      type: "OtherException",
+      message: e.message,
+    };
+  }
+
+  return null;
+}
+
+type AsyncStorageNativeError = {
+  message: string;
+  type: "SqliteException" | "OtherException";
+};
+
+type PotentialNativeError = {
+  message: string;
+  code: "AsyncStorageError";
+  userInfo: Record<string, any> | null;
+};

packages/async-storage/src/createAsyncStorage.ts

@@ -2,52 +2,95 @@ import type { AsyncStorage } from "./AsyncStorage";
 import NativeAsyncStorage, {
   type Spec as NativeAsyncStorageSpec,
 } from "./native-module/NativeAsyncStorage";
+import { AsyncStorageError } from "./AsyncStorageError";
 
 class AsyncStorageImpl implements AsyncStorage {
   constructor(private readonly dbName: string) {}
 
   private get db(): NativeAsyncStorageSpec {
     const mod = NativeAsyncStorage;
     if (!mod) {
-      throw new Error(`Native module is null, cannot create db`);
+      throw AsyncStorageError.jsError(
+        `Native module is null, cannot create db`,
+        AsyncStorageError.Type.NativeModuleError
+      );
     }
     return mod;
   }
 
   getItem = async (key: string): Promise<string | null> => {
-    const result = await this.db.getValues(this.dbName, [key]);
-    const value = result[0] ?? null;
-    return value?.value ?? null;
+    try {
+      const result = await this.db.getValues(this.dbName, [key]);
+      const value = result[0] ?? null;
+      return value?.value ?? null;
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
   };
 
   setItem = async (key: string, value: string): Promise<void> => {
-    await this.db.setValues(this.dbName, [{ key, value }]);
+    try {
+      await this.db.setValues(this.dbName, [{ key, value }]);
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
   };
 
-  removeItem = async (key: string): Promise<void> =>
-    this.db.removeValues(this.dbName, [key]);
+  removeItem = async (key: string): Promise<void> => {
+    try {
+      await this.db.removeValues(this.dbName, [key]);
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
+  };
 
-  getMany = async (keys: string[]): Promise<Record<string, string | null>> =>
-    this.db.getValues(this.dbName, keys).then((entries) =>
-      entries.reduce<Record<string, string | null>>((values, current) => {
-        values[current.key] = current.value;
-        return values;
-      }, {})
-    );
+  getMany = async (keys: string[]): Promise<Record<string, string | null>> => {
+    try {
+      return await this.db.getValues(this.dbName, keys).then((entries) =>
+        entries.reduce<Record<string, string | null>>((values, current) => {
+          values[current.key] = current.value;
+          return values;
+        }, {})
+      );
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
+  };
 
   setMany = async (entries: Record<string, string>): Promise<void> => {
-    await this.db.setValues(
-      this.dbName,
-      Object.entries(entries).map(([key, value]) => ({ key, value }))
-    );
+    try {
+      await this.db.setValues(
+        this.dbName,
+        Object.entries(entries).map(([key, value]) => ({ key, value }))
+      );
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
   };
 
-  removeMany = async (keys: string[]): Promise<void> =>
-    this.db.removeValues(this.dbName, keys);
+  removeMany = async (keys: string[]): Promise<void> => {
+    try {
+      await this.db.removeValues(this.dbName, keys);
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
+  };
 
-  getAllKeys = (): Promise<string[]> => this.db.getKeys(this.dbName);
+  getAllKeys = async (): Promise<string[]> => {
+    try {
+      return await this.db.getKeys(this.dbName);
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
+  };
 
-  clear = (): Promise<void> => this.db.clearStorage(this.dbName);
+  clear = async (): Promise<void> => {
+    try {
+      return await this.db.clearStorage(this.dbName);
+    } catch (e) {
+      throw AsyncStorageError.nativeError(e);
+    }
+  };
 }
 
 export function createAsyncStorage(databaseName: string): AsyncStorage {