@powersync/react-native 0.0.0-dev-20260525085311 → 0.0.0-dev-20260630141119

package/src/db/adapters/op-sqlite/SqliteOptions.ts

@@ -0,0 +1,93 @@
+export interface SqliteOptions {
+  /**
+   * SQLite journal mode. Defaults to [SqliteJournalMode.wal].
+   */
+  journalMode?: SqliteJournalMode;
+
+  /**
+   * SQLite synchronous flag. Defaults to [SqliteSynchronous.normal], which
+   * is safe for WAL mode.
+   */
+  synchronous?: SqliteSynchronous;
+
+  /**
+   * Journal/WAL size limit. Defaults to 6MB.
+   * The WAL may grow larger than this limit during writes, but SQLite will
+   * attempt to truncate the file afterwards.
+   */
+  journalSizeLimit?: number;
+
+  /**
+   * Timeout in milliseconds waiting for locks to be released by other connections.
+   * Defaults to 30 seconds.
+   * Set to null or zero to fail immediately when the database is locked.
+   */
+  lockTimeoutMs?: number;
+
+  /**
+   * Encryption key for the database.
+   * If set, the database will be encrypted using SQLCipher.
+   */
+  encryptionKey?: string | null;
+
+  /**
+   * Where to store SQLite temporary files. Defaults to 'MEMORY'.
+   * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
+   *
+   * For details, see: https://www.sqlite.org/pragma.html#pragma_temp_store
+   */
+  temporaryStorage?: TemporaryStorageOption;
+
+  /**
+   * Maximum SQLite cache size. Defaults to 50MB.
+   *
+   * For details, see: https://www.sqlite.org/pragma.html#pragma_cache_size
+   */
+  cacheSizeKb?: number;
+
+  /**
+   * Load extensions using the path and entryPoint.
+   * More info can be found here https://op-engineering.github.io/op-sqlite/docs/api#loading-extensions.
+   */
+  extensions?: Array<{
+    path: string;
+    entryPoint?: string;
+  }>;
+}
+
+export enum TemporaryStorageOption {
+  MEMORY = 'memory',
+  FILESYSTEM = 'file'
+}
+
+// SQLite journal mode. Set on the primary connection.
+// This library is written with WAL mode in mind - other modes may cause
+// unexpected locking behavior.
+enum SqliteJournalMode {
+  // Use a write-ahead log instead of a rollback journal.
+  // This provides good performance and concurrency.
+  wal = 'WAL',
+  delete = 'DELETE',
+  truncate = 'TRUNCATE',
+  persist = 'PERSIST',
+  memory = 'MEMORY',
+  off = 'OFF'
+}
+
+// SQLite file commit mode.
+enum SqliteSynchronous {
+  normal = 'NORMAL',
+  full = 'FULL',
+  off = 'OFF'
+}
+
+export const DEFAULT_SQLITE_OPTIONS: Required<SqliteOptions> = {
+  journalMode: SqliteJournalMode.wal,
+  synchronous: SqliteSynchronous.normal,
+  journalSizeLimit: 6 * 1024 * 1024,
+  cacheSizeKb: 50 * 1024,
+  temporaryStorage: TemporaryStorageOption.MEMORY,
+  lockTimeoutMs: 30000,
+  encryptionKey: null,
+  extensions: []
+};

package/src/index.ts

@@ -3,8 +3,6 @@ export * from '@powersync/common';
 export * from '@powersync/react';
 
 export * from './db/PowerSyncDatabase';
-export * from './db/adapters/react-native-quick-sqlite/RNQSDBAdapter';
-export * from './db/adapters/react-native-quick-sqlite/RNQSDBOpenFactory';
+export { PowerSyncFetchImplementation } from './sync/stream/fetch';
 export * from './sync/stream/ReactNativeRemote';
 export * from './sync/stream/ReactNativeStreamingSyncImplementation';
-export * from './db/adapters/react-native-quick-sqlite/ReactNativeQuickSQLiteOpenFactory';

package/src/sync/bucket/ReactNativeBucketStorageAdapter.ts

@@ -1,4 +1,4 @@
-import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/common';
+import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/shared-internals';
 
 export class ReactNativeBucketStorageAdapter extends SqliteBucketStorage {
   control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string> {

package/src/sync/stream/ReactNativeRemote.ts

@@ -1,60 +1,63 @@
-import {
-  AbstractRemote,
-  AbstractRemoteOptions,
-  DEFAULT_REMOTE_LOGGER,
-  FetchImplementation,
-  FetchImplementationProvider,
-  ILogger,
-  RemoteConnector,
-  SyncStreamOptions
-} from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { AbstractRemote, FetchOptions, RemoteConnector } from '@powersync/shared-internals';
 import { Platform } from 'react-native';
-import { TextDecoder } from 'text-encoding';
-
-import { fetch } from 'react-native-fetch-api';
+import { WebSocketSupport, WebSocketSyncStreamPlatform } from '@powersync/shared-internals/websockets';
+import { defaultFetchImplementation, PowerSyncFetchImplementation } from './fetch';
 
 export const STREAMING_POST_TIMEOUT_MS = 30_000;
 
-type ReactNativeFetchOptions = RequestInit & {
-  reactNative?: Record<string, unknown>;
-};
-
-/**
- * Directly imports fetch implementation from react-native-fetch-api.
- * This removes the requirement for the global `fetch` to be overridden by
- * a polyfill.
- */
-class ReactNativeFetchProvider extends FetchImplementationProvider {
-  getFetch(): FetchImplementation {
-    return fetch.bind(globalThis);
-  }
+export interface ReactNativeRemoteOptions {
+  fetchImplementation?: PowerSyncFetchImplementation;
 }
 
 export class ReactNativeRemote extends AbstractRemote {
   constructor(
     protected connector: RemoteConnector,
-    protected logger: ILogger = DEFAULT_REMOTE_LOGGER,
-    options?: Partial<AbstractRemoteOptions>
+    logger: PowerSyncLogger,
+    readonly options?: ReactNativeRemoteOptions
   ) {
-    super(connector, logger, {
-      ...(options ?? {}),
-      fetchImplementation: options?.fetchImplementation ?? new ReactNativeFetchProvider()
-    });
+    super(connector, logger);
   }
 
-  get fetch(): FetchImplementation {
-    const fetchImplementation = super.fetch;
-    return ((input, init) => {
-      const options = (init ?? {}) as ReactNativeFetchOptions;
+  protected async fetch(options: FetchOptions): Promise<Response> {
+    let timeout: ReturnType<typeof setTimeout> | null = null;
+    const { expectStreamingResponse } = options;
+    if (expectStreamingResponse) {
+      timeout =
+        Platform.OS == 'android'
+          ? setTimeout(() => {
+              this.logger.log({
+                level: LogLevels.warn,
+                message: `HTTP Streaming POST is taking longer than ${Math.ceil(
+                  STREAMING_POST_TIMEOUT_MS / 1000
+                )} seconds to resolve. If using a debug build, please ensure Flipper Network plugin is disabled.`
+              });
+            }, STREAMING_POST_TIMEOUT_MS)
+          : null;
+    }
+
+    try {
+      const fetchImpl = this.options?.fetchImplementation ?? defaultFetchImplementation(this.logger);
+
+      if (expectStreamingResponse && !fetchImpl.supportsStreams) {
+        // We can't fall back to the default fetch() implementation since we need a response stream.
+        const errorMessage =
+          'The PowerSync SDK requires a fetch() implementation capable of streaming responses, which React Native ' +
+          'does not support natively. The SDK was unable to import `expo/fetch`. ' +
+          "If you're not using expo, consider passing a custom fetchImplementation via the remote option on " +
+          'the PowerSyncDatabase constructor, or use `SyncStreamConnectionMethod.WEB_SOCKET` on your connect() call.';
+
+        throw new Error(errorMessage);
+      }
+
+      return fetchImpl.run(options);
+    } finally {
+      if (timeout != null) clearTimeout(timeout);
+    }
+  }
 
-      return fetchImplementation(input, {
-        ...options,
-        reactNative: {
-          ...(options.reactNative ?? {}),
-          textStreaming: true
-        }
-      } as RequestInit);
-    }) as FetchImplementation;
+  protected loadWebSocketSupport(platform: WebSocketSyncStreamPlatform): Promise<WebSocketSupport> {
+    return Promise.resolve((websockets ??= new WebSocketSupport(platform)));
   }
 
   getUserAgent(): string {
@@ -65,46 +68,6 @@ export class ReactNativeRemote extends AbstractRemote {
       `${Platform.OS}/${Platform.Version}`
     ].join(' ');
   }
-
-  createTextDecoder(): TextDecoder {
-    return new TextDecoder();
-  }
-
-  protected get supportsStreamingBinaryResponses(): boolean {
-    // We have to pass textStreaming: true to get streamed responses at all, and those don't support binary data.
-    return false;
-  }
-
-  protected async fetchStreamRaw(options: SyncStreamOptions) {
-    const timeout =
-      Platform.OS == 'android'
-        ? setTimeout(() => {
-            this.logger.warn(
-              `HTTP Streaming POST is taking longer than ${Math.ceil(
-                STREAMING_POST_TIMEOUT_MS / 1000
-              )} seconds to resolve. If using a debug build, please ensure Flipper Network plugin is disabled.`
-            );
-          }, STREAMING_POST_TIMEOUT_MS)
-        : null;
-
-    try {
-      return await super.fetchStreamRaw({
-        ...options,
-        fetchOptions: {
-          ...options.fetchOptions,
-          /**
-           * The `react-native-fetch-api` polyfill provides streaming support via
-           * this non-standard flag
-           * https://github.com/react-native-community/fetch#enable-text-streaming
-           */
-          // @ts-expect-error https://github.com/react-native-community/fetch#enable-text-streaming
-          reactNative: { textStreaming: true }
-        }
-      });
-    } finally {
-      if (timeout) {
-        clearTimeout(timeout);
-      }
-    }
-  }
 }
+
+let websockets: WebSocketSupport | undefined;

package/src/sync/stream/ReactNativeStreamingSyncImplementation.ts

@@ -2,9 +2,9 @@ import {
   AbstractStreamingSyncImplementation,
   AbstractStreamingSyncImplementationOptions,
   LockOptions,
-  LockType,
-  Mutex
-} from '@powersync/common';
+  LockType
+} from '@powersync/shared-internals';
+import { Mutex } from '@powersync/shared-internals';
 
 /**
  * Global locks which prevent multiple instances from syncing
@@ -13,7 +13,7 @@ import {
 const LOCKS = new Map<string, Map<LockType, Mutex>>();
 
 export class ReactNativeStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
-  locks: Map<LockType, Mutex>;
+  locks!: Map<LockType, Mutex>;
 
   constructor(options: AbstractStreamingSyncImplementationOptions) {
     super(options);

package/src/sync/stream/fetch.ts

@@ -0,0 +1,45 @@
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { FetchOptions } from '@powersync/shared-internals';
+
+export interface PowerSyncFetchImplementation {
+  /**
+   * Whether this fetch implementation supports streaming responses.
+   *
+   * The PowerSync service delivers sync data through a streaming (`Transfer-Encoding: chunked`) response, which is not
+   * supported by the default `fetch` polyfill on React Native.
+   */
+  readonly supportsStreams: boolean;
+  run(options: FetchOptions): Promise<Response>;
+}
+
+export function defaultFetchImplementation(logger: PowerSyncLogger): PowerSyncFetchImplementation {
+  return (resolvedDefault ??= resolveDefaultFetchImplementation(logger));
+}
+
+let resolvedDefault: PowerSyncFetchImplementation | undefined;
+
+function resolveDefaultFetchImplementation(logger: PowerSyncLogger): PowerSyncFetchImplementation {
+  try {
+    const { fetch } = require('expo/fetch');
+    return {
+      supportsStreams: true,
+      run({ resource, request }) {
+        return fetch(resource, request);
+      }
+    };
+  } catch (expoNotFound) {
+    logger.log({
+      level: LogLevels.debug,
+      message: 'Could not resolve expo/fetch, HTTP streams are unavailable.',
+      error: expoNotFound
+    });
+
+    // Fetch polyfill built in to React Native. This one doesn't support streaming responses.
+    return {
+      supportsStreams: false,
+      run({ resource, request }) {
+        return fetch(resource, request);
+      }
+    };
+  }
+}