remove react-native-sqlite-storage completely

src/storage/asyncstorage.ts

@@ -1,12 +1,5 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-const key = {
-  downloadedSongKeys: '@downloadedSongKeys',
-  downloadedAlbumKeys: '@downloadedAlbumKeys',
-  downloadedArtistKeys: '@downloadedArtistKeys',
-  downloadedPlaylistKeys: '@downloadedPlaylistKeys',
-};
-
 export async function getItem(key: string): Promise<string | null> {
   try {
     return await AsyncStorage.getItem(key);
@@ -40,59 +33,3 @@ export async function multiSet(items: string[][]): Promise<void> {
     console.error(`multiSet error`, e);
   }
 }
-
-type DownloadedSong = {
-  id: string;
-  type: 'song';
-  name: string;
-  album: string;
-  artist: string;
-};
-
-type DownloadedAlbum = {
-  id: string;
-  type: 'album';
-  songs: string[];
-  name: string;
-  artist: string;
-};
-
-type DownloadedArtist = {
-  id: string;
-  type: 'artist';
-  songs: string[];
-  name: string;
-};
-
-type DownloadedPlaylist = {
-  id: string;
-  type: 'playlist';
-  songs: string[];
-  name: string;
-};
-
-export async function getDownloadedSongs(): Promise<DownloadedSong[]> {
-  const keysItem = await getItem(key.downloadedSongKeys);
-  const keys: string[] = keysItem ? JSON.parse(keysItem) : [];
-
-  const items = await multiGet(keys);
-  return items.map(x => {
-    const parsed = JSON.parse(x[1] as string);
-    return {
-      id: x[0],
-      type: 'song',
-      ...parsed,
-    };
-  });
-}
-
-export async function setDownloadedSongs(items: DownloadedSong[]): Promise<void> {
-  await multiSet([
-    [key.downloadedSongKeys, JSON.stringify(items.map(x => x.id))],
-    ...items.map(x => [x.id, JSON.stringify({
-      name: x.name,
-      album: x.album,
-      artist: x.artist,
-    })]),
-  ]);
-}

src/storage/db.ts

@@ -1,59 +0,0 @@
-import SQLite, { DatabaseParams, ResultSet, SQLiteDatabase, Transaction } from 'react-native-sqlite-storage';
-
-SQLite.enablePromise(true);
-
-export abstract class DbStorage {
-  private dbParams: DatabaseParams;
-  private db: SQLiteDatabase | undefined;
-  
-  constructor(dbParams: DatabaseParams) {
-    this.dbParams = dbParams;
-  }
-
-  abstract createDb(): Promise<void>
-
-  protected async initDb(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;
-  }
-
-  async openDb(): Promise<void> {
-    this.db = await SQLite.openDatabase({ ...this.dbParams });
-  }
-
-  async deleteDb(): Promise<void> {
-    if (this.db) {
-      await this.db.close();
-    }
-    await SQLite.deleteDatabase({ ...this.dbParams });
-  }
-
-  async executeSql(sql: string, params?: any[]): Promise<[ResultSet]> {
-    // https://github.com/andpor/react-native-sqlite-storage/issues/410
-    return await (this.db as SQLiteDatabase).executeSql(sql, params);
-  }
-
-  async transaction(scope: (tx: Transaction) => void): Promise<void> {
-    await (this.db as SQLiteDatabase).transaction(scope);
-  }
-}

src/storage/music.ts

@@ -1,151 +1,35 @@
-import { Album, Artist, Song } from '../models/music';
-import { DbStorage } from './db';
+import { DownloadedSong } from '../models/music';
+import { getItem, multiGet, multiSet } from './asyncstorage';
 
-export class MusicDb extends DbStorage {
-  constructor() {
-    super({ name: 'music.db', location: 'default' });
-  }
+const key = {
+  downloadedSongKeys: '@downloadedSongKeys',
+  downloadedAlbumKeys: '@downloadedAlbumKeys',
+  downloadedArtistKeys: '@downloadedArtistKeys',
+  downloadedPlaylistKeys: '@downloadedPlaylistKeys',
+};
 
-  async createDb(): Promise<void> {
-    await this.initDb(tx => {
-      tx.executeSql(`
-      CREATE TABLE artists (
-        id TEXT PRIMARY KEY NOT NULL,
-        name TEXT NOT NULL,
-        starred TEXT,
-        coverArt TEXT
-      );
-      `);
-      tx.executeSql(`
-      CREATE TABLE albums (
-        id TEXT PRIMARY KEY NOT NULL,
-        artistId TEXT NOT NULL,
-        name TEXT NOT NULL,
-        starred TEXT,
-        coverArt TEXT
-      );
-      `);
-      tx.executeSql(`
-      CREATE TABLE songs (
-        id TEXT PRIMARY KEY NOT NULL,
-        albumId TEXT NOT NULL,
-        artistId TEXT NOT NULL,
-        name TEXT NOT NULL,
-        starred TEXT,
-        artist TEXT
-      );
-      `);
-    });
-  }
+export async function getDownloadedSongs(): Promise<DownloadedSong[]> {
+  const keysItem = await getItem(key.downloadedSongKeys);
+  const keys: string[] = keysItem ? JSON.parse(keysItem) : [];
 
-  async getArtists(): Promise<Artist[]> {
-    return (await this.executeSql(`
-    SELECT * FROM artists;
-    `))[0].rows.raw().map(x => ({
-      id: x.id,
-      name: x.name,
-      starred: x.starred ? new Date(x.starred) : undefined,
-      coverArt: x.coverArt || undefined,
-    }));
-  }
-
-  async updateArtists(artists: Artist[]): Promise<void> {
-    await this.transaction((tx) => {
-      tx.executeSql(`
-      DELETE FROM artists
-      `);
-      for (const a of artists) {
-        tx.executeSql(`
-        INSERT INTO artists (
-          id,
-          name,
-          starred,
-          coverArt
-        )
-        VALUES (?, ?, ?, ?);
-        `, [
-          a.id, 
-          a.name, 
-          a.starred ? a.starred.toISOString() : null, 
-          a.coverArt || null
-        ]);
-      }
-    });
-  }
-
-  async getAlbums(): Promise<Album[]> {
-    return (await this.executeSql(`
-    SELECT * FROM albums;
-    `))[0].rows.raw().map(x => ({
-      id: x.id,
-      artistId: x.artistid,
-      name: x.name,
-      starred: x.starred ? new Date(x.starred) : undefined,
-      coverArt: x.coverArt || undefined,
-    }));
-  }
-
-  async updateAlbums(albums: Album[]): Promise<void> {
-    await this.transaction((tx) => {
-      tx.executeSql(`
-      DELETE FROM albums
-      `);
-      for (const a of albums) {
-        tx.executeSql(`
-        INSERT INTO albums (
-          id,
-          artistId,
-          name,
-          starred,
-          coverArt
-        )
-        VALUES (?, ?, ?, ?, ?);
-        `, [
-          a.id,
-          a.artistId,
-          a.name,
-          a.starred ? a.starred.toISOString() : null,
-          a.coverArt || null
-        ]);
-      }
-    });
-  }
-
-  async getSongs(): Promise<Song[]> {
-    return (await this.executeSql(`
-    SELECT * FROM songs;
-    `))[0].rows.raw().map(x => ({
-      id: x.id,
-      artistId: x.artistid,
-      albumId: x.albumId,
-      name: x.name,
-      starred: x.starred ? new Date(x.starred) : undefined,
-    }));
-  }
-
-  async updateSongs(songs: Song[]): Promise<void> {
-    await this.transaction((tx) => {
-      tx.executeSql(`
-      DELETE FROM songs
-      `);
-      for (const x of songs) {
-        tx.executeSql(`
-        INSERT INTO songs (
-          id,
-          artistId,
-          albumId,
-          name,
-          starred
-        )
-        VALUES (?, ?, ?, ?, ?);
-        `, [
-          x.id,
-          x.artistId,
-          x.albumId,
-          x.name,
-          x.starred ? x.starred.toISOString() : null,
-        ]);
-      }
-    });
-  }
+  const items = await multiGet(keys);
+  return items.map(x => {
+    const parsed = JSON.parse(x[1] as string);
+    return {
+      id: x[0],
+      type: 'song',
+      ...parsed,
+    };
+  });
+}
+
+export async function setDownloadedSongs(items: DownloadedSong[]): Promise<void> {
+  await multiSet([
+    [key.downloadedSongKeys, JSON.stringify(items.map(x => x.id))],
+    ...items.map(x => [x.id, JSON.stringify({
+      name: x.name,
+      album: x.album,
+      artist: x.artist,
+    })]),
+  ]);
 }