Added executeRaw to @powersync/node.

Author: Chriztiaan

packages/node/package.json

@@ -45,6 +45,8 @@
   },
   "devDependencies": {
     "@types/async-lock": "^1.4.0",
+    "drizzle-orm": "^0.35.2",
+    "@powersync/drizzle-driver": "workspace:*",
     "typescript": "^5.5.3",
     "vitest": "^3.0.5"
   },

packages/node/src/db/AsyncDatabase.ts

@@ -13,6 +13,7 @@ export interface AsyncDatabaseOpener {
 
 export interface AsyncDatabase {
   execute: (query: string, params: any[]) => Promise<ProxiedQueryResult>;
+  executeRaw: (query: string, params: any[]) => Promise<any[][]>;
   executeBatch: (query: string, params: any[][]) => Promise<ProxiedQueryResult>;
   close: () => Promise<void>;
   // Collect table updates made since the last call to collectCommittedUpdates.

packages/node/src/db/BetterSQLite3DBAdapter.ts

@@ -53,7 +53,9 @@ export class BetterSQLite3DBAdapter extends BaseObserver<DBAdapterListener> impl
     }
 
     const openWorker = async (isWriter: boolean) => {
-      const worker = new Worker(new URL('./SqliteWorker.js', import.meta.url), {name: isWriter ? `write ${dbFilePath}` : `read ${dbFilePath}`});
+      const worker = new Worker(new URL('./SqliteWorker.js', import.meta.url), {
+        name: isWriter ? `write ${dbFilePath}` : `read ${dbFilePath}`
+      });
       const listeners = new WeakMap<EventListenerOrEventListenerObject, (e: any) => void>();
 
       const comlink = Comlink.wrap<AsyncDatabaseOpener>({
@@ -216,6 +218,7 @@ export class BetterSQLite3DBAdapter extends BaseObserver<DBAdapterListener> impl
       await connection.execute('BEGIN');
       const result = await fn({
         execute: (query, params) => connection.execute(query, params),
+        executeRaw: (query, params) => connection.executeRaw(query, params),
         executeBatch: (query, params) => connection.executeBatch(query, params),
         get: (query, params) => connection.get(query, params),
         getAll: (query, params) => connection.getAll(query, params),
@@ -252,6 +255,10 @@ export class BetterSQLite3DBAdapter extends BaseObserver<DBAdapterListener> impl
     return this.writeLock((ctx) => ctx.execute(query, params));
   }
 
+  executeRaw(query: string, params?: any[] | undefined): Promise<any[][]> {
+    return this.writeLock((ctx) => ctx.executeRaw(query, params));
+  }
+
   executeBatch(query: string, params?: any[][]): Promise<QueryResult> {
     return this.writeTransaction((ctx) => ctx.executeBatch(query, params));
   }

packages/node/src/db/RemoteConnection.ts

@@ -29,6 +29,10 @@ export class RemoteConnection implements LockContext {
     return RemoteConnection.wrapQueryResult(result);
   }
 
+  async executeRaw(query: string, params?: any[] | undefined): Promise<any[][]> {
+    return await this.database.executeRaw(query, params ?? []);
+  }
+
   async getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
     const res = await this.execute(sql, parameters);
     return res.rows?._array ?? [];

packages/node/src/db/SqliteWorker.ts

@@ -65,6 +65,17 @@ class BlockingAsyncDatabase implements AsyncDatabase {
     }
   }
 
+  async executeRaw(query: string, params: any[]) {
+    const stmt = this.db.prepare(query);
+
+    if (stmt.reader) {
+      return stmt.raw().all(params);
+    } else {
+      stmt.raw().run(params);
+      return [];
+    }
+  }
+
   async executeBatch(query: string, params: any[][]) {
     params = params ?? [];
 

packages/node/tests/DrizzleNode.test.ts

@@ -0,0 +1,99 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { eq, relations } from 'drizzle-orm';
+
+import { databaseTest } from './utils';
+import { wrapPowerSyncWithDrizzle } from '@powersync/drizzle-driver';
+import { PowerSyncDatabase } from '../lib';
+import { expect } from 'vitest';
+
+export const drizzleLists = sqliteTable('lists', {
+  id: text('id'),
+  name: text('name')
+});
+
+export const drizzleTodos = sqliteTable('todos', {
+  id: text('id'),
+  content: text('content'),
+  list_id: text('list_id')
+});
+
+export const listsRelations = relations(drizzleLists, ({ one, many }) => ({
+  todos: many(drizzleTodos)
+}));
+
+export const todosRelations = relations(drizzleTodos, ({ one, many }) => ({
+  list: one(drizzleLists, {
+    fields: [drizzleTodos.list_id],
+    references: [drizzleLists.id]
+  })
+}));
+
+export const drizzleSchema = {
+  lists: drizzleLists,
+  todos: drizzleTodos,
+  listsRelations,
+  todosRelations
+};
+
+const setupDrizzle = async (database: PowerSyncDatabase) => {
+  const db = wrapPowerSyncWithDrizzle(database, {
+    schema: drizzleSchema
+  });
+
+  await db.insert(drizzleLists).values({ id: '1', name: 'list 1' });
+  await db.insert(drizzleTodos).values({ id: '33', content: 'Post content', list_id: '1' });
+  return db;
+};
+
+databaseTest('should retrieve a list with todos', async ({ database }) => {
+  const db = await setupDrizzle(database);
+
+  const result = await db.query.lists.findMany({ with: { todos: true } });
+
+  expect(result).toEqual([{ id: '1', name: 'list 1', todos: [{ id: '33', content: 'Post content', list_id: '1' }] }]);
+});
+
+databaseTest('should retrieve a todo with its list', async ({ database }) => {
+  const db = await setupDrizzle(database);
+
+  const result = await db.query.todos.findMany({ with: { list: true } });
+
+  expect(result).toEqual([
+    {
+      id: '33',
+      content: 'Post content',
+      list_id: '1',
+      list: { id: '1', name: 'list 1' }
+    }
+  ]);
+});
+
+databaseTest('should return a list and todos using leftJoin', async ({ database }) => {
+  const db = await setupDrizzle(database);
+
+  const result = await db.select().from(drizzleLists).leftJoin(drizzleTodos, eq(drizzleLists.id, drizzleTodos.list_id));
+
+  expect(result[0].lists).toEqual({ id: '1', name: 'list 1' });
+  expect(result[0].todos).toEqual({ id: '33', content: 'Post content', list_id: '1' });
+});
+
+databaseTest('should return a list and todos using rightJoin', async ({ database }) => {
+  const db = await setupDrizzle(database);
+
+  const result = await db
+    .select()
+    .from(drizzleLists)
+    .rightJoin(drizzleTodos, eq(drizzleLists.id, drizzleTodos.list_id));
+
+  expect(result[0].lists).toEqual({ id: '1', name: 'list 1' });
+  expect(result[0].todos).toEqual({ id: '33', content: 'Post content', list_id: '1' });
+});
+
+databaseTest('should return a list and todos using fullJoin', async ({ database }) => {
+  const db = await setupDrizzle(database);
+
+  const result = await db.select().from(drizzleLists).fullJoin(drizzleTodos, eq(drizzleLists.id, drizzleTodos.list_id));
+
+  expect(result[0].lists).toEqual({ id: '1', name: 'list 1' });
+  expect(result[0].todos).toEqual({ id: '33', content: 'Post content', list_id: '1' });
+});

packages/node/tests/utils.ts

@@ -13,11 +13,17 @@ async function createTempDir() {
 export const LIST_TABLE = 'lists';
 export const TODO_TABLE = 'todos';
 
+const lists = new Table({
+  name: column.text
+});
+
 const todos = new Table({
-  content: column.text
+  content: column.text,
+  list_id: column.text
 });
 
 export const AppSchema = new Schema({
+  lists,
   todos
 });