@powersync/node 0.12.0 → 0.14.0

package/src/sync/stream/NodeRemote.ts

@@ -0,0 +1,123 @@
+import * as os from 'node:os';
+
+import {
+  type ILogger,
+  AbstractRemote,
+  AbstractRemoteOptions,
+  BSONImplementation,
+  DEFAULT_REMOTE_LOGGER,
+  FetchImplementation,
+  FetchImplementationProvider,
+  RemoteConnector
+} from '@powersync/common';
+import { BSON } from 'bson';
+import {
+  Dispatcher,
+  EnvHttpProxyAgent,
+  ErrorEvent,
+  getGlobalDispatcher,
+  ProxyAgent,
+  WebSocket as UndiciWebSocket
+} from 'undici';
+
+export const STREAMING_POST_TIMEOUT_MS = 30_000;
+
+class NodeFetchProvider extends FetchImplementationProvider {
+  getFetch(): FetchImplementation {
+    return fetch.bind(globalThis);
+  }
+}
+
+export type NodeCustomConnectionOptions = {
+  /**
+   * Optional custom dispatcher for HTTP or WEB_SOCKET connections.
+   *
+   * This can be used to customize proxy usage (using undici ProxyAgent),
+   * or other connection options.
+   */
+  dispatcher?: Dispatcher;
+};
+
+export type NodeRemoteOptions = AbstractRemoteOptions & NodeCustomConnectionOptions;
+
+export class NodeRemote extends AbstractRemote {
+  private wsDispatcher: Dispatcher | undefined;
+
+  constructor(
+    protected connector: RemoteConnector,
+    protected logger: ILogger = DEFAULT_REMOTE_LOGGER,
+    options?: Partial<NodeRemoteOptions>
+  ) {
+    const fetchDispatcher = options?.dispatcher ?? defaultFetchDispatcher();
+
+    super(connector, logger, {
+      fetchImplementation: options?.fetchImplementation ?? new NodeFetchProvider(),
+      fetchOptions: {
+        dispatcher: fetchDispatcher
+      },
+      ...(options ?? {})
+    });
+
+    this.wsDispatcher = options?.dispatcher;
+  }
+
+  protected createSocket(url: string): globalThis.WebSocket {
+    // Create dedicated dispatcher for this WebSocket
+    const baseDispatcher = this.getWebsocketDispatcher(url);
+
+    // Create WebSocket with dedicated dispatcher
+    const ws = new UndiciWebSocket(url, {
+      dispatcher: baseDispatcher,
+      headers: {
+        'User-Agent': this.getUserAgent()
+      }
+    });
+
+    return ws as globalThis.WebSocket;
+  }
+
+  protected getWebsocketDispatcher(url: string) {
+    if (this.wsDispatcher != null) {
+      return this.wsDispatcher;
+    }
+
+    const protocol = new URL(url).protocol.replace(':', '');
+    const proxy = getProxyForProtocol(protocol);
+    if (proxy != null) {
+      return new ProxyAgent(proxy);
+    } else {
+      return getGlobalDispatcher();
+    }
+  }
+
+  getUserAgent(): string {
+    return [
+      super.getUserAgent(),
+      `powersync-node`,
+      `node/${process.versions.node}`,
+      `${os.platform()}/${os.release()}`
+    ].join(' ');
+  }
+
+  async getBSON(): Promise<BSONImplementation> {
+    return BSON;
+  }
+}
+
+function defaultFetchDispatcher(): Dispatcher {
+  // EnvHttpProxyAgent automatically uses HTTP_PROXY, HTTPS_PROXY and NO_PROXY env vars by default.
+  // We add ALL_PROXY support.
+  return new EnvHttpProxyAgent({
+    httpProxy: getProxyForProtocol('http'),
+    httpsProxy: getProxyForProtocol('https')
+  });
+}
+
+function getProxyForProtocol(protocol: string): string | undefined {
+  return (
+    process.env[`${protocol.toLowerCase()}_proxy`] ??
+    process.env[`${protocol.toUpperCase()}_PROXY`] ??
+    process.env[`all_proxy`] ??
+    process.env[`ALL_PROXY`]
+  );
+}

package/src/sync/stream/NodeStreamingSyncImplementation.ts

@@ -0,0 +1,57 @@
+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>>();
+
+const lockTypes = new Set(Object.values(LockType));
+
+export class NodeStreamingSyncImplementation 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();
+    });
+  }
+}

package/src/utils/modules.ts

@@ -0,0 +1,6 @@
+// Note: When updating this file, always update module_commonjs.ts as well.
+export const isBundledToCommonJs: boolean = false;
+
+export async function dynamicImport(path: string) {
+  return await import(path);
+}

package/src/utils/modules_commonjs.ts

@@ -0,0 +1,7 @@
+// NOTE! Do not import this file directly! We have a rollup plugin that rewrites imports to modules.js to this file when
+// bundling to CommonJS.
+export const isBundledToCommonJs: boolean = true;
+
+export async function dynamicImport(path: string) {
+  return require(path);
+}

package/src/worker.ts

@@ -0,0 +1 @@
+export * from './db/SqliteWorker.js';