Introduced DrizzleAppSchema constructor.

Author: Chriztiaan

packages/common/src/db/schema/Schema.ts

@@ -2,7 +2,7 @@ import { RowType, Table } from './Table.js';
 
 type SchemaType = Record<string, Table<any>>;
 
-type SchemaTableType<S extends SchemaType> = {
+export type SchemaTableType<S extends SchemaType> = {
   [K in keyof S]: RowType<S[K]>;
 };
 

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

@@ -1,4 +1,12 @@
-import { column, IndexShorthand, Schema, Table, type BaseColumnType, type TableV2Options } from '@powersync/common';
+import {
+  column,
+  IndexShorthand,
+  Schema,
+  SchemaTableType,
+  Table,
+  type BaseColumnType,
+  type TableV2Options
+} from '@powersync/common';
 import { InferSelectModel, isTable, Relations } from 'drizzle-orm';
 import {
   getTableConfig,
@@ -111,3 +119,40 @@ export function toPowerSyncSchema<
 
   return new Schema(tables) as Schema<Expand<TablesFromSchemaEntries<T>>>;
 }
+
+export function toPowerSyncTables<
+  T extends Record<string, SQLiteTableWithColumns<any> | Relations | DrizzleTableWithPowerSyncOptions>
+>(schemaEntries: T) {
+  const tables: Record<string, Table> = {};
+  for (const schemaEntry of Object.values(schemaEntries)) {
+    let maybeTable: SQLiteTableWithColumns<any> | Relations | undefined = undefined;
+    let maybeOptions: DrizzleTablePowerSyncOptions | undefined = undefined;
+
+    if (typeof schemaEntry === 'object' && 'tableDefinition' in schemaEntry) {
+      const tableWithOptions = schemaEntry as DrizzleTableWithPowerSyncOptions;
+      maybeTable = tableWithOptions.tableDefinition;
+      maybeOptions = tableWithOptions.options;
+    } else {
+      maybeTable = schemaEntry;
+    }
+
+    if (isTable(maybeTable)) {
+      const { name } = getTableConfig(maybeTable);
+      tables[name] = toPowerSyncTable(maybeTable as SQLiteTableWithColumns<TableConfig>, maybeOptions);
+    }
+  }
+
+  return tables;
+}
+
+export class DrizzleAppSchema<
+  T extends Record<string, SQLiteTableWithColumns<any> | Relations | DrizzleTableWithPowerSyncOptions>
+> extends Schema {
+  constructor(drizzleSchema: T) {
+    super(toPowerSyncTables(drizzleSchema));
+    // This is just used for typing
+    this.types = {} as SchemaTableType<Expand<TablesFromSchemaEntries<T>>>;
+  }
+
+  readonly types: SchemaTableType<Expand<TablesFromSchemaEntries<T>>>;
+}

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

@@ -1,7 +1,12 @@
 import { column, Schema, Table } from '@powersync/common';
 import { index, integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { describe, expect, it } from 'vitest';
-import { DrizzleTableWithPowerSyncOptions, toPowerSyncSchema, toPowerSyncTable } from '../../src/utils/schema';
+import {
+  DrizzleAppSchema,
+  DrizzleTableWithPowerSyncOptions,
+  toPowerSyncSchema,
+  toPowerSyncTable
+} from '../../src/utils/schema';
 
 describe('toPowerSyncTable', () => {
   it('basic conversion', () => {
@@ -24,6 +29,36 @@ describe('toPowerSyncTable', () => {
     expect(convertedList).toEqual(expectedLists);
   });
 
+  it('basic conversion class', () => {
+    const lists = sqliteTable('lists', {
+      id: text('id').primaryKey(),
+      name: text('name').notNull(),
+      owner_id: text('owner_id'),
+      counter: integer('counter'),
+      completion: real('completion')
+    });
+    const convertedList = new DrizzleAppSchema({ lists });
+
+    const a: (typeof convertedList)['types']['lists'] = {
+      name: 'd',
+      completion: 1,
+      counter: 0,
+      id: '1',
+      owner_id: null
+    };
+  });
+
+  it('classed based types', () => {
+    const lists = sqliteTable('lists', {
+      id: text('id').primaryKey(),
+      name: text('name').notNull(),
+      owner_id: text('owner_id'),
+      counter: integer('counter'),
+      completion: real('completion')
+    });
+    const drizzle = new DrizzleAppSchema({ lists });
+  });
+
   it('conversion with index', () => {
     const lists = sqliteTable(
       'lists',