browser: add BrowserBacktraceStorage implementation [INT-355]

examples/sdk/browser/src/index.ts

@@ -14,6 +14,9 @@ const client = BacktraceClient.builder({
             prop2: 123,
         },
     },
+    database: {
+        enable: true,
+    },
 })
     .useModule(
         new BacktraceSessionReplayModule({

packages/browser/src/BacktraceClient.ts

@@ -11,6 +11,7 @@ import { BacktraceConfiguration } from './BacktraceConfiguration.js';
 import { BacktraceClientBuilder } from './builder/BacktraceClientBuilder.js';
 import { BacktraceClientSetup } from './builder/BacktraceClientSetup.js';
 import { getStackTraceConverter } from './converters/getStackTraceConverter.js';
+import { BrowserBacktraceStorage } from './storage/BrowserBacktraceStorage.js';
 
 export class BacktraceClient<O extends BacktraceConfiguration = BacktraceConfiguration> extends BacktraceCoreClient<O> {
     private readonly _disposeController: AbortController = new AbortController();
@@ -23,6 +24,10 @@ export class BacktraceClient<O extends BacktraceConfiguration = BacktraceConfigu
             debugIdMapProvider: new VariableDebugIdMapProvider(window as DebugIdContainer),
             sessionProvider: new BacktraceBrowserSessionProvider(),
             ...clientSetup,
+            database: {
+                storage: new BrowserBacktraceStorage(),
+                ...clientSetup.database,
+            },
         });
 
         this.captureUnhandledErrors(

packages/browser/src/storage/BrowserBacktraceStorage.ts

@@ -0,0 +1,63 @@
+import { BacktraceStorageModule } from '@backtrace/sdk-core';
+
+export class BrowserBacktraceStorage implements BacktraceStorageModule {
+    constructor(private readonly _storage = window.localStorage) {}
+
+    public async set(key: string, value: string): Promise<boolean> {
+        return this.setSync(key, value);
+    }
+
+    public async remove(key: string): Promise<boolean> {
+        return this.removeSync(key);
+    }
+
+    public async get(key: string): Promise<string | undefined> {
+        return this.getSync(key);
+    }
+
+    public async has(key: string): Promise<boolean> {
+        return this.hasSync(key);
+    }
+
+    public setSync(key: string, value: string): boolean {
+        try {
+            this._storage.setItem(key, value);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public removeSync(key: string): boolean {
+        try {
+            this._storage.removeItem(key);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public getSync(key: string): string | undefined {
+        try {
+            return this._storage.getItem(key) ?? undefined;
+        } catch {
+            return undefined;
+        }
+    }
+
+    public hasSync(key: string): boolean {
+        return key in this._storage;
+    }
+
+    public async *keys(): AsyncGenerator<string> {
+        for (const key of Object.keys(this._storage)) {
+            yield key;
+        }
+    }
+
+    public *keysSync(): Generator<string> {
+        for (const key of Object.keys(this._storage)) {
+            yield key;
+        }
+    }
+}