Add Postgres test coverage with pglite (#207)

## Summary
- run the backend test suite in separate sqlite and postgres Vitest
projects
- back the postgres project with pglite while exercising the normal
Postgres schema and migration paths
- remove sqlite-only test assumptions so the same tests pass under both
dialects

## Testing
- bun run test

Author: mcowger

bun.lock

@@ -34,6 +34,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.4.4",
     "@types/bun": "latest",
     "@types/node": "^25.6.0",
     "@types/winston": "^2.4.4",

packages/backend/package.json

@@ -1,9 +1,16 @@
 import { beforeEach, afterEach, describe, expect, it } from 'vitest';
 import { eq } from 'drizzle-orm';
-import { closeDatabase, getDatabase, getSchema, initializeDatabase } from '../client';
+import {
+  closeDatabase,
+  getCurrentDialect,
+  getDatabase,
+  getSchema,
+  initializeDatabase,
+} from '../client';
 import { runMigrations } from '../migrate';
 import { runEncryptionMigration } from '../encrypt-migration';
 import { decrypt, hashSecret, isEncrypted, resetEncryptionKeyCache } from '../../utils/encryption';
+import { toDbBoolean } from '../../utils/normalize';
 
 const TEST_KEY = 'b'.repeat(64);
 
@@ -22,11 +29,15 @@ describe('encryption migration', () => {
 
   beforeEach(async () => {
     await closeDatabase();
-    process.env.DATABASE_URL = 'sqlite://:memory:';
+    process.env.DATABASE_URL = process.env.PLEXUS_TEST_DB_URL ?? process.env.DATABASE_URL;
     initializeDatabase(process.env.DATABASE_URL);
     await runMigrations();
     db = getDatabase();
     schema = getSchema();
+    await db.delete(schema.providers);
+    await db.delete(schema.apiKeys);
+    await db.delete(schema.oauthCredentials);
+    await db.delete(schema.mcpServers);
   });
 
   afterEach(async () => {
@@ -100,11 +111,11 @@ describe('encryption migration', () => {
       slug: 'test-provider',
       apiBaseUrl: '"https://api.example.com"',
       apiKey: 'provider-api-key-123',
-      enabled: 1,
-      disableCooldown: 0,
-      estimateTokens: 0,
-      useClaudeMasking: 0,
-      quotaCheckerEnabled: 1,
+      enabled: toDbBoolean(true, getCurrentDialect()),
+      disableCooldown: toDbBoolean(false, getCurrentDialect()),
+      estimateTokens: toDbBoolean(false, getCurrentDialect()),
+      useClaudeMasking: toDbBoolean(false, getCurrentDialect()),
+      quotaCheckerEnabled: toDbBoolean(true, getCurrentDialect()),
       quotaCheckerInterval: 30,
       createdAt: ts,
       updatedAt: ts,
@@ -130,11 +141,11 @@ describe('encryption migration', () => {
       headers,
       extraBody,
       quotaCheckerOptions: quotaOpts,
-      enabled: 1,
-      disableCooldown: 0,
-      estimateTokens: 0,
-      useClaudeMasking: 0,
-      quotaCheckerEnabled: 1,
+      enabled: toDbBoolean(true, getCurrentDialect()),
+      disableCooldown: toDbBoolean(false, getCurrentDialect()),
+      estimateTokens: toDbBoolean(false, getCurrentDialect()),
+      useClaudeMasking: toDbBoolean(false, getCurrentDialect()),
+      quotaCheckerEnabled: toDbBoolean(true, getCurrentDialect()),
       quotaCheckerInterval: 30,
       createdAt: ts,
       updatedAt: ts,
@@ -164,7 +175,7 @@ describe('encryption migration', () => {
     await db.insert(schema.mcpServers).values({
       name: 'test-mcp',
       upstreamUrl: 'https://mcp.example.com/mcp',
-      enabled: 1,
+      enabled: toDbBoolean(true, getCurrentDialect()),
       headers,
       createdAt: ts,
       updatedAt: ts,

packages/backend/src/db/__tests__/encrypt-migration.test.ts

@@ -2,15 +2,20 @@ import { Database } from 'bun:sqlite';
 import { drizzle } from 'drizzle-orm/bun-sqlite';
 import { drizzle as drizzlePg } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
-import { getDatabaseConfig } from '../config';
 import { getCurrentLogLevel, logger } from '../utils/logger';
 import path from 'node:path';
 import fs from 'node:fs';
 
 type SupportedDialect = 'sqlite' | 'postgres';
+type PostgresDriver = 'postgres-js' | 'pglite';
 
-let dbInstance: ReturnType<typeof drizzle> | ReturnType<typeof drizzlePg> | null = null;
+type SqliteDb = ReturnType<typeof drizzle>;
+type PostgresJsDb = ReturnType<typeof drizzlePg>;
+type PgliteDb = any;
+
+let dbInstance: SqliteDb | PostgresJsDb | PgliteDb | null = null;
 let sqlClient: postgres.Sql | null = null;
+let pgliteClient: any = null;
 let currentDialect: SupportedDialect | null = null;
 let currentSchema: any = null;
 
@@ -45,6 +50,10 @@ function resolvePath(relPath: string): string {
   return path.join(projectRoot, relPath);
 }
 
+function getPostgresDriver(): PostgresDriver {
+  return process.env.PLEXUS_POSTGRES_DRIVER === 'pglite' ? 'pglite' : 'postgres-js';
+}
+
 export function initializeDatabase(connectionString?: string) {
   if (dbInstance) {
     logger.silly('Database already initialized, skipping');
@@ -124,19 +133,7 @@ export function initializeDatabase(connectionString?: string) {
       logger: createDrizzleLogger(),
     });
   } else {
-    sqlClient = postgres(connStr, {
-      ssl: false,
-      max: 10,
-      idle_timeout: 20,
-      connect_timeout: 10,
-      onnotice: () => {},
-    });
-
-    // Set statement timeout to prevent long-running queries from blocking
-    sqlClient`SET statement_timeout = '30s'`.catch((err) => {
-      logger.silly(`Failed to set statement_timeout: ${err}`);
-    });
-
+    const postgresDriver = getPostgresDriver();
     const pgSchema = require('../../drizzle/schema/postgres/index');
     const {
       requestUsage,
@@ -157,26 +154,53 @@ export function initializeDatabase(connectionString?: string) {
     } = pgSchema;
 
     currentSchema = pgSchema;
-    dbInstance = drizzlePg(sqlClient, {
-      schema: {
-        requestUsage,
-        providerCooldowns,
-        debugLogs,
-        inferenceErrors,
-        providerPerformance,
-        quotaState,
-        providers: providersTable,
-        providerModels,
-        modelAliases,
-        modelAliasTargets,
-        apiKeys,
-        userQuotaDefinitions,
-        mcpServers,
-        systemSettings,
-        oauthCredentials,
-      },
-      logger: createDrizzleLogger(),
-    });
+
+    const schema = {
+      requestUsage,
+      providerCooldowns,
+      debugLogs,
+      inferenceErrors,
+      providerPerformance,
+      quotaState,
+      providers: providersTable,
+      providerModels,
+      modelAliases,
+      modelAliasTargets,
+      apiKeys,
+      userQuotaDefinitions,
+      mcpServers,
+      systemSettings,
+      oauthCredentials,
+    };
+
+    if (postgresDriver === 'pglite') {
+      const { PGlite } = require('@electric-sql/pglite');
+      const { drizzle: drizzlePglite } = require('drizzle-orm/pglite');
+      const dataDir = process.env.PLEXUS_PGLITE_DATA_DIR;
+      pgliteClient = dataDir ? new PGlite(dataDir) : new PGlite();
+      dbInstance = drizzlePglite(pgliteClient, {
+        schema,
+        logger: createDrizzleLogger(),
+      });
+    } else {
+      sqlClient = postgres(connStr, {
+        ssl: false,
+        max: 10,
+        idle_timeout: 20,
+        connect_timeout: 10,
+        onnotice: () => {},
+      });
+
+      // Set statement timeout to prevent long-running queries from blocking
+      sqlClient`SET statement_timeout = '30s'`.catch((err) => {
+        logger.silly(`Failed to set statement_timeout: ${err}`);
+      });
+
+      dbInstance = drizzlePg(sqlClient, {
+        schema,
+        logger: createDrizzleLogger(),
+      });
+    }
   }
 
   return dbInstance;
@@ -186,7 +210,7 @@ export function getDatabase() {
   if (!dbInstance) {
     initializeDatabase();
   }
-  return dbInstance as ReturnType<typeof drizzle>;
+  return dbInstance as SqliteDb | PostgresJsDb | PgliteDb;
 }
 
 export function getSchema() {
@@ -208,5 +232,9 @@ export async function closeDatabase() {
     await sqlClient.end();
     sqlClient = null;
   }
+  if (pgliteClient) {
+    await pgliteClient.close();
+    pgliteClient = null;
+  }
   dbInstance = null;
 }

packages/backend/src/db/client.ts

@@ -12,7 +12,7 @@ describe('Usage summary route', () => {
 
   beforeEach(async () => {
     await closeDatabase();
-    process.env.DATABASE_URL = 'sqlite://:memory:';
+    process.env.DATABASE_URL = process.env.PLEXUS_TEST_DB_URL ?? process.env.DATABASE_URL;
     initializeDatabase(process.env.DATABASE_URL);
     await runMigrations();
 

packages/backend/src/routes/management/__tests__/usage-summary.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { sql, eq, and } from 'drizzle-orm';
 import { registerSpy } from '../../../test/test-utils';
 import { UsageStorageService } from '../usage-storage';
 import { closeDatabase, getDatabase, getSchema, initializeDatabase } from '../../db/client';
@@ -49,10 +50,15 @@ const createUsageRecord = (
 describe('UsageStorageService performance metrics', () => {
   beforeEach(async () => {
     await closeDatabase();
-    process.env.DATABASE_URL = 'sqlite://:memory:';
+    process.env.DATABASE_URL = process.env.PLEXUS_TEST_DB_URL ?? process.env.DATABASE_URL;
     delete process.env.PLEXUS_PROVIDER_PERFORMANCE_RETENTION_LIMIT;
     initializeDatabase(process.env.DATABASE_URL);
     await runMigrations();
+
+    const db = getDatabase() as any;
+    const schema = getSchema() as any;
+    await db.delete(schema.providerPerformance);
+    await db.delete(schema.requestUsage);
   });
 
   afterEach(async () => {
@@ -86,12 +92,16 @@ describe('UsageStorageService performance metrics', () => {
       );
     }
 
-    const rows = storage
+    const schema = getSchema() as any;
+    const rows = await storage
       .getDb()
-      .$client.query(
-        'SELECT provider, model, COUNT(*) as count FROM provider_performance GROUP BY provider, model'
-      )
-      .all() as Array<{ provider: string; model: string; count: number }>;
+      .select({
+        provider: schema.providerPerformance.provider,
+        model: schema.providerPerformance.model,
+        count: sql<number>`COUNT(*)`,
+      })
+      .from(schema.providerPerformance)
+      .groupBy(schema.providerPerformance.provider, schema.providerPerformance.model);
 
     const a = rows.find((r) => r.provider === 'provider-a' && r.model === 'model-1');
     const b = rows.find((r) => r.provider === 'provider-b' && r.model === 'model-2');
@@ -230,12 +240,22 @@ describe('UsageStorageService performance metrics', () => {
       );
     }
 
-    const rows = storage
+    const schema = getSchema() as any;
+    const rows = await storage
       .getDb()
-      .$client.query(
-        'SELECT provider, model, COUNT(*) as count FROM provider_performance WHERE provider = ? AND model = ? GROUP BY provider, model'
+      .select({
+        provider: schema.providerPerformance.provider,
+        model: schema.providerPerformance.model,
+        count: sql<number>`COUNT(*)`,
+      })
+      .from(schema.providerPerformance)
+      .where(
+        and(
+          eq(schema.providerPerformance.provider, 'provider-c'),
+          eq(schema.providerPerformance.model, 'model-3')
+        )
       )
-      .all('provider-c', 'model-3') as Array<{ provider: string; model: string; count: number }>;
+      .groupBy(schema.providerPerformance.provider, schema.providerPerformance.model);
 
     expect(rows[0]?.count).toBe(5);
   });