building out settings db

finally got transactions working too

src/storage/db.ts

@@ -0,0 +1,71 @@
+import SQLite, { DatabaseParams, ResultSet, SQLiteDatabase, Transaction } from 'react-native-sqlite-storage';
+
+SQLite.enablePromise(true);
+
+export abstract class DbStorage {
+  private dbParams: DatabaseParams;
+  
+  constructor(dbParams: DatabaseParams) {
+    this.dbParams = dbParams;
+  }
+
+  // abstract createDb(): Promise<void>
+
+  protected async createDb(scope: (tx: Transaction) => void): Promise<void> {
+    await this.transaction(tx => {
+      tx.executeSql(`
+      CREATE TABLE db_version (
+        version INTEGER NOT NULL
+      );
+      `);
+      tx.executeSql(`
+      INSERT INTO db_version (version)
+      VALUES (?);
+      `, [1]);
+
+      scope(tx);
+    });
+  }
+
+  async dbExists(): Promise<boolean> {
+    const results = await this.executeSql(`
+    SELECT name FROM sqlite_master
+    WHERE type='table' AND name='db_version';
+    `);
+
+    return results[0].rows.length > 0;
+  }
+
+  private async openDb(): Promise<SQLiteDatabase> {
+    return await SQLite.openDatabase({ ...this.dbParams });
+  }
+
+  async deleteDb(): Promise<void> {
+    await SQLite.deleteDatabase({ ...this.dbParams });
+  }
+
+  async executeSql(sql: string, params?: any[]): Promise<[ResultSet]> {
+    const db = await this.openDb();
+    try {
+      // https://github.com/andpor/react-native-sqlite-storage/issues/410
+      return await db.executeSql(sql, params);
+    } catch (err) {
+      try { await db.close(); } catch {}
+      throw err;
+    } finally {
+      try { await db.close(); } catch {}
+    }
+  }
+
+  async transaction(scope: (tx: Transaction) => void): Promise<void> {
+    const db = await this.openDb();
+    try {
+      await db.transaction(scope);
+    } catch (err) {
+      try { await db.close(); } catch {}
+      throw err;
+    } finally {
+      try { await db.close(); } catch {}
+    }
+  }
+}

src/storage/music.ts

@@ -0,0 +1,19 @@
+import { DbStorage } from './db';
+
+export class MusicDb extends DbStorage {
+  constructor() {
+    super({ name: 'music.db', location: 'default' });
+  }
+
+  async createDb(): Promise<void> {
+    super.createDb(tx => {
+      tx.executeSql(`
+      CREATE TABLE artists (
+        id TEXT PRIMARY KEY NOT NULL,
+        name TEXT NOT NULL,
+        starred INTEGER NOT NULL
+      );
+      `);
+    });
+  }
+}

src/storage/settings.ts

@@ -0,0 +1,103 @@
+import { DbStorage } from './db';
+
+export interface ServerSettings {
+  id: string;
+  address: string;
+  username: string;
+  token: string;
+  salt: string;
+}
+
+export interface AppSettings {
+  server?: string;
+}
+
+export class SettingsDb extends DbStorage {
+  constructor() {
+    super({ name: 'settings.db', location: 'Library' });
+  }
+
+  async createDb(): Promise<void> {
+    super.createDb(tx => {
+      tx.executeSql(`
+      CREATE TABLE servers (
+        id TEXT PRIMARY KEY NOT NULL,
+        address TEXT NOT NULL,
+        username TEXT NOT NULL,
+        token TEXT NOT NULL,
+        salt TEXT NOT NULL
+      );
+      `);
+      tx.executeSql(`
+      CREATE TABLE app (
+        server TEXT
+      );
+      `);
+      tx.executeSql(`
+      INSERT INTO app (server)
+      VALUES (NULL);
+      `);
+    });
+  }
+
+  async getServers(): Promise<ServerSettings[]> {
+    return (await this.executeSql(`
+    SELECT * FROM servers;
+    `))[0].rows.raw().map(x => ({
+      id: x.id,
+      address: x.address,
+      username: x.username,
+      token: x.token,
+      salt: x.salt,
+    }));
+  }
+
+  async getServer(id: string): Promise<ServerSettings | undefined> {
+    return (await this.getServers()).find(x => x.id === id);
+  }
+
+  async addServer(server: ServerSettings): Promise<void> {
+    await this.executeSql(`
+    INSERT INTO servers (id, address, username, token, salt)
+    VALUES (?, ?, ?, ?, ?);
+    `, [server.id, server.address, server.username, server.token, server.salt]);
+  }
+
+  async removeServer(id: string): Promise<void> {
+    await this.executeSql(`
+    DELETE FROM servers
+    WHERE id = ?;
+    `, [id]);
+  }
+
+  async updateServer(server: ServerSettings): Promise<void> {
+    await this.executeSql(`
+    UPDATE servers SET
+      address = ?,
+      username = ?,
+      token = ?,
+      salt = ?
+    WHERE id = ?;
+    `, [
+      server.address, server.username, server.token, server.salt,
+      server.id,
+    ]);
+  }
+
+  async getApp(): Promise<AppSettings> {
+    return (await this.executeSql(`
+    SELECT * FROM app;
+    `))[0].rows.raw().map(x => ({
+      server: x.server || undefined,
+    }))[0];
+  }
+
+  async updateApp(app: AppSettings): Promise<void> {
+    await this.executeSql(`
+    UPDATE app SET
+      server = ?;
+    `, [
+      app.server || null,
+    ]);
+  }
+}