wip: add sync compatibility

Author: joshua-journey-apps

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

@@ -4,7 +4,7 @@ import type { Logger } from 'drizzle-orm/logger';
 import { NoopLogger } from 'drizzle-orm/logger';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
 import { type Query } from 'drizzle-orm/sql/sql';
-import type { SQLiteAsyncDialect } from 'drizzle-orm/sqlite-core/dialect';
+import type { SQLiteAsyncDialect, SQLiteSyncDialect } from 'drizzle-orm/sqlite-core/dialect';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builders/select.types';
 import {
   type PreparedQueryConfig as PreparedQueryConfigBase,
@@ -26,35 +26,35 @@ export type PowerSyncSQLiteTransactionConfig = SQLiteTransactionConfig & {
 export class PowerSyncSQLiteTransaction<
   TFullSchema extends Record<string, unknown>,
   TSchema extends TablesRelationalConfig
-> extends SQLiteTransaction<'async', QueryResult, TFullSchema, TSchema> {
+> extends SQLiteTransaction<'async' | 'sync', QueryResult, TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'PowerSyncSQLiteTransaction';
 }
 
 export class PowerSyncSQLiteBaseSession<
   TFullSchema extends Record<string, unknown>,
   TSchema extends TablesRelationalConfig
-> extends SQLiteSession<'async', QueryResult, TFullSchema, TSchema> {
+> extends SQLiteSession<'async' | 'sync', QueryResult, TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'PowerSyncSQLiteBaseSession';
 
   protected logger: Logger;
 
   constructor(
     protected db: LockContext,
-    protected dialect: SQLiteAsyncDialect,
+    protected dialect: { sync: SQLiteSyncDialect; async: SQLiteAsyncDialect }['async' | 'sync'],
     protected schema: RelationalSchemaConfig<TSchema> | undefined,
     protected options: PowerSyncSQLiteSessionOptions = {}
   ) {
     super(dialect);
     this.logger = options.logger ?? new NoopLogger();
   }
 
-  prepareQuery<T extends PreparedQueryConfigBase & { type: 'async' }>(
+  prepareQuery<T extends PreparedQueryConfigBase>(
     query: Query,
     fields: SelectedFieldsOrdered | undefined,
     executeMethod: SQLiteExecuteMethod,
     isResponseInArrayMode: boolean,
     customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown
-  ): PowerSyncSQLitePreparedQuery<T> {
+  ): PowerSyncSQLitePreparedQuery<T, 'async' | 'sync'> {
     return new PowerSyncSQLitePreparedQuery(
       this.db,
       query,

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

@@ -26,10 +26,10 @@ export type DrizzleQuery<T> = { toSQL(): Query; execute(): Promise<T | T[]> };
 
 export class PowerSyncSQLiteDatabase<
   TSchema extends Record<string, unknown> = Record<string, never>
-> extends BaseSQLiteDatabase<'async', QueryResult, TSchema> {
+> extends BaseSQLiteDatabase<'async' | 'sync', QueryResult, TSchema> {
   private db: AbstractPowerSyncDatabase;
 
-  constructor(db: AbstractPowerSyncDatabase, config: DrizzleConfig<TSchema> = {}) {
+  constructor(db: AbstractPowerSyncDatabase, config: DrizzleConfig<TSchema> = {}, mode: 'async' | 'sync' = 'async') {
     const dialect = new SQLiteAsyncDialect({ casing: config.casing });
     let logger;
     if (config.logger === true) {
@@ -52,16 +52,16 @@ export class PowerSyncSQLiteDatabase<
       logger
     });
 
-    super('async', dialect, session as any, schema as any);
+    super(mode, dialect, session as any, schema as any);
     this.db = db;
   }
 
   transaction<T>(
     transaction: (
-      tx: SQLiteTransaction<'async', QueryResult, TSchema, ExtractTablesWithRelations<TSchema>>
+      tx: SQLiteTransaction<'async' | 'sync', QueryResult, TSchema, ExtractTablesWithRelations<TSchema>>
     ) => Promise<T>,
     config?: PowerSyncSQLiteTransactionConfig
-  ): Promise<T> {
+  ) {
     return super.transaction(transaction, config);
   }
 

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

@@ -1,5 +1,5 @@
 import { LockContext, QueryResult } from '@powersync/common';
-import { Column, DriverValueDecoder, getTableName, SQL } from 'drizzle-orm';
+import { Column, DriverValueDecoder, getTableName, NoopLogger, 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';
@@ -8,24 +8,31 @@ import type { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builde
 import {
   type PreparedQueryConfig as PreparedQueryConfigBase,
   type SQLiteExecuteMethod,
-  SQLitePreparedQuery
+  SQLitePreparedQuery,
+  type Result,
+  ExecuteResultSync
 } from 'drizzle-orm/sqlite-core/session';
 
-type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement'>;
 
-export class PowerSyncSQLitePreparedQuery<
-  T extends PreparedQueryConfig = PreparedQueryConfig
-> extends SQLitePreparedQuery<{
-  type: 'async';
+// Define the result types for both sync and async modes
+type PowerSyncPreparedQueryConfig<TSync extends 'sync' | 'async', T> = {
+  type: TSync;
   run: QueryResult;
-  all: T['all'];
-  get: T['get'];
-  values: T['values'];
-  execute: T['execute'];
-}> {
+  all: QueryResult[];
+  get: T;
+  values: T[][];
+  execute: T;
+};
+
+export class PowerSyncSQLitePreparedQuery<
+  T extends PreparedQueryConfig = PreparedQueryConfig,
+  TSync extends 'async' | 'sync' = 'async'
+> extends SQLitePreparedQuery<PowerSyncPreparedQueryConfig<TSync, T> & T> {
   static readonly [entityKind]: string = 'PowerSyncSQLitePreparedQuery';
 
   constructor(
+    private mode: TSync,
     private db: LockContext,
     query: Query,
     private logger: Logger,
@@ -34,62 +41,108 @@ export class PowerSyncSQLitePreparedQuery<
     private _isResponseInArrayMode: boolean,
     private customResultMapper?: (rows: unknown[][]) => unknown
   ) {
-    super('async', executeMethod, query);
+    super(mode, executeMethod, query);
   }
 
-  async run(placeholderValues?: Record<string, unknown>): Promise<QueryResult> {
-    const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-    this.logger.logQuery(this.query.sql, params);
-    const rs = await this.db.execute(this.query.sql, params);
-    return rs;
-  }
+  run(placeholderValues?: Record<string, unknown>): Result<TSync, QueryResult & T['run']> {
+    const runFn = async (): Promise<QueryResult> => {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      this.logger.logQuery(this.query.sql, params);
+      return await this.db.execute(this.query.sql, params);
+    };
 
-  async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-    const { fields, query, logger, customResultMapper } = this;
-    if (!fields && !customResultMapper) {
-      const params = fillPlaceholders(query.params, placeholderValues ?? {});
-      logger.logQuery(query.sql, params);
-      const rs = await this.db.execute(this.query.sql, params);
-      return rs.rows?._array ?? [];
+    if (this.mode === 'sync') {
+      return new ExecuteResultSync(() => {
+        // For sync mode, you'd need a synchronous version of your db operations
+        // This is just a placeholder - you'd need to implement sync versions
+        throw new Error('Sync mode not implemented for PowerSync');
+      }) as unknown as Result<TSync, QueryResult>;
     }
 
-    const rows = (await this.values(placeholderValues)) as unknown[][];
+    return runFn() as Result<TSync, QueryResult>;
+  }
+
+  all(placeholderValues?: Record<string, unknown>): Result<TSync, QueryResult[] & T['all']> {
+    const allFn = async (): Promise<T['all']> => {
+      const { fields, query, logger, customResultMapper } = this;
+
+      if (!fields && !customResultMapper) {
+        const params = fillPlaceholders(query.params, placeholderValues ?? {});
+        logger.logQuery(query.sql, params);
+        const rs = await this.db.execute(this.query.sql, params);
+        return rs.rows?._array ?? [];
+      }
+
+      const rows = (await this.valuesAsync(placeholderValues)) as unknown[][];
 
-    if (customResultMapper) {
-      const mapped = customResultMapper(rows) as T['all'];
-      return mapped;
+      if (customResultMapper) {
+        return customResultMapper(rows) as T['all'];
+      }
+
+      return rows.map((row) => mapResultRow(fields!, row, (this as any).joinsNotNullableMap));
+    };
+
+    if (this.mode === 'sync') {
+      return new ExecuteResultSync(() => {
+        throw new Error('Sync mode not implemented for PowerSync');
+      }) as unknown as Result<TSync, QueryResult[] & T['all']>;
     }
-    return rows.map((row) => mapResultRow(fields!, row, (this as any).joinsNotNullableMap));
+
+    return allFn() as Result<TSync, QueryResult[] & T['all']>;
   }
 
-  async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-    const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-    this.logger.logQuery(this.query.sql, params);
+  get(placeholderValues?: Record<string, unknown>): Result<TSync, T & T['get']> {
+    const getFn = async (): Promise<T['get']> => {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      this.logger.logQuery(this.query.sql, params);
 
-    const { fields, customResultMapper } = this;
-    const joinsNotNullableMap = (this as any).joinsNotNullableMap;
-    if (!fields && !customResultMapper) {
-      return this.db.get(this.query.sql, params);
-    }
+      const { fields, customResultMapper } = this;
+      const joinsNotNullableMap = (this as any).joinsNotNullableMap;
+
+      if (!fields && !customResultMapper) {
+        return this.db.get(this.query.sql, params);
+      }
+
+      const rows = (await this.valuesAsync(placeholderValues)) as unknown[][];
+      const row = rows[0];
+
+      if (!row) {
+        return undefined;
+      }
+
+      if (customResultMapper) {
+        return customResultMapper(rows) as T['get'];
+      }
 
-    const rows = (await this.values(placeholderValues)) as unknown[][];
-    const row = rows[0];
+      return mapResultRow(fields!, row, joinsNotNullableMap);
+    };
 
-    if (!row) {
-      return undefined;
+    if (this.mode === 'sync') {
+      return new ExecuteResultSync(() => {
+        throw new Error('Sync mode not implemented for PowerSync');
+      }) as unknown as Result<TSync, T & T['get']>;
     }
 
-    if (customResultMapper) {
-      return customResultMapper(rows) as T['get'];
+    return getFn() as Result<TSync, T & T['get']>;
+  }
+
+  values(placeholderValues?: Record<string, unknown>): Result<TSync, T[][] & T['values']> {
+    const valuesFn = async (): Promise<T['values']> => {
+      return this.valuesAsync(placeholderValues);
+    };
+
+    if (this.mode === 'sync') {
+      return new ExecuteResultSync(() => {
+        throw new Error('Sync mode not implemented for PowerSync');
+      }) as unknown as Result<TSync, T[][] &T['values']>;
     }
 
-    return mapResultRow(fields!, row, joinsNotNullableMap);
+    return valuesFn() as Result<TSync, T[][] &T['values']>;
   }
 
-  async values(placeholderValues?: Record<string, unknown>): Promise<T['values']> {
+  private async valuesAsync(placeholderValues?: Record<string, unknown>): Promise<T['values']> {
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
     this.logger.logQuery(this.query.sql, params);
-
     return await this.db.executeRaw(this.query.sql, params);
   }
 
@@ -98,6 +151,39 @@ export class PowerSyncSQLitePreparedQuery<
   }
 }
 
+// If you want to create specific sync/async versions for easier usage:
+export class PowerSyncSQLiteAsyncPreparedQuery<
+  T extends PreparedQueryConfig = PreparedQueryConfig
+> extends PowerSyncSQLitePreparedQuery<T, 'async'> {
+  constructor(
+    db: LockContext,
+    query: Query,
+    logger: Logger,
+    fields: SelectedFieldsOrdered | undefined,
+    executeMethod: SQLiteExecuteMethod,
+    isResponseInArrayMode: boolean,
+    customResultMapper?: (rows: unknown[][]) => unknown
+  ) {
+    super('async', db, query, logger, fields, executeMethod, isResponseInArrayMode, customResultMapper);
+  }
+}
+
+export class PowerSyncSQLiteSyncPreparedQuery<
+  T extends PreparedQueryConfig = PreparedQueryConfig
+> extends PowerSyncSQLitePreparedQuery<T, 'sync'> {
+  constructor(
+    db: LockContext, // You'd need a sync version of LockContext
+    query: Query,
+    logger: Logger,
+    fields: SelectedFieldsOrdered | undefined,
+    executeMethod: SQLiteExecuteMethod,
+    isResponseInArrayMode: boolean,
+    customResultMapper?: (rows: unknown[][]) => unknown
+  ) {
+    super('sync', db, query, logger, fields, executeMethod, isResponseInArrayMode, customResultMapper);
+  }
+}
+
 /**
  * Maps a flat array of database row values 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.