@trainstar/synchro-react-native 0.1.0

package/src/hooks/useQuery.ts

@@ -0,0 +1,93 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { SynchroClient } from '../SynchroClient';
+import type { Row } from '../types';
+import type { SynchroError } from '../errors';
+
+interface UseQueryResult {
+  data: Row[];
+  loading: boolean;
+  error: SynchroError | null;
+  refresh: () => void;
+}
+
+function arraysEqual<T>(
+  a?: readonly T[],
+  b?: readonly T[]
+): boolean {
+  if (a === b) return true;
+  if (!a || !b) return !a && !b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function useStableArray<T>(value?: readonly T[]): readonly T[] | undefined {
+  const ref = useRef<readonly T[] | undefined>(value);
+  if (!arraysEqual(ref.current, value)) {
+    ref.current = value ? [...value] : value;
+  }
+  return ref.current;
+}
+
+export function useQuery(
+  client: SynchroClient,
+  sql: string,
+  params?: unknown[],
+  tables?: string[]
+): UseQueryResult {
+  const [data, setData] = useState<Row[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<SynchroError | null>(null);
+  const refreshCounter = useRef(0);
+  const [, setRefreshTrigger] = useState(0);
+  const stableParams = useStableArray(params);
+  const stableTables = useStableArray(tables);
+
+  const refresh = useCallback(() => {
+    refreshCounter.current += 1;
+    setRefreshTrigger(refreshCounter.current);
+  }, []);
+
+  useEffect(() => {
+    if (stableTables && stableTables.length > 0) {
+      // Reactive mode: use watch()
+      setLoading(true);
+      let firstResult = true;
+      const unsubscribe = client.watch(sql, stableParams as unknown[] | undefined, stableTables as string[], (rows) => {
+        setData(rows);
+        setError(null);
+        if (firstResult) {
+          setLoading(false);
+          firstResult = false;
+        }
+      });
+      return unsubscribe;
+    } else {
+      // One-shot mode: use query()
+      let cancelled = false;
+      setLoading(true);
+      client
+        .query(sql, stableParams as unknown[] | undefined)
+        .then((rows) => {
+          if (!cancelled) {
+            setData(rows);
+            setError(null);
+            setLoading(false);
+          }
+        })
+        .catch((err) => {
+          if (!cancelled) {
+            setError(err);
+            setLoading(false);
+          }
+        });
+      return () => {
+        cancelled = true;
+      };
+    }
+  }, [client, sql, stableParams, stableTables, refreshCounter.current]);
+
+  return { data, loading, error, refresh };
+}

package/src/hooks/useSyncStatus.ts

@@ -0,0 +1,17 @@
+import { useState, useEffect } from 'react';
+import type { SynchroClient } from '../SynchroClient';
+import type { SyncStatus } from '../types';
+
+export function useSyncStatus(client: SynchroClient): SyncStatus {
+  const [status, setStatus] = useState<SyncStatus>({
+    status: 'idle',
+    retryAt: null,
+  });
+
+  useEffect(() => {
+    const unsubscribe = client.onStatusChange(setStatus);
+    return unsubscribe;
+  }, [client]);
+
+  return status;
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+export { SynchroClient } from './SynchroClient';
+export { useQuery } from './hooks/useQuery';
+export { useSyncStatus } from './hooks/useSyncStatus';
+export { usePendingChanges } from './hooks/usePendingChanges';
+
+export type {
+  Row,
+  ExecResult,
+  BatchResult,
+  SQLStatement,
+  ColumnDef,
+  TableOptions,
+  Transaction,
+  CheckpointMode,
+  SyncStatus,
+  SyncStatusType,
+  ConflictEvent,
+  SynchroConfig,
+  Unsubscribe,
+} from './types';
+
+export {
+  SynchroError,
+  NotConnectedError,
+  SchemaNotLoadedError,
+  TableNotSyncedError,
+  UpgradeRequiredError,
+  SchemaMismatchError,
+  SnapshotRequiredError,
+  PushRejectedError,
+  NetworkError,
+  ServerError,
+  DatabaseError,
+  InvalidResponseError,
+  AlreadyStartedError,
+  NotStartedError,
+  TransactionTimeoutError,
+  mapNativeError,
+} from './errors';
+
+export type { PushResultItem } from './errors';

package/src/types.ts

@@ -0,0 +1,71 @@
+export type Row = Record<string, unknown>;
+
+export interface ExecResult {
+  rowsAffected: number;
+}
+
+export interface BatchResult {
+  totalRowsAffected: number;
+}
+
+export interface SQLStatement {
+  sql: string;
+  params?: unknown[];
+}
+
+export interface ColumnDef {
+  name: string;
+  type: string;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  defaultValue?: string;
+}
+
+export interface TableOptions {
+  ifNotExists?: boolean;
+  withoutRowid?: boolean;
+}
+
+export interface Transaction {
+  query(sql: string, params?: unknown[]): Promise<Row[]>;
+  queryOne(sql: string, params?: unknown[]): Promise<Row | null>;
+  execute(sql: string, params?: unknown[]): Promise<ExecResult>;
+}
+
+export type CheckpointMode = 'passive' | 'full' | 'restart' | 'truncate';
+
+export type SyncStatusType =
+  | 'idle'
+  | 'connecting'
+  | 'syncing'
+  | 'error'
+  | 'stopped';
+
+export interface SyncStatus {
+  status: SyncStatusType;
+  retryAt: Date | null;
+}
+
+export interface ConflictEvent {
+  table: string;
+  recordID: string;
+  clientData: Row | null;
+  serverData: Row | null;
+}
+
+export interface SynchroConfig {
+  dbPath: string;
+  serverURL: string;
+  authProvider: () => Promise<string>;
+  clientID: string;
+  platform?: string;
+  appVersion: string;
+  syncInterval?: number;
+  pushDebounce?: number;
+  maxRetryAttempts?: number;
+  pullPageSize?: number;
+  pushBatchSize?: number;
+  snapshotPageSize?: number;
+}
+
+export type Unsubscribe = () => void;