Type-safed simple store use in electron.

simple_store.ts

import { app } from 'electron';
import * as path from 'path';
import * as fs from 'fs';

export default class SimpleStore<Model extends Object> {
  static STORE_NAME = 'persistence.json';

  private readonly storePath: string;

  constructor() {
    const appData = app.getPath('appData');
    this.storePath = path.join(appData, SimpleStore.STORE_NAME);
  }

  public async set(newValue: Partial<Model>) {
    const old = await this.readOrWriteEmpty();
    const str = JSON.stringify({ ...old, ...newValue });
    await fs.promises.writeFile(this.storePath, str);
  }

  public async get<Key extends keyof Model>(
    key: Key
  ): Promise<Model[keyof Model] | undefined> {
    if (await this.ensureFileExistsOrWriteEmpty()) {
      const data = await this.readOrWriteEmpty();
      return data[key];
    }
    return undefined;
  }

  private async ensureFileExistsOrWriteEmpty(): Promise<boolean> {
    try {
      await fs.promises.stat(this.storePath);
      return true;
    } catch {
      this.writeEmpty().then();
      return false;
    }
  }

  private async readOrWriteEmpty(): Promise<Partial<Model>> {
    const string = (await fs.promises.readFile(this.storePath)).toString();
    try {
      return JSON.parse(string) as Model;
    } catch {
      await this.writeEmpty();
      return {};
    }
  }

  private async writeEmpty() {
    await fs.promises.writeFile(this.storePath, '{}');
    return;
  }
}

use.ts

export default interface PersistenceModel {
  openedProductionID: string[];
}

const store = new Store<PersistenceModel>();

await this.store.get('openedProduction'); // string[]