Dropped Object.assign usage in favour of extending the classes.

Author: Chriztiaan

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

@@ -23,48 +23,55 @@ import { PowerSyncSQLiteSession, PowerSyncSQLiteTransactionConfig } from './sqli
 
 export type DrizzleQuery<T> = { toSQL(): Query; execute(): Promise<T> };
 
-export interface PowerSyncSQLiteDatabase<TSchema extends Record<string, unknown> = Record<string, never>>
-  extends BaseSQLiteDatabase<'async', QueryResult, TSchema> {
-  transaction<T>(
+export class PowerSyncSQLiteDatabase<
+  TSchema extends Record<string, unknown> = Record<string, never>
+> extends BaseSQLiteDatabase<'async', QueryResult, TSchema> {
+  private db: AbstractPowerSyncDatabase;
+
+  constructor(db: AbstractPowerSyncDatabase, config: DrizzleConfig<TSchema> = {}) {
+    const dialect = new SQLiteAsyncDialect({ casing: config.casing });
+    let logger;
+    if (config.logger === true) {
+      logger = new DefaultLogger();
+    } else if (config.logger !== false) {
+      logger = config.logger;
+    }
+
+    let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
+    if (config.schema) {
+      const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+      schema = {
+        fullSchema: config.schema,
+        schema: tablesConfig.tables,
+        tableNamesMap: tablesConfig.tableNamesMap
+      };
+    }
+
+    const session = new PowerSyncSQLiteSession(db, dialect, schema, {
+      logger
+    });
+
+    super('async', dialect, session as any, schema as any);
+    this.db = db;
+  }
+
+  override transaction<T>(
     transaction: (
       tx: SQLiteTransaction<'async', QueryResult, TSchema, ExtractTablesWithRelations<TSchema>>
     ) => Promise<T>,
     config?: PowerSyncSQLiteTransactionConfig
-  ): Promise<T>;
+  ): Promise<T> {
+    return super.transaction(transaction, config);
+  }
 
-  watch<T>(query: DrizzleQuery<T>, handler?: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void;
+  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,
   config: DrizzleConfig<TSchema> = {}
 ): PowerSyncSQLiteDatabase<TSchema> {
-  const dialect = new SQLiteAsyncDialect({ casing: config.casing });
-  let logger;
-  if (config.logger === true) {
-    logger = new DefaultLogger();
-  } else if (config.logger !== false) {
-    logger = config.logger;
-  }
-
-  let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-  if (config.schema) {
-    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
-    schema = {
-      fullSchema: config.schema,
-      schema: tablesConfig.tables,
-      tableNamesMap: tablesConfig.tableNamesMap
-    };
-  }
-
-  const session = new PowerSyncSQLiteSession(db, dialect, schema, {
-    logger
-  });
-
-  const baseDatabase = new BaseSQLiteDatabase('async', dialect, session, schema) as PowerSyncSQLiteDatabase<TSchema>;
-  return Object.assign(baseDatabase, {
-    watch: <T>(query: DrizzleQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions) => {
-      compilableQueryWatch(db, toCompilableQuery(query), handler, options);
-    }
-  });
+  return new PowerSyncSQLiteDatabase<TSchema>(db, config);
 }

packages/kysely-driver/src/sqlite/db.ts

@@ -15,24 +15,25 @@ export type PowerSyncKyselyOptions = Omit<KyselyConfig, 'dialect'> & {
   dialect?: Dialect;
 };
 
-export type PowerSyncKyselyDatabase<T> = Kysely<T> & {
-  watch: <K>(query: CompilableQuery<K>, handler: CompilableQueryWatchHandler<K>, options?: SQLWatchOptions) => void;
-};
+export class PowerSyncKyselyDatabase<T> extends Kysely<T> {
+  private db: AbstractPowerSyncDatabase;
+
+  constructor(db: AbstractPowerSyncDatabase, options?: PowerSyncKyselyOptions) {
+    super({
+      dialect: new PowerSyncDialect({ db }),
+      ...options
+    });
+    this.db = db;
+  }
+
+  watch<K>(query: CompilableQuery<K>, handler: CompilableQueryWatchHandler<K>, options?: SQLWatchOptions): void {
+    compilableQueryWatch(this.db, query, handler, options);
+  }
+}
 
 export const wrapPowerSyncWithKysely = <T>(
   db: AbstractPowerSyncDatabase,
   options?: PowerSyncKyselyOptions
 ): PowerSyncKyselyDatabase<T> => {
-  const kysely = new Kysely<T>({
-    dialect: new PowerSyncDialect({
-      db
-    }),
-    ...options
-  });
-
-  return Object.assign(kysely, {
-    watch: <K>(query: CompilableQuery<K>, handler: CompilableQueryWatchHandler<K>, options?: SQLWatchOptions) => {
-      compilableQueryWatch(db, query, handler, options);
-    }
-  });
+  return new PowerSyncKyselyDatabase<T>(db, options);
 };