Транзакция, откат и гонка: собираем CAS-обновление

// Таблица с индексами и уникальностью — на подложке; здесь только её типы и новое
type Row = Record<string, unknown> & { id: number };
declare class DbError extends Error {
  code: string;
  constraint: string;
}
declare class Table {
  scanned: number;
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
  where(match: (row: Row) => boolean): Row[];
}

const users = new Table().index("users_email_key", "email", { unique: true });
const profiles = new Table().index("profiles_nick_key", "nick", { unique: true });

// Регистрация пишет в две таблицы: учётную запись и профиль с прозвищем
function signup(email: string, nick: string): string {
  const user = users.insert({ email });
  profiles.insert({ userId: user.id, nick });
  return `создан #${user.id}`;
}

function attempt(email: string, nick: string): void {
  try {
    console.log(`${email} / ${nick}:`, signup(email, nick));
  } catch (error) {
    console.log(`${email} / ${nick}:`, (error as DbError).code, (error as DbError).constraint);
  }
  console.log("  строк: учётки", users.where(() => true).length, "| профили", profiles.where(() => true).length);
}

attempt("ann@example.com", "ann");
attempt("bob@example.com", "ann");
// Боб понял, что прозвище занято, и пробует ещё раз — тем же адресом, другим прозвищем
attempt("bob@example.com", "bob");

type Row = Record<string, unknown> & { id: number };
declare class DbError extends Error {
  code: string;
  constraint: string;
}
declare class Table {
  scanned: number;
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
  where(match: (row: Row) => boolean): Row[];
}

type Undo = () => void;

// Транзакция модели: каждое действие кладёт рядом обратное себе
class Tx {
  #undo: Undo[] = [];

  insert(table: Table, values: Record<string, unknown>): Row {
    const row = table.insert(values);
    this.#undo.push(() => table.remove(row.id));
    return row;
  }

  update(table: Table, id: number, patch: Record<string, unknown>): Row | null {
    // прежние значения читаются ДО правки: после неё взять их уже негде
    const before = table.where((row) => row.id === id)[0];
    const next = table.update(id, patch);
    // колонки таблицы заданы заранее, поэтому вернуть прежние значения всех полей достаточно
    if (before) this.#undo.push(() => table.update(id, before));
    return next;
  }

  rollback(): void {
    // в обратном порядке: последнее действие отменяется первым
    for (const undo of this.#undo.reverse()) undo();
    this.#undo = [];
  }
}

function transaction<T>(body: (tx: Tx) => T): T {
  const tx = new Tx();
  try {
    return body(tx);
  } catch (error) {
    tx.rollback();
    throw error;
  }
}

const users = new Table().index("users_email_key", "email", { unique: true });
const profiles = new Table().index("profiles_nick_key", "nick", { unique: true });

function signup(email: string, nick: string): string {
  return transaction((tx) => {
    const user = tx.insert(users, { email });
    tx.insert(profiles, { userId: user.id, nick });
    return `создан #${user.id}`;
  });
}

function attempt(email: string, nick: string): void {
  try {
    console.log(`${email} / ${nick}:`, signup(email, nick));
  } catch (error) {
    console.log(`${email} / ${nick}:`, (error as DbError).code, (error as DbError).constraint);
  }
  console.log("  строк: учётки", users.where(() => true).length, "| профили", profiles.where(() => true).length);
}

attempt("ann@example.com", "ann");
attempt("bob@example.com", "ann");
attempt("bob@example.com", "bob");

type Row = Record<string, unknown> & { id: number };
declare class Table {
  scanned: number;
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
  where(match: (row: Row) => boolean): Row[];
}

const notes = new Table();
notes.insert({ title: "черновик", edits: 0 });

// «сходить в базу» — это await: обработчик отпускает поток, и соседний запрос
// успевает сделать ровно то же самое
const roundTrip = (): Promise<void> => Promise.resolve();

async function rename(id: number, title: string): Promise<string> {
  const before = notes.where((row) => row.id === id)[0];
  await roundTrip();
  notes.update(id, { title, edits: (before.edits as number) + 1 });
  return `записал «${title}»`;
}

function show(label: string): void {
  const row = notes.where((item) => item.id === 1)[0];
  console.log(label, "название:", row.title, "| правок:", row.edits);
}

async function main(): Promise<void> {
  console.log((await rename(1, "план на неделю")) + " | " + (await rename(1, "план на месяц")));
  show("по очереди:");

  notes.update(1, { title: "черновик", edits: 0 });
  const both = await Promise.all([rename(1, "список покупок"), rename(1, "список дел")]);
  console.log(both.join(" | "));
  show("разом:");
}

main();

type Row = Record<string, unknown> & { id: number };
declare class Table {
  scanned: number;
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
  where(match: (row: Row) => boolean): Row[];
}

const notes = new Table();
notes.insert({ title: "черновик", edits: 0, version: 1 });

const roundTrip = (): Promise<void> => Promise.resolve();

// UPDATE notes SET …, version = version + 1 WHERE id = $1 AND version = $2
// Возвращается не строка, а число изменённых строк — как rowCount у драйвера
function updateIfVersion(id: number, version: number, patch: Record<string, unknown>): number {
  // условие и запись стоят вплотную, без await между ними: в базе это одна команда
  const row = notes.where((item) => item.id === id && item.version === version)[0];
  if (!row) return 0;
  notes.update(id, { ...patch, version: version + 1 });
  return 1;
}

async function rename(id: number, title: string): Promise<string> {
  const before = notes.where((row) => row.id === id)[0];
  await roundTrip();
  const changed = updateIfVersion(id, before.version as number, { title, edits: (before.edits as number) + 1 });
  return `«${title}»: строк изменено ${changed}`;
}

async function main(): Promise<void> {
  const both = await Promise.all([rename(1, "список покупок"), rename(1, "список дел")]);
  console.log(both.join(" | "));
  const row = notes.where((item) => item.id === 1)[0];
  console.log("в строке:", row.title, "| правок:", row.edits, "| версия:", row.version);
}

main();

type Row = Record<string, unknown> & { id: number };
declare class Table {
  scanned: number;
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
  where(match: (row: Row) => boolean): Row[];
}

const notes = new Table();
notes.insert({ title: "черновик", views: 0, version: 1 });

const roundTrip = (): Promise<void> => Promise.resolve();

// то же обновление с условием, что и в прошлом разделе
function updateIfVersion(id: number, version: number, patch: Record<string, unknown>): number {
  const row = notes.where((item) => item.id === id && item.version === version)[0];
  if (!row) return 0;
  notes.update(id, { ...patch, version: version + 1 });
  return 1;
}

// Ноль строк — три разных ответа, и какой из них ваш, знает только перечитанная строка
function save(id: number, version: number, patch: Record<string, unknown>): string {
  if (updateIfVersion(id, version, patch) === 1) return "сохранено";
  const row = notes.where((item) => item.id === id)[0];
  if (!row) return "NOT_FOUND";
  return `VERSION_CONFLICT: у вас ${version}, в базе ${row.version}`;
}

console.log("правка с версией 1:", save(1, 1, { title: "список покупок" }));
console.log("ещё одна с версией 1:", save(1, 1, { title: "список дел" }));
console.log("правка строки 99:", save(99, 1, { title: "чужая заметка" }));

// Счётчик просмотров можно пересчитать заново — такой отказ незачем нести человеку,
// его проще повторить
async function view(id: number): Promise<string> {
  for (let attempt = 1; attempt <= 5; attempt += 1) {
    const row = notes.where((item) => item.id === id)[0];
    await roundTrip();
    if (updateIfVersion(id, row.version as number, { views: (row.views as number) + 1 }) === 1) {
      return `попыток ${attempt}`;
    }
  }
  return "VERSION_CONFLICT";
}

async function main(): Promise<void> {
  console.log("три просмотра разом:", (await Promise.all([view(1), view(1), view(1)])).join(" | "));
  console.log("насчитано просмотров:", notes.where((item) => item.id === 1)[0].views);
}

main();