Dropped sql.js temp package. Using dev release from standalone project.

Author: Chriztiaan

packages/dev-adapter/README.md

@@ -1,3 +1,89 @@
 # PowerSync SDK Dev Adapter
 
-A very small development DB Adapter for PowerSync which uses [SQL.js](https://sql.js.org/#/)
+A development DB Adapter for PowerSync which uses [SQL.js](https://sql.js.org/#/)
+
+## Usage
+
+By default the SQLJS adapter will be in-memory. Read further for persistor examples.
+
+```tsx
+import { SQLJSOpenFactory } from '@powersync/dev-adapter';
+
+powersync = new PowerSyncDatabase({
+  schema: AppSchema,
+  database: new SQLJSOpenFactory({
+    dbFilename: 'powersync.db'
+  })
+});
+```
+
+````
+
+## Persister examples
+
+### Expo
+
+We can use the [Expo File System](https://docs.expo.dev/versions/latest/sdk/filesystem/) to persist the database in an Expo app.
+
+```tsx
+import { SQLJSPersister } from '@powersync/dev-adapter';
+import * as FileSystem from 'expo-file-system';
+
+const createSQLJSPersister = (dbFilename: string): SQLJSPersister => {
+  const dbPath = `${FileSystem.documentDirectory}${dbFilename}`;
+
+  return {
+    readFile: async (): Promise<ArrayLike<number> | Buffer | null> => {
+      try {
+        const fileInfo = await FileSystem.getInfoAsync(dbPath);
+        if (!fileInfo.exists) {
+          return null;
+        }
+
+        const result = await FileSystem.readAsStringAsync(dbPath, {
+          encoding: FileSystem.EncodingType.Base64
+        });
+
+        const binary = atob(result);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+      } catch (error) {
+        console.error('Error reading database file:', error);
+        return null;
+      }
+    },
+
+    writeFile: async (data: ArrayLike<number> | Buffer): Promise<void> => {
+      try {
+        const uint8Array = new Uint8Array(data);
+        const binary = Array.from(uint8Array, (byte) => String.fromCharCode(byte)).join('');
+        const base64 = btoa(binary);
+
+        await FileSystem.writeAsStringAsync(dbPath, base64, {
+          encoding: FileSystem.EncodingType.Base64
+        });
+      } catch (error) {
+        console.error('Error writing database file:', error);
+        throw error;
+      }
+    }
+  };
+};
+````
+
+Which can then be used here
+
+```tsx
+import { SQLJSOpenFactory, SQLJSPersister } from '@powersync/dev-adapter';
+
+powersync = new PowerSyncDatabase({
+  schema: AppSchema,
+  database: new SQLJSOpenFactory({
+    dbFilename: 'powersync.db',
+    persister: createSQLJSPersister('powersync.db')
+  })
+});
+```

packages/dev-adapter/package.json

@@ -32,9 +32,12 @@
     "async-mutex": "^0.4.0"
   },
   "devDependencies": {
+    "@powersync/sql-js": "0.0.0-dev-20250711104904",
+    "@powersync/web": "workspace:*",
     "@rollup/plugin-alias": "^5.1.0",
     "@types/sql.js": "^1.4.9",
+    "chance": "^1.1.9",
     "rollup": "4.14.3",
-    "sql.js": "workspace:*"
+    "uuid": "^11.1.0"
   }
 }

packages/dev-adapter/src/SQLJSAdapter.ts

@@ -14,13 +14,18 @@ import {
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 // This uses a pure JS version which avoids the need for WebAssembly, which is not supported in React Native.
-import SQLJs from 'sql.js/dist/sql-asm.js';
+import SQLJs from '@powersync/sql-js/dist/sql-asm.js';
 
 export interface SQLJSPersister {
   readFile: () => Promise<ArrayLike<number> | Buffer | null>;
   writeFile: (data: ArrayLike<number> | Buffer) => Promise<void>;
 }
+
 export interface SQLJSOpenOptions extends SQLOpenOptions {
+  persister?: SQLJSPersister;
+}
+
+export interface ResolvedSQLJSOpenOptions extends SQLJSOpenOptions {
   persister: SQLJSPersister;
 }
 
@@ -53,6 +58,7 @@ export class SQLJSDBAdapter extends BaseObserver<DBAdapterListener> implements D
   protected tableUpdateCache: Set<string>;
   protected dbP: number | null;
   protected writeScheduler: ControlledExecutor<SQLJs.Database>;
+  protected options: ResolvedSQLJSOpenOptions;
 
   static sharedObserver = new TableObserver();
   protected disposeListener: () => void;
@@ -67,8 +73,9 @@ export class SQLJSDBAdapter extends BaseObserver<DBAdapterListener> implements D
     return this.options.dbFilename;
   }
 
-  constructor(protected options: SQLJSOpenOptions) {
+  constructor(options: SQLJSOpenOptions) {
     super();
+    this.options = this.resolveOptions(options);
     this.initPromise = this.init();
     this._db = null;
     this.tableUpdateCache = new Set<string>();
@@ -89,18 +96,27 @@ export class SQLJSDBAdapter extends BaseObserver<DBAdapterListener> implements D
     });
   }
 
+  protected resolveOptions(options: SQLJSOpenOptions): ResolvedSQLJSOpenOptions {
+    const persister = options.persister ?? {
+      readFile: async () => null,
+      writeFile: async () => {}
+    };
+    return {
+      ...options,
+      persister
+    };
+  }
+
   protected async init(): Promise<SQLJs.Database> {
-    console.log('Initializing SQL.js database with options');
     const SQL = await SQLJs({
       locateFile: (filename: any) => `../dist/${filename}`,
       print: (text) => {
         console.log('[stdout]', text);
       },
       printErr: (text) => {
-        console.warn('[stderr]', text);
+        console.error('[stderr]', text);
       }
     });
-    console.log('SQL.js loaded:');
     const existing = await this.options.persister.readFile();
     const db = new SQL.Database(existing);
     this.dbP = db['db'];
@@ -205,9 +221,26 @@ export class SQLJSDBAdapter extends BaseObserver<DBAdapterListener> implements D
     return this.writeLock((tx) => tx.executeRaw(query, params));
   }
 
-  executeBatch(query: string, params?: any[][]): Promise<QueryResult> {
-    // TODO
-    throw new Error('Method not implemented.');
+  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult> {
+    let totalRowsAffected = 0;
+    const db = await this.getDB();
+
+    try {
+      const stmt = db.prepare(query);
+
+      for (const paramSet of params) {
+        stmt.run(paramSet);
+        totalRowsAffected += db.getRowsModified();
+      }
+
+      stmt.free();
+
+      return {
+        rowsAffected: totalRowsAffected
+      };
+    } catch (error) {
+      throw error;
+    }
   }
 
   readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {

packages/dev-adapter/src/types.d.ts

@@ -0,0 +1,4 @@
+declare module '@powersync/sql-js/dist/sql-asm.js' {
+  import sqljs from 'sql.js/dist/sql-asm.js';
+  export default sqljs;
+}