@powersync/node 0.3.0 → 0.4.1

package/download_core.js

@@ -1,4 +1,5 @@
 // TODO: Make this a pre-publish hook and just bundle everything
+import { createHash } from 'node:crypto';
 import * as OS from 'node:os';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
@@ -6,7 +7,15 @@ import { Readable } from 'node:stream';
 import { finished } from 'node:stream/promises';
 import { exit } from 'node:process';
 
-const version = '0.3.11';
+// When changing this version, run node download_core.js update_hashes
+const version = '0.3.14';
+const versionHashes = {
+  'powersync_x64.dll': 'ba0fda2496878d195ea5530562509cc585fa4702fd308594d0eef6f37060dafe',
+  'libpowersync_x64.so': '4cee8675b78af786f26f1e1666367de3d228f584084cca257e879060302c1371',
+  'libpowersync_aarch64.so': 'ed4ec55cb29ac4b295dc076de71e4247b08d46db562a53e2875cc47420a97a55',
+  'libpowersync_x64.dylib': 'cec6fb04732dd8c9a8ec6c6028b1b996965a0a359b0461d7dd6aa885d6eccddf',
+  'libpowersync_aarch64.dylib': '55b60e156c3ddc9e7d6fae273943b94b83481c861676c9bcd1e2cfcea02b0a18'
+};
 
 const platform = OS.platform();
 let destination;
@@ -23,24 +32,68 @@ if (platform === 'win32') {
   destination = 'libpowersync.dylib';
 }
 
+const expectedHash = versionHashes[asset];
 const destinationPath = path.resolve('lib', destination);
-try {
-  await fs.access(destinationPath);
-  exit(0);
-} catch {}
-
-const url = `https://github.com/powersync-ja/powersync-sqlite-core/releases/download/v${version}/${asset}`;
-const response = await fetch(url);
-if (response.status != 200) {
-  throw `Could not download ${url}`;
-}
 
-try {
-  await fs.access('lib');
-} catch {
-  await fs.mkdir('lib');
-}
+const hashStream = async (input) => {
+  for await (const chunk of input.pipe(createHash('sha256')).setEncoding('hex')) {
+    return chunk;
+  }
+};
+
+const hashLocal = async () => {
+  try {
+    const handle = await fs.open(destinationPath, 'r');
+    const input = handle.createReadStream();
+
+    const result = await hashStream(input);
+    await handle.close();
+    return result;
+  } catch {
+    return null;
+  }
+};
+
+const download = async () => {
+  if ((await hashLocal()) == expectedHash) {
+    console.debug('Local copy is up-to-date, skipping download');
+    exit(0);
+  }
+
+  const url = `https://github.com/powersync-ja/powersync-sqlite-core/releases/download/v${version}/${asset}`;
+  const response = await fetch(url);
+  if (response.status != 200) {
+    throw `Could not download ${url}`;
+  }
 
-const file = await fs.open(destinationPath, 'w');
-await finished(Readable.fromWeb(response.body).pipe(file.createWriteStream()));
-await file.close();
+  try {
+    await fs.access('lib');
+  } catch {
+    await fs.mkdir('lib');
+  }
+
+  const file = await fs.open(destinationPath, 'w');
+  await finished(Readable.fromWeb(response.body).pipe(file.createWriteStream()));
+  await file.close();
+
+  const hashAfterDownloading = await hashLocal();
+  if (hashAfterDownloading != expectedHash) {
+    throw `Unexpected hash after downloading (got ${hashAfterDownloading}, expected ${expectedHash})`;
+  }
+};
+
+const updateReferenceHashes = async () => {
+  for (const asset of Object.keys(versionHashes)) {
+    const url = `https://github.com/powersync-ja/powersync-sqlite-core/releases/download/v${version}/${asset}`;
+    const response = await fetch(url);
+    const hash = await hashStream(Readable.fromWeb(response.body));
+
+    console.log(`  '${asset}': '${hash}',`);
+  }
+};
+
+if (process.argv[process.argv.length - 1] == 'update_hashes') {
+  await updateReferenceHashes();
+} else {
+  await download();
+}

package/lib/db/PowerSyncDatabase.d.ts

@@ -1,8 +1,14 @@
-import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, AdditionalConnectionOptions, BucketStorageAdapter, DBAdapter, PowerSyncBackendConnector, PowerSyncConnectionOptions, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithSettings, SQLOpenFactory } from '@powersync/common';
+import { AbstractPowerSyncDatabase, AbstractRemoteOptions, AbstractStreamingSyncImplementation, AdditionalConnectionOptions, BucketStorageAdapter, DBAdapter, PowerSyncBackendConnector, PowerSyncConnectionOptions, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithSettings, SQLOpenFactory } from '@powersync/common';
 import { NodeSQLOpenOptions } from './options.js';
 import { Dispatcher } from 'undici';
 export type NodePowerSyncDatabaseOptions = PowerSyncDatabaseOptions & {
     database: DBAdapter | SQLOpenFactory | NodeSQLOpenOptions;
+    /**
+     * Options to override how the SDK will connect to the sync service.
+     *
+     * This option is intended to be used for internal tests.
+     */
+    remoteOptions?: Partial<AbstractRemoteOptions>;
 };
 export type NodeAdditionalConnectionOptions = AdditionalConnectionOptions & {
     /**

package/lib/db/PowerSyncDatabase.js

@@ -36,7 +36,10 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         return super.connect(connector, options);
     }
     generateSyncStreamImplementation(connector, options) {
-        const remote = new NodeRemote(connector, this.options.logger, { dispatcher: options.dispatcher });
+        const remote = new NodeRemote(connector, this.options.logger, {
+            dispatcher: options.dispatcher,
+            ...this.options.remoteOptions
+        });
         return new NodeStreamingSyncImplementation({
             adapter: this.bucketStorageAdapter,
             remote,

package/lib/db/RemoteConnection.d.ts

@@ -11,6 +11,11 @@ export declare class RemoteConnection implements LockContext {
     private readonly comlink;
     readonly database: Remote<AsyncDatabase>;
     constructor(worker: Worker, comlink: Remote<AsyncDatabaseOpener>, database: Remote<AsyncDatabase>);
+    /**
+     * Runs the inner function, but appends the stack trace where this function was called. This is useful for workers
+     * because stack traces from worker errors are otherwise unrelated to the application issue that has caused them.
+     */
+    private recoverTrace;
     executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
     execute(query: string, params?: any[] | undefined): Promise<QueryResult>;
     executeRaw(query: string, params?: any[] | undefined): Promise<any[][]>;

package/lib/db/RemoteConnection.js

@@ -12,16 +12,39 @@ export class RemoteConnection {
         this.comlink = comlink;
         this.database = database;
     }
-    async executeBatch(query, params = []) {
-        const result = await this.database.executeBatch(query, params ?? []);
-        return RemoteConnection.wrapQueryResult(result);
+    /**
+     * Runs the inner function, but appends the stack trace where this function was called. This is useful for workers
+     * because stack traces from worker errors are otherwise unrelated to the application issue that has caused them.
+     */
+    async recoverTrace(inner) {
+        const trace = {};
+        Error.captureStackTrace(trace);
+        try {
+            return await inner();
+        }
+        catch (e) {
+            if (e instanceof Error && e.stack) {
+                e.stack += trace.stack;
+            }
+            throw e;
+        }
+    }
+    executeBatch(query, params = []) {
+        return this.recoverTrace(async () => {
+            const result = await this.database.executeBatch(query, params ?? []);
+            return RemoteConnection.wrapQueryResult(result);
+        });
     }
-    async execute(query, params) {
-        const result = await this.database.execute(query, params ?? []);
-        return RemoteConnection.wrapQueryResult(result);
+    execute(query, params) {
+        return this.recoverTrace(async () => {
+            const result = await this.database.execute(query, params ?? []);
+            return RemoteConnection.wrapQueryResult(result);
+        });
     }
-    async executeRaw(query, params) {
-        return await this.database.executeRaw(query, params ?? []);
+    executeRaw(query, params) {
+        return this.recoverTrace(async () => {
+            return await this.database.executeRaw(query, params ?? []);
+        });
     }
     async getAll(sql, parameters) {
         const res = await this.execute(sql, parameters);

package/lib/sync/stream/NodeRemote.js

@@ -17,11 +17,11 @@ export class NodeRemote extends AbstractRemote {
         // EnvHttpProxyAgent automatically uses relevant env vars for HTTP
         const dispatcher = options?.dispatcher ?? new EnvHttpProxyAgent();
         super(connector, logger, {
-            ...(options ?? {}),
             fetchImplementation: options?.fetchImplementation ?? new NodeFetchProvider(),
             fetchOptions: {
                 dispatcher
-            }
+            },
+            ...(options ?? {})
         });
         this.connector = connector;
         this.logger = logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/node",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -36,7 +36,7 @@
   },
   "homepage": "https://docs.powersync.com/",
   "peerDependencies": {
-    "@powersync/common": "^1.28.0"
+    "@powersync/common": "^1.30.0"
   },
   "dependencies": {
     "@powersync/better-sqlite3": "^0.1.1",
@@ -46,7 +46,7 @@
     "proxy-agent": "^6.5.0",
     "undici": "^7.8.0",
     "ws": "^8.18.1",
-    "@powersync/common": "1.28.0"
+    "@powersync/common": "1.30.0"
   },
   "devDependencies": {
     "@types/async-lock": "^1.4.0",