wip: use forked execute raw sync branch

Author: joshua-journey-apps

packages/drizzle-driver-sync/package.json

@@ -46,8 +46,8 @@
     "drizzle-orm": "<1.0.0"
   },
   "devDependencies": {
+    "@op-engineering/op-sqlite": "github:joshua-journey-apps/op-sqlite#execute-raw-sync",
     "@powersync/web": "workspace:*",
-    "@op-engineering/op-sqlite": "^14.0.2",
     "@journeyapps/wa-sqlite": "^1.2.0",
     "@types/node": "^20.17.6",
     "drizzle-orm": "^0.35.2",

packages/drizzle-driver-sync/src/sqlite/PowerSyncSQLiteBaseSession.ts

@@ -1,4 +1,3 @@
-import { LockContext, QueryResult } from '@powersync/common';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { NoopLogger } from 'drizzle-orm/logger';
@@ -14,8 +13,7 @@ import {
   type SQLiteTransactionConfig
 } from 'drizzle-orm/sqlite-core/session';
 import { PowerSyncSQLitePreparedQuery } from './PowerSyncSQLitePreparedQuery.js';
-import { DB } from '@op-engineering/op-sqlite';
-
+import { DB, QueryResult } from '@op-engineering/op-sqlite';
 export interface PowerSyncSQLiteSessionOptions {
   logger?: Logger;
 }

packages/drizzle-driver-sync/src/sqlite/PowerSyncSQLiteDatabase.ts

@@ -1,10 +1,3 @@
-import {
-  AbstractPowerSyncDatabase,
-  compilableQueryWatch,
-  CompilableQueryWatchHandler,
-  QueryResult,
-  SQLWatchOptions
-} from '@powersync/common';
 import { Query } from 'drizzle-orm';
 import { DefaultLogger } from 'drizzle-orm/logger';
 import {
@@ -18,18 +11,18 @@ import { SQLiteTransaction } from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core/db';
 import { SQLiteSyncDialect } from 'drizzle-orm/sqlite-core/dialect';
 import type { DrizzleConfig } from 'drizzle-orm/utils';
-import { toCompilableQuery } from '../utils/compilableQuery.js';
 import { PowerSyncSQLiteTransactionConfig } from './PowerSyncSQLiteBaseSession.js';
 import { PowerSyncSQLiteSession } from './PowerSyncSQLiteSession.js';
+import { DB, QueryResult } from '@op-engineering/op-sqlite';
 
 export type DrizzleQuery<T> = { toSQL(): Query; execute(): Promise<T | T[]> };
 
 export class PowerSyncSQLiteDatabase<
   TSchema extends Record<string, unknown> = Record<string, never>
 > extends BaseSQLiteDatabase<'sync', QueryResult, TSchema> {
-  private db: AbstractPowerSyncDatabase;
+  private db: DB;
 
-  constructor(db: AbstractPowerSyncDatabase, config: DrizzleConfig<TSchema> = {}) {
+  constructor(db: DB, config: DrizzleConfig<TSchema> = {}) {
     const dialect = new SQLiteSyncDialect({ casing: config.casing });
     let logger;
     if (config.logger === true) {
@@ -63,13 +56,13 @@ export class PowerSyncSQLiteDatabase<
     return super.transaction(transaction, config);
   }
 
-  watch<T>(query: DrizzleQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void {
-    compilableQueryWatch(this.db, toCompilableQuery(query), handler, options);
-  }
+  // watch<T>(query: DrizzleQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void {
+  //   compilableQueryWatch(this.db, toCompilableQuery(query), handler, options);
+  // }
 }
 
 export function wrapPowerSyncWithDrizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
-  db: AbstractPowerSyncDatabase,
+  db: DB,
   config: DrizzleConfig<TSchema> = {}
 ): PowerSyncSQLiteDatabase<TSchema> {
   return new PowerSyncSQLiteDatabase<TSchema>(db, config);

packages/drizzle-driver-sync/src/sqlite/PowerSyncSQLitePreparedQuery.ts

@@ -1,12 +1,12 @@
 import { DB, QueryResult, Scalar } from '@op-engineering/op-sqlite';
-import { LockContext } from '@powersync/common';
 import { Column, DriverValueDecoder, getTableName, SQL } from 'drizzle-orm';
 import { entityKind, is } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { fillPlaceholders, type Query } from 'drizzle-orm/sql/sql';
 import { SQLiteColumn } from 'drizzle-orm/sqlite-core';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builders/select.types';
 import {
+  ExecuteResultSync,
   type PreparedQueryConfig as PreparedQueryConfigBase,
   type SQLiteExecuteMethod,
   SQLitePreparedQuery
@@ -38,6 +38,15 @@ export class PowerSyncSQLitePreparedQuery<
     super('sync', executeMethod, query);
   }
 
+  execute(placeholderValues?: Record<string, unknown>): ExecuteResultSync<T['execute']> {
+    const params = fillPlaceholders(this.query.params, placeholderValues ?? {}) as Scalar[];
+    this.logger.logQuery(this.query.sql, params);
+    const rs = this.db.executeRawSync(this.query.sql, params);
+    return new ExecuteResultSync(() => {
+      return this.mapResult(rs, false);
+    });
+  }
+
   run(placeholderValues?: Record<string, unknown>): QueryResult {
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {}) as Scalar[];
     this.logger.logQuery(this.query.sql, params);
@@ -56,10 +65,10 @@ export class PowerSyncSQLitePreparedQuery<
 
     const rows = this.values(placeholderValues) as unknown[][];
 
-    if (customResultMapper) {
-      const mapped = customResultMapper(rows) as T['all'];
-      return mapped;
-    }
+    // if (customResultMapper) {
+    //   const mapped = customResultMapper(rows) as T['all'];
+    //   return mapped;
+    // }
     return rows.map((row) => mapResultRow(fields!, row, (this as any).joinsNotNullableMap));
   }
 
@@ -70,7 +79,6 @@ export class PowerSyncSQLitePreparedQuery<
     const { fields, customResultMapper } = this;
     const joinsNotNullableMap = (this as any).joinsNotNullableMap;
     if (!fields && !customResultMapper) {
-      // return this.db.get(this.query.sql, params);
       return this.db.executeSync(this.query.sql, params) as T['get'];
     }
 
@@ -81,9 +89,9 @@ export class PowerSyncSQLitePreparedQuery<
       return undefined;
     }
 
-    if (customResultMapper) {
-      return customResultMapper(rows) as T['get'];
-    }
+    // if (customResultMapper) {
+    //   return customResultMapper(rows) as T['get'];
+    // }
 
     return mapResultRow(fields!, row, joinsNotNullableMap);
   }
@@ -92,7 +100,7 @@ export class PowerSyncSQLitePreparedQuery<
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {}) as Scalar[];
     this.logger.logQuery(this.query.sql, params);
 
-    return this.db.executeRaw(this.query.sql, params);
+    return this.db.executeRawSync(this.query.sql, params);
   }
 
   isResponseInArrayMode(): boolean {
@@ -101,7 +109,7 @@ export class PowerSyncSQLitePreparedQuery<
 }
 
 /**
- * Maps a flat array of database row values to a result object based on the provided column definitions.
+ * Maps a database row object to a result object based on the provided column definitions.
  * It reconstructs the hierarchical structure of the result by following the specified paths for each field.
  * It also handles nullification of nested objects when joined tables are nullable.
  */

packages/drizzle-driver-sync/src/sqlite/PowerSyncSQLiteSession.ts

@@ -1,4 +1,3 @@
-import { AbstractPowerSyncDatabase, DBAdapter } from '@powersync/common';
 import { entityKind } from 'drizzle-orm/entity';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
 import type { SQLiteSyncDialect } from 'drizzle-orm/sqlite-core/dialect';
@@ -8,15 +7,16 @@ import {
   PowerSyncSQLiteTransaction,
   PowerSyncSQLiteTransactionConfig
 } from './PowerSyncSQLiteBaseSession.js';
+import { DB, Transaction } from '@op-engineering/op-sqlite';
 
 export class PowerSyncSQLiteSession<
   TFullSchema extends Record<string, unknown>,
   TSchema extends TablesRelationalConfig
 > extends PowerSyncSQLiteBaseSession<TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'PowerSyncSQLiteSession';
-  protected client: AbstractPowerSyncDatabase;
+  protected client: DB;
   constructor(
-    db: AbstractPowerSyncDatabase,
+    db: DB,
     dialect: SQLiteSyncDialect,
     schema: RelationalSchemaConfig<TSchema> | undefined,
     options: PowerSyncSQLiteSessionOptions = {}
@@ -29,34 +29,51 @@ export class PowerSyncSQLiteSession<
     transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
     config: PowerSyncSQLiteTransactionConfig = {}
   ): T {
-    const { accessMode = 'read write' } = config;
+    let result: T;
 
-    if (accessMode === 'read only') {
-      return this.client.readLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
-    }
+    this.client.transaction(async (trx) => {
+      const tx = new PowerSyncSQLiteTransaction<TFullSchema, TSchema>(
+        'sync',
+        this.dialect,
+        new PowerSyncSQLiteBaseSession(this.client, this.dialect, this.schema, this.options),
+        // trx,
+        this.schema
+      );
+      result = this.internalTransaction(trx, () => transaction(tx), config);
+    });
+
+    // @ts-ignore
+    return result;
+
+    // const { accessMode = 'read write' } = config;
 
-    return this.client.writeLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
+    // if (accessMode === 'read only') {
+    // return this.client.readLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
+    // return this.client.transaction(async (ctx) => this.internalTransaction(ctx, transaction, config));
+    // }
+
+    // return this.client.writeLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
   }
 
-  protected async internalTransaction<T>(
-    connection: DBAdapter,
+  protected internalTransaction<T>(
+    transaction: Transaction,
     fn: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
     config: PowerSyncSQLiteTransactionConfig = {}
-  ): Promise<T> {
+  ): T {
     const tx = new PowerSyncSQLiteTransaction<TFullSchema, TSchema>(
       'sync',
       (this as any).dialect,
-      new PowerSyncSQLiteBaseSession(connection, this.dialect, this.schema, this.options),
+      new PowerSyncSQLiteBaseSession(this.client, this.dialect, this.schema, this.options),
       this.schema
     );
 
-    await connection.execute(`begin${config?.behavior ? ' ' + config.behavior : ''}`);
+    transaction.execute(`begin${config?.behavior ? ' ' + config.behavior : ''}`);
     try {
-      const result = await fn(tx);
-      await connection.execute(`commit`);
+      const result = fn(tx);
+      transaction.commit();
       return result;
     } catch (err) {
-      await connection.execute(`rollback`);
+      transaction.rollback();
       throw err;
     }
   }

packages/drizzle-driver-sync/src/utils/compilableQuery.ts

@@ -21,7 +21,7 @@ import { Query } from 'drizzle-orm';
  * );
  */
 export function toCompilableQuery<T>(query: {
-  execute: () => Promise<T | T[]>;
+  execute: () => T | T[];
   toSQL: () => Query;
 }): CompilableQuery<T> {
   return {
@@ -33,8 +33,8 @@ export function toCompilableQuery<T>(query: {
       };
     },
     execute: async () => {
-      const result = await query.execute();
+      const result = query.execute();
       return Array.isArray(result) ? result : [result];
-    },
+    }
   };
 }