Дневник принадлежит вам: выгрузка и загрузка обратно

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 Store {
  write(row: Row): void;
  sets(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  adopt(op: Op): boolean;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

// неделя дневника: два подхода и правка веса
const phone = createClient("A", createServer());
const bench = phone.journal.newId();
phone.journal.change(bench, { exercise: "жим", weightKg: 80, reps: 5 });
const squat = phone.journal.newId();
phone.journal.change(squat, { exercise: "присед", weightKg: 100, reps: 5 });
phone.journal.change(bench, { weightKg: 82.5 });

// две выгрузки одного дневника: снимок ленты и журнал целиком
const snapshot = JSON.stringify(phone.store.sets());
const journal = JSON.stringify(phone.journal.outbox());

// сервис закрылся: дневник переносят на новый телефон и к новому серверу
const fromSnapshot = createClient("B", createServer());
(JSON.parse(snapshot) as Row[]).forEach((row) => fromSnapshot.store.write(row));
console.log("из снимка: подходов", fromSnapshot.store.sets().length, "| ждут отправки", fromSnapshot.queue().length);

const fromJournal = createClient("C", createServer());
(JSON.parse(journal) as Op[]).forEach((op) => fromJournal.journal.adopt(op));
console.log("из журнала: подходов", fromJournal.store.sets().length, "| ждут отправки", fromJournal.queue().length);
console.log("вес жима:", fromSnapshot.store.sets()[0].weightKg, "и", fromJournal.store.sets()[0].weightKg);

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 Store {
  sets(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  adopt(op: Op): boolean;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

type Backup = { app: string; schema: number; device: string; ops: Op[] };

const server = createServer();
const phone = createClient("A", server);
const bench = phone.journal.newId();
phone.journal.change(bench, { exercise: "жим", weightKg: 80, reps: 5 });
phone.journal.change(bench, { weightKg: 82.5 });
const squat = phone.journal.newId();
phone.journal.change(squat, { exercise: "присед", weightKg: 100, reps: 5 });
phone.sync();

// выгрузка: журнал как есть, вместе с номером схемы и именем устройства
const file = JSON.stringify({ app: "podhod", schema: 2, device: "A", ops: phone.journal.outbox() });
const backup = JSON.parse(file) as Backup;

// загрузка: операция узнаётся по своему имени, а не по содержимому
function load(client: Client, box: Backup): string {
  let added = 0;
  let known = 0;
  box.ops.forEach((op) => (client.journal.adopt(op) ? (added += 1) : (known += 1)));
  return "добавлено: " + added + ", уже было: " + known;
}

console.log("операций в файле:", backup.ops.length, "| символов:", file.length);
console.log("первая загрузка:", load(phone, backup));
console.log("вторая загрузка:", load(phone, backup));
console.log("на экране подходов:", phone.store.sets().length, "| ждут отправки:", phone.queue().length);

// журнал устройства: метод, который появился ради загрузки из файла
adopt(op: Op): boolean {
  // имя операции родилось на телефоне и уехало в файл вместе с ней —
  // поэтому «уже было» узнаётся без всякого сравнения полей
  if (known.has(op.opId)) return false;
  known.add(op.opId);
  log.push(op);
  // отметка времени у операции своя, старая: гибридные часы подтягиваются
  // до неё, но не переписывают её сегодняшним временем
  clock.see(op.at);
  store.apply(op);
  return true;
},

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 Store {
  sets(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  adopt(op: Op): boolean;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  push(batch: Op[]): { verdicts: Verdict[] };
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const bench = phone.journal.newId();
phone.journal.change(bench, { exercise: "жим", weightKg: 80, reps: 5 });
phone.journal.change(bench, { weightKg: 82.5 });
const squat = phone.journal.newId();
phone.journal.change(squat, { exercise: "присед", weightKg: 100, reps: 5 });
phone.sync();
console.log("до переноса у сервера записей:", server.journal.length, "| строк:", server.rows.size);

// один и тот же файл открыли на двух новых устройствах
const file = JSON.stringify(phone.journal.outbox());
const second = createClient("B", server);
const third = createClient("C", server);
[second, third].forEach((client) => {
  (JSON.parse(file) as Op[]).forEach((op) => client.journal.adopt(op));
});
console.log("после загрузки ждут отправки:", second.queue().length, "и", third.queue().length);

const verdicts = server.push(second.queue()).verdicts;
console.log("что ответил сервер:", verdicts.map((v) => v.status).join(", "));
second.sync();
third.sync();
console.log("после отправки у сервера записей:", server.journal.length, "| строк:", server.rows.size);
console.log("подходов: на втором", second.store.sets().length, "| на третьем", third.store.sets().length);

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 Store {
  sets(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  outbox(): Op[];
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createServer(): unknown;
declare function createClient(device: string, server: unknown): Client;

const phone = createClient("A", createServer());
phone.journal.change(phone.journal.newId(), { exercise: "жим, узкий хват", weightKg: 82.5, reps: 5 });
phone.journal.change(phone.journal.newId(), { exercise: "присед", weightKg: 100, reps: 5 });

// ячейка берётся в кавычки, если внутри есть запятая, кавычка или перевод строки,
// а сами кавычки удваиваются: так CSV описан в RFC 4180 и так его ждут таблицы
const cell = (value: string | number): string => {
  const text = String(value);
  return /[",\n]/.test(text) ? '"' + text.replace(/"/g, '""') + '"' : text;
};
const toCsv = (rows: Row[]): string =>
  ["упражнение,вес_кг,повторы"]
    .concat(rows.map((row) => [cell(String(row.exercise)), cell(Number(row.weightKg)), cell(Number(row.reps))].join(",")))
    .join("\n");

const csv = toCsv(phone.store.sets());
csv.split("\n").forEach((line) => console.log("csv:", line));

// а читают такой файл обычно так: разрезать строку по запятой
const rows = csv.split("\n").slice(1).map((line) => {
  const cells = line.split(",");
  return { exercise: cells[0], weightKg: Number(cells[1]), reps: Number(cells[2]) };
});
console.log("наивный разбор:", rows[0].exercise, "|", rows[0].weightKg, "|", rows[0].reps);

// и загрузили обратно в тот же дневник
rows.forEach((row) => phone.journal.change(phone.journal.newId(), row));
console.log("подходов на экране:", phone.store.sets().length);

npm view expo-file-system@sdk-57 version
npm view expo-sharing@sdk-57 version

// shared/podhod/backup.ts — выгрузка дневника в файл и меню «Поделиться»
import { File, Paths } from "expo-file-system"; // 57.0.7
import * as Sharing from "expo-sharing"; // 57.0.19
import type { Backup, Op } from "./backup.types";

export async function exportJournal(device: string, ops: Op[]): Promise<void> {
  const backup: Backup = { app: "podhod", schema: 2, device, ops };
  // кеш, а не документы: файл нужен ровно до конца меню «Поделиться»,
  // а очистить кеш система вправе и без нашего ведома
  const file = new File(Paths.cache, "podhod-" + new Date().toISOString().slice(0, 10) + ".json");
  file.create({ overwrite: true });
  file.write(JSON.stringify(backup));

  // на устройстве без меню «Поделиться» вызов бросил бы ошибку
  if (!(await Sharing.isAvailableAsync())) return;
  await Sharing.shareAsync(file.uri, {
    mimeType: "application/json", // Android
    UTI: "public.json", // iOS
    dialogTitle: "Дневник «Подход»",
  });
}

// shared/podhod/backup.ts — загрузка: тот же adopt, что в примерах выше
import { File } from "expo-file-system";
import type { Backup, Journal } from "./backup.types";

export async function importJournal(journal: Journal): Promise<{ added: number; known: number }> {
  const picked = await File.pickFileAsync({ mimeTypes: ["application/json"] });
  // canceled: true отдаёт result === null — до файла компилятор не пустит
  if (picked.canceled) return { added: 0, known: 0 };

  const backup = JSON.parse(await picked.result.text()) as Backup;
  if (backup.app !== "podhod") throw new Error("это не выгрузка «Подхода»");
  // файл старше приложения — обычное дело: ступеньку ему поднимет та же
  // лестница, что и базе на устройстве
  const ops = liftOps(backup.ops, backup.schema);

  let added = 0;
  ops.forEach((op) => {
    if (journal.adopt(op)) added += 1;
  });
  return { added, known: ops.length - added };
}