Выдача с курсора: надгробия, их срок и снимок для нового телефона

синхронизация≈ 22 минут

Здесь будет встроен видео-разбор темы (5–7 минут, YouTube / RuTube / VK Видео) — тем, кто лучше воспринимает на слух, текст ниже не обязателен.

Сервер-партнёр части V отдавал с курсора операции: у него был журнал, и свернуть его он не мог — операции с курсора нельзя свернуть, не зная, что у клиента уже есть. Сервер этой главы журнала не держит вовсе. У него итог: строка, отметки [at, opId] по её полям и номер последней правки — тот самый, что выдаёт строка-счётчик пользователя. Свернуть он поэтому может: не хвост операций с курсора, а всю строку, и отдать её записями по отметкам. Из этого сразу получаются три вещи, которых часть V ждала от части VI: снимок для нового телефона, отставший на любой срок и срок жизни надгробия. Срок окажется странным — бессрочно, — и защищать его придётся запуском. А ещё выяснится, что клиента части V всё-таки придётся поправить в одном месте: без этой правки опечатка в чужом подходе расходит устройства навсегда.

Разделы темы:·

Что сервер делает с пачкой, решено в прошлых статьях. Номер выдаёт строка-счётчик человека, и номер получает только операция, сдвинувшая хоть одну отметку: правка, проигравшая по времени всем полям, принята, но никому не нужна. Осталось сказать, где этот номер живёт. В части V он стоял на операции в журнале. Здесь он стоит на строке: sync_rows держит поля, отметки полей и seq — номер последней правки именно этой строки.

Выдача из этого получается короткой: where user_id = $1 and seq > $2 order by seq — строки, которые менялись после курсора, по порядку номера. Каждая строка уходит записями Entry по отметкам: поля с общей отметкой — одной записью с её исходными at и opId, и у всех записей строки один номер, её seq. PullInput { cursor, limit } и PullOutput { changes, cursor, hasMore } при этом не меняются: клиент части V применяет записи тем же слиянием по полям и итога от истории не отличает.

Почему записи, а не строка целиком? Соблазн ровно обратный: раз у сервера готовая строка, отдадим её одной записью — одно имя, одна отметка, меньше байтов. Проверим три формы одной и той же страницы на одном сюжете. Строку завёл телефон; потом веб-версия подняла вес; потом она же поправила повторы, но отметкой более ранней, чем у веса, — так бывает, когда операция сделана раньше, а уехала позже. Забирает всё это планшет, у которого есть своя неотправленная правка веса. Прогноз: какая форма страницы сойдётся с сервером, какая нет и на каком поле?

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Mark = { at: number; opId: string };
type Marks = Record<string, Mark>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface Client {
  store: { get(id: string): Row | undefined };
  journal: { change(rowId: string, fields: Fields): void };
  sync(): Promise<Verdict[]>;
}

// слияние по полям и клиент части V — с подложки, без правок
declare function merge(row: Fields | undefined, op: Op, mark: Marks): Row;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// Сервер хранит не журнал операций, а итог: поля строки, отметки [at, opId]
// по полям и seq — номер последней правки строки из строки-счётчика
function createRowsServer() {
  const heads = new Map<string, number>();
  const rows = new Map<string, Stored>();
  const answered = new Map<string, Verdict>();
  const key = (userId: string, rowId: string) => userId + "|" + rowId;
  // проверяется строка после применения операции — правило части V
  function checkRow(row: Row): string | null {
    const missing = ["exercise", "weightKg", "reps"].filter((field) => !(field in row));
    if (missing.length > 0) return "нет полей: " + missing.join(", ");
    return Number(row.reps) > 100 ? "повторов больше сотни" : null;
  }
  // строка уходит записями по отметкам: поля с общей отметкой — одной записью
  // с её исходными at и opId, а номер у всех записей строки один — её seq
  function entriesOf(stored: Stored): Entry[] {
    const byMark = new Map<string, Entry>();
    for (const field of Object.keys(stored.fields).sort()) {
      const mark = stored.marks[field];
      const name = mark.at + "|" + mark.opId;
      const entry = byMark.get(name) ?? { opId: mark.opId, rowId: stored.rowId, fields: {}, at: mark.at, seq: stored.seq };
      entry.fields[field] = stored.fields[field];
      byMark.set(name, entry);
    }
    return Array.from(byMark.values()).sort((a, b) => a.at - b.at || (a.opId < b.opId ? -1 : 1));
  }
  const ofUser = (userId: string) => Array.from(rows.values()).filter((row) => row.userId === userId).sort((a, b) => a.seq - b.seq);
  function take(userId: string, op: Op) {
    const stored = rows.get(key(userId, op.rowId));
    const before = stored?.marks ?? {};
    const marks: Marks = { ...before };
    const row = merge(stored?.fields, op, marks);
    const moved = JSON.stringify(marks) !== JSON.stringify(before);
    // у существующей строки ни одна отметка не сдвинулась — проверять нечего
    const reason = stored && !moved ? null : checkRow(row);
    const verdict: Verdict = reason ? { opId: op.opId, status: "rejected", reason } : { opId: op.opId, status: "applied" };
    return { verdict, moved, row, marks };
  }
  return {
    // заглянуть в итог — только для примеров
    rowsOf: ofUser,
    // чистка по сроку: выбросить надгробия совсем
    sweep(userId: string): number {
      const gone = ofUser(userId).filter((row) => row.fields.deleted === true);
      gone.forEach((row) => rows.delete(key(userId, row.rowId)));
      return gone.length;
    },
    as(userId: string): Connection {
      return {
        async push(batch: Op[]) {
          const verdicts: Verdict[] = batch.slice(0, 1000).map((op): Verdict => {
            const known = answered.get(key(userId, op.opId));
            // память вердиктов: повтор принятой — duplicate, отвергнутой — тот же отказ
            if (known) return known.status === "applied" ? { opId: op.opId, status: "duplicate" } : { ...known };
            const got = take(userId, op);
            answered.set(key(userId, op.opId), got.verdict);
            if (got.verdict.status === "applied" && got.moved) {
              const seq = (heads.get(userId) ?? 0) + 1;
              heads.set(userId, seq);
              const { id, ...fields } = got.row;
              rows.set(key(userId, op.rowId), { userId, rowId: op.rowId, fields, marks: got.marks, seq });
            }
            return { ...got.verdict };
          });
          // строка целиком — после всей пачки: к этому времени она окончательная
          verdicts.forEach((verdict, i) => {
            if (verdict.status !== "rejected") return;
            const stored = rows.get(key(userId, batch[i].rowId));
            verdict.row = stored ? entriesOf(stored) : [];
          });
          return { verdicts };
        },
        async pull(cursor: number, limit: number) {
          // limit считается в строках, и сервер сам урезает его до 500
          const ahead = ofUser(userId).filter((row) => row.seq > cursor);
          const page = ahead.slice(0, Math.min(limit, 500));
          const last = page.length > 0 ? page[page.length - 1].seq : cursor;
          return { changes: page.flatMap(entriesOf), cursor: last, hasMore: ahead.length > page.length };
        },
      };
    },
  };
}

// три формы страницы: записи по отметкам и две «оптимизации» строки в одну запись
const squash = (entries: Entry[], bare: boolean): Entry[] => {
  const byRow = new Map<string, Entry>();
  for (const entry of entries) {
    const found = byRow.get(entry.rowId);
    const newest = found && found.at > entry.at ? found : entry;
    const fields = { ...(found?.fields ?? {}), ...entry.fields };
    byRow.set(entry.rowId, { opId: newest.opId, rowId: entry.rowId, fields, at: bare ? 0 : newest.at, seq: entry.seq });
  }
  return Array.from(byRow.values());
};
type Form = { name: string; page: (entries: Entry[]) => Entry[] };
const FORMS: Form[] = [
  { name: "записи по отметкам", page: (entries) => entries },
  { name: "одна запись на строку, отметка самая новая", page: (entries) => squash(entries, false) },
  { name: "одна запись на строку, без отметок", page: (entries) => squash(entries, true) },
];

// счётчик записей на проводе: у формы есть не только верность, но и цена
function shaped(connection: Connection, form: Form, count: { got: number }): Connection {
  return {
    push: (batch) => connection.push(batch),
    async pull(cursor, limit) {
      const page = await connection.pull(cursor, limit);
      const changes = form.page(page.changes);
      count.got += changes.length;
      return { changes, cursor: page.cursor, hasMore: page.hasMore };
    },
  };
}

const show = (fields: Fields | undefined): string =>
  fields === undefined
    ? "строки нет"
    : Object.keys(fields).sort().filter((field) => field !== "id").map((field) => field + " " + fields[field]).join(", ");

// строку правили трижды: завёл телефон, вес подняла веб-версия, повторы — она же,
// но отметкой между первой правкой и второй
const HISTORY: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "W:1", rowId: "A-1", fields: { weightKg: 90 }, at: 5 },
  { opId: "W:2", rowId: "A-1", fields: { reps: 8 }, at: 3 },
];

async function main(): Promise<void> {
  const plain = createRowsServer();
  await plain.as("аня").push(HISTORY);
  const stored = plain.rowsOf("аня")[0];
  const page = await plain.as("аня").pull(0, 10);
  console.log("итог у сервера:", show(stored.fields), "· номер", stored.seq, "· записей на странице", page.changes.length);

  for (const form of FORMS) {
    const server = createRowsServer();
    const wire = server.as("аня");
    const count = { got: 0 };
    const tablet = createClient("T", shaped(wire, form, count), 0);
    await wire.push([HISTORY[0]]);
    await tablet.sync();
    // планшет без сети поправил вес у себя
    tablet.journal.change("A-1", { weightKg: 85 });
    await wire.push([HISTORY[1]]);
    await tablet.sync();
    await wire.push([HISTORY[2]]);
    await tablet.sync();
    const mine = show(tablet.store.get("A-1"));
    const theirs = show(server.rowsOf("аня")[0].fields);
    console.log(form.name + ": " + mine);
    console.log("  сошлось с сервером:", mine === theirs ? "да" : "нет", "· записей приехало", count.got);
  }
}

main();

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Mark = { at: number; opId: string };
type Marks = Record<string, Mark>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface Client {
  store: { get(id: string): Row | undefined };
  journal: { change(rowId: string, fields: Fields): void };
  sync(): Promise<Verdict[]>;
}

// слияние по полям и клиент части V — с подложки, без правок
declare function merge(row: Fields | undefined, op: Op, mark: Marks): Row;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// Сервер хранит не журнал операций, а итог: поля строки, отметки [at, opId]
// по полям и seq — номер последней правки строки из строки-счётчика
function createRowsServer() {
  const heads = new Map<string, number>();
  const rows = new Map<string, Stored>();
  const answered = new Map<string, Verdict>();
  const key = (userId: string, rowId: string) => userId + "|" + rowId;
  // проверяется строка после применения операции — правило части V
  function checkRow(row: Row): string | null {
    const missing = ["exercise", "weightKg", "reps"].filter((field) => !(field in row));
    if (missing.length > 0) return "нет полей: " + missing.join(", ");
    return Number(row.reps) > 100 ? "повторов больше сотни" : null;
  }
  // строка уходит записями по отметкам: поля с общей отметкой — одной записью
  // с её исходными at и opId, а номер у всех записей строки один — её seq
  function entriesOf(stored: Stored): Entry[] {
    const byMark = new Map<string, Entry>();
    for (const field of Object.keys(stored.fields).sort()) {
      const mark = stored.marks[field];
      const name = mark.at + "|" + mark.opId;
      const entry = byMark.get(name) ?? { opId: mark.opId, rowId: stored.rowId, fields: {}, at: mark.at, seq: stored.seq };
      entry.fields[field] = stored.fields[field];
      byMark.set(name, entry);
    }
    return Array.from(byMark.values()).sort((a, b) => a.at - b.at || (a.opId < b.opId ? -1 : 1));
  }
  const ofUser = (userId: string) => Array.from(rows.values()).filter((row) => row.userId === userId).sort((a, b) => a.seq - b.seq);
  function take(userId: string, op: Op) {
    const stored = rows.get(key(userId, op.rowId));
    const before = stored?.marks ?? {};
    const marks: Marks = { ...before };
    const row = merge(stored?.fields, op, marks);
    const moved = JSON.stringify(marks) !== JSON.stringify(before);
    // у существующей строки ни одна отметка не сдвинулась — проверять нечего
    const reason = stored && !moved ? null : checkRow(row);
    const verdict: Verdict = reason ? { opId: op.opId, status: "rejected", reason } : { opId: op.opId, status: "applied" };
    return { verdict, moved, row, marks };
  }
  return {
    // заглянуть в итог — только для примеров
    rowsOf: ofUser,
    // чистка по сроку: выбросить надгробия совсем
    sweep(userId: string): number {
      const gone = ofUser(userId).filter((row) => row.fields.deleted === true);
      gone.forEach((row) => rows.delete(key(userId, row.rowId)));
      return gone.length;
    },
    as(userId: string): Connection {
      return {
        async push(batch: Op[]) {
          const verdicts: Verdict[] = batch.slice(0, 1000).map((op): Verdict => {
            const known = answered.get(key(userId, op.opId));
            // память вердиктов: повтор принятой — duplicate, отвергнутой — тот же отказ
            if (known) return known.status === "applied" ? { opId: op.opId, status: "duplicate" } : { ...known };
            const got = take(userId, op);
            answered.set(key(userId, op.opId), got.verdict);
            if (got.verdict.status === "applied" && got.moved) {
              const seq = (heads.get(userId) ?? 0) + 1;
              heads.set(userId, seq);
              const { id, ...fields } = got.row;
              rows.set(key(userId, op.rowId), { userId, rowId: op.rowId, fields, marks: got.marks, seq });
            }
            return { ...got.verdict };
          });
          // строка целиком — после всей пачки: к этому времени она окончательная
          verdicts.forEach((verdict, i) => {
            if (verdict.status !== "rejected") return;
            const stored = rows.get(key(userId, batch[i].rowId));
            verdict.row = stored ? entriesOf(stored) : [];
          });
          return { verdicts };
        },
        async pull(cursor: number, limit: number) {
          // limit считается в строках, и сервер сам урезает его до 500
          const ahead = ofUser(userId).filter((row) => row.seq > cursor);
          const page = ahead.slice(0, Math.min(limit, 500));
          const last = page.length > 0 ? page[page.length - 1].seq : cursor;
          return { changes: page.flatMap(entriesOf), cursor: last, hasMore: ahead.length > page.length };
        },
      };
    },
  };
}

// три формы страницы: записи по отметкам и две «оптимизации» строки в одну запись
const squash = (entries: Entry[], bare: boolean): Entry[] => {
  const byRow = new Map<string, Entry>();
  for (const entry of entries) {
    const found = byRow.get(entry.rowId);
    const newest = found && found.at > entry.at ? found : entry;
    const fields = { ...(found?.fields ?? {}), ...entry.fields };
    byRow.set(entry.rowId, { opId: newest.opId, rowId: entry.rowId, fields, at: bare ? 0 : newest.at, seq: entry.seq });
  }
  return Array.from(byRow.values());
};
type Form = { name: string; page: (entries: Entry[]) => Entry[] };
const FORMS: Form[] = [
  { name: "записи по отметкам", page: (entries) => entries },
  { name: "одна запись на строку, отметка самая новая", page: (entries) => squash(entries, false) },
  { name: "одна запись на строку, без отметок", page: (entries) => squash(entries, true) },
];

// счётчик записей на проводе: у формы есть не только верность, но и цена
function shaped(connection: Connection, form: Form, count: { got: number }): Connection {
  return {
    push: (batch) => connection.push(batch),
    async pull(cursor, limit) {
      const page = await connection.pull(cursor, limit);
      const changes = form.page(page.changes);
      count.got += changes.length;
      return { changes, cursor: page.cursor, hasMore: page.hasMore };
    },
  };
}

const show = (fields: Fields | undefined): string =>
  fields === undefined
    ? "строки нет"
    : Object.keys(fields).sort().filter((field) => field !== "id").map((field) => field + " " + fields[field]).join(", ");

// строку правили трижды: завёл телефон, вес подняла веб-версия, повторы — она же,
// но отметкой между первой правкой и второй
const HISTORY: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "W:1", rowId: "A-1", fields: { weightKg: 90 }, at: 5 },
  { opId: "W:2", rowId: "A-1", fields: { reps: 8 }, at: 3 },
];

async function main(): Promise<void> {
  const plain = createRowsServer();
  await plain.as("аня").push(HISTORY);
  const stored = plain.rowsOf("аня")[0];
  const page = await plain.as("аня").pull(0, 10);
  console.log("итог у сервера:", show(stored.fields), "· номер", stored.seq, "· записей на странице", page.changes.length);

for (const form of FORMS) {
    const server = createRowsServer();
    const wire = server.as("аня");
    const count = { got: 0 };
    const tablet = createClient("T", shaped(wire, form, count), 0);
    await wire.push([HISTORY[0]]);
    await tablet.sync();
    // планшет без сети поправил вес у себя
    tablet.journal.change("A-1", { weightKg: 85 });
    await wire.push([HISTORY[1]]);
    await tablet.sync();
    await wire.push([HISTORY[2]]);
    await tablet.sync();
    const mine = show(tablet.store.get("A-1"));
    const theirs = show(server.rowsOf("аня")[0].fields);
    console.log(form.name + ": " + mine);
    console.log("  сошлось с сервером:", mine === theirs ? "да" : "нет", "· записей приехало", count.got);
  }
}

main();

страница примера

Сначала предположите, что выведет код

Записи по отметкам сошлись. Строка одной записью с самой новой отметкой — нет: повторы у планшета остались прежними. Причина видна в отметках: первая же такая страница проштамповала все поля планшета отметкой веса — самой новой в строке. После этого правка повторов, сделанная раньше веса, оказалась для планшета старее того, что у него записано, и слияние её отбросило. Сервер прав, планшет по своим отметкам тоже прав, расхождение молчит и повторным pull не лечится.

Третья форма — строка без отметок вовсе — ломается ещё раньше. В правиле слияния по полям поле, у которого отметки нет, применяется всегда — сравнивать не с чем, — но поле, у которого она есть, страницу без отметки побеждает: у планшета остался свой вес 85, у сервера — чужие 90. Новому телефону такая страница, кстати, ляжет верно: у него отметок ещё нет. Это и есть худший вид ошибки — та, что проявляется не у всех и не сразу.

Абзац части V, с которого начинается статья, при этом не опровергнут. Свернуть хвост операций с курсора действительно нельзя: для этого надо знать, что у клиента уже есть. Сервер главы сворачивает не хвост, а всю строку и отдаёт её со всеми отметками — и знать, что у клиента есть, ему не нужно: слияние по полям идемпотентно, лишняя запись с прежней отметкой ничего не меняет. Ровно поэтому одна и та же выдача годится и новому телефону, и отставшему, и тому, кто зашёл дважды подряд.

форма страницы	записей на строку	чем платит
записи по отметкам	по одной на отметку	лишние записи и эхо на странице; сходится у любого устройства и при любом курсоре
одна запись, отметка самая новая	одна	штампует все поля получателя чужой отметкой: правка, сделанная раньше, отбрасывается навсегда
одна запись, без отметок	одна	новому телефону ляжет верно, а у того, у кого свои отметки есть, отберёт его правку

Отметки полей — единственное, что делает страницу применимой дважды. Строка без отметок — это не строка, а мнение сервера о ней на момент отправки.

У страницы теперь две единицы измерения, и путать их дорого. Курсор — номер строки, а не записи. limit — тоже строки: записей на странице может оказаться до limit, умноженного на число полей, потому что строка с четырьмя разными отметками уедет четырьмя записями. Считать предел в записях выглядит честнее по трафику, но тогда страница рвёт строку пополам, и клиент получает ровно тот обрубок, из-за которого часть V и не сворачивала операции.

Отсюда два правила. Строка целиком всегда на одной странице. И limit сервер урезает сам — до 500 строк, кодом, а не отказом схемы: телефон, попросивший тысячу, получит пятьсот и hasMore. Отказ здесь был бы наказанием за то, что не запрещено, а старый бандл, для которого тысяча была нормой, перестал бы синхронизироваться совсем.

shлистинг · не запускается

-- страница выдачи: строки, которые менялись после курсора, по порядку номера
select row_id, fields, marks, seq
  from sync_rows
 where user_id = $1 and seq > $2
 order by seq
 limit least($3, 500) + 1;
-- лишняя строка в выборке и есть ответ на «ещё есть»: её не отдают,
-- а только смотрят, пришла ли она

-- страница выдачи: строки, которые менялись после курсора, по порядку номера
select row_id, fields, marks, seq
  from sync_rows
 where user_id = $1 and seq > $2
 order by seq
 limit least($3, 500) + 1;
-- лишняя строка в выборке и есть ответ на «ещё есть»: её не отдают,
-- а только смотрят, пришла ли она

В модели строки лежат в памяти, поэтому «ещё есть» она считает сравнением длин, а базе для того же нужна лишняя строка в выборке. Разница только в этом. Прогноз к запуску: у человека три строки, у первой четыре поля с четырьмя разными отметками — сколько будет страниц при limit 1, какие номера пройдёт курсор и сколько записей придёт на первой странице?

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}

// сервер-итог из прошлого раздела — целиком на подложке
declare function createRowsServer(): RowsServer;

const WEEK: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at: 2 },
  { opId: "A:3", rowId: "A-1", fields: { reps: 6 }, at: 3 },
  { opId: "A:4", rowId: "A-1", fields: { note: "легко" }, at: 4 },
  { opId: "A:5", rowId: "A-2", fields: { exercise: "тяга", weightKg: 100, reps: 3 }, at: 5 },
  { opId: "A:6", rowId: "A-3", fields: { exercise: "приседания", weightKg: 60, reps: 10 }, at: 6 },
];

async function main(): Promise<void> {
  const server = createRowsServer();
  const wire = server.as("аня");
  await wire.push(WEEK);
  const first = server.rowsOf("аня")[0];
  console.log("строк у человека", server.rowsOf("аня").length, "· у первой полей", Object.keys(first.fields).length, "и отметок", new Set(Object.keys(first.marks).map((field) => first.marks[field].opId)).size);

  // цикл клиента части V: крутить, пока сервер говорит «ещё есть»
  let cursor = 0;
  let hasMore = true;
  let number = 0;
  const cut: string[] = [];
  while (hasMore && number < 10) {
    number += 1;
    const page = await wire.pull(cursor, 1);
    const rowIds = Array.from(new Set(page.changes.map((entry) => entry.rowId)));
    // обрубок — строка, у которой на странице оказались не все поля итога
    for (const rowId of rowIds) {
      const stored = server.rowsOf("аня").find((row) => row.rowId === rowId);
      const came = new Set(page.changes.filter((entry) => entry.rowId === rowId).flatMap((entry) => Object.keys(entry.fields)));
      if (stored && Object.keys(stored.fields).some((field) => !came.has(field))) cut.push(rowId);
    }
    console.log("limit 1, страница " + number + ": строк " + rowIds.length + ", записей " + page.changes.length + ", курсор " + page.cursor + ", ещё есть: " + (page.hasMore ? "да" : "нет"));
    cursor = page.cursor;
    hasMore = page.hasMore;
  }
  console.log("строк, приехавших без части полей:", cut.length);

  // шестьсот строк и limit, о котором клиента никто не предупреждал
  const many = createRowsServer();
  const wide = many.as("боря");
  const batch: Op[] = [];
  for (let i = 1; i <= 600; i += 1) batch.push({ opId: "T:" + i, rowId: "B-" + i, fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: i });
  await wide.push(batch);
  const big = await wide.pull(0, 1000);
  console.log("строк 600, limit 1000: строк на странице", new Set(big.changes.map((entry) => entry.rowId)).size, "· курсор", big.cursor, "· ещё есть:", big.hasMore ? "да" : "нет");
}

main();

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}

// сервер-итог из прошлого раздела — целиком на подложке
declare function createRowsServer(): RowsServer;

const WEEK: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at: 2 },
  { opId: "A:3", rowId: "A-1", fields: { reps: 6 }, at: 3 },
  { opId: "A:4", rowId: "A-1", fields: { note: "легко" }, at: 4 },
  { opId: "A:5", rowId: "A-2", fields: { exercise: "тяга", weightKg: 100, reps: 3 }, at: 5 },
  { opId: "A:6", rowId: "A-3", fields: { exercise: "приседания", weightKg: 60, reps: 10 }, at: 6 },
];

async function main(): Promise<void> {
  const server = createRowsServer();
  const wire = server.as("аня");
  await wire.push(WEEK);
  const first = server.rowsOf("аня")[0];
  console.log("строк у человека", server.rowsOf("аня").length, "· у первой полей", Object.keys(first.fields).length, "и отметок", new Set(Object.keys(first.marks).map((field) => first.marks[field].opId)).size);

// цикл клиента части V: крутить, пока сервер говорит «ещё есть»
  let cursor = 0;
  let hasMore = true;
  let number = 0;
  const cut: string[] = [];
  while (hasMore && number < 10) {
    number += 1;
    const page = await wire.pull(cursor, 1);
    const rowIds = Array.from(new Set(page.changes.map((entry) => entry.rowId)));
    // обрубок — строка, у которой на странице оказались не все поля итога
    for (const rowId of rowIds) {
      const stored = server.rowsOf("аня").find((row) => row.rowId === rowId);
      const came = new Set(page.changes.filter((entry) => entry.rowId === rowId).flatMap((entry) => Object.keys(entry.fields)));
      if (stored && Object.keys(stored.fields).some((field) => !came.has(field))) cut.push(rowId);
    }
    console.log("limit 1, страница " + number + ": строк " + rowIds.length + ", записей " + page.changes.length + ", курсор " + page.cursor + ", ещё есть: " + (page.hasMore ? "да" : "нет"));
    cursor = page.cursor;
    hasMore = page.hasMore;
  }
  console.log("строк, приехавших без части полей:", cut.length);

// шестьсот строк и limit, о котором клиента никто не предупреждал
  const many = createRowsServer();
  const wide = many.as("боря");
  const batch: Op[] = [];
  for (let i = 1; i <= 600; i += 1) batch.push({ opId: "T:" + i, rowId: "B-" + i, fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: i });
  await wide.push(batch);
  const big = await wide.pull(0, 1000);
  console.log("строк 600, limit 1000: строк на странице", new Set(big.changes.map((entry) => entry.rowId)).size, "· курсор", big.cursor, "· ещё есть:", big.hasMore ? "да" : "нет");
}

main();

страница примера

Сначала предположите, что выведет код

Первая страница — одна строка и четыре записи: столько у неё отметок. Курсор идёт по номерам строк — 4, 5, 6, — и номер 4 у первой строки не потому, что она четвёртая, а потому, что её последняя правка была четвёртой по счёту у этого человека. Обрубков нет ни на одной странице, и проверено это не глазами: пример сверяет поля каждой пришедшей строки с полями итога. Шестьсот строк при limit 1000 превратились в пятьсот и «ещё есть».

Соблазн спрятать на выдаче то, что клиенту не нужно, живёт долго: свои же записи (эхо), строки моложе водяного знака, надгробия за горизонтом. Любое такое сокрытие обязано двигать курсор за спрятанным, иначе цикл while (hasMore) клиента части V крутится вечно — этот случай уже разобран запуском: пятьдесят первый pull с тем же нулевым курсором.

Поэтому сервер главы не прячет ничего, а эхо отсекает клиент — по префиксу opId, как он это и делал. Поля устройства в PullInput нет и не понадобится: если серверу когда-нибудь нужно будет имя устройства — для журнала или метрик, — он прочитает его из префикса opId пришедших операций.

Курсор измеряется в строках, а трафик — в записях. Как только одно начинают считать другим, на странице появляется обрубок или бесконечный цикл.

Третья полка проекта части V ждала от сервера трёх вещей: горизонта курсора, срока надгробий и снимка для нового телефона. Снимок закрывается первым и без нового механизма: первая синхронизация — обычный pull с нуля, а с нуля сервер отдаёт все строки человека, каждую записями по отметкам. Отставший на месяц — тот же pull со своего курсора: выбрасывать сервер ничего не будет (об этом следующий раздел), значит и сбрасывать нечего.

Теперь честная цена, потому что «снимок вместо истории» звучит как обещание трафика. Прогноз: неделя дневника из той же таблицы части V — три подхода, правки веса, правки повторов и одно удаление, девять операций. Сколько записей получит новый телефон? И сколько он получит, если вес одной строки правили двадцать раз?

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined; visible(): Row[] };
  journal: { newId(): string; change(rowId: string, fields: Fields): void; remove(rowId: string): void; outbox(): Op[] };
  sync(): Promise<Verdict[]>;
  readonly cursor: number;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// сколько записей приехало устройству и сколько из них — его собственные
function counted(connection: Connection, count: { got: number; own: number }, device: string): Connection {
  return {
    push: (batch) => connection.push(batch),
    async pull(cursor, limit) {
      const page = await connection.pull(cursor, limit);
      count.got += page.changes.length;
      count.own += page.changes.filter((entry) => entry.opId.indexOf(device + ":") === 0).length;
      return page;
    },
  };
}

const numbers = (server: RowsServer, userId: string): number =>
  server.rowsOf(userId).reduce((top, row) => Math.max(top, row.seq), 0);

const show = (fields: Fields | undefined): string =>
  fields === undefined
    ? "строки нет"
    : Object.keys(fields).sort().filter((field) => field !== "id").map((field) => field + " " + fields[field]).join(", ");

const sameRows = (server: RowsServer, userId: string, client: Client): boolean =>
  server.rowsOf(userId).every((row) => show(client.store.get(row.rowId)) === show(row.fields));

// неделя дневника из «Что не закрыть ни кодом, ни телефоном»: три подхода,
// правки веса, правки повторов и одно удаление
function week(phone: Client): void {
  const first = phone.journal.newId();
  phone.journal.change(first, { exercise: "жим", weightKg: 80, reps: 5 });
  phone.journal.change(first, { weightKg: 82.5 });
  phone.journal.change(first, { reps: 6 });
  const second = phone.journal.newId();
  phone.journal.change(second, { exercise: "тяга", weightKg: 100, reps: 3 });
  phone.journal.change(second, { weightKg: 105 });
  const third = phone.journal.newId();
  phone.journal.change(third, { exercise: "приседания", weightKg: 60, reps: 10 });
  phone.journal.change(third, { reps: 12 });
  phone.journal.change(third, { weightKg: 65 });
  phone.journal.remove(second);
}

async function main(): Promise<void> {
  const server = createRowsServer();
  const phone = createClient("A", server.as("аня"), 0);
  week(phone);
  await phone.sync();

  // новый телефон: тот же pull, курсор нулевой
  const boughtToday = { got: 0, own: 0 };
  const fresh = createClient("C", counted(server.as("аня"), boughtToday, "C"), 0);
  await fresh.sync();
  console.log("неделя: операций у телефона " + phone.journal.outbox().length + " · номеров выдал сервер " + numbers(server, "аня"));
  console.log("  новому телефону записей " + boughtToday.got + " · строк " + server.rowsOf("аня").length + ", видно " + fresh.store.visible().length);
  console.log("  сошлось со старым телефоном:", sameRows(server, "аня", fresh) && sameRows(server, "аня", phone) ? "да" : "нет");

  // планшет, отставший на одну правку: тот же pull со своего курсора
  const behind = { got: 0, own: 0 };
  const tablet = createClient("D", counted(server.as("аня"), behind, "D"), 0);
  await tablet.sync();
  const was = tablet.cursor;
  phone.journal.change("A-1", { weightKg: 85 });
  await phone.sync();
  behind.got = 0;
  await tablet.sync();
  console.log("планшет отстал на одну правку (курсор " + was + "): записей " + behind.got + " · сошлось: " + (sameRows(server, "аня", tablet) ? "да" : "нет"));

  // строка, вес которой правили двадцать раз
  const gym = createRowsServer();
  const heavy = createClient("A", gym.as("боря"), 0);
  const only = heavy.journal.newId();
  heavy.journal.change(only, { exercise: "жим", weightKg: 80, reps: 5 });
  for (let i = 1; i <= 20; i += 1) heavy.journal.change(only, { weightKg: 80 + i });
  await heavy.sync();
  const after = { got: 0, own: 0 };
  const second = createClient("C", counted(gym.as("боря"), after, "C"), 0);
  await second.sync();
  console.log("вес правили 20 раз: операций " + heavy.journal.outbox().length + " · номеров " + numbers(gym, "боря") + " · новому телефону записей " + after.got);

  // постоянная синхронизация: своя правка возвращается автору всей строкой
  const pair = createRowsServer();
  const echo = { got: 0, own: 0 };
  const mine = createClient("A", counted(pair.as("аня"), echo, "A"), 0);
  const theirs = createClient("B", pair.as("аня"), 0);
  const shared = mine.journal.newId();
  mine.journal.change(shared, { exercise: "жим", weightKg: 80, reps: 5 });
  await mine.sync();
  await theirs.sync();
  for (let i = 1; i <= 5; i += 1) {
    mine.journal.change(shared, { weightKg: 80 + i });
    await mine.sync();
    theirs.journal.change(shared, { reps: 5 + i });
    await theirs.sync();
    await mine.sync();
  }
  console.log("пять кругов на двух устройствах: телефону приехало записей " + echo.got + " · своих среди них " + echo.own);
}

main();

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined; visible(): Row[] };
  journal: { newId(): string; change(rowId: string, fields: Fields): void; remove(rowId: string): void; outbox(): Op[] };
  sync(): Promise<Verdict[]>;
  readonly cursor: number;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// сколько записей приехало устройству и сколько из них — его собственные
function counted(connection: Connection, count: { got: number; own: number }, device: string): Connection {
  return {
    push: (batch) => connection.push(batch),
    async pull(cursor, limit) {
      const page = await connection.pull(cursor, limit);
      count.got += page.changes.length;
      count.own += page.changes.filter((entry) => entry.opId.indexOf(device + ":") === 0).length;
      return page;
    },
  };
}

const numbers = (server: RowsServer, userId: string): number =>
  server.rowsOf(userId).reduce((top, row) => Math.max(top, row.seq), 0);

const sameRows = (server: RowsServer, userId: string, client: Client): boolean =>
  server.rowsOf(userId).every((row) => show(client.store.get(row.rowId)) === show(row.fields));

// неделя дневника из «Что не закрыть ни кодом, ни телефоном»: три подхода,
// правки веса, правки повторов и одно удаление
function week(phone: Client): void {
  const first = phone.journal.newId();
  phone.journal.change(first, { exercise: "жим", weightKg: 80, reps: 5 });
  phone.journal.change(first, { weightKg: 82.5 });
  phone.journal.change(first, { reps: 6 });
  const second = phone.journal.newId();
  phone.journal.change(second, { exercise: "тяга", weightKg: 100, reps: 3 });
  phone.journal.change(second, { weightKg: 105 });
  const third = phone.journal.newId();
  phone.journal.change(third, { exercise: "приседания", weightKg: 60, reps: 10 });
  phone.journal.change(third, { reps: 12 });
  phone.journal.change(third, { weightKg: 65 });
  phone.journal.remove(second);
}

async function main(): Promise<void> {
  const server = createRowsServer();
  const phone = createClient("A", server.as("аня"), 0);
  week(phone);
  await phone.sync();

// новый телефон: тот же pull, курсор нулевой
  const boughtToday = { got: 0, own: 0 };
  const fresh = createClient("C", counted(server.as("аня"), boughtToday, "C"), 0);
  await fresh.sync();
  console.log("неделя: операций у телефона " + phone.journal.outbox().length + " · номеров выдал сервер " + numbers(server, "аня"));
  console.log("  новому телефону записей " + boughtToday.got + " · строк " + server.rowsOf("аня").length + ", видно " + fresh.store.visible().length);
  console.log("  сошлось со старым телефоном:", sameRows(server, "аня", fresh) && sameRows(server, "аня", phone) ? "да" : "нет");

// планшет, отставший на одну правку: тот же pull со своего курсора
  const behind = { got: 0, own: 0 };
  const tablet = createClient("D", counted(server.as("аня"), behind, "D"), 0);
  await tablet.sync();
  const was = tablet.cursor;
  phone.journal.change("A-1", { weightKg: 85 });
  await phone.sync();
  behind.got = 0;
  await tablet.sync();
  console.log("планшет отстал на одну правку (курсор " + was + "): записей " + behind.got + " · сошлось: " + (sameRows(server, "аня", tablet) ? "да" : "нет"));

// строка, вес которой правили двадцать раз
  const gym = createRowsServer();
  const heavy = createClient("A", gym.as("боря"), 0);
  const only = heavy.journal.newId();
  heavy.journal.change(only, { exercise: "жим", weightKg: 80, reps: 5 });
  for (let i = 1; i <= 20; i += 1) heavy.journal.change(only, { weightKg: 80 + i });
  await heavy.sync();
  const after = { got: 0, own: 0 };
  const second = createClient("C", counted(gym.as("боря"), after, "C"), 0);
  await second.sync();
  console.log("вес правили 20 раз: операций " + heavy.journal.outbox().length + " · номеров " + numbers(gym, "боря") + " · новому телефону записей " + after.got);

// постоянная синхронизация: своя правка возвращается автору всей строкой
  const pair = createRowsServer();
  const echo = { got: 0, own: 0 };
  const mine = createClient("A", counted(pair.as("аня"), echo, "A"), 0);
  const theirs = createClient("B", pair.as("аня"), 0);
  const shared = mine.journal.newId();
  mine.journal.change(shared, { exercise: "жим", weightKg: 80, reps: 5 });
  await mine.sync();
  await theirs.sync();
  for (let i = 1; i <= 5; i += 1) {
    mine.journal.change(shared, { weightKg: 80 + i });
    await mine.sync();
    theirs.journal.change(shared, { reps: 5 + i });
    await theirs.sync();
    await mine.sync();
  }
  console.log("пять кругов на двух устройствах: телефону приехало записей " + echo.got + " · своих среди них " + echo.own);
}

main();

страница примера

Сначала предположите, что выведет код

Девять операций — девять записей. Ровно столько отдал бы и журнал: у каждой правки своё поле и своя отметка, сворачивать нечего. Выигрыш появляется там, где правок в одно поле много: двадцать одна операция по одной строке ушла двумя записями — по числу отметок, а не по числу правок. Так об итоге и надо думать: он сворачивает повторные правки одного поля, а не историю вообще.

Ещё две строки вывода — про цену. Планшет, отставший на одну правку веса, получил три записи, то есть всю строку: номер стоит на строке, и отдаётся она целиком. И эхо: за пять кругов на двух устройствах телефону приехало тридцать записей, двадцать одна из которых — его собственные, вернувшиеся вместе со строкой. На строке из трёх полей, два из которых правил сам телефон, это две записи из трёх; в сводном опыте на десяти устройствах и тысяче раундов эхо вышло около 23 % записей. Журнал отдал бы меньше.

Значит, выигрыш итога — не байты. Выигрыш в том, чего в сервере нет: отдельной процедуры снимка, сброса, горизонта и второго пути выдачи, который пришлось бы проверять наравне с первым. Список вопросов, который часть V передала части VI, глава закрывает без второго пути выдачи — а у одной выдачи один набор ошибок, а не два.

Снимок — это не новая процедура, а нулевой курсор. Всякий раз, когда для особого случая просят второй путь выдачи, стоит проверить, не тот ли это путь, что уже есть.

Удаление в этом протоколе — операция с полем deleted, и на сервере она ничем не выделена: та же строка, те же отметки, тот же номер. Отдельной процедуры удаления нет, DELETE по строке нет, «вернуть» — операция { deleted: false }. Правило «удаление побеждает» из части V тоже не меняется, и по той же причине: deleted для слияния — обычное поле, а правка другого поля его не снимает — она прилипает к надгробию и остаётся невидимой.

А вот срок надгробия часть V прямо оставила серверу: убирать можно не раньше, чем его увидели все устройства, то есть за горизонтом самого отставшего курсора. Ответ этой главы: не убирать вовсе. Прогноз к запуску: в первой половине сервер не чистит ничего, во второй — выбросил надгробие до того, как спавший планшет проснулся. Что покажет планшет в каждом случае и что случится, если человек допишет в увиденный подход ещё один?

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined; visible(): Row[] };
  journal: { newId(): string; change(rowId: string, fields: Fields): void; remove(rowId: string): void };
  sync(): Promise<Verdict[]>;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

const tombs = (server: RowsServer, userId: string): number =>
  server.rowsOf(userId).filter((row) => row.fields.deleted === true).length;

const diary = (server: RowsServer, userId: string): string =>
  "строк у сервера " + server.rowsOf(userId).length + ", надгробий " + tombs(server, userId);

// два подхода, второй удалён: удаление — операция с полем deleted
function twoSets(phone: Client): string {
  const first = phone.journal.newId();
  phone.journal.change(first, { exercise: "жим", weightKg: 80, reps: 5 });
  const second = phone.journal.newId();
  phone.journal.change(second, { exercise: "тяга", weightKg: 100, reps: 3 });
  return second;
}

async function main(): Promise<void> {
  const keep = createRowsServer();
  const phone = createClient("A", keep.as("аня"), 0);
  const tablet = createClient("B", keep.as("аня"), 0);
  const removed = twoSets(phone);
  await phone.sync();
  await tablet.sync();
  phone.journal.remove(removed);
  await phone.sync();
  await tablet.sync();
  console.log("надгробия не чистим: у планшета видно " + tablet.store.visible().length + " · " + diary(keep, "аня"));
  // «вернуть» — та же операция, только deleted: false
  phone.journal.change(removed, { deleted: false });
  await phone.sync();
  await tablet.sync();
  console.log("  после «вернуть»: у планшета видно " + tablet.store.visible().length + " · " + diary(keep, "аня"));

  const swept = createRowsServer();
  const owner = createClient("A", swept.as("аня"), 0);
  const asleep = createClient("B", swept.as("аня"), 0);
  const buried = twoSets(owner);
  await owner.sync();
  // планшет засыпает до удаления — и просыпается уже после чистки
  await asleep.sync();
  owner.journal.remove(buried);
  await owner.sync();
  const gone = swept.sweep("аня");
  await asleep.sync();
  console.log("чистка по сроку: выброшено надгробий " + gone + " · " + diary(swept, "аня"));
  console.log("  планшет проснулся: видно " + asleep.store.visible().length + " · удалённый подход на экране: " + (asleep.store.get(buried) === undefined ? "нет" : "да"));
  // и записывает в него подход целиком — как это делает загрузка журнала из файла
  asleep.journal.change(buried, { exercise: "тяга", weightKg: 105, reps: 4 });
  const verdicts = await asleep.sync();
  const newbie = createClient("C", swept.as("аня"), 0);
  await newbie.sync();
  console.log("  планшет дописал строку: " + verdicts.length + " отказов · " + diary(swept, "аня") + " · у нового устройства видно " + newbie.store.visible().length);
}

main();

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined; visible(): Row[] };
  journal: { newId(): string; change(rowId: string, fields: Fields): void; remove(rowId: string): void };
  sync(): Promise<Verdict[]>;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

const tombs = (server: RowsServer, userId: string): number =>
  server.rowsOf(userId).filter((row) => row.fields.deleted === true).length;

const diary = (server: RowsServer, userId: string): string =>
  "строк у сервера " + server.rowsOf(userId).length + ", надгробий " + tombs(server, userId);

// два подхода, второй удалён: удаление — операция с полем deleted
function twoSets(phone: Client): string {
  const first = phone.journal.newId();
  phone.journal.change(first, { exercise: "жим", weightKg: 80, reps: 5 });
  const second = phone.journal.newId();
  phone.journal.change(second, { exercise: "тяга", weightKg: 100, reps: 3 });
  return second;
}

async function main(): Promise<void> {
  const keep = createRowsServer();
  const phone = createClient("A", keep.as("аня"), 0);
  const tablet = createClient("B", keep.as("аня"), 0);
  const removed = twoSets(phone);
  await phone.sync();
  await tablet.sync();
  phone.journal.remove(removed);
  await phone.sync();
  await tablet.sync();
  console.log("надгробия не чистим: у планшета видно " + tablet.store.visible().length + " · " + diary(keep, "аня"));
  // «вернуть» — та же операция, только deleted: false
  phone.journal.change(removed, { deleted: false });
  await phone.sync();
  await tablet.sync();
  console.log("  после «вернуть»: у планшета видно " + tablet.store.visible().length + " · " + diary(keep, "аня"));

const swept = createRowsServer();
  const owner = createClient("A", swept.as("аня"), 0);
  const asleep = createClient("B", swept.as("аня"), 0);
  const buried = twoSets(owner);
  await owner.sync();
  // планшет засыпает до удаления — и просыпается уже после чистки
  await asleep.sync();
  owner.journal.remove(buried);
  await owner.sync();
  const gone = swept.sweep("аня");
  await asleep.sync();
  console.log("чистка по сроку: выброшено надгробий " + gone + " · " + diary(swept, "аня"));
  console.log("  планшет проснулся: видно " + asleep.store.visible().length + " · удалённый подход на экране: " + (asleep.store.get(buried) === undefined ? "нет" : "да"));
  // и записывает в него подход целиком — как это делает загрузка журнала из файла
  asleep.journal.change(buried, { exercise: "тяга", weightKg: 105, reps: 4 });
  const verdicts = await asleep.sync();
  const newbie = createClient("C", swept.as("аня"), 0);
  await newbie.sync();
  console.log("  планшет дописал строку: " + verdicts.length + " отказов · " + diary(swept, "аня") + " · у нового устройства видно " + newbie.store.visible().length);
}

main();

страница примера

Сначала предположите, что выведет код

Без чистки всё скучно и правильно: планшет получил надгробие, подход исчез с экрана, строк у сервера осталось две. «Вернуть» приехало такой же обычной записью, и видно снова два. С чисткой скучного нет: надгробие выбросили до того, как планшет проснулся, — и он показывает удалённый подход как живой. Стоит человеку дописать в него подход целиком, и удалённое возвращается ко всем: сервер видит вставку строки, которой у него нет, и принимает её. Это тот же сюжет, которым кончалась статья про надгробия, только данные испортил не забывчивый клиент, а аккуратный сервер.

Чистку по горизонту живых курсоров сервер главы не строит, и это не лень. Ей нужны сразу четыре вещи, которых в контракте части V нет: личность устройства на pull (там только cursor и limit); календарная граница живости вместо самого горизонта — часть V просила ответ про устройства («увидели все»), а не про срок; сброс, который клиент части V не прочитает, потому что читает только changes, cursor и hasMore; и запись курсора на pull, после которой выдача перестаёт быть чтением. Каждая — правка контракта и клиента ради килобайтов.

Килобайты, кстати, посчитаны: надгробия года дневника — около 145 КиБ, удалённые строки — 5 % кортежей за год и 4 % за пять лет. Цена решения в другом, и назвать её надо прямо: содержимое удалённых подходов остаётся на сервере навсегда. «Удалить дневник везде» ставит надгробия на все строки и данных не стирает; стереть их — отдельная операция над всеми строками человека, и к синхронизации она не относится.

Путь понятен, и он не собирался и не проверялся — поэтому в главе его нет, а не потому, что он невозможен. Устройство берётся не из тела запроса, а из сессии входа. Входной курсор каждого устройства пишется в отдельную таблицу через greatest(), чтобы отставший запрос не откатил горизонт назад. Граница живости — срок refresh-токена: календарь, но обоснованный. Сброс — поле в PullOutput и фолд на клиенте, который умеет забыть всё и пойти с нуля, обойдя фильтр эха. Четыре правки в четырёх местах ради 145 КиБ в год.

Решение «не чистить» дороже места и дешевле механизма. Оно обязано быть названным: «мы не чистим никогда» — это ответ, а «мы пока не чистим» — долг, о котором забудут.

Остался отказ. Клиент части V на rejected пересобирает строку свёрткой своего журнала, и это работает, пока строку правил только он. Чужие поля в его журнал не попадали — их применяли мимо журнала, прямо в хранилище. Значит, точную строку после отказа может дать только сервер.

Дать её выдачей не получится: курсор клиента уже за этой строкой, а второго входа в pull мы не заводим. Поэтому строка приезжает в самом вердикте: Verdict.row — записи строки по отметкам, прочитанные после разбора всей пачки, когда строка уже окончательная. Пустой массив значит «строки у сервера нет»: вставку отвергли — или имя строки принадлежит другому человеку, и под ключом-парой её для отправителя не существует. Повтор той же пачки получит тот же отказ со свежей строкой, а поле необязательное: клиент, который про него не знает, ведёт себя как раньше.

Прогноз к запуску: в обеих сценах телефон правит строку, которую завёл планшет, и сервер отказывает — «повторов больше сотни». В первой сцене у телефона по этой строке одна операция, во второй — две, и первую сервер принял. Что останется на экране у клиента части V и у клиента с правкой?

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined };
  journal: { change(rowId: string, fields: Fields): void };
  sync(): Promise<Verdict[]>;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// сервер тот же, но клиент части V про поле row не знает: выбросим его из вердикта
const withoutRow = (connection: Connection): Connection => ({
  async push(batch) {
    const answer = await connection.push(batch);
    return { verdicts: answer.verdicts.map((verdict) => ({ opId: verdict.opId, status: verdict.status, reason: verdict.reason })) };
  },
  pull: (cursor, limit) => connection.pull(cursor, limit),
});

const show = (fields: Fields | undefined): string =>
  fields === undefined
    ? "строки нет"
    : Object.keys(fields).sort().filter((field) => field !== "id").map((field) => field + " " + fields[field]).join(", ");

// alone: у телефона по этой строке одна операция, и её отвергли
async function scene(alone: boolean, patched: boolean) {
  const server = createRowsServer();
  const wire = server.as("аня");
  // строку завёл планшет, телефон получил её с курсора
  await wire.push([{ opId: "B:1", rowId: "B-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 }]);
  const phone = createClient("A", patched ? wire : withoutRow(wire), 0);
  await phone.sync();
  if (!alone) {
    // телефон поднял вес, а планшет в это же время поднял его выше
    phone.journal.change("B-1", { weightKg: 85 });
    await wire.push([{ opId: "B:2", rowId: "B-1", fields: { weightKg: 95 }, at: 4 }]);
  }
  phone.journal.change("B-1", { reps: 800 });
  const rejected = await phone.sync();
  return {
    mine: show(phone.store.get("B-1")),
    theirs: show(server.rowsOf("аня")[0].fields),
    reason: rejected[0].reason ?? "",
    entries: (rejected[0].row ?? []).length,
  };
}

async function main(): Promise<void> {
  for (const alone of [true, false]) {
    const five = await scene(alone, false);
    const fixed = await scene(alone, true);
    console.log(alone ? "сцена 1 — отвергли единственную правку чужой строки:" : "сцена 2 — первую правку сервер принял, вторую отверг:");
    console.log("  у сервера:        " + fixed.theirs + " · отказ «" + fixed.reason + "» · записей строки в отказе " + fixed.entries);
    console.log("  клиент части V:   " + five.mine + " · сошлось: " + (five.mine === five.theirs ? "да" : "нет"));
    console.log("  клиент с правкой: " + fixed.mine + " · сошлось: " + (fixed.mine === fixed.theirs ? "да" : "нет"));
  }
}

main();

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Marks = Record<string, { at: number; opId: string }>;
type Row = Fields & { id: string };
type Entry = Op & { seq: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string; row?: Entry[] };
type Page = { changes: Entry[]; cursor: number; hasMore: boolean };
type Stored = { userId: string; rowId: string; fields: Fields; marks: Marks; seq: number };
interface Connection {
  push(batch: Op[]): Promise<{ verdicts: Verdict[] }>;
  pull(cursor: number, limit: number): Promise<Page>;
}
interface RowsServer {
  as(userId: string): Connection;
  rowsOf(userId: string): Stored[];
  sweep(userId: string): number;
}
interface Client {
  store: { get(id: string): Row | undefined };
  journal: { change(rowId: string, fields: Fields): void };
  sync(): Promise<Verdict[]>;
}

declare function createRowsServer(): RowsServer;
declare function createClient(device: string, server: Connection, offset?: number): Client;

// сервер тот же, но клиент части V про поле row не знает: выбросим его из вердикта
const withoutRow = (connection: Connection): Connection => ({
  async push(batch) {
    const answer = await connection.push(batch);
    return { verdicts: answer.verdicts.map((verdict) => ({ opId: verdict.opId, status: verdict.status, reason: verdict.reason })) };
  },
  pull: (cursor, limit) => connection.pull(cursor, limit),
});

// alone: у телефона по этой строке одна операция, и её отвергли
async function scene(alone: boolean, patched: boolean) {
  const server = createRowsServer();
  const wire = server.as("аня");
  // строку завёл планшет, телефон получил её с курсора
  await wire.push([{ opId: "B:1", rowId: "B-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 }]);
  const phone = createClient("A", patched ? wire : withoutRow(wire), 0);
  await phone.sync();
  if (!alone) {
    // телефон поднял вес, а планшет в это же время поднял его выше
    phone.journal.change("B-1", { weightKg: 85 });
    await wire.push([{ opId: "B:2", rowId: "B-1", fields: { weightKg: 95 }, at: 4 }]);
  }
  phone.journal.change("B-1", { reps: 800 });
  const rejected = await phone.sync();
  return {
    mine: show(phone.store.get("B-1")),
    theirs: show(server.rowsOf("аня")[0].fields),
    reason: rejected[0].reason ?? "",
    entries: (rejected[0].row ?? []).length,
  };
}

async function main(): Promise<void> {
  for (const alone of [true, false]) {
    const five = await scene(alone, false);
    const fixed = await scene(alone, true);
    console.log(alone ? "сцена 1 — отвергли единственную правку чужой строки:" : "сцена 2 — первую правку сервер принял, вторую отверг:");
    console.log("  у сервера:        " + fixed.theirs + " · отказ «" + fixed.reason + "» · записей строки в отказе " + fixed.entries);
    console.log("  клиент части V:   " + five.mine + " · сошлось: " + (five.mine === five.theirs ? "да" : "нет"));
    console.log("  клиент с правкой: " + fixed.mine + " · сошлось: " + (fixed.mine === fixed.theirs ? "да" : "нет"));
  }
}

main();

страница примера

Сначала предположите, что выведет код

Три поломки в двух строках вывода. Первая: отвергли единственную операцию строки — значит отвергли и первую операцию строки, а на этот случай у клиента части V есть store.remove. Строка исчезла с экрана, хотя у сервера она есть, и вернуть её нечем: курсор за ней, а отметки полей на телефоне остались — перевыданная запись с той же отметкой будет пропущена. Вторая: во второй сцене выброшена не первая операция, и клиент собирает строку свёрткой того, что осталось, то есть из одной своей правки веса. На экране обрубок в одно поле. Третья спрятана в отметках: повторы не вернулись и после pull, потому что отметка отвергнутой правки новее пришедшей записи, а вес вернулся только потому, что планшет поднял его позже.

Клиент с правкой сошёлся с сервером в обеих сценах. Порядок у него такой: забыть строку вместе с отметками, применить записи из отказа, а поверх — свои операции этой строки, которые не отвергнуты. Забыть отметки обязательно: без этого перевыданная строка со своими исходными отметками проиграет тем, что уже лежат на телефоне, и не применится вовсе.

Правка клиента части V за всю главу одна, и вот она целиком. Ветка без row — дословно прежний reject(), поэтому примеры части V на её миниатюре печатают то же, что печатали: там в отказе строки нет, и путь выполнения тот же.

jsлистинг · не запускается

// createStore: строка уходит вместе с отметками полей
      forget: function (id) {
        rows.delete(id);
        mergeInto.forget(id);
        version += 1;
        listeners.forEach(function (listener) { listener(); });
      },

// createMerge: у возвращаемой функции появляется forget
  function createMerge() {
    var all = new Map();
    var fn = function (row, op) {
      var mark = all.get(op.rowId) || {};
      var next = merge(row, op, mark);
      all.set(op.rowId, mark);
      return next;
    };
    fn.forget = function (id) { all.delete(id); };
    return fn;
  }

// createClient: sync() зовёт reject(v) вместо reject(v.opId)
    function reject(verdict) {
      var bad = journal.outbox().find(function (op) { return op.opId === verdict.opId; });
      if (!bad) return;
      dropped.add(verdict.opId);
      var rowOps = journal.outbox().filter(function (op) { return op.rowId === bad.rowId; });
      if (verdict.row === undefined) {
        // сервер без строки в отказе (миниатюра части V) — прежняя пересборка
        if (rowOps[0].opId === verdict.opId) rowOps.forEach(function (op) { dropped.add(op.opId); });
        var rest = rowOps.filter(function (op) { return !dropped.has(op.opId); });
        if (rest.length === 0) store.remove(bad.rowId);
        else store.write(fold(rest).get(bad.rowId));
        return;
      }
      store.forget(bad.rowId);
      // у сервера строки нет — вставку отвергли, правки класть не на что
      if (verdict.row.length === 0) { rowOps.forEach(function (op) { dropped.add(op.opId); }); return; }
      verdict.row.forEach(function (entry) { clock.see(entry.at); store.apply(entry); });
      rowOps.forEach(function (op) { if (!dropped.has(op.opId)) store.apply(op); });
    }

// createStore: строка уходит вместе с отметками полей
      forget: function (id) {
        rows.delete(id);
        mergeInto.forget(id);
        version += 1;
        listeners.forEach(function (listener) { listener(); });
      },

// createMerge: у возвращаемой функции появляется forget
  function createMerge() {
    var all = new Map();
    var fn = function (row, op) {
      var mark = all.get(op.rowId) || {};
      var next = merge(row, op, mark);
      all.set(op.rowId, mark);
      return next;
    };
    fn.forget = function (id) { all.delete(id); };
    return fn;
  }

// createClient: sync() зовёт reject(v) вместо reject(v.opId)
    function reject(verdict) {
      var bad = journal.outbox().find(function (op) { return op.opId === verdict.opId; });
      if (!bad) return;
      dropped.add(verdict.opId);
      var rowOps = journal.outbox().filter(function (op) { return op.rowId === bad.rowId; });
      if (verdict.row === undefined) {
        // сервер без строки в отказе (миниатюра части V) — прежняя пересборка
        if (rowOps[0].opId === verdict.opId) rowOps.forEach(function (op) { dropped.add(op.opId); });
        var rest = rowOps.filter(function (op) { return !dropped.has(op.opId); });
        if (rest.length === 0) store.remove(bad.rowId);
        else store.write(fold(rest).get(bad.rowId));
        return;
      }
      store.forget(bad.rowId);
      // у сервера строки нет — вставку отвергли, правки класть не на что
      if (verdict.row.length === 0) { rowOps.forEach(function (op) { dropped.add(op.opId); }); return; }
      verdict.row.forEach(function (entry) { clock.see(entry.at); store.apply(entry); });
      rowOps.forEach(function (op) { if (!dropped.has(op.opId)) store.apply(op); });
    }

Почему не проще. «Переиздать строку свежей отметкой» с сервера соблазнительно и неверно: свежая отметка перебьёт чужую правку, которая на самом деле новее, и потеря будет молчаливой. «Прислать в PullInput список нужных строк» — это второй путь выдачи со своим набором ошибок, и клиенту пришлось бы хранить этот список на диске атомарно с курсором. Строка в отказе приезжает в том же ответе, что вердикт, повторяется вместе с повтором пачки — и нового состояния на диске у клиента не появляется.

И последнее про сам отказ: он остаётся обычным ответом, а не ошибкой запроса. Код ответа тут про запрос целиком — нет токена, тело не разобралось, — а вердикт по операции едет внутри успешного ответа. Клиенту это важно: 401 ставит паузу, а любая другая неудача — отсрочку, и отказ по операции ни того, ни другого не вызывает.

Сервер, который отказывает, обязан приложить к отказу то, чем его лечить. Отказ без состояния — приглашение клиенту угадать состояние, а угадывает он по своему журналу, в котором чужого нет.

Сервер главы хранит итог, а не журнал: строка, отметки [at, opId] по её полям и seq — номер последней правки этой строки. Номер получает только операция, сдвинувшая отметку, а выдача отдаёт строки с номером больше курсора, по порядку номера.
Строка уходит записями по отметкам: поля с общей отметкой — одной записью с её исходными at и opId, и у всех записей строки её номер. Контракт части V не меняется, клиент применяет записи тем же слиянием по полям и итога от истории не отличает.
Свернуть строку в одну запись нельзя. С самой новой отметкой она штампует ею все поля получателя, и правка, сделанная раньше, отбрасывается навсегда; без отметок — проигрывает собственным отметкам получателя. Сходится только форма по отметкам, и это показывает запуск.
Снимок для нового телефона и отставший на любой срок — это один и тот же pull с курсора. Выигрыш не в трафике (неделя дневника — те же девять записей, а эхо возвращает автору его же правки), а в том, что второго пути выдачи, сброса и горизонта в сервере нет.
Надгробия не чистятся никогда. Чистка по сроку воскрешает удалённое у планшета, который спал, а чистка по горизонту требует личности устройства на pull, календарной границы живости, сброса и записи курсора на чтение. Цена решения названа: содержимое удалённых строк остаётся на сервере, и «удалить везде» данных не стирает.
Отказ несёт строку целиком: Verdict.row — записи по отметкам после разбора всей пачки, пустой массив у строки, которой у сервера нет. Без неё клиент части V убирает чужую строку с экрана или оставляет обрубок в одно поле — это единственная правка клиента за всю главу.

1/4Сервер хранит итог: строку, отметки по её полям и номер последней правки. Правка приехала, но проиграла по отметке всем полям строки. Что она получит?

2/4Почему страница отдаёт строку записями по отметкам, а не одной записью с самой новой отметкой строки?

3/4Телефон попросил limit 1000, а у человека 600 строк. Что вернёт сервер?

4/4Клиент части V получил rejected на единственную свою правку строки, которую завёл его же планшет. Строку сервер не присылает. Что будет с ней на этом телефоне?

Предел, посчитанный в записях

Трафик посчитали и решили, что limit в строках непредсказуем: строка с десятью отметками — это десять записей. Выдачу переписали так, чтобы страница набиралась до limit записей.

tsлистинг · не запускается

// было: limit считается в строках
const page = ahead.slice(0, Math.min(limit, 500));

// стало: набирать строки, пока записей не наберётся limit
const page = [];
let entries = 0;
for (const row of ahead) {
  const next = entriesOf(row);
  if (entries + next.length > limit && page.length > 0) break;
  page.push(row);
  entries += next.length;
}

// было: limit считается в строках
const page = ahead.slice(0, Math.min(limit, 500));

// стало: набирать строки, пока записей не наберётся limit
const page = [];
let entries = 0;
for (const row of ahead) {
  const next = entriesOf(row);
  if (entries + next.length > limit && page.length > 0) break;
  page.push(row);
  entries += next.length;
}

Строка целиком на странице при этом сохранена: цикл не обрывает её, а прекращает набор. Что всё-таки сломается и почему одной этой заботы недостаточно?

Страница действительно не рвётся, и потому правка выглядит безобидной. Ломается смысл предела. Строку, у которой записей больше limit, условие page.length > 0 пропускает целиком — иначе страница вышла бы пустой и цикл клиента встал бы на месте. Значит, при limit 1 клиент всё равно получит четыре записи: предел в записях не соблюдён. А предел в строках, который был, потерян: одна строка с десятью отметками съедает страницу целиком, и у догоняющего устройства число заходов вырастает во столько же раз.

Второе — цена в базе. Предел в записях одним limit в SQL не выражается: сколько записей даст строка, видно только после чтения её отметок, поэтому выборку придётся брать с запасом и досчитывать в приложении. Правильный ответ на вопрос о трафике — не менять единицу измерения курсора, а уменьшить limit в строках: его присылает сам клиент, а сервер только урезает сверху.

Отказ без строки, чтобы сэкономить байты

На код-ревью заметили, что Verdict.row приезжает в каждом отказе, и отказов у пачки может быть много. Предложение: строку не прикладывать, потому что клиент всё равно заберёт её следующим pull.

tsлистинг · не запускается

// «строку он и так получит следующим pull, а байты сэкономим»
verdicts.forEach((verdict) => {
  if (verdict.status !== 'rejected') return;
  verdict.reason = verdict.reason ?? 'отказ';
});

// «строку он и так получит следующим pull, а байты сэкономим»
verdicts.forEach((verdict) => {
  if (verdict.status !== 'rejected') return;
  verdict.reason = verdict.reason ?? 'отказ';
});

Разберите предложение: что именно получит клиент следующим pull и что покажет человеку?

Следующим pull клиент не получит ничего. Выдача отдаёт строки с номером больше курсора, а отказ строку не менял — её номер остался прежним и меньше курсора. Строка приедет только если её потом кто-то поправит.

Но и тогда она приедет не целиком в смысле применения: записи придут со своими исходными отметками, а на телефоне лежит отметка отвергнутой правки — она новее. Слияние по полям пропустит такую запись, и обрубок останется на экране. Ровно это и печатает прогон раздела: у клиента без строки в отказе на экране одно поле, а вернулось только то, что чужое устройство поправило позже отвергнутой правки.

Особая ветка для нулевого курсора

Раз новому телефону отметки всё равно не с чем сравнивать, для нулевого курсора сделали отдельную ветку: строка отдаётся одной записью, отметки не выписываются.

tsлистинг · не запускается

// «новому телефону отметки не нужны: у него всё равно ничего нет»
async pull(cursor, limit) {
  const page = страницаСтрок(cursor, limit);
  if (cursor === 0) return { ...page, changes: однойЗаписьюНаСтроку(page.changes) };
  return page;
}

// «новому телефону отметки не нужны: у него всё равно ничего нет»
async pull(cursor, limit) {
  const page = страницаСтрок(cursor, limit);
  if (cursor === 0) return { ...page, changes: однойЗаписьюНаСтроку(page.changes) };
  return page;
}

Назовите случай, в котором эта ветка испортит данные, и скажите, чем такая оптимизация плоха сама по себе.

Нулевой курсор не доказывает, что у телефона нет отметок. Курсор и отметки лежат в разных местах и теряются по-разному: курсор сохраняется после применения страницы, поэтому убитый процесс оставляет применённые строки с прежним курсором; кнопка «пересинхронизировать» сбрасывает курсор, а не дневник; восстановление приложения из резервной копии может вернуть базу и не вернуть курсор. В любом из этих случаев телефон придёт с нулём, имея свои отметки, — и страница без отметок отберёт у него его же правку, а страница с одной самой новой отметкой проштампует ею все поля.

Плоха она и сама по себе: это второй путь выдачи. У него свои ошибки, и проверять его надо наравне с первым, а срабатывает он редко — значит, ошибка в нём будет найдена не тестом, а человеком с новым телефоном.

Выдача с курсора: надгробия, их срок и снимок для нового телефона

Видеоразбор темы за 5–7 минут

Итог вместо истории: номер переезжает на строкуСтрока с отметками полей вместо журнала операций, а страница собирается из отметок

Страница: limit считается в строкахСтрока целиком всегда на одной странице, а предел в 500 стоит в коде, а не в схеме

Новый телефон и отставший — это один и тот же pullСнимок отдаёт обычная выдача с нулевого курсора, и выигрыш здесь не в объёме

Надгробия не чистятся, и это решениеСрок надгробия — бессрочно, а цена тут не в килобайтах, а в удалённом, которое видно

Строка целиком приходит в самом отказеПоле row у вердикта и единственная правка клиента части V за всю главу

Итогошпаргалка по теме

Проверьте себявопросы по теме

Задачизадачи с решениями

Предел, посчитанный в записях

Отказ без строки, чтобы сэкономить байты

Особая ветка для нулевого курсора