Собираем таблицу: строки, индекс, уникальность

type Row = { id: number; email: string; city: string };

// Таблица без базы: строки лежат в карте по id, а id раздаёт счётчик
const rows = new Map<number, Row>();
let nextId = 1;
let scanned = 0;

function insert(email: string, city: string): Row {
  const row = { id: nextId, email, city };
  rows.set(row.id, row);
  nextId += 1;
  return row;
}

// Единственный способ что-то найти: просмотреть строки подряд
function where(match: (row: Row) => boolean): Row[] {
  const found: Row[] = [];
  for (const row of rows.values()) {
    scanned += 1;
    if (match(row)) found.push(row);
  }
  return found;
}

const cities = ["Казань", "Пермь", "Томск"];
for (let n = 1; n <= 12; n += 1) insert(`user${n}@example.com`, cities[n % 3]);

scanned = 0;
console.log("по почте нашлось:", where((row) => row.email === "user7@example.com").length, "| просмотрено:", scanned);

scanned = 0;
console.log("в Томске нашлось:", where((row) => row.city === "Томск").length, "| просмотрено:", scanned);

scanned = 0;
console.log("такой почты нет:", where((row) => row.email === "zzz@example.com").length, "| просмотрено:", scanned);

type Row = { id: number; email: string; city: string };

const rows = new Map<number, Row>();
const cities = ["Казань", "Пермь", "Томск"];
for (let n = 1; n <= 12; n += 1) rows.set(n, { id: n, email: `user${n}@example.com`, city: cities[n % 3] });

// Индекс — вторая карта: значение колонки → номера строк с этим значением
const byCity = new Map<string, Set<number>>();
function addToIndex(row: Row): void {
  const ids = byCity.get(row.city) ?? new Set<number>();
  ids.add(row.id);
  byCity.set(row.city, ids);
}
for (const row of rows.values()) addToIndex(row);

// Поиск по индексу: одна выборка из карты и переход по номерам, без единого лишнего чтения
function byIndex(city: string): number {
  return [...(byCity.get(city) ?? [])].map((id) => rows.get(id) as Row).length;
}
function byScan(city: string): number {
  return [...rows.values()].filter((row) => row.city === city).length;
}

console.log("Томск — индекс:", byIndex("Томск"), "перебор:", byScan("Томск"));

// Правка мимо индекса: строка переехала, а вторая карта об этом не знает
const moved = rows.get(3) as Row;
moved.city = "Томск";
console.log("после переезда Томск — индекс:", byIndex("Томск"), "перебор:", byScan("Томск"));
console.log("после переезда Казань — индекс:", byIndex("Казань"), "перебор:", byScan("Казань"));

type Row = Record<string, unknown> & { id: number };

// Ошибка базы: код SQLSTATE и имя нарушенного ограничения — полями, как у драйвера pg
class DbError extends Error {
  code: string;
  constraint: string;
  constructor(code: string, constraint: string, message: string) {
    super(message);
    this.name = "DbError";
    this.code = code;
    this.constraint = constraint;
  }
}

// Индекс — вторая карта: значение колонки → номера строк. Уникальный ещё и отказывает
class TableIndex {
  name: string;
  column: string;
  unique: boolean;
  #ids = new Map<unknown, Set<number>>();

  constructor(name: string, column: string, unique: boolean) {
    this.name = name;
    this.column = column;
    this.unique = unique;
  }

  check(row: Row): void {
    if (!this.unique) return;
    const ids = this.#ids.get(row[this.column]);
    // строка сама с собой не спорит: иначе правка города ломалась бы о свою же почту
    if (ids && [...ids].some((id) => id !== row.id)) {
      throw new DbError("23505", this.name, `duplicate key value violates unique constraint "${this.name}"`);
    }
  }

  add(row: Row): void {
    const ids = this.#ids.get(row[this.column]) ?? new Set<number>();
    ids.add(row.id);
    this.#ids.set(row[this.column], ids);
  }

  remove(row: Row): void {
    const ids = this.#ids.get(row[this.column]);
    if (!ids) return;
    ids.delete(row.id);
    if (ids.size === 0) this.#ids.delete(row[this.column]);
  }

  find(value: unknown): number[] {
    return [...(this.#ids.get(value) ?? [])];
  }
}

class Table {
  scanned = 0;
  #rows = new Map<number, Row>();
  #indexes: TableIndex[] = [];
  #nextId = 1;

  index(name: string, column: string, options: { unique?: boolean } = {}): Table {
    const index = new TableIndex(name, column, options.unique === true);
    for (const row of this.#rows.values()) {
      index.check(row);
      index.add(row);
    }
    this.#indexes.push(index);
    return this;
  }

  insert(values: Record<string, unknown>): Row {
    const row = { ...values, id: this.#nextId };
    // сначала спрашиваем все индексы и только потом пишем: иначе отказ второго
    // оставил бы строку в первом
    for (const index of this.#indexes) index.check(row);
    this.#rows.set(row.id, row);
    for (const index of this.#indexes) index.add(row);
    this.#nextId += 1;
    return row;
  }

  update(id: number, patch: Record<string, unknown>): Row | null {
    const row = this.#rows.get(id);
    if (!row) return null;
    const next = { ...row, ...patch, id };
    for (const index of this.#indexes) index.check(next);
    for (const index of this.#indexes) index.remove(row);
    this.#rows.set(id, next);
    for (const index of this.#indexes) index.add(next);
    return next;
  }

  remove(id: number): boolean {
    const row = this.#rows.get(id);
    if (!row) return false;
    for (const index of this.#indexes) index.remove(row);
    this.#rows.delete(id);
    return true;
  }

  find(indexName: string, value: unknown): Row[] {
    const index = this.#indexes.find((item) => item.name === indexName);
    if (!index) throw new DbError("42704", indexName, `index "${indexName}" does not exist`);
    return index.find(value).map((id) => this.#rows.get(id) as Row);
  }

  where(match: (row: Row) => boolean): Row[] {
    this.scanned = 0;
    const found: Row[] = [];
    for (const row of this.#rows.values()) {
      this.scanned += 1;
      if (match(row)) found.push(row);
    }
    return found;
  }
}

const users = new Table()
  .index("users_email_key", "email", { unique: true })
  .index("users_city_idx", "city");

const cities = ["Казань", "Пермь", "Томск"];
for (let n = 1; n <= 12; n += 1) users.insert({ email: `user${n}@example.com`, city: cities[n % 3] });

console.log("вставилась строка:", users.insert({ email: "ann@example.com", city: "Казань" }));
console.log("по индексу города:", users.find("users_city_idx", "Казань").length, "| просмотрено:", users.scanned);
console.log("перебором:", users.where((row) => row.city === "Казань").length, "| просмотрено:", users.scanned);

try {
  users.insert({ email: "ann@example.com", city: "Томск" });
} catch (error) {
  const db = error as DbError;
  console.log("дубль:", db.code, db.constraint);
  console.log(db.message);
}

// переезд идёт через таблицу, и оба индекса чинятся сами
users.update(13, { city: "Томск" });
console.log("после переезда Казань:", users.find("users_city_idx", "Казань").length, "Томск:", users.find("users_city_idx", "Томск").length);
console.log("строк в таблице:", users.where(() => true).length);

// Таблица с индексами и уникальностью — на подложке; здесь только её типы и новое
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[];
}

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

async function register(table: Table, email: string): Promise<string> {
  const busy = table.where((row) => row.email === email).length > 0;
  await roundTrip();
  if (busy) return "отказ: занято";
  try {
    return `создан #${table.insert({ email }).id}`;
  } catch (error) {
    return `отказ: ${(error as DbError).code} ${(error as DbError).constraint}`;
  }
}

async function main(): Promise<void> {
  const calm = new Table();
  const first = await register(calm, "ann@example.com");
  const second = await register(calm, "ann@example.com");
  console.log("по очереди:", first, "|", second, "| строк:", calm.where(() => true).length);

  const loose = new Table();
  const raced = await Promise.all([register(loose, "ann@example.com"), register(loose, "ann@example.com")]);
  console.log("разом:", raced.join(" | "), "| строк:", loose.where(() => true).length);

  const strict = new Table().index("users_email_key", "email", { unique: true });
  const guarded = await Promise.all([register(strict, "ann@example.com"), register(strict, "ann@example.com")]);
  console.log("разом с индексом:", guarded.join(" | "), "| строк:", strict.where(() => true).length);
}

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[];
}

// Проверка из статьи про доменные коды — переписывать её не пришлось
interface PgErrorLike {
  code?: string;
  constraint?: string;
  cause?: PgErrorLike;
}

function isUniqueViolation(error: unknown, indexName: string): boolean {
  const outer = error as PgErrorLike | undefined;
  const pg = outer?.code === "23505" ? outer : outer?.cause;
  return pg?.code === "23505" && pg.constraint === indexName;
}

const users = new Table()
  .index("users_email_key", "email", { unique: true })
  .index("users_phone_key", "phone", { unique: true });

users.insert({ email: "ann@example.com", phone: "+79990000001" });

function signup(email: string, phone: string): string {
  try {
    return `создан #${users.insert({ email, phone }).id}`;
  } catch (error) {
    if (isUniqueViolation(error, "users_email_key")) return "EMAIL_TAKEN";
    if (isUniqueViolation(error, "users_phone_key")) return "PHONE_TAKEN";
    throw error;
  }
}

console.log(signup("bob@example.com", "+79990000002"));
console.log(signup("ann@example.com", "+79990000003"));
console.log(signup("cat@example.com", "+79990000001"));

// та же ошибка, но завёрнутая: так её отдаёт библиотека доступа к данным
try {
  users.insert({ email: "ann@example.com", phone: "+79990000004" });
} catch (error) {
  const wrapped = new Error("Failed query: insert into users (email, phone) values ($1, $2)", { cause: error });
  console.log("снаружи код:", (wrapped as PgErrorLike).code, "| узнали:", isUniqueViolation(wrapped, "users_email_key"));
}

// правка идёт через те же индексы
try {
  users.update(2, { email: "ann@example.com" });
  console.log("правка прошла");
} catch (error) {
  console.log("правка на чужую почту:", isUniqueViolation(error, "users_email_key") ? "EMAIL_TAKEN" : "другая ошибка");
}