Memento Pattern

The Problem

A shopping cart changes frequently as users add, remove, and modify items. Users expect undo capability. Storing cart state externally would break encapsulation — external code would need to know about the cart’s internal structure to save and restore it.

The Solution

The shopping cart (originator) creates opaque snapshot objects (mementos) of its own state. A caretaker service stores these snapshots in undo and redo stacks. The cart can restore itself from any memento without exposing its internals.

Structure

Originator (ShoppingCart) — Creates mementos via save() and restores via restore().
Memento (CartMemento) — Immutable snapshot with timestamp.
Caretaker (CartHistoryService) — Manages undo/redo stacks.

Implementation

The shopping cart supports adding items (with quantity merging for duplicates), undo, redo, and full history viewing. Each modification saves a memento before the change.

export interface CartItem {
  name: string;
  price: number;
  quantity: number;
}

export class CartMemento {
  private readonly items: CartItem[];
  private readonly timestamp: string;

  constructor(items: CartItem[]) {
    this.items = items.map((item) => ({ ...item }));
    this.timestamp = new Date().toISOString();
  }

  getItems(): CartItem[] {
    return this.items.map((item) => ({ ...item }));
  }

  getTimestamp(): string {
    return this.timestamp;
  }

  getTotal(): number {
    return this.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  }
}

import { CartMemento, CartItem } from './cart-memento';

export class ShoppingCart {
  private items: CartItem[] = [];

  addItem(item: CartItem): void {
    const existing = this.items.find((i) => i.name === item.name);
    if (existing) {
      existing.quantity += item.quantity;
    } else {
      this.items.push({ ...item });
    }
  }

  removeItem(name: string): boolean {
    const index = this.items.findIndex((i) => i.name === name);
    if (index === -1) {
      return false;
    }
    this.items.splice(index, 1);
    return true;
  }

  getItems(): CartItem[] {
    return this.items.map((item) => ({ ...item }));
  }

  getTotal(): number {
    return this.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  }

  save(): CartMemento {
    return new CartMemento(this.items);
  }

  restore(memento: CartMemento): void {
    this.items = memento.getItems();
  }
}

import { Injectable } from '@nestjs/common';
import { CartMemento } from './cart-memento';
import { ShoppingCart } from './shopping-cart';

@Injectable()
export class CartHistoryService {
  private readonly undoStack: CartMemento[] = [];
  private readonly redoStack: CartMemento[] = [];
  private readonly cart: ShoppingCart;

  constructor() {
    this.cart = new ShoppingCart();
  }

  getCart(): ShoppingCart {
    return this.cart;
  }

  push(memento: CartMemento): void {
    this.undoStack.push(memento);
    this.redoStack.length = 0;
  }

  undo(): CartMemento | null {
    if (this.undoStack.length === 0) {
      return null;
    }

    const currentState = this.cart.save();
    this.redoStack.push(currentState);

    const memento = this.undoStack.pop()!;
    this.cart.restore(memento);

    return memento;
  }

  redo(): CartMemento | null {
    if (this.redoStack.length === 0) {
      return null;
    }

    const currentState = this.cart.save();
    this.undoStack.push(currentState);

    const memento = this.redoStack.pop()!;
    this.cart.restore(memento);

    return memento;
  }

  getHistory(): { timestamp: string; itemCount: number; total: number }[] {
    return this.undoStack.map((memento) => ({
      timestamp: memento.getTimestamp(),
      itemCount: memento.getItems().length,
      total: memento.getTotal(),
    }));
  }
}

NestJS Integration

The CartHistoryService is an @Injectable() singleton that persists undo/redo stacks across requests. The ShoppingCart is also a singleton provider, simulating a single-user cart for demonstration. In production, you would use request-scoped or session-scoped providers.

When to Use

You need to implement undo/redo functionality.
You want to save and restore object state without violating encapsulation.
You need snapshots for transaction-like operations (commit/rollback).

When NOT to Use

The object’s state is trivially simple — just store a copy directly.
Creating mementos is expensive due to large state — consider storing deltas instead.

Command

Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

Iterator

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Prototype

Create objects by cloning a prototype rather than constructing from scratch.