electron-conf

Simple data persistence for your Electron app - save and load user settings, app state, cache, etc

Another electron-store, minimal fork of conf, with more features.

electron-conf is a fork of conf (behind electron-store). What we try to achieve in this library, is to eliminate some dependencies and features that our target users don't need, and is designed only for Electron.

• ✅ Minimal and simple
• ✅ Read data form disk once, ~100x faster
• ✅ Simpler migration strategy
• ✅ Safer to use it in Electron renderer (no nodeIntegration)
• ✅ Written in TypeScript, and support CommonJS and ESM. For Electron 15.x and higher.
• ❌ No watch
• ❌ No encryption

If you need features like watch or encryption, electron-store is a better choice for you.

Install

1$ npm install electron-conf

Usage

Using in Electron Main Process

1import { Conf } from 'electron-conf/main'
2
3const conf = new Conf()
4
5conf.set('foo', '🌈')
6console.log(conf.get('foo')) // => 🌈
7
8// Use dot-notation to access nested properties
9conf.set('a.b', true)
10console.log(conf.get('a')) // => {b: true}
11
12conf.delete('foo')
13console.log(conf.get('foo')) // => undefined

Using in Electron Renderer Process

1. Register a listener in main process, so that you can use it in the renderer process.

1import { Conf } from 'electron-conf/main'
2
3const conf = new Conf()
4
5conf.registerRendererListener()

2. Expose the Conf API.

You can expose it in the specified preload script:

1import { exposeConf } from 'electron-conf/preload'
2
3exposeConf()

Or, you can expose it globally in the main process for all renderer processes:

1import { useConf } from 'electron-conf/main'
2
3useConf()

3. Use it in the renderer process

1import { Conf } from 'electron-conf/renderer'
2
3const conf = new Conf()
4
5await conf.set('foo', 1)

[!NOTE] Use the same way as the main process. The difference is that all APIs are promise-based.

API

Conf([options])

return a new instance.

[!WARNING] It does not support multiple instances reading and writing the same configuration file.

Constructor Options

[!NOTE] Conf for the renderer process, only supports the name option.

dir

• Type: string
• Default: app.getPath('userData')

The directory for storing your app's configuration file.

name

• Type: string
• Default: config

Configuration file name without extension.

ext

• Type: string
• Default: .json

Configuration file extension.

defaults

• Type: object

Default config used if there are no existing config.

serializer

• Type: Serializer

Provides functionality to serialize object types to UTF-8 strings and to deserialize UTF-8 strings into object types.

By default, JSON.stringify is used for serialization and JSON.parse is used for deserialization.

You would usually not need this, but it could be useful if you want to use a format other than JSON.

1interface Serializer<T> {
2  /**
3   * Deserialize the config object from a UTF-8 string when reading the config file.
4   * @param raw UTF-8 encoded string.
5   */
6  read: (raw: string) => T
7  /**
8   * Serialize the config object to a UTF-8 string when writing the config file.
9   * @param value The config object.
10   */
11  write: (value: T) => string
12}

schema

• Type: JSONSchema

JSON Schema to validate your config data.

Under the hood, we use the ajv JSON Schema validator to validate config data.

You should define your schema as an object where each key is the name of your data's property and each value is a JSON schema used to validate that property.

1import { Conf } from 'electron-conf/main'
2
3const schema = {
4  type: 'object',
5  properties: {
6    foo: {
7      type: 'string',
8      maxLength: 10,
9      nullable: true
10    }
11  }
12}
13
14const conf = new Conf({ schema })

migrations

• type: Migration[]

You can customize versions and perform operations to migrate configurations. When instantiated, it will be compared with the version number of the configuration file and a higher version migration operation will be performed.

Note: The migration version must be greater than 0. A new version is defined on each migration and is incremented on the previous version.

1import { Conf } from 'electron-conf/main'
2
3const migrations = [
4  {
5    version: 1,
6    hook: (conf, version): void => {
7      conf.set('foo', 'a')
8      console.log(`migrate from ${version} to 1`) // migrate from 0 to 1
9    }
10  },
11  {
12    version: 2,
13    hook: (conf, version): void => {
14      conf.set('foo', 'b')
15      console.log(`migrate from ${version} to 2`) // migrate from 1 to 2
16    }
17  }
18]
19
20const conf = new Conf({ migrations })

1type Migration<T extends Record<string, any>> = {
2  /**
3   * Migration version. The initial version must be greater than `0`. A new
4   * version is defined on each migration and is incremented on the previous version.
5   */
6  version: number
7  /**
8   * Migration hook. You can perform operations to update your configuration.
9   * @param instance config instance.
10   * @param currentVersion current version.
11   */
12  hook: (instance: BaseConf<T>, currentVersion: number) => void
13}

Instance Methods

You can use dot-notation in a key to access nested properties.

The instance is iterable so you can use it directly in a for…of loop.

[!NOTE] All methods in renderer are promise-based.

.get(key, defaultValue?)

Get an item or defaultValue if the item does not exist.

.set(key, value)

Set an item.

.set(object)

Set an item or multiple items at once.

1conf.set({ foo: 'boo', bar: { baz: 1 } })

.reset(...keys)

Reset items to their default values, as defined by the defaults or schema option.

.has(key)

Check if an item exists.

.delete(key)

Delete an item.

.clear()

Delete all items.

.onDidChange(key, callback)

• callback: (newValue, oldValue) => {}

Watches the given key, calling callback on any changes.

When a key is first set oldValue will be undefined, and when a key is deleted newValue will be undefined.

Returns a function which you can use to unsubscribe:

1const unsubscribe = conf.onDidChange(key, callback)
2
3unsubscribe()

[!TIP] Not available in renderer

.onDidAnyChange(callback)

• callback: (newValue, oldValue) => {}

Watches the whole config object, calling callback on any changes.

oldValue and newValue will be the config object before and after the change, respectively. You must compare oldValue to newValue to find out what changed.

Returns a function which you can use to unsubscribe:

1const unsubscribe = store.onDidAnyChange(callback)
2
3unsubscribe()

[!TIP] Not available in renderer

.fileName

Get the configuration file path.

[!TIP] Not available in renderer

Credits

Conf, simple config handling for your app or module.