Mastering the 60-Minute Craft Round:
The Engineering Lead's Code Design Playbook

// In-Memory Key-Value Store with TTL & Nested Transactions in TypeScript

export interface IKeyValueStore<V = string> {
  get(key: string): V | null;
  set(key: string, value: V, ttlMs?: number): void;
  delete(key: string): boolean;
  begin(): void;
  commit(): boolean;
  rollback(): boolean;
}

interface ValueEntry<V> {
  value: V;
  expiresAt: number | null; // epoch timestamp in ms, null if indefinite
}

export class TransactionalKeyValueStore<V = string> implements IKeyValueStore<V> {
  // Committed global storage
  private globalStore: Map<string, ValueEntry<V>> = new Map();

  // Transaction stack: each level contains deltas (null represents a deleted key tombstone)
  private transactionStack: Map<string, ValueEntry<V> | null>[] = [];

  // Begins a new transactional scope (O(1))
  public begin(): void {
    this.transactionStack.push(new Map());
  }

  // Commits the current active transaction scope
  public commit(): boolean {
    if (this.transactionStack.length === 0) {
      return false; // No active transaction to commit
    }
    const currentDelta = this.transactionStack.pop()!;

    if (this.transactionStack.length > 0) {
      // Merge delta into parent active scope
      const parentDelta = this.transactionStack[this.transactionStack.length - 1];
      currentDelta.forEach((entry, key) => {
        parentDelta.set(key, entry);
      });
    } else {
      // Merge into committed global storage
      currentDelta.forEach((entry, key) => {
        if (entry === null) {
          this.globalStore.delete(key);
        } else {
          this.globalStore.set(key, entry);
        }
      });
    }
    return true;
  }

  // Rolls back active transaction, discarding uncommitted deltas (O(1))
  public rollback(): boolean {
    if (this.transactionStack.length === 0) {
      return false;
    }
    this.transactionStack.pop();
    return true;
  }

  // Set with optional TTL in milliseconds (O(1))
  public set(key: string, value: V, ttlMs?: number): void {
    let expiresAt: number | null = null;
    if (typeof ttlMs === "number") {
      expiresAt = ttlMs > 0 ? Date.now() + ttlMs : 0; // 0 indicates immediately expired
    }
    const entry: ValueEntry<V> = { value, expiresAt };

    if (this.transactionStack.length > 0) {
      this.transactionStack[this.transactionStack.length - 1].set(key, entry);
    } else {
      this.globalStore.set(key, entry);
    }
  }

  // Get key value, inspecting active transactions from top to bottom
  public get(key: string): V | null {
    const now = Date.now();

    // Check transaction deltas from newest to oldest
    for (let i = this.transactionStack.length - 1; i >= 0; i--) {
      const delta = this.transactionStack[i];
      if (delta.has(key)) {
        const entry = delta.get(key);
        if (entry === null) return null; // Marked deleted in transaction
        if (entry.expiresAt !== null && entry.expiresAt <= now) {
          delta.set(key, null); // Lazy cleanup in active transaction
          return null;
        }
        return entry.value;
      }
    }

    // Fallback to committed global storage
    const globalEntry = this.globalStore.get(key);
    if (!globalEntry) return null;

    if (globalEntry.expiresAt !== null && globalEntry.expiresAt <= now) {
      this.globalStore.delete(key); // Lazy cleanup
      return null;
    }

    return globalEntry.value;
  }

  public delete(key: string): boolean {
    // If the key does not exist or has expired, deletion fails
    if (this.get(key) === null) {
      return false;
    }

    if (this.transactionStack.length > 0) {
      this.transactionStack[this.transactionStack.length - 1].set(key, null); // Tombstone
    } else {
      this.globalStore.delete(key);
    }
    return true;
  }
}