Удаление — это запись: надгробие

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
  list(): Row[];
  remove(id: string): void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);

// подход записан в зале и уехал на сервер, веб-версия его забрала
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// дома подход удаляют — так, как удаляют строку: её больше нет
web.store.remove(set);
web.sync();
phone.sync();
console.log("после удаления — на телефоне:", phone.store.list().length, "| на вебе:", web.store.list().length);

// в зале, ещё не зная об удалении, в том же подходе правят вес
phone.journal.change(set, { weightKg: 82.5 });
phone.sync();
web.sync();
console.log("веб после синхронизации:", JSON.stringify(web.store.list()));

// новое устройство: курсор нулевой, дневник переносится целиком
const fresh = createClient("C", server);
fresh.sync();
console.log("у C осталось:", JSON.stringify(fresh.store.list().map((row) => row.id)));
console.log("а у сервера строк:", server.rows.size);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
  list(): Row[];
  remove(id: string): void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

// удаление — такая же операция, как правка: поле deleted с отметкой времени
function remove(client: Client, rowId: string) {
  client.journal.change(rowId, { deleted: true });
}
// экран показывает живые строки, надгробия остаются в хранилище
const visible = (rows: Row[]) => rows.filter((row) => !row.deleted);

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

remove(web, set);
web.sync();
phone.sync();
const fresh = createClient("C", server);
fresh.sync();

const show = (client: Client) => visible(client.store.list()).map((row) => row.id).join(", ") || "(пусто)";
console.log("A: " + show(phone) + " | B: " + show(web) + " | C: " + show(fresh));
console.log("строк у сервера:", server.rows.size, "| видимых:", visible([...server.rows.values()]).length);
console.log("строка целиком:", JSON.stringify(server.rows.get(set)));

// store.ts — живые строки лежат рядом с обычным списком
let shown: { version: number; rows: Row[] } = { version: 0, rows: [] };

function visible(): Row[] {
  // снимок пересобирается только при новой версии: иначе каждый вызов
  // getSnapshot возвращал бы новый массив — ловушка из главы 6
  if (shown.version !== version) {
    shown = { version, rows: [...rows.values()].filter((row) => !row.deleted) };
  }
  return shown.rows;
}

// journal.ts — удаление как операция, в одну строку
function remove(rowId: string) {
  change(rowId, { deleted: true });
}

// contracts/sync.ts — общий для телефона и сервера
// было: Record<string, string | number>
export type Fields = Record<string, string | number | boolean>;

// процедуры остаются те же: удаление едет обычным sync.push как операция
// { opId, rowId, fields: { deleted: true }, at }

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
  list(): Row[];
  visible(): Row[];
  subscribe(listener: () => void): () => void;
  remove(id: string): void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;
const { View, Text, Pressable, FlatList } = ReactNative;

const server = createServer();
const client = createClient("A", server);
for (const exercise of ["жим", "присед"]) {
  client.journal.change(client.journal.newId(), { exercise, weightKg: 80, reps: 5 });
}

function Diary() {
  // getSnapshot отдаёт живые строки снимком по версии, а не фильтрует на лету
  const rows = React.useSyncExternalStore(client.store.subscribe, client.store.visible);
  console.log("в ленте:", rows.map((row) => row.id).join(", ") || "(пусто)", "| строк в хранилище:", client.store.list().length);
  return (
    <View>
      <FlatList
        data={rows}
        keyExtractor={(row: Row) => row.id}
        renderItem={({ item }: { item: Row }) => (
          <Pressable testID={"del-" + item.id} onPress={() => client.journal.remove(item.id)}>
            <Text>{String(item.exercise) + " · удалить"}</Text>
          </Pressable>
        )}
      />
      <Pressable testID="undo" onPress={() => client.journal.change("A-1", { deleted: false })}>
        <Text>вернуть</Text>
      </Pressable>
    </View>
  );
}

mount(<Diary />);
setTimeout(() => fireEvent.press("del-A-1"), 50);
setTimeout(() => fireEvent.press("undo"), 120);
setTimeout(() => console.log("операций в журнале:", client.journal.outbox().length), 200);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
  list(): Row[];
  visible(): Row[];
  subscribe(listener: () => void): () => void;
  remove(id: string): void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;
declare function apply(row: Row | undefined, op: Op): Row;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// дома подход удалили, а в зале — ещё не зная об этом — поправили повторы
web.journal.remove(set);
phone.journal.change(set, { reps: 12 });
web.sync();
phone.sync();
console.log("в журнале сервера:", server.journal.map((e) => e.opId + " " + JSON.stringify(e.fields)).join(", "));

// правка воскрешает: любое поле, кроме самого надгробия, снимает отметку
function reviving(row: Row | undefined, op: Op): Row {
  const next = apply(row, op);
  if (!("deleted" in op.fields)) next.deleted = false;
  return next;
}

for (const rule of ["удаление побеждает", "правка воскрешает"] as const) {
  const merge = rule === "удаление побеждает" ? apply : reviving;
  const rows = new Map<string, Row>();
  for (const entry of server.journal) rows.set(entry.rowId, merge(rows.get(entry.rowId), entry));
  const row = rows.get(set)!;
  console.log(rule + ": deleted " + row.deleted + ", reps " + row.reps + ", видно " + (row.deleted ? 0 : 1));
}

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
  list(): Row[];
  visible(): Row[];
  subscribe(listener: () => void): () => void;
  remove(id: string): void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
for (const exercise of ["жим", "присед"]) {
  phone.journal.change(phone.journal.newId(), { exercise, weightKg: 80, reps: 5 });
}
phone.journal.remove("A-1");
phone.sync();
console.log("строк у сервера:", server.rows.size, "| видимых:", [...server.rows.values()].filter((row) => !row.deleted).length);

// новое устройство приходит, пока надгробие на месте
const before = createClient("C", server);
before.sync();
console.log("C до чистки видит:", before.store.visible().map((row) => row.id).join(", "));

// сервер «прибрался»: надгробие старше срока выброшено из журнала
const index = server.journal.findIndex((entry) => entry.fields.deleted === true);
server.journal.splice(index, 1);

const after = createClient("D", server);
after.sync();
console.log("D после чистки видит:", after.store.visible().map((row) => row.id).join(", "));

// migrations.ts — шаг схемы: надгробие вместо удаления строки
await db.execAsync("alter table sets add column deleted_at integer");
// частичный индекс держит ленту быстрой и не разрастается на надгробия
await db.execAsync(
  "create index sets_live on sets (started_at) where deleted_at is null",
);

// лента берёт только живые строки — про надгробия она не знает вовсе
const live = await db.getAllAsync<SetRow>(
  "select * from sets where deleted_at is null order by started_at desc",
);