Back up and restore an IndexedDB database

idb-backup-and-restore.md

Back up and restore an IndexedDB database

This gist is an ES module which provides functions to import and export data from an IndexedDB database as JSON. It's based on Justin Emery's indexeddb-export-import package, but applies some adjustments that reflect better on the current browser landscape (i.e. better developer ergonomics but no support for Internet Explorer).

Usage

For each of the provided functionalities, you need a connected IDBDatabase instance.

Export Data

import { idb } from 'some-database'

import { exportToJson } from 'idb-backup-and-restore.mjs'

exportToJson(idb)
  .then(result => {
    console.log('Exported JSON string:', result)
  })
  .catch(error => {
    console.error('Something went wrong during export:', error)
  })

Import Data

import { idb } from 'some-database'
import { serializedData } from 'some-serialized-data'

import { importFromJson } from 'idb-backup-and-restore.mjs'

importFromJson(idb, serializedData)
  .then(() => {
    console.log('Successfully imported data')
  })
  .catch(error => {
    console.error('Something went wrong during import:', error)
  })

Clear Database

Depending on your use case, it can be reasonable to clear a database before importing serialized data:

import { idb } from 'some-database'
import { serializedData } from 'some-serialized-data'

import { importFromJson, clearDatabase } from 'idb-backup-and-restore.mjs'

clearDatabase(idb)
  .then(() => importFromJson(idb, serializedData))
  .then(() => {
    console.log('Successfully cleared database and imported data')
  })
  .catch(error => {
    console.error('Could not clear & import database:', error)
  })

idb-backup-and-restore.mjs

/**
 * Export all data from an IndexedDB database
 *
 * @param {IDBDatabase} idbDatabase The database to export from
 * @return {Promise<string>}
 */
export function exportToJson(idbDatabase) {
  return new Promise((resolve, reject) => {
    const exportObject = {}
    if (idbDatabase.objectStoreNames.length === 0) {
      resolve(JSON.stringify(exportObject))
    } else {
      const transaction = idbDatabase.transaction(
        idbDatabase.objectStoreNames,
        'readonly'
      )

      transaction.addEventListener('error', reject)

      for (const storeName of idbDatabase.objectStoreNames) {
        const allObjects = []
        transaction
          .objectStore(storeName)
          .openCursor()
          .addEventListener('success', event => {
            const cursor = event.target.result
            if (cursor) {
              // Cursor holds value, put it into store data
              allObjects.push(cursor.value)
              cursor.continue()
            } else {
              // No more values, store is done
              exportObject[storeName] = allObjects

              // Last store was handled
              if (
                idbDatabase.objectStoreNames.length ===
                Object.keys(exportObject).length
              ) {
                resolve(JSON.stringify(exportObject))
              }
            }
          })
      }
    }
  })
}

/**
 * Import data from JSON into an IndexedDB database.
 * This does not delete any existing data from the database, so keys may clash.
 *
 * @param {IDBDatabase} idbDatabase Database to import into
 * @param {string}      json        Data to import, one key per object store
 * @return {Promise<void>}
 */
export function importFromJson(idbDatabase, json) {
  return new Promise((resolve, reject) => {
    const transaction = idbDatabase.transaction(
      idbDatabase.objectStoreNames,
      'readwrite'
    )
    transaction.addEventListener('error', reject)

    var importObject = JSON.parse(json)
    for (const storeName of idbDatabase.objectStoreNames) {
      let count = 0
      for (const toAdd of importObject[storeName]) {
        const request = transaction.objectStore(storeName).add(toAdd)
        request.addEventListener('success', () => {
          count++
          if (count === importObject[storeName].length) {
            // Added all objects for this store
            delete importObject[storeName]
            if (Object.keys(importObject).length === 0) {
              // Added all object stores
              resolve()
            }
          }
        })
      }
    }
  })
}

/**
 * Clear a database
 *
 * @param {IDBDatabase} idbDatabase The database to delete all data from
 * @return {Promise<void>}
 */
export function clearDatabase(idbDatabase) {
  return new Promise((resolve, reject) => {
    const transaction = idbDatabase.transaction(
      idbDatabase.objectStoreNames,
      'readwrite'
    )
    transaction.addEventListener('error', reject)

    let count = 0
    for (const storeName of idbDatabase.objectStoreNames) {
      transaction
        .objectStore(storeName)
        .clear()
        .addEventListener('success', () => {
          count++
          if (count === idbDatabase.objectStoreNames.length) {
            // Cleared all object stores
            resolve()
          }
        })
    }
  })
}

Glad I could help. 🙂 Have a nice day! 👋

Thank you ! Have a nice day too

Mh, I cannot say from the distance what your problem might be, but I have created a Gist for you which includes the whole workflow for exporting a database. Copy the script as a whole and paste it into your browser console — that should clearly state whether it worked or not:

https://gist.github.com/loilo/ddfdb3c54fa474a89f71ce0660cd38b7

Thanks very much for this script, it was just what I was looking for!

Thanks so much @loilo! In case anyone is wondering, the callback function that handles the cursor can also extract the key corresponding to each object in the store, if you want that information (as I did). The modification in exportToJson simply becomes:

allObjects.push([cursor.key, cursor.value])

and the corresponding modification in importFromJson within the loop:

 let [k,value] = toAdd ; 
 const request = transaction.objectStore(storeName).add(value,k)

Hope that helps someone and thanks again! Web tech is so dope , more info on cursors here

Okay, that should be relatively straightforward, under one condition: You'll still have the IndexedDB on the new machine, even though it may be empty. This is necessary because the export script from above can only export the DB's data, not its strucure.

For both exporting and importing data, you'll need an IndexedDB instance. Say you're wanting to back up the foo database, then you could get an instance in the console like this:

var db
var request = window.indexedDB.open('foo')
request.onerror = () => console.error('Could not open database')
request.onsuccess = () => { db = request.result }

Export:

1. Copy the exportToJson function (without the prepended export statement), paste it into the DevTools Console and hit Enter.
2. Run this: await exportToJson(db)
3. If you see some JSON output in the console it means that the export worked. Run copy($_) to copy the return value of the previous command (= the exported data) to your clipboard.
4. Save that exported data somewhere.

Import:

1. Copy the importFromJson function (without the prepended export statement), paste it into the DevTools Console and hit Enter.
2. Invoke it with the IndexedDB instance and the exported data as parameters: await importFromJson(db, exportedString).
   Note that you actually have to pass the exported data as a string, not as a JSON object. For example: If you exported and empty database {}, you'd have to pass into the function the following: await importFromJson(db, '{}').

This should be it. Probably test it before you actually rely on it. 🙂

Hi, Thanks for the script, But when I tried to dump the two emscripten_filesystem and gscyclone database on https://play.wo1wan.com/jjnext/play?id=540&mode=0&gstate=def, the script just copied {"FILES":[]} and then the page redirected to about:blank.

I also tried the script on https://gist.github.com/loilo/ddfdb3c54fa474a89f71ce0660cd38b7, however, it's the same problems.

I could not found any error in the console.

Am I correct that the importFromJson function requires that the target db has all the necessary stores created beforehand?

@moniuch Yes, if I remember correctly, this is the case.

@moniuch It simple to modify the code to create stores by JSON before the import.

I may have found a bug - I had a few object stores that were empty. When importing, because there were no records, delete importObject[storeName] was never run. I fixed it by adding a check before the for loop:

      const importObject = JSON.parse(json)
      for (const storeName of idbDatabase.objectStoreNames) {
        // ignore empty stores (we have to do this explicitly or the keys will never be deleted, and the promise will not resolve)
        if(importObject[storeName].length == 0){
            delete importObject[storeName];
            continue;
        }
        let count = 0
        for (const toAdd of importObject[storeName]) {
....