Rewrite drizzle driver for v1 beta relations

Author: ziahamza

.changeset/calm-rivers-appear.md

@@ -0,0 +1,5 @@
+---
+'@powersync/drizzle-driver': minor
+---
+
+Rewrite the Drizzle driver against the Drizzle v1 beta `relations` + `db.query` API and drop `0.x` compatibility from this release line.

demos/react-neon-tanstack-query-notes/package.json

@@ -28,7 +28,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "drizzle-kit": "^0.31.7",
-    "drizzle-orm": "^0.44.7",
+    "drizzle-orm": "1.0.0-beta.19",
     "lucide-react": "^0.503.0",
     "moment": "^2.30.1",
     "react": "^19.2.0",

demos/react-neon-tanstack-query-notes/src/lib/powersync-schema.ts

@@ -1,5 +1,5 @@
+import { defineRelations } from 'drizzle-orm';
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { relations } from 'drizzle-orm';
 
 export const notes = sqliteTable('notes', {
   id: text().primaryKey(),
@@ -17,10 +17,9 @@ export const paragraphs = sqliteTable('paragraphs', {
   created_at: text().notNull(),
 });
 
-export const notesRelations = relations(notes, ({ many }) => ({
-  paragraphs: many(paragraphs),
-}));
-
 export const drizzleSchema = {
-  notes, paragraphs, notesRelations
-};
+  notes,
+  paragraphs
+};
+
+export const drizzleRelations = defineRelations(drizzleSchema);

demos/react-neon-tanstack-query-notes/src/lib/powersync.ts

@@ -15,7 +15,7 @@ import {
   DrizzleAppSchema,
 } from "@powersync/drizzle-driver";
 
-import { drizzleSchema } from "./powersync-schema";
+import { drizzleRelations, drizzleSchema } from "./powersync-schema";
 
 /// Postgres Response codes that we cannot recover from by retrying.
 const FATAL_RESPONSE_CODES = [
@@ -205,7 +205,9 @@ export const powersync = new PowerSyncDatabase({
   },
 });
 
-export const powersyncDrizzle = wrapPowerSyncWithDrizzle(powersync);
+export const powersyncDrizzle = wrapPowerSyncWithDrizzle(powersync, {
+  relations: drizzleRelations,
+});
 
 let isInitialized = false;
 

packages/drizzle-driver/README.md

@@ -4,29 +4,7 @@ This package (`@powersync/drizzle-driver`) brings the benefits of an ORM through
 
 ## Beta Release
 
-The `drizzle-driver` package is currently in an Beta release.
-
-## Drizzle Version Support
-
-- `drizzle-orm@0.44.x`
-  - Pass `schema`.
-  - `db.query` keeps working as before.
-  - `db._query` is available as an alias to the same legacy relational query builder.
-- `drizzle-orm@1.0.0-beta`
-  - Pass `relations`.
-  - Use `db.query` for relational queries.
-  - If you only pass `schema`, the driver exposes a basic `db.query.<table>.findMany()` surface for simple table queries, but relational `with` queries should use `relations`.
-
-## Drizzle Version Support
-
-- `drizzle-orm@0.44.x`
-  - Use `schema`.
-  - `db.query` continues to use the legacy relational query builder.
-  - `db._query` is available as a compatibility alias to the same legacy query builder.
-- `drizzle-orm@1.0.0-beta`
-  - Use `relations` for the new relational query builder and query via `db.query`.
-  - Keep using `schema` if you want the legacy relational query builder on `db._query`.
-  - If you only pass `schema`, the driver synthesizes a basic `db.query.<table>.findMany()` surface for simple table queries.
+This release line targets `drizzle-orm@1.0.0-beta` and the beta `relations` + `db.query` API.
 
 ## Getting Started
 
@@ -35,7 +13,7 @@ Set up the PowerSync Database and wrap it with Drizzle.
 ```js
 import { wrapPowerSyncWithDrizzle } from '@powersync/drizzle-driver';
 import { PowerSyncDatabase } from '@powersync/web';
-import { relations } from 'drizzle-orm';
+import { defineRelations } from 'drizzle-orm';
 import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { AppSchema } from './schema';
 
@@ -51,52 +29,6 @@ export const todos = sqliteTable('todos', {
   created_at: text('created_at')
 });
 
-export const listsRelations = relations(lists, ({ one, many }) => ({
-  todos: many(todos)
-}));
-
-export const todosRelations = relations(todos, ({ one, many }) => ({
-  list: one(lists, {
-    fields: [todos.list_id],
-    references: [lists.id]
-  })
-}));
-
-export const drizzleSchema = {
-  lists,
-  todos,
-  listsRelations,
-  todosRelations
-};
-
-// As an alternative to manually defining a PowerSync schema, generate the local PowerSync schema from the Drizzle schema with the `DrizzleAppSchema` constructor:
-// import { DrizzleAppSchema } from '@powersync/drizzle-driver';
-// export const AppSchema = new DrizzleAppSchema(drizzleSchema);
-//
-// This is optional, but recommended, since you will only need to maintain one schema on the client-side
-// Read on to learn more.
-
-export const powerSyncDb = new PowerSyncDatabase({
-  database: {
-    dbFilename: 'test.sqlite'
-  },
-  schema: AppSchema
-});
-
-// This is the DB you will use in queries
-export const db = wrapPowerSyncWithDrizzle(powerSyncDb, {
-  schema: drizzleSchema
-});
-```
-
-### Drizzle v1 beta
-
-For Drizzle beta relational queries, pass `relations` and use `db.query`.
-
-```js
-import { defineRelations } from 'drizzle-orm';
-import { wrapPowerSyncWithDrizzle } from '@powersync/drizzle-driver';
-
 export const relations = defineRelations({ lists, todos }, (r) => ({
   lists: {
     todos: r.many.todos({
@@ -113,82 +45,30 @@ export const relations = defineRelations({ lists, todos }, (r) => ({
   }
 }));
 
-export const db = wrapPowerSyncWithDrizzle(powerSyncDb, {
-  relations
-});
-
-const listsWithTodos = await db.query.lists.findMany({
-  with: {
-    todos: true
-  }
-});
-```
-
-### Drizzle v1 beta
-
-For Drizzle beta relational queries, pass `relations` and use `db.query`.
-
-```js
-import { defineRelations } from 'drizzle-orm';
-import { wrapPowerSyncWithDrizzle } from '@powersync/drizzle-driver';
+// As an alternative to manually defining a PowerSync schema, generate the local PowerSync schema from the Drizzle schema with the `DrizzleAppSchema` constructor:
+// import { DrizzleAppSchema } from '@powersync/drizzle-driver';
+// export const AppSchema = new DrizzleAppSchema({ lists, todos });
+//
+// This is optional, but recommended, since you will only need to maintain one schema on the client-side
+// Read on to learn more.
 
-export const relations = defineRelations({ lists, todos }, (r) => ({
-  lists: {
-    todos: r.many.todos({
-      from: r.lists.id,
-      to: r.todos.list_id
-    })
+export const powerSyncDb = new PowerSyncDatabase({
+  database: {
+    dbFilename: 'test.sqlite'
   },
-  todos: {
-    list: r.one.lists({
-      from: r.todos.list_id,
-      to: r.lists.id,
-      optional: false
-    })
-  }
-}));
+  schema: AppSchema
+});
 
+// This is the DB you will use in queries
 export const db = wrapPowerSyncWithDrizzle(powerSyncDb, {
   relations
 });
-
-const listsWithTodos = await db.query.lists.findMany({
-  with: {
-    todos: true
-  }
-});
 ```
 
-### Partial upgrade on Drizzle beta
-
-If you are upgrading incrementally, keep legacy relation definitions in `drizzle-orm/_relations`, pass them via `schema`, and use `db._query`.
+To make relational queries, use `db.query`:
 
 ```js
-import { relations } from 'drizzle-orm/_relations';
-
-const listsRelations = relations(lists, ({ many }) => ({
-  todos: many(todos)
-}));
-
-const todosRelations = relations(todos, ({ one }) => ({
-  list: one(lists, {
-    fields: [todos.list_id],
-    references: [lists.id]
-  })
-}));
-
-const legacySchema = {
-  lists,
-  todos,
-  listsRelations,
-  todosRelations
-};
-
-export const db = wrapPowerSyncWithDrizzle(powerSyncDb, {
-  schema: legacySchema
-});
-
-const listsWithTodos = await db._query.lists.findMany({
+const listsWithTodos = await db.query.lists.findMany({
   with: {
     todos: true
   }

packages/drizzle-driver/package.json

@@ -47,7 +47,7 @@
   },
   "peerDependencies": {
     "@powersync/common": "workspace:^1.50.0",
-    "drizzle-orm": ">=0.44.7 <1.0.0 || >=1.0.0-beta.1 <1.0.0"
+    "drizzle-orm": ">=1.0.0-beta.19 <1.0.0"
   },
   "devDependencies": {
     "@journeyapps/wa-sqlite": "catalog:",
@@ -56,7 +56,7 @@
     "@rollup/plugin-node-resolve": "catalog:",
     "@rollup/plugin-typescript": "catalog:",
     "@types/node": "catalog:",
-    "drizzle-orm": "catalog:",
+    "drizzle-orm": "1.0.0-beta.19",
     "rollup": "catalog:",
     "rollup-plugin-dts": "catalog:",
     "vite": "catalog:"

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

@@ -1,9 +1,9 @@
-import type { QueryResult } from '@powersync/common';
+import type { AbstractPowerSyncDatabase, QueryResult } from '@powersync/common';
 import type { WithCacheConfig } from 'drizzle-orm/cache/core/types';
 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 { AnyRelations, EmptyRelations } 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';
@@ -16,38 +16,45 @@ import {
 } from 'drizzle-orm/sqlite-core/session';
 import { PowerSyncSQLitePreparedQuery, type ContextProvider } from './PowerSyncSQLitePreparedQuery.js';
 
-const SQLiteSessionBase = SQLiteSession as unknown as abstract new (...args: any[]) => any;
-const SQLiteTransactionBase = SQLiteTransaction as unknown as abstract new (...args: any[]) => any;
+type ResultMapper = (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown;
+type RelationalResultMapper = (
+  rows: Record<string, unknown>[],
+  mapColumnValue?: (value: unknown) => unknown
+) => unknown;
 
 export interface PowerSyncSQLiteSessionOptions {
   logger?: Logger;
+  db: AbstractPowerSyncDatabase;
 }
 
 export type PowerSyncSQLiteTransactionConfig = SQLiteTransactionConfig & {
   accessMode?: 'read only' | 'read write';
 };
 
-export class PowerSyncSQLiteTransaction<
-  TFullSchema extends Record<string, unknown>,
-  TSchema extends TablesRelationalConfig
-> extends SQLiteTransactionBase {
+export class PowerSyncSQLiteTransaction<TRelations extends AnyRelations = EmptyRelations> extends SQLiteTransaction<
+  'async',
+  QueryResult,
+  Record<string, never>,
+  TRelations
+> {
   static readonly [entityKind]: string = 'PowerSyncSQLiteTransaction';
 }
 
-export class PowerSyncSQLiteBaseSession<
-  TFullSchema extends Record<string, unknown>,
-  TSchema extends TablesRelationalConfig
-> extends SQLiteSessionBase {
+export class PowerSyncSQLiteBaseSession<TRelations extends AnyRelations = EmptyRelations> extends SQLiteSession<
+  'async',
+  QueryResult,
+  Record<string, never>,
+  TRelations
+> {
   static readonly [entityKind]: string = 'PowerSyncSQLiteBaseSession';
 
   protected logger: Logger;
 
   constructor(
     protected contextProvider: ContextProvider,
     protected dialect: SQLiteAsyncDialect,
-    protected schema: RelationalSchemaConfig<TSchema> | undefined,
-    protected options: PowerSyncSQLiteSessionOptions = {},
-    protected relations: Record<string, unknown> = {}
+    protected relations: TRelations,
+    protected options: PowerSyncSQLiteSessionOptions
   ) {
     super(dialect);
     this.logger = options.logger ?? new NoopLogger();
@@ -58,7 +65,7 @@ export class PowerSyncSQLiteBaseSession<
     fields: SelectedFieldsOrdered | undefined,
     executeMethod: SQLiteExecuteMethod,
     isResponseInArrayMode: boolean,
-    customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
+    customResultMapper?: ResultMapper,
     queryMetadata?: {
       type: 'select' | 'update' | 'delete' | 'insert';
       tables: string[];
@@ -73,7 +80,7 @@ export class PowerSyncSQLiteBaseSession<
       executeMethod,
       isResponseInArrayMode,
       customResultMapper,
-      undefined, // cache not supported yet
+      undefined,
       queryMetadata,
       cacheConfig
     );
@@ -83,7 +90,7 @@ export class PowerSyncSQLiteBaseSession<
     query: Query,
     fields: SelectedFieldsOrdered | undefined,
     executeMethod: SQLiteExecuteMethod,
-    customResultMapper: (rows: Record<string, unknown>[], mapColumnValue?: (value: unknown) => unknown) => unknown
+    customResultMapper: RelationalResultMapper
   ): PowerSyncSQLitePreparedQuery<T> {
     return new PowerSyncSQLitePreparedQuery(
       this.contextProvider,
@@ -101,7 +108,7 @@ export class PowerSyncSQLiteBaseSession<
   }
 
   transaction<T>(
-    _transaction: (tx: PowerSyncSQLiteTransaction<TFullSchema, TSchema>) => T,
+    _transaction: (tx: PowerSyncSQLiteTransaction<TRelations>) => T,
     _config: PowerSyncSQLiteTransactionConfig = {}
   ): T {
     throw new Error('Nested transactions are not supported');