chore(common): merge Table and TableV2 (#282)

Co-authored-by: Steven Ontong <steven@journeyapps.com>
Co-authored-by: DominicGBauer <dominic@nomanini.com>
Co-authored-by: Ralf Kistner <ralf@journeyapps.com>

Author: 4 people

.changeset/sharp-donuts-push.md

@@ -0,0 +1,5 @@
+---
+'@powersync/common': minor
+---
+
+Merge `Table` and `TableV2`  but kept `TableV2` to avoid making this a breaking change.

.prettierignore

@@ -11,4 +11,6 @@
 **/android/**
 **/assets/**
 **/bin/**
-**/ios/**
+**/ios/**
+
+pnpm-lock.yaml

demos/example-vite/src/index.js

@@ -19,9 +19,9 @@ class DummyConnector {
   async uploadData(database) {}
 }
 
-export const AppSchema = new Schema([
-  new Table({ name: 'customers', columns: [new Column({ name: 'name', type: ColumnType.TEXT })] })
-]);
+const customers = new Table({ name: column.text })
+
+export const AppSchema = new Schema({ customers });
 
 let PowerSync;
 

demos/example-webpack/src/index.js

@@ -1,4 +1,4 @@
-import { Column, ColumnType, Schema, Table, PowerSyncDatabase } from '@powersync/web';
+import { Column, ColumnType, Schema, Table, PowerSyncDatabase, column } from '@powersync/web';
 import Logger from 'js-logger';
 
 Logger.useDefaults();
@@ -19,9 +19,9 @@ class DummyConnector {
   async uploadData(database) {}
 }
 
-export const AppSchema = new Schema([
-  new Table({ name: 'customers', columns: [new Column({ name: 'name', type: ColumnType.TEXT })] })
-]);
+const customers = new Table({ name: column.text })
+
+export const AppSchema = new Schema({ customers });
 
 let PowerSync;
 

demos/react-multi-client/.gitignore

@@ -35,4 +35,4 @@ yarn-error.log*
 .vercel
 
 # typescript
-*.tsbuildinfo
+*.tsbuildinfo

demos/react-supabase-todolist/src/library/powersync/AppSchema.ts

@@ -1,9 +1,9 @@
-import { column, Schema, TableV2 } from '@powersync/web';
+import { column, Schema, Table } from '@powersync/web';
 
 export const LISTS_TABLE = 'lists';
 export const TODOS_TABLE = 'todos';
 
-const todos = new TableV2(
+const todos = new Table(
   {
     list_id: column.text,
     created_at: column.text,
@@ -16,7 +16,7 @@ const todos = new TableV2(
   { indexes: { list: ['list_id'] } }
 );
 
-const lists = new TableV2({
+const lists = new Table({
   created_at: column.text,
   name: column.text,
   owner_id: column.text

packages/common/src/db/Column.ts

@@ -0,0 +1,60 @@
+// https://www.sqlite.org/lang_expr.html#castexpr
+export enum ColumnType {
+  TEXT = 'TEXT',
+  INTEGER = 'INTEGER',
+  REAL = 'REAL'
+}
+
+export interface ColumnOptions {
+  name: string;
+  type?: ColumnType;
+}
+
+export type BaseColumnType<T extends number | string | null> = {
+  type: ColumnType;
+};
+
+export type ColumnsType = Record<string, BaseColumnType<any>>;
+
+export type ExtractColumnValueType<T extends BaseColumnType<any>> = T extends BaseColumnType<infer R> ? R : unknown;
+
+const text: BaseColumnType<string | null> = {
+  type: ColumnType.TEXT
+};
+
+const integer: BaseColumnType<number | null> = {
+  type: ColumnType.INTEGER
+};
+
+const real: BaseColumnType<number | null> = {
+  type: ColumnType.REAL
+};
+
+// There is maximum of 127 arguments for any function in SQLite. Currently we use json_object which uses 1 arg per key (column name)
+// and one per value, which limits it to 63 arguments.
+export const MAX_AMOUNT_OF_COLUMNS = 63;
+
+export const column = {
+  text,
+  integer,
+  real
+};
+
+export class Column {
+  constructor(protected options: ColumnOptions) {}
+
+  get name() {
+    return this.options.name;
+  }
+
+  get type() {
+    return this.options.type;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type
+    };
+  }
+}

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

@@ -1,4 +1,4 @@
-import { ColumnType } from '../Column';
+import { ColumnType } from './Column';
 import { Table } from './Table';
 
 export interface IndexColumnOptions {

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

@@ -1,7 +1,6 @@
-import { Table as ClassicTable } from './Table';
-import { RowType, TableV2 } from './TableV2';
+import { RowType, Table } from './Table';
 
-type SchemaType = Record<string, TableV2<any>>;
+type SchemaType = Record<string, Table<any>>;
 
 type SchemaTableType<S extends SchemaType> = {
   [K in keyof S]: RowType<S[K]>;
@@ -16,9 +15,9 @@ export class Schema<S extends SchemaType = SchemaType> {
   */
   readonly types: SchemaTableType<S>;
   readonly props: S;
-  readonly tables: ClassicTable[];
+  readonly tables: Table[];
 
-  constructor(tables: ClassicTable[] | S) {
+  constructor(tables: Table[] | S) {
     if (Array.isArray(tables)) {
       this.tables = tables;
     } else {
@@ -28,20 +27,29 @@ export class Schema<S extends SchemaType = SchemaType> {
   }
 
   validate() {
-    for (const table of this.tables as ClassicTable[]) {
+    for (const table of this.tables) {
       table.validate();
     }
   }
 
   toJSON() {
     return {
-      tables: (this.tables as ClassicTable[]).map((t) => t.toJSON())
+      // This is required because "name" field is not present in TableV2
+      tables: this.tables.map((t) => t.toJSON())
     };
   }
 
   private convertToClassicTables(props: S) {
     return Object.entries(props).map(([name, table]) => {
-      return ClassicTable.createTable(name, table);
+      const convertedTable = new Table({
+        name,
+        columns: table.columns,
+        indexes: table.indexes,
+        localOnly: table.localOnly,
+        insertOnly: table.insertOnly,
+        viewName: table.viewNameOverride || name
+      });
+      return convertedTable;
     });
   }
 }