expo-sqlite: настоящая база в телефоне

// expo-sqlite 57.0.3, src/ExpoSQLite.ts — файл целиком
import { requireNativeModule } from 'expo';

export default requireNativeModule('ExpoSQLite');

// expo-modules-core 57.0.13, src/requireNativeModule.ts — первая строка и суть
import { TurboModuleRegistry } from 'react-native';
// …
createTurboModuleToExpoProxy(TurboModuleRegistry.get(moduleName), moduleName) ??

// expo-sqlite 57.0.3, src/ExpoSQLite.web.ts — сокращено
} else {
  ExpoSQLite = require('../web/SQLiteModule').default;
}

// web/SQLiteModule.ts — база живёт в отдельном потоке
function getWorker(): Worker {
  if (!worker) {
    worker = new Worker(new URL('./worker', window.location.href));
    // …

// web/WorkerChannel.ts — синхронный вызов ждёт ответ через разделяемую память
const id = messageId++;
const lockBuffer = new SharedArrayBuffer(4);
const lock = new Int32Array(lockBuffer);
const resultBuffer = new SharedArrayBuffer(1024 * 1024);

// веб-сборка expo-sqlite держит базу в Worker, а синхронный вызов ждёт от него
// ответ через разделяемую память
console.log("SharedArrayBuffer:", typeof SharedArrayBuffer, "| Atomics:", typeof Atomics);
try {
  new SharedArrayBuffer(4);
} catch (error) {
  console.log((error as Error).name + ":", (error as Error).message);
}
console.log("crossOriginIsolated =", crossOriginIsolated);

// а сам Worker создаётся от адреса страницы
console.log("адрес документа:", location.href);
try {
  console.log("адрес рабочего потока:", new URL("./worker", location.href).href);
} catch (error) {
  console.log((error as Error).name + ":", (error as Error).message);
}

// shared/db/journal-db.ts — телефон: настоящая база за тем же интерфейсом
import { addDatabaseChangeListener, openDatabaseAsync } from "expo-sqlite";
import type { JournalDb, Op, Row } from "./journal-db.types";

export async function openJournalDb(): Promise<JournalDb> {
  // без enableChangeListener база не расскажет о записи: событий просто не будет
  const db = await openDatabaseAsync("podhod.db", { enableChangeListener: true });
  return {
    // строка и операция — одним шагом: сбой между ними откатывает обе
    change: (row, op) =>
      db.withTransactionAsync(async () => {
        await db.runAsync(
          "INSERT INTO sets (id, workoutId, exercise, weightKg, reps) VALUES (?, ?, ?, ?, ?)" +
            " ON CONFLICT(id) DO UPDATE SET workoutId = excluded.workoutId," +
            " exercise = excluded.exercise, weightKg = excluded.weightKg, reps = excluded.reps",
          row.id, row.workoutId, row.exercise, row.weightKg, row.reps,
        );
        await db.runAsync(
          "INSERT INTO ops (opId, rowId, fields, at) VALUES (?, ?, ?, ?)",
          op.opId, op.rowId, JSON.stringify(op.fields), op.at,
        );
      }),
    sets: () => db.getAllAsync<Row>("SELECT * FROM sets"),
    outbox: async () => {
      const rows = await db.getAllAsync<Omit<Op, "fields"> & { fields: string }>(
        "SELECT opId, rowId, fields, at FROM ops ORDER BY rowid",
      );
      return rows.map((row) => ({ ...row, fields: JSON.parse(row.fields) }));
    },
    subscribe: (listener) => {
      const subscription = addDatabaseChangeListener(() => listener());
      return () => subscription.remove();
    },
  };
}

// app/_layout.tsx — лестница идёт до первого кадра, как в прошлой статье
import { SQLiteProvider, type SQLiteDatabase } from "expo-sqlite";
import { Suspense } from "react";

const SCHEMA = 2;
const steps: Record<number, string> = {
  1: "ALTER TABLE sets RENAME COLUMN weight TO weightKg",
};

// onInit в типах подписан «run database migrations» — это она и есть
async function migrate(db: SQLiteDatabase) {
  const row = await db.getFirstAsync<{ user_version: number }>("PRAGMA user_version");
  let version = row?.user_version ?? 0;
  if (version > SCHEMA) {
    throw new Error(`схема ${version} новее приложения (${SCHEMA})`);
  }
  while (version < SCHEMA) {
    const step = steps[version];
    const next = version + 1;
    // номер схемы и сам шаг — одна транзакция: разойтись им негде
    await db.withTransactionAsync(async () => {
      await db.execAsync(step);
      await db.execAsync(`PRAGMA user_version = ${next}`);
    });
    version = next;
  }
}

export default function RootLayout() {
  return (
    <Suspense fallback={null}>
      <SQLiteProvider databaseName="podhod.db" options={{ enableChangeListener: true }} onInit={migrate} useSuspense>
        <Stack />
      </SQLiteProvider>
    </Suspense>
  );
}

// expo-sqlite 57.0.3, src/hooks.tsx — сокращено
async function openDatabaseWithInitAsync({ databaseName, directory, options, assetSource, onInit }) {
  const database = await openDatabaseAsync(databaseName, options, directory);
  if (onInit != null) {
    await onInit(database);
  }
  return database;
}

// с useSuspense — промис открытия отдаётся use(); это своя копия хука, она
// объявлена в этом же файле и так же бросает промис
function SQLiteProviderSuspense({ databaseName, directory, options, assetSource, children, onInit }) {
  const databasePromise = getDatabaseAsync({ databaseName, directory, options, assetSource, onInit });
  const database = use(databasePromise);
  return <SQLiteContext.Provider value={database}>{children}</SQLiteContext.Provider>;
}

// без него — то же состояние «открывается», написанное руками
  if (loading || !databaseRef.current) {
    return null;
  }

type Fields = Record<string, string | number>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
interface JournalDb {
  change(row: Row, op: Op): Promise<void>;
  sets(): Promise<Row[]>;
  outbox(): Promise<Op[]>;
  subscribe(listener: () => void): () => void;
}
interface Disk {
  getItem(key: string): Promise<string | null>;
  setItem(key: string, value: string): Promise<void>;
}
declare const disk: Disk;
declare function now(): number;
type Tables = { sets: Row[]; ops: Op[] };
const EMPTY = '{"sets":[],"ops":[]}';

// journal-db.web.ts: тот же интерфейс, но поверх ящика из прошлой статьи
async function openJournalDb(): Promise<JournalDb> {
  const read = async (): Promise<Tables> => JSON.parse((await disk.getItem("podhod.db")) ?? EMPTY);
  let data = await read();
  const listeners = new Set<() => void>();
  return {
    async change(row, op) {
      const sets = [...data.sets.filter((s) => s.id !== row.id), row];
      const next = { sets, ops: [...data.ops, op] };
      // обе «таблицы» уезжают одним значением: это и есть одна транзакция
      await disk.setItem("podhod.db", JSON.stringify(next));
      data = next;
      listeners.forEach((listener) => listener());
    },
    // чтение идёт на диск, как getAllAsync: это не память процесса
    sets: async () => (await read()).sets,
    outbox: async () => (await read()).ops,
    subscribe(listener) {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
  };
}

(async () => {
  const db = await openJournalDb();
  const bench: Row = { id: "A-1", exercise: "bench", weightKg: 80, reps: 5 };
  await db.change(bench, { opId: "A:1", rowId: "A-1", fields: { ...bench }, at: now() });
  await db.change({ ...bench, weightKg: 82.5 }, { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at: now() });
  // «убить процесс»: память выброшена, остался файл базы
  const again = await openJournalDb();
  console.log("поднято с диска:", (await again.outbox()).length, "операции");
  const rows = await again.sets();
  console.log("лента:", rows.map((row) => row.id + " " + row.weightKg + "×" + row.reps).join(" | "));
})();

// echo-platform, apps/mobile/src/shared/db/client.ts — сокращено
/**
 * Открывает локальную БД текущего пользователя.
 * enableChangeListener обязателен для useLiveQuery — без него список чатов не оживёт.
 */
export function openUserDb(userId: string): LocalDb {
  if (db && openedFor === userId) return db;
  closeUserDb();

  native = openDatabaseSync(fileFor(userId), { enableChangeListener: true });
  // WAL: запись в фоне (флашер outbox) не блокирует чтение списка чатов
  native.execSync('PRAGMA journal_mode = WAL;');
  native.execSync('PRAGMA foreign_keys = ON;');
  db = drizzle(native, { schema });
  openedFor = userId;
  return db;
}

// drizzle-orm 0.45.2, expo-sqlite/query.js — сокращено
const useLiveQuery = (query, deps = []) => {
  const [data, setData] = useState(
    is(query, SQLiteRelationalQuery) && query.mode === "first" ? void 0 : []
  );
  const [error, setError] = useState();
  const [updatedAt, setUpdatedAt] = useState();
  useEffect(() => {
    // …
    query.then(handleData).catch(setError);
    listener = addDatabaseChangeListener(({ tableName }) => {
      if (config.name === tableName) {
        query.then(handleData).catch(setError);
      }
    });
    return () => {
      listener?.remove();
    };
  }, deps);
  return { data, error, updatedAt };
};

type Fields = Record<string, string | number>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
interface JournalDb {
  change(row: Row, op: Op): Promise<void>;
  sets(): Promise<Row[]>;
  outbox(): Promise<Op[]>;
  subscribe(listener: () => void): () => void;
}
declare function openJournalDb(): Promise<JournalDb>;
declare function now(): number;
const { Text } = ReactNative;
let db: JournalDb;

// та же форма, что у useLiveQuery из drizzle-orm/expo-sqlite: { data, error, updatedAt }
function useLiveQuery<T>(query: () => Promise<T>, initial: T) {
  const [data, setData] = React.useState(initial);
  const [updatedAt, setUpdatedAt] = React.useState<number | undefined>(undefined);
  React.useEffect(() => {
    const read = () => {
      query().then((rows) => {
        setData(rows);
        setUpdatedAt(now());
      });
    };
    read();
    // событие базы вместо своей подписки — это addDatabaseChangeListener
    return db.subscribe(read);
  }, []);
  return { data, updatedAt };
}

function Diary() {
  const { data, updatedAt } = useLiveQuery<Row[]>(() => db.sets(), []);
  const text = data.length > 0 ? "дневник: " + data.length : "у вас ещё нет тренировок";
  console.log("кадр:", text, "| updatedAt:", updatedAt);
  return <Text>{text}</Text>;
}

(async () => {
  db = await openJournalDb();
  const bench: Row = { id: "A-1", exercise: "bench", weightKg: 80, reps: 5 };
  // подход уже лежит в базе: его записали в прошлый запуск
  await db.change(bench, { opId: "A:1", rowId: "A-1", fields: { ...bench }, at: now() });
  mount(<Diary />);
  const squat: Row = { id: "A-2", exercise: "squat", weightKg: 100, reps: 5 };
  setTimeout(() => db.change(squat, { opId: "A:2", rowId: "A-2", fields: { ...squat }, at: now() }), 120);
})();

// вместо пакета сообщества — тот же интерфейс, но поверх SQLite
import Storage from "expo-sqlite/kv-store";

await Storage.setItem("sync-cursor", "42");
const cursor = await Storage.getItem("sync-cursor");

// expo-sqlite 57.0.3, src/Storage.ts — его собственная лестница; сокращено
const result = await db.getFirstAsync<{ user_version: number }>('PRAGMA user_version');
const currentDbVersion = result?.user_version ?? 0;
// …
if (currentDbVersion >= DATABASE_VERSION) {
  return;
}
await db.execAsync(`PRAGMA user_version = ${DATABASE_VERSION}`);

// stack-starter, apps/mobile/src/entities/session/session-storage.ts
import * as SecureStore from 'expo-secure-store';
import type { SessionStorage } from './session-storage.types';

/** Натив: токен лежит в защищённом хранилище ОС (Keychain / Keystore). */
export const sessionStorage: SessionStorage = {
  getItem: (key) => SecureStore.getItemAsync(key),
  setItem: (key, value) => SecureStore.setItemAsync(key, value),
  removeItem: (key) => SecureStore.deleteItemAsync(key),
};

// expo-secure-store 57.0.1, build/ExpoSecureStore.web.js — файл целиком
export default {};