[Init] Initial commit - NetMesh terminal manager

application/state/pluginImporterTransaction.ts

@@ -0,0 +1,108 @@
+import { STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION } from '../../infrastructure/config/storageKeys';
+
+type TransactionStorage = {
+  read<T>(key: string): T | null;
+  readString(key: string): string | null;
+  write<T>(key: string, value: T): boolean;
+  writeString(key: string, value: string): boolean;
+  remove(key: string): void;
+};
+
+type PreviousEntry = { key: string; value: string | null };
+type PreparedJournal = {
+  version: 1;
+  phase: 'prepared';
+  previous: PreviousEntry[];
+};
+type CommittedJournal = { version: 1; phase: 'committed' };
+type ImportJournal = PreparedJournal | CommittedJournal;
+
+const restorePrevious = (storage: TransactionStorage, previous: PreviousEntry[]) => {
+  for (const entry of previous) {
+    if (entry.value === null) {
+      storage.remove(entry.key);
+      if (storage.readString(entry.key) !== null) {
+        throw new Error(`Vault importer rollback failed for ${entry.key}`);
+      }
+    } else if (
+      !storage.writeString(entry.key, entry.value)
+      || storage.readString(entry.key) !== entry.value
+    ) {
+      throw new Error(`Vault importer rollback failed for ${entry.key}`);
+    }
+  }
+};
+
+const parseJournal = (value: unknown, allowedKeys: ReadonlySet<string>): ImportJournal | null => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const journal = value as Partial<ImportJournal>;
+  if (journal.version !== 1 || (journal.phase !== 'prepared' && journal.phase !== 'committed')) return null;
+  if (journal.phase === 'committed') return { version: 1, phase: 'committed' };
+  const previous = (journal as Partial<PreparedJournal>).previous;
+  if (!Array.isArray(previous) || previous.length === 0 || previous.length > allowedKeys.size) return null;
+  const seen = new Set<string>();
+  for (const entry of previous) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)
+      || typeof entry.key !== 'string' || !allowedKeys.has(entry.key) || seen.has(entry.key)
+      || (entry.value !== null && typeof entry.value !== 'string')) return null;
+    seen.add(entry.key);
+  }
+  return { version: 1, phase: 'prepared', previous: previous as PreviousEntry[] };
+};
+
+export function recoverPluginImporterTransaction(
+  storage: TransactionStorage,
+  allowedKeys: ReadonlySet<string>,
+): 'none' | 'rolled-back' | 'committed' | 'discarded' {
+  if (storage.readString(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION) === null) return 'none';
+  const raw = storage.read<unknown>(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+  if (raw === null) {
+    storage.remove(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+    return 'discarded';
+  }
+  const journal = parseJournal(raw, allowedKeys);
+  if (!journal) {
+    storage.remove(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+    return 'discarded';
+  }
+  if (journal.phase === 'prepared') restorePrevious(storage, journal.previous);
+  storage.remove(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+  return journal.phase === 'prepared' ? 'rolled-back' : 'committed';
+}
+
+export function commitPluginImporterTransaction(
+  storage: TransactionStorage,
+  writes: ReadonlyArray<readonly [key: string, value: unknown]>,
+): void {
+  if (storage.readString(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION) !== null) {
+    throw new Error('An unfinished Vault import recovery record already exists');
+  }
+  const keys = new Set(writes.map(([key]) => key));
+  if (keys.size !== writes.length || keys.has(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION)) {
+    throw new Error('Vault importer transaction keys are invalid');
+  }
+  const previous = writes.map(([key]) => ({ key, value: storage.readString(key) }));
+  const prepared: PreparedJournal = { version: 1, phase: 'prepared', previous };
+  if (!storage.write(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION, prepared)) {
+    throw new Error('Vault storage rejected the importer transaction journal');
+  }
+  try {
+    for (const [key, value] of writes) {
+      const expected = JSON.stringify(value);
+      if (expected === undefined
+        || !storage.write(key, value)
+        || storage.readString(key) !== expected) {
+        throw new Error(`Vault storage rejected importer transaction key ${key}`);
+      }
+    }
+    const committed: CommittedJournal = { version: 1, phase: 'committed' };
+    if (!storage.write(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION, committed)) {
+      throw new Error('Vault storage rejected the importer transaction commit marker');
+    }
+  } catch (error) {
+    restorePrevious(storage, previous);
+    storage.remove(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+    throw error;
+  }
+  storage.remove(STORAGE_KEY_PLUGIN_IMPORT_TRANSACTION);
+}