@pol-studios/powersync 1.0.7 → 1.0.11

package/README.md

@@ -0,0 +1,933 @@
+# @pol-studios/powersync
+
+A comprehensive offline-first data synchronization library for React Native and Web apps, built on top of PowerSync with Supabase integration.
+
+## Features
+
+- **Offline-First Database** - Full local SQLite database with automatic sync
+- **Reactive Queries** - Live-updating queries that respond to local and remote changes
+- **Durable Uploads** - CRUD operations queued and retried automatically
+- **Attachment Management** - File uploads/downloads with caching and compression
+- **Conflict Detection** - Field-level conflict detection with resolution options
+- **Background Sync** - iOS/Android background sync support
+- **Health Monitoring** - Connection health, metrics, and diagnostics
+- **Platform Agnostic** - Works on React Native and Web with same API
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Provider Configuration](#provider-configuration)
+- [React Hooks](#react-hooks)
+- [Database Operations](#database-operations)
+- [Sync Control](#sync-control)
+- [Connection & Status](#connection--status)
+- [Pending Mutations](#pending-mutations)
+- [Failed Transactions](#failed-transactions)
+- [Attachments](#attachments)
+- [Conflict Handling](#conflict-handling)
+- [Background Sync](#background-sync)
+- [Cache Management](#cache-management)
+- [Error Handling](#error-handling)
+- [Platform Adapters](#platform-adapters)
+- [API Reference](#api-reference)
+
+---
+
+## Installation
+
+```bash
+# Core package
+pnpm add @pol-studios/powersync
+
+# Required peer dependencies
+pnpm add @powersync/attachments @supabase/supabase-js @tanstack/react-query
+
+# React Native specific
+pnpm add @powersync/react-native @powersync/op-sqlite expo-file-system
+pnpm add @react-native-community/netinfo react-native-background-upload
+pnpm add @react-native-async-storage/async-storage
+
+# Web specific
+pnpm add @powersync/web
+```
+
+---
+
+## Quick Start
+
+### 1. Create Your Schema
+
+```typescript
+// powersync-schema.ts
+import { Schema, Table, column } from '@powersync/react-native';
+
+export const AppSchema = new Schema([
+  new Table({
+    name: 'todos',
+    columns: [
+      column.text('title'),
+      column.text('description'),
+      column.integer('completed'),
+      column.text('created_at'),
+    ],
+  }),
+]);
+```
+
+### 2. Configure the Provider
+
+```tsx
+import { OfflineDataProvider } from '@pol-studios/powersync';
+import { createClient } from '@supabase/supabase-js';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+
+const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+const queryClient = new QueryClient();
+
+function App() {
+  return (
+    <OfflineDataProvider
+      config={{
+        supabaseClient: supabase,
+        powerSyncUrl: 'https://your-instance.powersync.com',
+        schema: AppSchema,
+        queryClient,  // Pass queryClient to enable cache invalidation on sync
+        dbFilename: 'myapp.db',
+      }}
+    >
+      <QueryClientProvider client={queryClient}>
+        <YourApp />
+      </QueryClientProvider>
+    </OfflineDataProvider>
+  );
+}
+```
+
+> **Note:** The same `queryClient` instance is passed to both `OfflineDataProvider` config and `QueryClientProvider`. This allows the sync system to invalidate React Query caches when data changes. The `QueryClientProvider` must be nested inside `OfflineDataProvider` so that child components can use both PowerSync hooks and React Query hooks.
+
+### 3. Use the Database
+
+```tsx
+import { usePowerSync, useDatabase } from '@pol-studios/powersync';
+
+function TodoList() {
+  const { db, isReady } = usePowerSync();
+  const [todos, setTodos] = useState([]);
+
+  useEffect(() => {
+    if (!db || !isReady) return;
+
+    // Reactive query - updates automatically
+    db.watch('SELECT * FROM todos ORDER BY created_at DESC', [], {
+      onResult: (result) => setTodos(result.rows._array),
+    });
+  }, [db, isReady]);
+
+  const addTodo = async (title: string) => {
+    await db.execute(
+      'INSERT INTO todos (id, title, completed, created_at) VALUES (?, ?, 0, ?)',
+      [uuid(), title, new Date().toISOString()]
+    );
+  };
+
+  return (
+    <View>
+      {todos.map(todo => <TodoItem key={todo.id} todo={todo} />)}
+    </View>
+  );
+}
+```
+
+---
+
+## Provider Configuration
+
+### OfflineDataProviderConfig
+
+```typescript
+interface OfflineDataProviderConfig {
+  // Required
+  supabaseClient: SupabaseClient;
+  schema: Schema;
+  queryClient: QueryClient;
+
+  // Optional - PowerSync connection
+  powerSyncUrl?: string;              // If omitted, runs in online-only mode
+  dbFilename?: string;                // Default: 'powersync.db'
+
+  // Optional - Connector configuration
+  connector?: {
+    schemaRouter?: (table: string) => string;  // Route tables to Supabase schemas
+    conflictDetection?: { enabled: boolean };  // Enable conflict detection
+  };
+
+  // Optional - Sync behavior
+  sync?: {
+    autoConnect?: boolean;            // Default: true
+    enableHealthMonitoring?: boolean; // Default: true
+    enableMetrics?: boolean;          // Default: true
+  };
+
+  // Optional - Attachments
+  attachments?: AttachmentConfig;
+
+  // Optional - Background sync (React Native only)
+  backgroundSync?: {
+    enabled: boolean;
+    minimumInterval?: number;         // Minutes, default: 15
+    callbacks?: {
+      onSyncStart?: () => void;
+      onSyncComplete?: () => void;
+      onSyncError?: (error: Error) => void;
+    };
+  };
+
+  // Optional - Platform adapter (auto-detected if omitted)
+  platform?: PlatformAdapter;
+}
+```
+
+### Provider Callbacks
+
+```tsx
+<OfflineDataProvider
+  config={config}
+  onReady={() => console.log('Database ready')}
+  onError={(error) => console.error('Init failed:', error)}
+  onSyncStatusChange={(status) => console.log('Sync status:', status)}
+  onBackgroundSyncSystemReady={(system) => {
+    // Background sync system is ready
+  }}
+>
+  {children}
+</OfflineDataProvider>
+```
+
+---
+
+## React Hooks
+
+### Core Hooks
+
+```typescript
+import {
+  usePowerSync,
+  useDatabase,
+  usePlatform,
+  useAttachmentQueue,
+  useAttachmentQueueReady,
+} from '@pol-studios/powersync';
+
+// Main context - database, connector, initialization state
+const { db, connector, isReady, isInitializing, error } = usePowerSync();
+
+// Get initialized database (throws if not ready)
+const db = useDatabase();
+
+// Access platform adapter
+const platform = usePlatform();
+
+// Attachment queue
+const attachmentQueue = useAttachmentQueue();
+const isQueueReady = useAttachmentQueueReady();
+```
+
+### Status Hooks (Recommended - Focused)
+
+```typescript
+import {
+  useConnectionStatus,
+  useSyncActivityContext,
+  usePendingMutationsContext,
+  useFailedTransactionsContext,
+  useCompletedTransactionsContext,
+  useSyncModeContext,
+  useConnectionHealth,
+  useSyncMetrics,
+} from '@pol-studios/powersync';
+
+// Connection state only (minimal re-renders)
+const { connected, connecting, hasSynced, lastSyncedAt } = useConnectionStatus();
+
+// Upload/download activity
+const { uploading, downloading, downloadProgress } = useSyncActivityContext();
+
+// Pending mutations
+const { pendingMutations, pendingCount, discardPendingMutation } = usePendingMutationsContext();
+
+// Failed transactions with retry
+const { failedTransactions, hasUploadErrors, retryFailure, clearFailure } = useFailedTransactionsContext();
+
+// Completed transactions
+const { completedTransactions, newCompletedTransactions, markNotificationsAsSeen } = useCompletedTransactionsContext();
+
+// Sync mode control
+const { syncMode, isPaused, setSyncMode, networkReachable } = useSyncModeContext();
+
+// Health monitoring
+const health = useConnectionHealth(); // Returns ConnectionHealth object directly
+
+// Sync metrics
+const { metrics } = useSyncMetrics(); // totalSyncs, successRate, avgDuration, etc.
+```
+
+### Convenience Hooks
+
+```typescript
+import {
+  useOnlineStatus,
+  useSyncControl,
+  useSyncMode,
+  useIsSyncing,
+  useDownloadProgress,
+  useEntitySyncStatus,
+  useUploadStatus,
+  useSyncActivity,
+} from '@pol-studios/powersync';
+
+// Device online/offline
+const { isOnline } = useOnlineStatus();
+
+// Sync control actions
+const { triggerSync, syncNow, pause, resume, disconnect, setSyncMode } = useSyncControl();
+
+// Quick sync mode access
+const { mode, setMode, canUpload, canDownload } = useSyncMode();
+
+// Simple syncing check
+const isSyncing = useIsSyncing();
+
+// Download progress
+const progress = useDownloadProgress(); // { current, target, percentage } | null
+
+// Entity-specific sync state
+const { state, error, pendingOperations, dismiss } = useEntitySyncStatus(entityId);
+// state: 'idle' | 'saving' | 'syncing' | 'synced' | 'error'
+
+// Overall upload status
+const { pendingCount, failedCount, permanentFailureCount, retryAll } = useUploadStatus();
+
+// Comprehensive activity tracking
+const { pending, failed, completed, counts, hasActivity, retryAll, dismissFailure } = useSyncActivity();
+```
+
+---
+
+## Database Operations
+
+### Reading Data
+
+```typescript
+// One-time query
+const todos = await db.getAll('SELECT * FROM todos WHERE completed = 0');
+
+// Single row
+const todo = await db.get('SELECT * FROM todos WHERE id = ?', [todoId]);
+
+// Reactive watch (updates on changes)
+db.watch('SELECT * FROM todos ORDER BY created_at DESC', [], {
+  onResult: (result) => {
+    const todos = result.rows._array;
+    setTodos(todos);
+  },
+});
+
+// Watch with abort signal for cleanup
+const controller = new AbortController();
+db.watch(query, params, { onResult }, { signal: controller.signal });
+// Later: controller.abort();
+```
+
+### Writing Data
+
+```typescript
+// Insert
+await db.execute(
+  'INSERT INTO todos (id, title, completed) VALUES (?, ?, ?)',
+  [uuid(), 'New todo', 0]
+);
+
+// Update
+await db.execute(
+  'UPDATE todos SET completed = 1 WHERE id = ?',
+  [todoId]
+);
+
+// Delete
+await db.execute('DELETE FROM todos WHERE id = ?', [todoId]);
+
+// Transaction
+await db.writeTransaction(async (tx) => {
+  await tx.execute('INSERT INTO todos ...', [...]);
+  await tx.execute('INSERT INTO todo_items ...', [...]);
+});
+```
+
+---
+
+## Sync Control
+
+### Sync Modes
+
+```typescript
+type SyncMode = 'push-pull' | 'pull-only' | 'offline';
+```
+
+| Mode | Uploads | Downloads | Use Case |
+|------|---------|-----------|----------|
+| `push-pull` | Yes | Yes | Normal operation |
+| `pull-only` | No | Yes | Read-only mode |
+| `offline` | No | No | Fully offline |
+
+### Control Methods
+
+```typescript
+const { triggerSync, syncNow, pause, resume, setSyncMode } = useSyncControl();
+
+// Force fresh sync (disconnect + reconnect)
+await triggerSync();
+
+// Sync now regardless of mode (forces upload)
+await syncNow();
+
+// Pause syncing (sets offline mode)
+await pause();
+
+// Resume syncing (sets push-pull mode)
+await resume();
+
+// Set specific mode
+await setSyncMode('pull-only');
+```
+
+---
+
+## Connection & Status
+
+### Online/Offline Detection
+
+```tsx
+import { useOnlineStatus, useConnectionStatus } from '@pol-studios/powersync';
+
+function OfflineBanner() {
+  const { isOnline } = useOnlineStatus();
+  const { connected, connecting } = useConnectionStatus();
+
+  if (isOnline && connected) return null;
+
+  return (
+    <Banner>
+      {!isOnline ? 'You are offline' : connecting ? 'Reconnecting...' : 'Disconnected'}
+    </Banner>
+  );
+}
+```
+
+### Connection Health
+
+```tsx
+const health = useConnectionHealth();
+
+// health.status: 'healthy' | 'degraded' | 'disconnected'
+// health.latency: number | null
+// health.lastHealthCheck: Date | null
+// health.consecutiveFailures: number
+
+const statusColor = {
+  healthy: 'green',
+  degraded: 'yellow',
+  disconnected: 'red',
+}[health.status];
+```
+
+### Sync Metrics
+
+```tsx
+const { metrics } = useSyncMetrics();
+
+// metrics.totalSyncs: number
+// metrics.successfulSyncs: number
+// metrics.failedSyncs: number
+// metrics.successRate: number (0-1)
+// metrics.averageDurationMs: number
+// metrics.totalDataDownloaded: number (bytes)
+// metrics.totalDataUploaded: number (bytes)
+// metrics.lastError: SyncError | null
+```
+
+---
+
+## Pending Mutations
+
+Track local changes waiting to sync:
+
+```tsx
+import { usePendingMutationsContext } from '@pol-studios/powersync';
+
+function PendingChanges() {
+  const { pendingMutations, pendingCount, discardPendingMutation } = usePendingMutationsContext();
+
+  return (
+    <View>
+      <Text>{pendingCount} changes pending</Text>
+      {pendingMutations.map(mutation => (
+        <View key={mutation.id}>
+          <Text>{mutation.op} on {mutation.table}</Text>
+          <Button onPress={() => discardPendingMutation(mutation.id)}>
+            Discard
+          </Button>
+        </View>
+      ))}
+    </View>
+  );
+}
+```
+
+### Mutation Types
+
+```typescript
+interface CrudEntry {
+  id: string;
+  op: 'PUT' | 'PATCH' | 'DELETE';
+  table: string;
+  opData: Record<string, any>;
+  transactionId: number;
+}
+```
+
+---
+
+## Failed Transactions
+
+Handle sync failures with retry capability:
+
+```tsx
+import { useFailedTransactionsContext } from '@pol-studios/powersync';
+
+function FailedUploads() {
+  const {
+    failedTransactions,
+    hasUploadErrors,
+    permanentErrorCount,
+    retryFailure,
+    clearFailure,
+    clearAllFailures,
+  } = useFailedTransactionsContext();
+
+  if (!hasUploadErrors) return null;
+
+  const retryAll = async () => {
+    for (const failure of failedTransactions) {
+      await retryFailure(failure.id);
+    }
+  };
+
+  return (
+    <View>
+      <Text>{failedTransactions.length} failed</Text>
+      <Button onPress={retryAll}>Retry All</Button>
+      {failedTransactions.map(failure => (
+        <View key={failure.id}>
+          <Text>{failure.error.userMessage}</Text>
+          <Text>Retried {failure.retryCount} times</Text>
+          <Button onPress={() => retryFailure(failure.id)}>Retry</Button>
+          <Button onPress={() => clearFailure(failure.id)}>Dismiss</Button>
+        </View>
+      ))}
+    </View>
+  );
+}
+```
+
+### Failed Transaction Structure
+
+```typescript
+interface FailedTransaction {
+  id: string;
+  affectedTables: string[];
+  affectedEntityIds: string[];
+  error: SyncError;
+  retryCount: number;
+  lastAttemptAt: Date;
+  createdAt: Date;
+}
+
+interface SyncError {
+  type: 'network' | 'auth' | 'server' | 'conflict' | 'validation' | 'quota' | 'unknown';
+  message: string;
+  userMessage: string;
+  isPermanent: boolean;
+  code?: string;
+}
+```
+
+---
+
+## Attachments
+
+For detailed attachment documentation, see [docs/ATTACHMENTS.md](./docs/ATTACHMENTS.md).
+
+### Quick Setup
+
+```tsx
+<OfflineDataProvider
+  config={{
+    // ... other config
+    attachments: {
+      bucket: 'my-attachments',
+      watchIds: (db, onUpdate) => {
+        db.watch(
+          'SELECT storage_path as id FROM photos WHERE storage_path IS NOT NULL',
+          [],
+          { onResult: (r) => onUpdate(r.rows._array.map(row => row.id)) }
+        );
+      },
+      skipDownload: async ({ ids }) => {
+        // Skip video files
+        return ids.filter(id => id.endsWith('.mp4'));
+      },
+      maxCacheBytes: CACHE_SIZE_PRESETS.GB_1,
+    },
+  }}
+/>
+```
+
+### Upload Files
+
+```tsx
+const attachmentQueue = useAttachmentQueue();
+
+await attachmentQueue.queueUpload({
+  storagePath: `photos/${uuid()}.jpg`,
+  sourceUri: localFileUri,
+  filename: 'photo.jpg',
+  mediaType: 'image/jpeg',
+});
+```
+
+### Track Progress
+
+```tsx
+const [stats, setStats] = useState(null);
+
+useEffect(() => {
+  if (!attachmentQueue) return;
+  return attachmentQueue.onProgress(setStats);
+}, [attachmentQueue]);
+
+// stats.syncedCount - downloaded files
+// stats.pendingCount - queued for download
+// stats.pendingUploadCount - queued for upload
+// stats.failedPermanentCount - failed uploads
+```
+
+---
+
+## Conflict Handling
+
+Enable field-level conflict detection:
+
+```tsx
+<OfflineDataProvider
+  config={{
+    connector: {
+      conflictDetection: { enabled: true },
+    },
+  }}
+/>
+```
+
+### Conflict Structure
+
+```typescript
+interface ConflictCheckResult {
+  hasConflict: boolean;
+  conflicts: FieldConflict[];
+  nonConflictingChanges: string[];
+  table: string;
+  recordId: string;
+}
+
+interface FieldConflict {
+  field: string;
+  localValue: any;
+  serverValue: any;
+  changedBy: string;
+  changedAt: Date;
+}
+```
+
+### Resolution Options
+
+```typescript
+type ConflictResolution =
+  | { action: 'overwrite' }      // Use local, overwrite server
+  | { action: 'keep-server' }    // Discard local changes
+  | { action: 'partial'; fields: string[] }; // Sync specific fields only
+```
+
+---
+
+## Background Sync
+
+Configure background sync for React Native:
+
+```tsx
+<OfflineDataProvider
+  config={{
+    backgroundSync: {
+      enabled: true,
+      minimumInterval: 15, // minutes
+      callbacks: {
+        onSyncStart: () => console.log('Background sync starting'),
+        onSyncComplete: () => console.log('Background sync complete'),
+        onSyncError: (error) => console.error('Background sync failed:', error),
+      },
+    },
+  }}
+  onBackgroundSyncSystemReady={(system) => {
+    // Background sync system initialized
+    // Call system.signalReady() when app is ready
+  }}
+/>
+```
+
+---
+
+## Cache Management
+
+### Database Statistics
+
+```tsx
+import { useDatabaseMaintenance } from '@pol-studios/powersync';
+
+const { getCacheStats, compactDatabase, checkIntegrity, checkStorageQuota } = useDatabaseMaintenance();
+
+// Get table statistics
+const stats = await getCacheStats();
+// stats.totalRows, stats.totalTables
+// stats.tables: [{ name, rowCount, size, sizeFormatted }]
+// stats.storage: { used, usedFormatted, reclaimable }
+
+// Compact database (VACUUM)
+const result = await compactDatabase();
+// result.bytesReclaimed
+
+// Check integrity
+const integrity = await checkIntegrity();
+// integrity.ok, integrity.issues
+
+// Check device storage
+const quota = await checkStorageQuota();
+// quota.status: 'ok' | 'warning' | 'critical'
+// quota.freeSpace, quota.threshold
+```
+
+### Reset Cache
+
+```tsx
+import { useDatabase } from '@pol-studios/powersync';
+
+const db = useDatabase();
+
+// Clear synced data but keep local changes
+await db.disconnectAndClear({ clearLocal: false });
+
+// Then reconnect
+await triggerSync();
+```
+
+---
+
+## Error Handling
+
+### Error Boundary
+
+```tsx
+import { PowerSyncErrorBoundary } from '@pol-studios/powersync';
+
+function Screen() {
+  return (
+    <PowerSyncErrorBoundary
+      fallback={(error, retry) => (
+        <View>
+          <Text>Something went wrong: {error.message}</Text>
+          <Button onPress={retry}>Retry</Button>
+        </View>
+      )}
+    >
+      <ScreenContent />
+    </PowerSyncErrorBoundary>
+  );
+}
+```
+
+### Error Types
+
+```typescript
+import {
+  PowerSyncError,
+  InitializationError,
+  SyncOperationError,
+  ConnectorError,
+  AttachmentError,
+  ConfigurationError,
+} from '@pol-studios/powersync';
+
+// Check error type
+if (error instanceof SyncOperationError && error.retryable) {
+  // Can retry
+}
+```
+
+### Error Classification
+
+```typescript
+import { classifyError, classifySupabaseError } from '@pol-studios/powersync';
+
+// Classify any error
+const errorType = classifyError(error);
+// 'network' | 'auth' | 'server' | 'conflict' | 'validation' | 'quota' | 'unknown'
+
+// Classify Supabase/PostgreSQL error
+const classified = classifySupabaseError(error);
+// { type, isPermanent, userMessage }
+```
+
+---
+
+## Platform Adapters
+
+### Auto-Detection
+
+The platform is auto-detected. Override if needed:
+
+```tsx
+import { createNativePlatformAdapter } from '@pol-studios/powersync/platform';
+
+const platform = createNativePlatformAdapter({
+  debug: (...args) => console.debug('[PowerSync]', ...args),
+  info: (...args) => console.info('[PowerSync]', ...args),
+  warn: (...args) => console.warn('[PowerSync]', ...args),
+  error: (...args) => console.error('[PowerSync]', ...args),
+});
+
+<OfflineDataProvider
+  config={{
+    platform,
+    // ... other config
+  }}
+/>
+```
+
+### Platform Features
+
+```typescript
+interface PlatformAdapter {
+  createDatabase(options): PowerSyncDatabase;
+  fileSystem: FileSystemAdapter;
+  storage: AsyncStorageAdapter;
+  network: NetworkAdapter;
+  logger: LoggerAdapter;
+  imageProcessor?: ImageProcessorAdapter;
+}
+```
+
+---
+
+## API Reference
+
+### Import Paths
+
+```typescript
+// Main exports
+import {
+  OfflineDataProvider,
+  usePowerSync,
+  useDatabase,
+  useConnectionStatus,
+  useSyncActivityContext,
+  usePendingMutationsContext,
+  useFailedTransactionsContext,
+  useSyncControl,
+  useAttachmentQueue,
+  CACHE_SIZE_PRESETS,
+} from '@pol-studios/powersync';
+
+// Attachment types
+import type {
+  AttachmentConfig,
+  SkipDownloadContext,
+  PolAttachmentState,
+  AttachmentSyncStats,
+} from '@pol-studios/powersync/attachments';
+
+// Platform adapters
+import {
+  createNativePlatformAdapter,
+  createWebPlatformAdapter,
+} from '@pol-studios/powersync/platform';
+
+// Storage utilities
+import { createSupabaseStorage } from '@pol-studios/powersync/storage';
+
+// Core types
+import type {
+  SyncStatus,
+  SyncError,
+  CrudEntry,
+  FailedTransaction,
+  ConnectionHealth,
+  SyncMetrics,
+} from '@pol-studios/powersync/core';
+```
+
+### Default Values
+
+```typescript
+// Sync defaults
+DEFAULT_SYNC_CONFIG = {
+  autoConnect: true,
+  syncInterval: 0,
+  enableHealthMonitoring: true,
+  enableMetrics: true,
+};
+
+// Cache presets
+CACHE_SIZE_PRESETS = {
+  MB_250: 262144000,
+  MB_500: 524288000,
+  GB_1: 1073741824,
+  GB_2: 2147483648,
+  GB_5: 5368709120,
+  UNLIMITED: Number.MAX_SAFE_INTEGER,
+};
+
+// Upload retry defaults
+DEFAULT_UPLOAD_CONFIG = {
+  concurrency: 5,
+  timeoutMs: 120000,
+  baseRetryDelayMs: 30000,
+  maxRetryDelayMs: 3600000,
+  maxRetryCount: 100,
+};
+
+// Download defaults
+DEFAULT_DOWNLOAD_CONFIG = {
+  concurrency: 3,
+  timeoutMs: 120000,
+};
+```
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for development setup and guidelines.
+
+## Related Documentation
+
+- [Attachments Guide](./docs/ATTACHMENTS.md) - Detailed attachment system documentation
+- [PowerSync Documentation](https://docs.powersync.com) - Official PowerSync docs
+- [Supabase Documentation](https://supabase.com/docs) - Supabase integration