Command

// The receiver: the real objects that commands act on.
class Fleet {
  readonly bikes: Record<string, number> = { "S-12": 7, "S-31": 3 };
  readonly disabled = new Set<string>();
  state(): string {
    const docks = [...this.disabled].sort().join(", ") || "none";
    return `S-12 ${this.bikes["S-12"]}, S-31 ${this.bikes["S-31"]} | disabled docks: ${docks}`;
  }
}

class Refused extends Error {}

// ---- Each request is an object: it can be run, undone, stored and described. ----
interface Command {
  run(fleet: Fleet): void;
  undo(fleet: Fleet): void;
  describe(): string;
}

class DisableDock implements Command {
  constructor(private readonly dock: string) {}
  run(fleet: Fleet) { fleet.disabled.add(this.dock); }
  undo(fleet: Fleet) { fleet.disabled.delete(this.dock); }
  describe() { return `disable ${this.dock}`; }
}

class MoveBikes implements Command {
  constructor(private readonly src: string, private readonly dst: string, private readonly count: number) {}
  run(fleet: Fleet) {
    if (fleet.bikes[this.src] < this.count) throw new Refused(`${this.src} has only ${fleet.bikes[this.src]}`);
    fleet.bikes[this.src] -= this.count;
    fleet.bikes[this.dst] += this.count;
  }
  undo(fleet: Fleet) { fleet.bikes[this.dst] -= this.count; fleet.bikes[this.src] += this.count; }
  describe() { return `move ${this.count} bikes ${this.src} -> ${this.dst}`; }
}

// ---- The invoker: runs commands, keeps a history for undo and a log for audit. It knows no command types. ----
class OperatorConsole {
  private readonly history: Command[] = [];
  readonly log: string[] = [];
  constructor(private readonly fleet: Fleet) {}

  submit(cmd: Command): string {
    try {
      cmd.run(this.fleet);
    } catch (e) {
      if (!(e instanceof Refused)) throw e;
      this.log.push(`refused ${cmd.describe()}`);
      return `run: ${cmd.describe()} -> refused: ${e.message}`;
    }
    this.history.push(cmd);
    this.log.push(cmd.describe());
    return `run: ${cmd.describe()} -> ${this.fleet.state()}`;
  }

  undo(): string {
    const cmd = this.history.pop()!;
    cmd.undo(this.fleet);
    this.log.push(`undo ${cmd.describe()}`);
    return `undo: ${cmd.describe()} -> ${this.fleet.state()}`;
  }
}

const consoleUi = new OperatorConsole(new Fleet());
console.log(consoleUi.submit(new DisableDock("D9")));
console.log(consoleUi.submit(new MoveBikes("S-12", "S-31", 5)));
console.log(consoleUi.submit(new MoveBikes("S-12", "S-31", 4)));
console.log(consoleUi.undo());
console.log(consoleUi.undo());
console.log("audit log: " + consoleUi.log.join("; "));

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

public class Main {
    // The receiver: the real objects that commands act on.
    static class Fleet {
        final Map<String, Integer> bikes = new HashMap<>(Map.of("S-12", 7, "S-31", 3));
        final TreeSet<String> disabled = new TreeSet<>();
        String state() {
            String docks = disabled.isEmpty() ? "none" : String.join(", ", disabled);
            return "S-12 " + bikes.get("S-12") + ", S-31 " + bikes.get("S-31") + " | disabled docks: " + docks;
        }
    }

    static class Refused extends Exception {
        private static final long serialVersionUID = 1L;
        Refused(String message) { super(message); }
    }

    // ---- Each request is an object: it can be run, undone, stored and described. ----
    interface Command {
        void run(Fleet fleet) throws Refused;
        void undo(Fleet fleet);
        String describe();
    }

    static class DisableDock implements Command {
        private final String dock;
        DisableDock(String dock) { this.dock = dock; }
        public void run(Fleet fleet) { fleet.disabled.add(dock); }
        public void undo(Fleet fleet) { fleet.disabled.remove(dock); }
        public String describe() { return "disable " + dock; }
    }

    static class MoveBikes implements Command {
        private final String src, dst;
        private final int count;
        MoveBikes(String src, String dst, int count) { this.src = src; this.dst = dst; this.count = count; }
        public void run(Fleet fleet) throws Refused {
            if (fleet.bikes.get(src) < count) throw new Refused(src + " has only " + fleet.bikes.get(src));
            fleet.bikes.merge(src, -count, Integer::sum);
            fleet.bikes.merge(dst, count, Integer::sum);
        }
        public void undo(Fleet fleet) { fleet.bikes.merge(dst, -count, Integer::sum); fleet.bikes.merge(src, count, Integer::sum); }
        public String describe() { return "move " + count + " bikes " + src + " -> " + dst; }
    }

    // ---- The invoker: runs commands, keeps a history for undo and a log for audit. It knows no command types. ----
    static class OperatorConsole {
        private final Fleet fleet;
        private final Deque<Command> history = new ArrayDeque<>();
        final List<String> log = new ArrayList<>();
        OperatorConsole(Fleet fleet) { this.fleet = fleet; }

        String submit(Command cmd) {
            try {
                cmd.run(fleet);
            } catch (Refused e) {
                log.add("refused " + cmd.describe());
                return "run: " + cmd.describe() + " -> refused: " + e.getMessage();
            }
            history.push(cmd);
            log.add(cmd.describe());
            return "run: " + cmd.describe() + " -> " + fleet.state();
        }

        String undo() {
            Command cmd = history.pop();
            cmd.undo(fleet);
            log.add("undo " + cmd.describe());
            return "undo: " + cmd.describe() + " -> " + fleet.state();
        }
    }

    public static void main(String[] args) {
        OperatorConsole console = new OperatorConsole(new Fleet());
        System.out.println(console.submit(new DisableDock("D9")));
        System.out.println(console.submit(new MoveBikes("S-12", "S-31", 5)));
        System.out.println(console.submit(new MoveBikes("S-12", "S-31", 4)));
        System.out.println(console.undo());
        System.out.println(console.undo());
        System.out.println("audit log: " + String.join("; ", console.log));
    }
}