import { SQLiteSyncProvider } from '@sqliteai/sqlite-sync-react-native';

export default function App() {
  return (
    <SQLiteSyncProvider
      databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
      databaseName="myapp.db"
      apiKey="your-api-key"
      syncMode="polling"
      tablesToBeSynced={[
        {
          name: 'tasks',
          createTableSql: `
            CREATE TABLE IF NOT EXISTS tasks (
              id TEXT PRIMARY KEY NOT NULL,
              title TEXT,
              completed INTEGER DEFAULT 0,
              created_at TEXT DEFAULT CURRENT_TIMESTAMP
            );
          `,
        },
      ]}
    >
      <YourApp />
    </SQLiteSyncProvider>
  );
}

import { useSqliteSyncQuery } from '@sqliteai/sqlite-sync-react-native';

interface Task {
  id: string;
  title: string;
  completed: number;
}

function TaskList() {
  const {
    data: tasks,
    isLoading,
    error,
  } = useSqliteSyncQuery<Task>({
    query: 'SELECT * FROM tasks ORDER BY created_at DESC',
    arguments: [],
    fireOn: [{ table: 'tasks' }],
  });

  if (isLoading) return <Text>Loading...</Text>;
  if (error) return <Text>Error: {error.message}</Text>;

  return (
    <FlatList
      data={tasks}
      keyExtractor={(item) => item.id}
      renderItem={({ item }) => <Text>{item.title}</Text>}
    />
  );
}

import { useSqliteTransaction } from '@sqliteai/sqlite-sync-react-native';

function AddTaskButton() {
  const { executeTransaction } = useSqliteTransaction();

  const addTask = async (title: string) => {
    await executeTransaction(async (tx) => {
      await tx.execute(
        'INSERT INTO tasks (id, title) VALUES (cloudsync_uuid(), ?);',
        [title]
      );
    });
  };

  return <Button title="Add Task" onPress={() => addTask('New Task')} />;
}

import {
  useTriggerSqliteSync,
  useSyncStatus,
} from '@sqliteai/sqlite-sync-react-native';

function SyncControls() {
  const { triggerSync } = useTriggerSqliteSync();
  const { isSyncing, lastSyncTime, syncError, syncMode } = useSyncStatus();

  return (
    <View>
      <Text>Mode: {syncMode}</Text>
      <Button
        title={isSyncing ? 'Syncing...' : 'Sync Now'}
        onPress={triggerSync}
        disabled={isSyncing}
      />
      {lastSyncTime && (
        <Text>Last sync: {new Date(lastSyncTime).toLocaleTimeString()}</Text>
      )}
      {syncError && <Text>Sync error: {syncError.message}</Text>}
    </View>
  );
}

// Polling mode with runtime defaults
<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="your-api-key"
  tablesToBeSynced={[...]}
  syncMode="polling"
>

// Polling mode with custom intervals
<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="your-api-key"
  tablesToBeSynced={[...]}
  syncMode="polling"
  adaptivePolling={{
    baseInterval: 3000,
    maxInterval: 60000,
    emptyThreshold: 3
  }}
>

// Push mode - foreground only
<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="your-api-key"
  tablesToBeSynced={[...]}
  syncMode="push"
  notificationListening="foreground"
>

// Push mode - foreground + background + terminated
<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="your-api-key"
  tablesToBeSynced={[...]}
  syncMode="push"
  notificationListening="always"
  renderPushPermissionPrompt={({ allow, deny }) => (
    <YourCustomPermissionDialog onAllow={allow} onDeny={deny} />
  )}
>

import { registerBackgroundSyncCallback } from '@sqliteai/sqlite-sync-react-native';
import * as Notifications from 'expo-notifications';

registerBackgroundSyncCallback(async ({ changes, db }) => {
  const newItems = changes.filter(
    (c) => c.table === 'tasks' && c.operation === 'INSERT'
  );

  if (newItems.length === 0) return;

  const result = await db.execute(
    `SELECT * FROM tasks WHERE rowid IN (${newItems
      .map((c) => c.rowId)
      .join(',')})`
  );

  await Notifications.scheduleNotificationAsync({
    content: {
      title: `${newItems.length} new tasks synced`,
      body: result.rows?.[0]?.title || 'New data available',
    },
    trigger: null,
  });
});

<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="..."
  tablesToBeSynced={[...]}
  onDatabaseReady={async (db) => {
    const { rows } = await db.execute('PRAGMA user_version');
    const version = rows?.[0]?.user_version ?? 0;

    if (version < 1) {
      await db.execute('ALTER TABLE tasks ADD COLUMN priority INTEGER DEFAULT 0');
      await db.execute('PRAGMA user_version = 1');
    }
  }}
>

interface AdaptivePollingConfig {
  baseInterval?: number;
  maxInterval?: number;
  emptyThreshold?: number;
  idleBackoffMultiplier?: number;
  errorBackoffMultiplier?: number;
}

interface TableConfig {
  name: string;
  createTableSql: string;
}

{
  name: 'users',
  createTableSql: `
    CREATE TABLE IF NOT EXISTS users (
      id TEXT PRIMARY KEY NOT NULL,
      name TEXT,
      email TEXT UNIQUE,
      created_at TEXT DEFAULT CURRENT_TIMESTAMP
    );
  `
}

interface ReactiveQueryConfig {
  query: string;
  arguments?: any[];
  fireOn: Array<{
    table: string;
    operation?: 'INSERT' | 'UPDATE' | 'DELETE';
  }>;
}

interface TableUpdateData<T = any> {
  table: string;
  operation: 'INSERT' | 'UPDATE' | 'DELETE';
  rowId: number;
  row: T | null;
}

interface TableUpdateConfig<T = any> {
  tables: string[];
  onUpdate: (data: TableUpdateData<T>) => void;
}

import { useContext } from 'react';
import { SQLiteDbContext } from '@sqliteai/sqlite-sync-react-native';

const { writeDb, readDb, initError } = useContext(SQLiteDbContext);

import { useContext } from 'react';
import { SQLiteSyncStatusContext } from '@sqliteai/sqlite-sync-react-native';

const { isSyncing, lastSyncTime, syncError, syncMode, currentSyncInterval } =
  useContext(SQLiteSyncStatusContext);

import { useContext } from 'react';
import { SQLiteSyncActionsContext } from '@sqliteai/sqlite-sync-react-native';

const { triggerSync } = useContext(SQLiteSyncActionsContext);

useSqliteDb(): {
  writeDb: DB | null;
  readDb: DB | null;
  initError: Error | null;
}

const { writeDb, readDb, initError } = useSqliteDb();

useSyncStatus(): {
  syncMode: 'polling' | 'push';
  isSyncReady: boolean;
  isSyncing: boolean;
  lastSyncTime: number | null;
  lastSyncChanges: number;
  syncError: Error | null;
  currentSyncInterval: number | null;
  consecutiveEmptySyncs: number;
  consecutiveSyncErrors: number;
  isAppInBackground: boolean;
  isNetworkAvailable: boolean;
}

const { syncMode, isSyncing, lastSyncTime, syncError, currentSyncInterval } =
  useSyncStatus();

return (
  <View>
    <Text>Mode: {syncMode}</Text>
    <Text>{isSyncing ? 'Syncing...' : 'Idle'}</Text>
    {lastSyncTime && (
      <Text>Last sync: {new Date(lastSyncTime).toLocaleTimeString()}</Text>
    )}
    {currentSyncInterval && (
      <Text>Next sync: {currentSyncInterval / 1000}s</Text>
    )}
    {syncError && <Text>Sync error: {syncError.message}</Text>}
  </View>
);

useSqliteSync(): {
  writeDb: DB | null;
  readDb: DB | null;
  initError: Error | null;
  syncMode: 'polling' | 'push';
  isSyncReady: boolean;
  isSyncing: boolean;
  lastSyncTime: number | null;
  lastSyncChanges: number;
  syncError: Error | null;
  currentSyncInterval: number | null;
  consecutiveEmptySyncs: number;
  consecutiveSyncErrors: number;
  isAppInBackground: boolean;
  isNetworkAvailable: boolean;
  triggerSync: () => Promise<void>;
}

const { writeDb, initError, isSyncing, lastSyncTime, triggerSync } =
  useSqliteSync();

return (
  <View>
    <Text>Database: {writeDb ? 'Ready' : 'Loading'}</Text>
    <Button onPress={triggerSync} disabled={isSyncing} />
  </View>
);

useTriggerSqliteSync(): {
  triggerSync: () => Promise<void>;
}

const { triggerSync } = useTriggerSqliteSync();
const { isSyncing } = useSyncStatus();

<Button
  onPress={triggerSync}
  disabled={isSyncing}
  title={isSyncing ? 'Syncing...' : 'Sync Now'}
/>;

interface ReactiveQueryConfig {
  query: string;
  arguments?: any[];
  fireOn: Array<{
    table: string;
    operation?: 'INSERT' | 'UPDATE' | 'DELETE';
  }>;
}

useSqliteSyncQuery<T = any>(config: ReactiveQueryConfig): {
  data: T[];
  isLoading: boolean;
  error: Error | null;
  unsubscribe: () => void;
}

const { data, isLoading, error } = useSqliteSyncQuery<Task>({
  query: 'SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at DESC',
  arguments: [userId],
  fireOn: [{ table: 'tasks' }, { table: 'task_assignments' }],
});

if (isLoading) return <Spinner />;
if (error) return <Error message={error.message} />;

return (
  <FlatList data={data} renderItem={({ item }) => <TaskItem task={item} />} />
);

const { execute } = useSqliteExecute();
const { executeTransaction } = useSqliteTransaction();

// Triggers reactive queries
await executeTransaction(async (tx) => {
  await tx.execute('INSERT INTO tasks (id, title) VALUES (?, ?)', [id, title]);
});

// Does not trigger reactive queries
await execute('INSERT INTO tasks (id, title) VALUES (?, ?)', [id, title]);

interface TableUpdateConfig<T = any> {
  tables: string[];
  onUpdate: (data: TableUpdateData<T>) => void;
}

interface TableUpdateData<T = any> {
  table: string;
  operation: 'INSERT' | 'UPDATE' | 'DELETE';
  rowId: number;
  row: T | null;
}

useOnTableUpdate<T = any>(config: TableUpdateConfig<T>): void

interface Task {
  id: string;
  title: string;
  completed: boolean;
}

useOnTableUpdate<Task>({
  tables: ['tasks', 'notes'],
  onUpdate: (data) => {
    console.log(`Table: ${data.table}`);
    console.log(`Operation: ${data.operation}`);

    if (data.row) {
      Toast.show(
        `Task "${data.row.title}" was ${data.operation.toLowerCase()}d`
      );

      analytics.track('task_modified', {
        operation: data.operation,
        taskId: data.row.id,
      });
    } else {
      console.log('Row was deleted');
    }
  },
});

interface SqliteExecuteOptions {
  readOnly?: boolean;
  autoSync?: boolean;
}

useSqliteExecute(): {
  execute: (
    sql: string,
    params?: any[],
    options?: SqliteExecuteOptions
  ) => Promise<QueryResult | undefined>;
  isExecuting: boolean;
  error: Error | null;
}

import { useSqliteExecute } from '@sqliteai/sqlite-sync-react-native';

function TaskManager() {
  const { execute, isExecuting, error } = useSqliteExecute();

  const addTask = async (title: string) => {
    try {
      const result = await execute(
        'INSERT INTO tasks (id, title) VALUES (cloudsync_uuid(), ?)',
        [title]
      );
      console.log('Inserted row ID:', result?.insertId);
    } catch (err) {
      console.error('Failed to insert:', err);
    }
  };

  const getTask = async (id: string) => {
    try {
      const result = await execute('SELECT * FROM tasks WHERE id = ?', [id], {
        readOnly: true,
      });
      return result?.rows?.[0];
    } catch (err) {
      console.error('Failed to fetch:', err);
    }
  };

  return (
    <View>
      <Button
        title="Add Task"
        onPress={() => addTask('New Task')}
        disabled={isExecuting}
      />
      {error && <Text>Error: {error.message}</Text>}
    </View>
  );
}

await execute(
  'INSERT INTO local_cache (key, value) VALUES (?, ?)',
  [key, value],
  { autoSync: false }
);

useSqliteTransaction(): {
  executeTransaction: (
    fn: (tx: Transaction) => Promise<void>,
    options?: { autoSync?: boolean }
  ) => Promise<void>;
  isExecuting: boolean;
  error: Error | null;
}

import { useSqliteTransaction } from '@sqliteai/sqlite-sync-react-native';

function TaskManager() {
  const { executeTransaction, isExecuting } = useSqliteTransaction();

  const addTaskWithLog = async (title: string) => {
    try {
      await executeTransaction(async (tx) => {
        await tx.execute(
          'INSERT INTO tasks (id, title) VALUES (cloudsync_uuid(), ?)',
          [title]
        );
        await tx.execute('INSERT INTO logs (action, timestamp) VALUES (?, ?)', [
          'task_created',
          Date.now(),
        ]);
      });
      console.log('Task and log inserted successfully');
    } catch (err) {
      console.error('Transaction failed:', err);
    }
  };

  const addLocalOnlyTask = async (title: string) => {
    await executeTransaction(
      async (tx) => {
        await tx.execute('INSERT INTO tasks (id, title) VALUES (?, ?)', [
          'local-id',
          title,
        ]);
      },
      { autoSync: false }
    );
  };

  return (
    <Button
      title="Add Task"
      onPress={() => addTaskWithLog('New Task')}
      disabled={isExecuting}
    />
  );
}

await executeTransaction(
  async (tx) => {
    await tx.execute('INSERT INTO local_cache (key, value) VALUES (?, ?)', [
      key,
      value,
    ]);
  },
  { autoSync: false }
);

const { initError, writeDb } = useSqliteDb();

if (initError) {
  return <ErrorScreen message="Database unavailable" />;
}

const { writeDb } = useSqliteDb();
const { syncError } = useSyncStatus();

if (writeDb) {
  await writeDb.execute('INSERT INTO tasks ...');
}

{
  syncError && <Banner warning={syncError.message} />;
}

<SQLiteSyncProvider
  databaseId="db_xxxxxxxxxxxxxxxxxxxxxxxx"
  databaseName="myapp.db"
  apiKey="your-api-key"
  tablesToBeSynced={[...]}
  syncMode="polling"
  debug={__DEV__}
>