Basic tests for Drizzle ORM package.

Author: Chriztiaan

packages/drizzle-driver/package.json

@@ -22,12 +22,27 @@
     "build": "tsc --build",
     "build:prod": "tsc --build --sourceMap false",
     "clean": "rm -rf lib tsconfig.tsbuildinfo",
-    "watch": "tsc --build -w"
+    "watch": "tsc --build -w",
+    "test": "vitest"
   },
   "peerDependencies": {
     "@powersync/common": "workspace:^1.19.0"
   },
   "dependencies": {
     "drizzle-orm": "0.35.2"
+  },
+  "devDependencies": {
+    "@powersync/web": "workspace:*",
+    "@journeyapps/wa-sqlite": "^0.4.1",
+    "@types/node": "^20.17.6",
+    "@vitest/browser": "^2.1.4",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10",
+    "vite-plugin-top-level-await": "^1.4.4",
+    "vite-plugin-wasm": "^3.3.0",
+    "vitest": "^2.1.4",
+    "webdriverio": "^9.2.8"
   }
 }

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

@@ -0,0 +1,32 @@
+import { Schema, PowerSyncDatabase, column, Table, AbstractPowerSyncDatabase } from '@powersync/web';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { wrapPowerSyncWithDrizzle, PowerSyncSQLiteDatabase } from '../../src/sqlite/db';
+
+const users = new Table({
+  name: column.text
+});
+
+export const drizzleUsers = sqliteTable('users', {
+  id: text('id').primaryKey().notNull(),
+  name: text('name').notNull()
+});
+
+export const TestSchema = new Schema({ users });
+export const DrizzleSchema = { users: drizzleUsers };
+
+export const getPowerSyncDb = () => {
+  const database = new PowerSyncDatabase({
+    database: {
+      dbFilename: 'test.db'
+    },
+    schema: TestSchema
+  });
+
+  return database;
+};
+
+export const getDrizzleDb = (db: AbstractPowerSyncDatabase) => {
+  const database = wrapPowerSyncWithDrizzle(db, { schema: DrizzleSchema });
+
+  return database;
+};

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

@@ -0,0 +1,5 @@
+import { TestSchema } from './db';
+
+export type Database = (typeof TestSchema)['types'];
+
+export type UsersTable = Database['users'];

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

@@ -0,0 +1,63 @@
+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 { DrizzleSchema, drizzleUsers, getDrizzleDb, getPowerSyncDb } from '../setup/db';
+
+describe('Database operations', () => {
+  let powerSyncDb: AbstractPowerSyncDatabase;
+  let db: SUT.PowerSyncSQLiteDatabase<typeof DrizzleSchema>;
+
+  beforeEach(() => {
+    powerSyncDb = getPowerSyncDb();
+    db = getDrizzleDb(powerSyncDb);
+  });
+
+  afterEach(async () => {
+    await powerSyncDb.disconnectAndClear();
+  });
+
+  it('should insert a user and select that user', async () => {
+    await db.insert(drizzleUsers).values({ id: '1', name: 'John' });
+    const result = await db.select().from(drizzleUsers);
+
+    expect(result.length).toEqual(1);
+  });
+
+  it('should insert a user and delete that user', async () => {
+    await db.insert(drizzleUsers).values({ id: '2', name: 'Ben' });
+    await db.delete(drizzleUsers).where(eq(drizzleUsers.name, 'Ben'));
+    const result = await db.select().from(drizzleUsers);
+
+    expect(result.length).toEqual(0);
+  });
+
+  it('should insert a user and update that user', async () => {
+    await db.insert(drizzleUsers).values({ id: '3', name: 'Lucy' });
+    await db.update(drizzleUsers).set({ name: 'Lucy Smith' }).where(eq(drizzleUsers.name, 'Lucy'));
+    const result = await db.select().from(drizzleUsers).get();
+
+    expect(result!.name).toEqual('Lucy Smith');
+  });
+
+  it('should insert a user and update that user within a transaction', async () => {
+    await db.transaction(async (transaction) => {
+      await transaction.insert(drizzleUsers).values({ id: '4', name: 'James' });
+      await transaction.update(drizzleUsers).set({ name: 'James Smith' }).where(eq(drizzleUsers.name, 'James'));
+    });
+    const result = await db.select().from(drizzleUsers).get();
+
+    expect(result!.name).toEqual('James Smith');
+  });
+
+  it('should insert a user and update that user within a transaction when raw sql is used', async () => {
+    await db.transaction(async (transaction) => {
+      await transaction.run(sql`INSERT INTO users (id, name) VALUES ('4', 'James');`);
+      await db.update(drizzleUsers).set({ name: 'James Smith' }).where(eq(drizzleUsers.name, 'James'));
+    });
+
+    const result = await db.select().from(drizzleUsers).get();
+
+    expect(result!.name).toEqual('James Smith');
+  });
+});

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

@@ -0,0 +1,65 @@
+// import { PowerSyncSQLitePreparedQuery, mapResultRow } from './PowerSyncSQLitePreparedQuery';
+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 { DrizzleSchema, drizzleUsers, getDrizzleDb, getPowerSyncDb } from '../setup/db';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+describe('PowerSyncSQLitePreparedQuery', () => {
+  let powerSyncDb: AbstractPowerSyncDatabase;
+  let db: PowerSyncSQLiteDatabase<typeof DrizzleSchema>;
+  const loggerMock = { logQuery: () => {} };
+
+  beforeEach(async () => {
+    powerSyncDb = getPowerSyncDb();
+    db = getDrizzleDb(powerSyncDb);
+
+    await db.insert(drizzleUsers).values({ id: '1', name: 'Alice' });
+    await db.insert(drizzleUsers).values({ id: '2', name: 'Bob' });
+  });
+
+  afterEach(async () => {
+    await powerSyncDb.disconnectAndClear();
+  });
+
+  it('should execute a query in run()', async () => {
+    const query: Query = { sql: `SELECT * FROM users WHERE id = ?`, params: [1] };
+    const preparedQuery = new PowerSyncSQLitePreparedQuery(powerSyncDb, query, loggerMock, undefined, 'run', false);
+
+    const result = await preparedQuery.run();
+    expect(result.rows?._array).toEqual([{ id: '1', name: 'Alice' }]);
+  });
+
+  it('should retrieve all rows in all()', async () => {
+    const query: Query = { sql: `SELECT * FROM users`, params: [] } as Query;
+    const preparedQuery = new PowerSyncSQLitePreparedQuery(powerSyncDb, query, loggerMock, undefined, 'all', false);
+
+    const rows = await preparedQuery.all();
+    expect(rows).toEqual([
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' }
+    ]);
+  });
+
+  it('should retrieve a single row in get()', async () => {
+    const query: Query = { sql: `SELECT * FROM users WHERE id = ?`, params: [1] };
+
+    const preparedQuery = new PowerSyncSQLitePreparedQuery(powerSyncDb, query, loggerMock, undefined, 'get', false);
+
+    const row = await preparedQuery.get();
+    expect(row).toEqual({ id: '1', name: 'Alice' });
+  });
+
+  it('should retrieve values in values()', async () => {
+    const query: Query = { sql: `SELECT * FROM users`, params: [] } as Query;
+
+    const preparedQuery = new PowerSyncSQLitePreparedQuery(powerSyncDb, query, loggerMock, undefined, 'all', false);
+
+    const values = await preparedQuery.values();
+    expect(values).toEqual([
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' }
+    ]);
+  });
+});

packages/drizzle-driver/vitest.config.ts

@@ -0,0 +1,29 @@
+import wasm from 'vite-plugin-wasm';
+import topLevelAwait from 'vite-plugin-top-level-await';
+import { defineConfig, UserConfigExport } from 'vitest/config';
+
+const config: UserConfigExport = {
+  worker: {
+    format: 'es',
+    plugins: () => [wasm(), topLevelAwait()]
+  },
+  optimizeDeps: {
+    // Don't optimise these packages as they contain web workers and WASM files.
+    // https://github.com/vitejs/vite/issues/11672#issuecomment-1415820673
+    exclude: ['@journeyapps/wa-sqlite', '@powersync/web']
+  },
+  plugins: [wasm(), topLevelAwait()],
+  test: {
+    isolate: false,
+    globals: true,
+    include: ['tests/**/*.test.ts'],
+    browser: {
+      enabled: true,
+      headless: true,
+      provider: 'webdriverio',
+      name: 'chrome' // browser name is required
+    }
+  }
+};
+
+export default defineConfig(config);

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

@@ -51,13 +51,11 @@ describe('CRUD operations', () => {
     expect(result.name).toEqual('James Smith');
   });
 
-
   it('should insert a user and update that user within a transaction when raw sql is used', async () => {
     await db.transaction().execute(async (transaction) => {
-      await sql`INSERT INTO users (id, name) VALUES ('4', 'James');`.execute(transaction)
+      await sql`INSERT INTO users (id, name) VALUES ('4', 'James');`.execute(transaction);
       await transaction.updateTable('users').where('name', '=', 'James').set('name', 'James Smith').execute();
     });
-    console.log(await db.selectFrom('users').selectAll().execute())
     const result = await db.selectFrom('users').select('name').executeTakeFirstOrThrow();
 
     expect(result.name).toEqual('James Smith');