Class FileSystem

src/file-system.ts:5–145

import { EventEmitter } from 'events';

export class FileSystem extends EventEmitter {
  protected fsMap: Map<string, string[]> = new Map();
  // mtime of the file when its cache entry was hydrated, so external
  // writes to the same path invalidate the in-memory copy.
  protected mtimes: Map<string, number> = new Map();
  // Per-path promise chain so concurrent append() calls can't interleave
  // their read-modify-write cycles and drop entries.
  protected writeChains: Map<string, Promise<void>> = new Map();
  protected currentAESKey: Buffer;
  protected logger = new Logger('file-system');

  constructor(protected config: Config) {
    super();
    this.currentAESKey = config.getAESKey();
  }

  /**
   * Appends contents to a file-path for persistance. File contents are
   * encrypted before being saved to disk. Reads happen via the in-memory
   * lookup of the internal map. Appends to the same path are serialized.
   *
   * @param path The filepath to persist contents to
   * @param newContent A string of new content to add to the file
   * @param shouldEncode Whether contents are AES encoded on disk
   * @param maxEntries When set (a positive integer), only the most recent N
   * entries are kept, bounding both the file and its in-memory cache. Throws
   * for a non-integer or non-positive value — a negative count would splice
   * away the entry just appended (silent data loss) and 0 would disable the
   * cap it was meant to enforce.
   * @returns void
   */
  public async append(
    path: string,
    newContent: string,
    shouldEncode: boolean,
    maxEntries?: number,
  ): Promise<void> {
    if (
      maxEntries !== undefined &&
      (!Number.isInteger(maxEntries) || maxEntries < 1)
    ) {
      throw new Error(
        `maxEntries must be a positive integer when set, got "${maxEntries}"`,
      );
    }

    const prior = this.writeChains.get(path) ?? Promise.resolve();
    const task = prior.then(async () => {
      // Work on a copy — read() returns the live cached array, and the
      // cache must only reflect the new entry once the disk write has
      // succeeded, or a failed write leaves cache and file diverged.
      const contents = [...(await this.read(path, shouldEncode))];

      contents.push(newContent);
      if (maxEntries && contents.length > maxEntries) {
        contents.splice(0, contents.length - maxEntries);
      }