@powersync/react-native 1.26.0 → 1.26.1

package/src/sync/stream/ReactNativeRemote.ts

@@ -0,0 +1,98 @@
+import { ILogger } from 'js-logger';
+
+import {
+  AbstractRemote,
+  AbstractRemoteOptions,
+  BSONImplementation,
+  DEFAULT_REMOTE_LOGGER,
+  DataStream,
+  FetchImplementation,
+  FetchImplementationProvider,
+  RemoteConnector,
+  SyncStreamOptions
+} from '@powersync/common';
+import { Platform } from 'react-native';
+// Note docs for React Native https://github.com/mongodb/js-bson?tab=readme-ov-file#react-native
+import { BSON } from 'bson';
+import { TextDecoder } from 'text-encoding';
+
+import { fetch } from 'react-native-fetch-api';
+
+export const STREAMING_POST_TIMEOUT_MS = 30_000;
+
+/**
+ * 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 class ReactNativeRemote extends AbstractRemote {
+  constructor(
+    protected connector: RemoteConnector,
+    protected logger: ILogger = DEFAULT_REMOTE_LOGGER,
+    options?: Partial<AbstractRemoteOptions>
+  ) {
+    super(connector, logger, {
+      ...(options ?? {}),
+      fetchImplementation: options?.fetchImplementation ?? new ReactNativeFetchProvider()
+    });
+  }
+
+  getUserAgent(): string {
+    return [
+      super.getUserAgent(),
+      `powersync-react-native`,
+      `react-native/${Platform.constants.reactNativeVersion.major}.${Platform.constants.reactNativeVersion.minor}`,
+      `${Platform.OS}/${Platform.Version}`
+    ].join(' ');
+  }
+
+  async getBSON(): Promise<BSONImplementation> {
+    return BSON;
+  }
+
+  protected createTextDecoder(): TextDecoder {
+    return new TextDecoder();
+  }
+
+  async postStreamRaw<T>(options: SyncStreamOptions, mapLine: (line: string) => T): Promise<DataStream<T>> {
+    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.postStreamRaw(
+        {
+          ...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 }
+          }
+        },
+        mapLine
+      );
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+}

package/src/sync/stream/ReactNativeStreamingSyncImplementation.ts

@@ -0,0 +1,55 @@
+import {
+  AbstractStreamingSyncImplementation,
+  AbstractStreamingSyncImplementationOptions,
+  LockOptions,
+  LockType
+} from '@powersync/common';
+import { Mutex } from 'async-mutex';
+
+/**
+ * Global locks which prevent multiple instances from syncing
+ * concurrently.
+ */
+const LOCKS = new Map<string, Map<LockType, Mutex>>();
+
+export class ReactNativeStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+  locks: Map<LockType, Mutex>;
+
+  constructor(options: AbstractStreamingSyncImplementationOptions) {
+    super(options);
+    this.initLocks();
+  }
+
+  /**
+   *  Configures global locks on sync process
+   */
+  initLocks() {
+    const { identifier } = this.options;
+    if (identifier && LOCKS.has(identifier)) {
+      this.locks = LOCKS.get(identifier)!;
+      return;
+    }
+
+    this.locks = new Map<LockType, Mutex>();
+    this.locks.set(LockType.CRUD, new Mutex());
+    this.locks.set(LockType.SYNC, new Mutex());
+
+    if (identifier) {
+      LOCKS.set(identifier, this.locks);
+    }
+  }
+
+  obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
+    const lock = this.locks.get(lockOptions.type);
+    if (!lock) {
+      throw new Error(`Lock type ${lockOptions.type} not found`);
+    }
+    return lock.runExclusive(async () => {
+      if (lockOptions.signal?.aborted) {
+        throw new Error('Aborted');
+      }
+
+      return lockOptions.callback();
+    });
+  }
+}