Storage and Offline

import AsyncStorage from '@react-native-async-storage/async-storage';

await AsyncStorage.setItem('onboardingComplete', JSON.stringify(true));
const raw = await AsyncStorage.getItem('onboardingComplete');
const onboardingComplete: boolean = raw !== null ? JSON.parse(raw) : false;

import { MMKV } from 'react-native-mmkv';

export const settingsStorage = new MMKV({ id: 'places-settings' });

settingsStorage.set('distanceUnit', 'km');
const distanceUnit = settingsStorage.getString('distanceUnit') ?? 'km';

// src/features/places/storage/placesRepository.ts (excerpt: schema)
import * as SQLite from 'expo-sqlite';

const db = SQLite.openDatabaseSync('places.db');

const CURRENT_SCHEMA_VERSION = 1;

function migrate() {
  const { user_version: version } = db.getFirstSync<{ user_version: number }>('PRAGMA user_version;')!;

  if (version < 1) {
    db.execSync(`
      CREATE TABLE IF NOT EXISTS places (
        id TEXT PRIMARY KEY NOT NULL,
        name TEXT NOT NULL,
        notes TEXT NOT NULL,
        category TEXT NOT NULL,
        favourite INTEGER NOT NULL,
        visited_at TEXT NOT NULL,
        latitude REAL,
        longitude REAL,
        photo_uri TEXT,
        created_at TEXT NOT NULL,
        updated_at TEXT NOT NULL
      );

      CREATE TABLE IF NOT EXISTS pending_writes (
        id TEXT PRIMARY KEY NOT NULL,
        op TEXT NOT NULL,
        payload TEXT NOT NULL,
        created_at TEXT NOT NULL
      );
    `);
  }

  db.execSync(`PRAGMA user_version = ${CURRENT_SCHEMA_VERSION};`);
}

migrate();

// src/features/places/storage/placesRepository.ts (excerpt: repository)
import type { Place } from '../types';

export type PendingWriteOp = 'create' | 'update' | 'delete';

export interface PendingWrite {
  id: string;
  op: PendingWriteOp;
  payload: string; // JSON-serialized Place (or { id } alone for a delete)
  createdAt: string;
}

function rowToPlace(row: any): Place {
  return {
    id: row.id,
    name: row.name,
    notes: row.notes,
    category: row.category,
    favourite: row.favourite === 1,
    visitedAt: row.visited_at,
    latitude: row.latitude,
    longitude: row.longitude,
    photoUri: row.photo_uri,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
  };
}

export const placesRepository = {
  getAll(): Place[] {
    const rows = db.getAllSync<any>('SELECT * FROM places ORDER BY visited_at DESC;');
    return rows.map(rowToPlace);
  },

  upsert(place: Place): void {
    db.runSync(
      `INSERT INTO places (id, name, notes, category, favourite, visited_at, latitude, longitude, photo_uri, created_at, updated_at)
       VALUES ($id, $name, $notes, $category, $favourite, $visitedAt, $latitude, $longitude, $photoUri, $createdAt, $updatedAt)
       ON CONFLICT(id) DO UPDATE SET
         name = excluded.name, notes = excluded.notes, category = excluded.category,
         favourite = excluded.favourite, visited_at = excluded.visited_at,
         latitude = excluded.latitude, longitude = excluded.longitude,
         photo_uri = excluded.photo_uri, updated_at = excluded.updated_at;`,
      {
        $id: place.id,
        $name: place.name,
        $notes: place.notes,
        $category: place.category,
        $favourite: place.favourite ? 1 : 0,
        $visitedAt: place.visitedAt,
        $latitude: place.latitude,
        $longitude: place.longitude,
        $photoUri: place.photoUri,
        $createdAt: place.createdAt,
        $updatedAt: place.updatedAt,
      },
    );
  },

  enqueueWrite(op: PendingWriteOp, payload: unknown): void {
    db.runSync('INSERT INTO pending_writes (id, op, payload, created_at) VALUES ($id, $op, $payload, $createdAt);', {
      $id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
      $op: op,
      $payload: JSON.stringify(payload),
      $createdAt: new Date().toISOString(),
    });
  },

  getPendingWrites(): PendingWrite[] {
    const rows = db.getAllSync<any>('SELECT * FROM pending_writes ORDER BY created_at ASC;');
    return rows.map((row) => ({ id: row.id, op: row.op, payload: row.payload, createdAt: row.created_at }));
  },

  clearPendingWrite(id: string): void {
    db.runSync('DELETE FROM pending_writes WHERE id = $id;', { $id: id });
  },
};

// src/features/places/storage/addPlace.ts
import type { NewPlaceInput, Place } from '../types';
import { placesRepository } from './placesRepository';

export function addPlace(input: NewPlaceInput): Place {
  const now = new Date().toISOString();
  const place: Place = {
    id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
    ...input,
    favourite: false,
    createdAt: now,
    updatedAt: now,
  };

  placesRepository.upsert(place);           // optimistic local write, visible immediately
  placesRepository.enqueueWrite('create', place);

  return place;
}

// src/features/places/storage/syncWorker.ts
import NetInfo from '@react-native-community/netinfo';
import { placesApi } from '../../../lib/apiClient';
import { placesRepository } from './placesRepository';
import type { Place } from '../types';

let syncing = false;

async function drainPendingWrites(): Promise<void> {
  if (syncing) {
    return; // a drain is already in flight; the next reachability event will trigger another one
  }
  syncing = true;

  try {
    for (const write of placesRepository.getPendingWrites()) {
      const payload = JSON.parse(write.payload) as Place;

      try {
        if (write.op === 'create' || write.op === 'update') {
          const serverPlace = await placesApi.addPlace(payload);
          resolveConflict(payload, serverPlace);
        } else if (write.op === 'delete') {
          await placesApi.deletePlace(payload.id);
        }
        placesRepository.clearPendingWrite(write.id);
      } catch {
        break; // stop draining on the first failure; retry the same row (and any after it) next time
      }
    }
  } finally {
    syncing = false;
  }
}

function resolveConflict(local: Place, server: Place): void {
  // Last-write-wins: whichever side has the newer updatedAt is kept locally.
  const winner = new Date(server.updatedAt) > new Date(local.updatedAt) ? server : local;
  placesRepository.upsert(winner);
}

export function startSyncWorker(): void {
  NetInfo.addEventListener((state) => {
    if (state.isInternetReachable === true) {
      void drainPendingWrites();
    }
  });
}