Feat resumability (#547)

* add resumability functionality

---------

Co-authored-by: arc-alex <ac@omnivox.dk>
Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>

apps/server/src/services/RestoreService.ts

@@ -0,0 +1,160 @@
+import { Playback } from 'ontime-types';
+
+import { readFileSync } from 'fs';
+import { Writer } from 'steno';
+
+import { resolveRestoreFile } from '../setup.js';
+
+export type RestorePoint = {
+  playback: Playback;
+  selectedEventId: string | null;
+  startedAt: number | null;
+  addedTime: number | null;
+  pausedAt: number | null;
+};
+
+/**
+ * Utility validates a RestorePoint
+ * @param obj
+ * @return boolean
+ */
+export function isRestorePoint(obj: unknown): obj is RestorePoint {
+  if (!obj) {
+    return false;
+  }
+
+  const restorePoint = obj as RestorePoint;
+
+  if (typeof restorePoint.playback !== 'string' || !Object.values(Playback).includes(restorePoint.playback)) {
+    return false;
+  }
+
+  if (typeof restorePoint.selectedEventId !== 'string' && restorePoint.selectedEventId !== null) {
+    return false;
+  }
+
+  if (typeof restorePoint.startedAt !== 'number' && restorePoint.startedAt !== null) {
+    return false;
+  }
+
+  if (typeof restorePoint.addedTime !== 'number' && restorePoint.addedTime !== null) {
+    return false;
+  }
+
+  if (typeof restorePoint.pausedAt !== 'number' && restorePoint.pausedAt !== null) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Utility interface to allow dependency injection during test
+ */
+
+/**
+ * Service manages saving of application state
+ * that can then be restored when reopening
+ */
+export class RestoreService {
+  private readonly filePath: string | null;
+
+  private lastStore: string | null;
+  private file: Writer | null;
+  private failedCreateAttempts: number;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+
+    this.lastStore = null;
+    this.file = null;
+    this.failedCreateAttempts = 0;
+  }
+
+  /**
+   * Utility, creates a restore file
+   */
+  create() {
+    this.file = new Writer(this.filePath);
+  }
+
+  /**
+   * Utility, reads from file
+   * @private
+   */
+  private read() {
+    return readFileSync(this.filePath, 'utf-8');
+  }
+
+  /**
+   * Utility writes payload to file
+   * @throws
+   * @param stringifiedState
+   */
+  private async write(stringifiedState: string) {
+    // Create a file if it doesnt exist
+    if (!this.file) {
+      this.create();
+    }
+    // steno is async, and it uses a queue to avoid unnecessary re-writes
+    await this.file.write(stringifiedState);
+  }
+
+  /**
+   * Saves runtime data to restore file
+   * @param newState RestorePoint
+   */
+  async save(newState: RestorePoint) {
+    // after three failed attempts, mark the service as unavailable
+    if (this.failedCreateAttempts > 3) {
+      return;
+    }
+
+    const stringifiedStore = JSON.stringify(newState);
+    if (stringifiedStore !== this.lastStore) {
+      try {
+        await this.write(stringifiedStore);
+        this.lastStore = stringifiedStore;
+        this.failedCreateAttempts = 0;
+      } catch (_err) {
+        this.failedCreateAttempts += 1;
+      }
+    }
+  }
+
+  /**
+   * Attempts reading a restore point from a given file path
+   * Returns null if none found, restore point otherwise
+   */
+  load(): RestorePoint | null {
+    try {
+      const data = this.read();
+      const maybeRestorePoint = JSON.parse(data);
+
+      if (!isRestorePoint(maybeRestorePoint)) {
+        return null;
+      }
+
+      return maybeRestorePoint;
+    } catch (_error) {
+      // no need to notify the user
+      return null;
+    }
+  }
+
+  /**
+   * Clears the restore file
+   */
+  async clear() {
+    if (this.file && this.failedCreateAttempts <= 3) {
+      try {
+        await this.file.write('');
+      } catch (_error) {
+        // nothing to do
+      }
+    }
+    this.file = undefined;
+  }
+}
+
+export const restoreService = new RestoreService(resolveRestoreFile);