Class NodeStorageInterface

packages/core/__mocks__/node-storage.mock.ts:29–131

import { randomBytes } from "crypto";

export class NodeStorageInterface implements IStorage {
  storage = {};
  crypto = new NNCrypto();

  async removeMulti(keys: string[]): Promise<void> {
    for (const key of keys) {
      this.remove(key);
    }
  }

  async write<T>(key: string, data: T): Promise<void> {
    this.storage[key] = data;
  }

  async writeMulti<T>(entries: [key: string, data: T][]) {
    for (const [key, value] of entries) {
      this.storage[key] = value;
    }
  }

  async readMulti<T>(keys: string[]): Promise<[string, T][]> {
    const result: [string, T][] = [];
    keys.forEach((key) => {
      result.push([key, this.storage[key]]);
    });
    return result;
  }

  async read<T>(
    key: string,
    isArray?: boolean | undefined
  ): Promise<T | undefined> {
    return this.storage[key];
  }

  async remove(key: string): Promise<void> {
    delete this.storage[key];
  }

  async clear(): Promise<void> {
    this.storage = {};
  }

  async getAllKeys(): Promise<string[]> {
    return Object.keys(this.storage);
  }

  async encrypt(key: SerializedKey, plainText: string) {
    return await this.crypto.encrypt(key, plainText, "text", "base64");
  }

  async encryptMulti(key: SerializedKey, items: string[]) {
    return await this.crypto.encryptMulti(key, items, "text", "base64");
  }

  decrypt(key: SerializedKey, cipherData: Cipher<"base64">): Promise<string> {
    cipherData.format = "base64";
    return this.crypto.decrypt(key, cipherData, "text");