Merge branch 'main' into configurable-vfs

packages/drizzle-driver/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @powersync/drizzle-driver
 
+## 0.3.2
+
+### Patch Changes
+
+- 6580f29: Added support for custom column types when converting a Drizzle schema to a PowerSync app schema.
+
+## 0.3.1
+
+### Patch Changes
+
+- 86a753f: Fixed Drizzle transactions breaking for react-native projects, correctly using lock context for transactions.
+
 ## 0.3.0
 
 ### Minor Changes

packages/drizzle-driver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/drizzle-driver",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Drizzle driver for PowerSync",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

packages/drizzle-driver/src/index.ts

@@ -1,4 +1,8 @@
-import { wrapPowerSyncWithDrizzle, type DrizzleQuery, type PowerSyncSQLiteDatabase } from './sqlite/db';
+import {
+  wrapPowerSyncWithDrizzle,
+  type DrizzleQuery,
+  type PowerSyncSQLiteDatabase
+} from './sqlite/PowerSyncSQLiteDatabase';
 import { toCompilableQuery } from './utils/compilableQuery';
 import {
   DrizzleAppSchema,

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

@@ -1,9 +1,9 @@
-import { AbstractPowerSyncDatabase, QueryResult } from '@powersync/common';
+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';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
-import { type Query, sql } from 'drizzle-orm/sql/sql';
+import { type Query } from 'drizzle-orm/sql/sql';
 import type { SQLiteAsyncDialect } from 'drizzle-orm/sqlite-core/dialect';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builders/select.types';
 import {
@@ -13,7 +13,7 @@ import {
   SQLiteTransaction,
   type SQLiteTransactionConfig
 } from 'drizzle-orm/sqlite-core/session';
-import { PowerSyncSQLitePreparedQuery } from './sqlite-query';
+import { PowerSyncSQLitePreparedQuery } from './PowerSyncSQLitePreparedQuery';
 
 export interface PowerSyncSQLiteSessionOptions {
   logger?: Logger;
@@ -30,19 +30,19 @@ export class PowerSyncSQLiteTransaction<
   static readonly [entityKind]: string = 'PowerSyncSQLiteTransaction';
 }
 
-export class PowerSyncSQLiteSession<
+export class PowerSyncSQLiteBaseSession<
   TFullSchema extends Record<string, unknown>,
   TSchema extends TablesRelationalConfig
 > extends SQLiteSession<'async', QueryResult, TFullSchema, TSchema> {
-  static readonly [entityKind]: string = 'PowerSyncSQLiteSession';
+  static readonly [entityKind]: string = 'PowerSyncSQLiteBaseSession';
 
-  private logger: Logger;
+  protected logger: Logger;
 
   constructor(
-    private db: AbstractPowerSyncDatabase,
-    dialect: SQLiteAsyncDialect,
-    private schema: RelationalSchemaConfig<TSchema> | undefined,
-    options: PowerSyncSQLiteSessionOptions = {}
+    protected db: LockContext,
+    protected dialect: SQLiteAsyncDialect,
+    protected schema: RelationalSchemaConfig<TSchema> | undefined,
+    protected options: PowerSyncSQLiteSessionOptions = {}
   ) {
     super(dialect);
     this.logger = options.logger ?? new NoopLogger();
@@ -66,33 +66,10 @@ export class PowerSyncSQLiteSession<
     );
   }
 
-  override transaction<T>(
-    transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
-    config: PowerSyncSQLiteTransactionConfig = {}
+  transaction<T>(
+    _transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
+    _config: PowerSyncSQLiteTransactionConfig = {}
   ): T {
-    const { accessMode = 'read write' } = config;
-
-    if (accessMode === 'read only') {
-      return this.db.readLock(async () => this.internalTransaction(transaction, config)) as T;
-    }
-
-    return this.db.writeLock(async () => this.internalTransaction(transaction, config)) as T;
-  }
-
-  async internalTransaction<T>(
-    transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
-    config: PowerSyncSQLiteTransactionConfig = {}
-  ): Promise<T> {
-    const tx = new PowerSyncSQLiteTransaction('async', (this as any).dialect, this, this.schema);
-
-    await this.run(sql.raw(`begin${config?.behavior ? ' ' + config.behavior : ''}`));
-    try {
-      const result = await transaction(tx);
-      await this.run(sql`commit`);
-      return result;
-    } catch (err) {
-      await this.run(sql`rollback`);
-      throw err;
-    }
+    throw new Error('Nested transactions are not supported');
   }
 }

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

@@ -19,7 +19,8 @@ import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core/db';
 import { SQLiteAsyncDialect } from 'drizzle-orm/sqlite-core/dialect';
 import type { DrizzleConfig } from 'drizzle-orm/utils';
 import { toCompilableQuery } from './../utils/compilableQuery';
-import { PowerSyncSQLiteSession, PowerSyncSQLiteTransactionConfig } from './sqlite-session';
+import { PowerSyncSQLiteSession } from './PowerSyncSQLiteSession';
+import { PowerSyncSQLiteTransactionConfig } from './PowerSyncSQLiteBaseSession';
 
 export type DrizzleQuery<T> = { toSQL(): Query; execute(): Promise<T | T[]> };
 
@@ -55,7 +56,7 @@ export class PowerSyncSQLiteDatabase<
     this.db = db;
   }
 
-  override transaction<T>(
+  transaction<T>(
     transaction: (
       tx: SQLiteTransaction<'async', QueryResult, TSchema, ExtractTablesWithRelations<TSchema>>
     ) => Promise<T>,

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

@@ -1,4 +1,4 @@
-import { AbstractPowerSyncDatabase, QueryResult } from '@powersync/common';
+import { LockContext, QueryResult } 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';
@@ -26,7 +26,7 @@ export class PowerSyncSQLitePreparedQuery<
   static readonly [entityKind]: string = 'PowerSyncSQLitePreparedQuery';
 
   constructor(
-    private db: AbstractPowerSyncDatabase,
+    private db: LockContext,
     query: Query,
     private logger: Logger,
     private fields: SelectedFieldsOrdered | undefined,

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

@@ -0,0 +1,70 @@
+import { AbstractPowerSyncDatabase, DBAdapter } from '@powersync/common';
+import { entityKind } from 'drizzle-orm/entity';
+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 { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builders/select.types';
+import {
+  type PreparedQueryConfig as PreparedQueryConfigBase,
+  type SQLiteExecuteMethod
+} from 'drizzle-orm/sqlite-core/session';
+import { PowerSyncSQLitePreparedQuery } from './PowerSyncSQLitePreparedQuery';
+import {
+  PowerSyncSQLiteSessionOptions,
+  PowerSyncSQLiteTransaction,
+  PowerSyncSQLiteTransactionConfig,
+  PowerSyncSQLiteBaseSession
+} from './PowerSyncSQLiteBaseSession';
+
+export class PowerSyncSQLiteSession<
+  TFullSchema extends Record<string, unknown>,
+  TSchema extends TablesRelationalConfig
+> extends PowerSyncSQLiteBaseSession<TFullSchema, TSchema> {
+  static readonly [entityKind]: string = 'PowerSyncSQLiteSession';
+  protected client: AbstractPowerSyncDatabase;
+  constructor(
+    db: AbstractPowerSyncDatabase,
+    dialect: SQLiteAsyncDialect,
+    schema: RelationalSchemaConfig<TSchema> | undefined,
+    options: PowerSyncSQLiteSessionOptions = {}
+  ) {
+    super(db, dialect, schema, options);
+    this.client = db;
+  }
+
+  transaction<T>(
+    transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
+    config: PowerSyncSQLiteTransactionConfig = {}
+  ): T {
+    const { accessMode = 'read write' } = config;
+
+    if (accessMode === 'read only') {
+      return this.client.readLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
+    }
+
+    return this.client.writeLock(async (ctx) => this.internalTransaction(ctx, transaction, config)) as T;
+  }
+
+  protected async internalTransaction<T>(
+    connection: DBAdapter,
+    fn: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
+    config: PowerSyncSQLiteTransactionConfig = {}
+  ): Promise<T> {
+    const tx = new PowerSyncSQLiteTransaction<TFullSchema, TSchema>(
+      'async',
+      (this as any).dialect,
+      new PowerSyncSQLiteBaseSession(connection, this.dialect, this.schema, this.options),
+      this.schema
+    );
+
+    await connection.execute(`begin${config?.behavior ? ' ' + config.behavior : ''}`);
+    try {
+      const result = await fn(tx);
+      await connection.execute(`commit`);
+      return result;
+    } catch (err) {
+      await connection.execute(`rollback`);
+      throw err;
+    }
+  }
+}

packages/drizzle-driver/src/utils/schema.ts

@@ -12,6 +12,7 @@ import { CasingCache } from 'drizzle-orm/casing';
 import {
   getTableConfig,
   SQLiteBoolean,
+  SQLiteCustomColumn,
   SQLiteInteger,
   SQLiteReal,
   SQLiteText,
@@ -44,24 +45,7 @@ export function toPowerSyncTable<T extends SQLiteTableWithColumns<any>>(
       continue;
     }
 
-    let mappedType: BaseColumnType<number | string | null>;
-    switch (drizzleColumn.columnType) {
-      case SQLiteText[entityKind]:
-      case SQLiteTextJson[entityKind]:
-        mappedType = column.text;
-        break;
-      case SQLiteInteger[entityKind]:
-      case SQLiteTimestamp[entityKind]:
-      case SQLiteBoolean[entityKind]:
-        mappedType = column.integer;
-        break;
-      case SQLiteReal[entityKind]:
-        mappedType = column.real;
-        break;
-      default:
-        throw new Error(`Unsupported column type: ${drizzleColumn.columnType}`);
-    }
-    columns[name] = mappedType;
+    columns[name] = mapDrizzleColumnToType(drizzleColumn);
   }
   const indexes: IndexShorthand = {};
 
@@ -82,6 +66,34 @@ export function toPowerSyncTable<T extends SQLiteTableWithColumns<any>>(
   return new Table(columns, { ...options, indexes }) as Table<Expand<ExtractPowerSyncColumns<T>>>;
 }
 
+function mapDrizzleColumnToType(drizzleColumn: SQLiteColumn<any, object>): BaseColumnType<number | string | null> {
+  switch (drizzleColumn.columnType) {
+    case SQLiteText[entityKind]:
+    case SQLiteTextJson[entityKind]:
+      return column.text;
+    case SQLiteInteger[entityKind]:
+    case SQLiteTimestamp[entityKind]:
+    case SQLiteBoolean[entityKind]:
+      return column.integer;
+    case SQLiteReal[entityKind]:
+      return column.real;
+    case SQLiteCustomColumn[entityKind]:
+      const sqlName = (drizzleColumn as SQLiteCustomColumn<any>).getSQLType();
+      switch (sqlName) {
+        case 'text':
+          return column.text;
+        case 'integer':
+          return column.integer;
+        case 'real':
+          return column.real;
+        default:
+          throw new Error(`Unsupported custom column type: ${drizzleColumn.columnType}: ${sqlName}`);
+      }
+    default:
+      throw new Error(`Unsupported column type: ${drizzleColumn.columnType}`);
+  }
+}
+
 export type DrizzleTablePowerSyncOptions = Omit<TableV2Options, 'indexes'>;
 
 export type DrizzleTableWithPowerSyncOptions = {

packages/drizzle-driver/tests/setup/db.ts

@@ -1,6 +1,6 @@
-import { Schema, PowerSyncDatabase, column, Table, AbstractPowerSyncDatabase } from '@powersync/web';
+import { AbstractPowerSyncDatabase, column, PowerSyncDatabase, Schema, Table } from '@powersync/web';
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { wrapPowerSyncWithDrizzle, PowerSyncSQLiteDatabase } from '../../src/sqlite/db';
+import { wrapPowerSyncWithDrizzle } from '../../src/sqlite/PowerSyncSQLiteDatabase';
 
 const users = new Table({
   name: column.text

packages/drizzle-driver/tests/sqlite/db.test.ts

@@ -1,7 +1,7 @@
 import { AbstractPowerSyncDatabase } from '@powersync/common';
 import { eq, sql } from 'drizzle-orm';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as SUT from '../../src/sqlite/db';
+import * as SUT from '../../src/sqlite/PowerSyncSQLiteDatabase';
 import { DrizzleSchema, drizzleUsers, getDrizzleDb, getPowerSyncDb } from '../setup/db';
 
 describe('Database operations', () => {

packages/drizzle-driver/tests/sqlite/sqlite-query.test.ts → packages/drizzle-driver/tests/sqlite/query.test.ts

@@ -1,7 +1,7 @@
 import { AbstractPowerSyncDatabase } from '@powersync/web';
 import { Query } from 'drizzle-orm/sql/sql';
-import { PowerSyncSQLiteDatabase } from '../../src/sqlite/db';
-import { PowerSyncSQLitePreparedQuery } from '../../src/sqlite/sqlite-query';
+import { PowerSyncSQLiteDatabase } from '../../src/sqlite/PowerSyncSQLiteDatabase';
+import { PowerSyncSQLitePreparedQuery } from '../../src/sqlite/PowerSyncSQLitePreparedQuery';
 import { DrizzleSchema, drizzleUsers, getDrizzleDb, getPowerSyncDb } from '../setup/db';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 

packages/drizzle-driver/tests/sqlite/schema.test.ts

@@ -1,5 +1,5 @@
 import { column, Schema, Table } from '@powersync/common';
-import { index, integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { customType, index, integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { describe, expect, it } from 'vitest';
 import { DrizzleAppSchema, DrizzleTableWithPowerSyncOptions, toPowerSyncTable } from '../../src/utils/schema';
 import { CasingCache } from 'drizzle-orm/casing';
@@ -105,6 +105,61 @@ describe('toPowerSyncTable', () => {
 
     expect(convertedList).toEqual(expectedLists);
   });
+
+  it('custom column conversion', () => {
+    const customSqliteText = customType<{ data: string; driverData: string }>({
+      dataType() {
+        return 'text';
+      },
+      fromDriver(value) {
+        return value;
+      },
+      toDriver(value) {
+        return value;
+      }
+    });
+
+    const customSqliteInteger = customType<{ data: number; driverData: number }>({
+      dataType() {
+        return 'integer';
+      },
+      fromDriver(value) {
+        return Number(value);
+      },
+      toDriver(value) {
+        return value;
+      }
+    });
+
+    const customSqliteReal = customType<{ data: number; driverData: number }>({
+      dataType() {
+        return 'real';
+      },
+      fromDriver(value) {
+        return Number(value);
+      },
+      toDriver(value) {
+        return value;
+      }
+    });
+
+    const lists = sqliteTable('lists', {
+      id: text('id').primaryKey(),
+      text_col: customSqliteText('text_col'),
+      int_col: customSqliteInteger('int_col'),
+      real_col: customSqliteReal('real_col')
+    });
+
+    const convertedList = toPowerSyncTable(lists);
+
+    const expectedLists = new Table({
+      text_col: column.text,
+      int_col: column.integer,
+      real_col: column.real
+    });
+
+    expect(convertedList).toEqual(expectedLists);
+  });
 });
 
 describe('DrizzleAppSchema constructor', () => {