Method rollbackLast

src/filesystem/transaction.ts:393–431

Roll back the last N transactions in a session.

(sessionId: string, count: number)

  async storeBlob(hash: string, content: string): Promise<void> {
    const blobPath = path.join(this.blobsDir, hash.slice(0, 2), hash);
    await fs.mkdir(path.dirname(blobPath), { recursive: true });
    try {
      await fs.access(blobPath);
      return;
    } catch {}
    await writeFileAtomic(blobPath, content, { encoding: 'utf-8' });
  }

  async loadBlob(hash: string): Promise<string> {
    const blobPath = path.join(this.blobsDir, hash.slice(0, 2), hash);
    return await fs.readFile(blobPath, 'utf-8');
  }

  /** Rollback every committed transaction in a session, newest first. */
  async rollbackSession(sessionId: string): Promise<{ filesRestored: number; txnsRolled: number }> {
    const rows = this.db.prepare(`
      SELECT * FROM transactions WHERE session_id = ? AND status = 'committed'
      ORDER BY id DESC
    `).all(sessionId) as any[];

    let filesRestored = 0;
    const txnIds = new Set<number>();

    for (const row of rows) {
      try {
        if (row.before_hash) {
          const content = await this.loadBlob(row.before_hash);
          await fs.mkdir(path.dirname(row.path), { recursive: true });
          await writeFileAtomic(row.path, content, { encoding: 'utf-8' });
          filesRestored++;
        } else if (row.operation === 'write' || row.operation === 'create') {
          await fs.unlink(row.path).catch(() => {});
          filesRestored++;
        }
        txnIds.add(row.txn_id);
      } catch (e: any) {
        logger.warn('Failed to rollback op', { id: row.id, err: e.message });
      }
    }

    const tx = this.db.transaction(() => {