@pikku/cli 0.12.38 → 0.12.40

package/dist/src/functions/db/local-db.js

@@ -3,7 +3,7 @@ import { resolve, isAbsolute, relative, dirname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { runInNewContext } from 'node:vm';
 import { transformSync } from 'esbuild';
-import { CamelCasePlugin, CompiledQuery, Kysely, PostgresDialect } from 'kysely';
+import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely';
 import { migrate } from './db-migrator.js';
 import { loadAuthOptions, getAuthMigrations } from './better-auth-schema.js';
 import { generateSchemaTypes } from './db-codegen.js';
@@ -15,6 +15,7 @@ import { createSqliteKysely } from './sqlite/sqlite-kysely.js';
 import { loadSqliteRuntime } from './sqlite/sqlite-runtime.js';
 import { seed as runSeed } from './sqlite/seed.js';
 import { PostgresMigrationExecutor } from './postgres/postgres-migrator.js';
+import { createPGliteKysely } from './postgres/pglite-kysely.js';
 import { PostgresIntrospector } from './postgres/postgres-introspector.js';
 // ─── Resolution ───────────────────────────────────────────────────────────────
 /**
@@ -35,6 +36,9 @@ export function parseDatabaseUrl(url) {
  * Returns null when neither sqliteDb nor postgresUrl is configured.
  */
 export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
+    const resolvedRuntimeDir = runtimeDir
+        ? resolveAgainst(rootDir, runtimeDir)
+        : join(rootDir, '.pikku-runtime');
     const base = (sub) => ({
         rootDir,
         migrationsDir: resolveAgainst(rootDir, sub),
@@ -58,7 +62,10 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
     if (userConfig.postgresUrl) {
         return {
             dialect: 'postgres',
+            mode: 'url',
             connectionString: userConfig.postgresUrl,
+            runtimeDir: resolvedRuntimeDir,
+            seedFile: resolveAgainst(rootDir, 'db/postgres-seed.sql'),
             ...base('db/postgres'),
         };
     }
@@ -67,9 +74,6 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
             ? '.pikku-runtime/dev.db'
             : undefined);
     if (sqliteDb) {
-        const resolvedRuntimeDir = runtimeDir
-            ? resolveAgainst(rootDir, runtimeDir)
-            : join(rootDir, '.pikku-runtime');
         return {
             dialect: 'sqlite',
             dbFile: resolveAgainst(rootDir, sqliteDb),
@@ -78,6 +82,16 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
             ...base('db/sqlite'),
         };
     }
+    if (existsSync(join(rootDir, 'db/postgres'))) {
+        return {
+            dialect: 'postgres',
+            mode: 'pglite',
+            pgliteDir: join(resolvedRuntimeDir, 'dev-postgres'),
+            runtimeDir: resolvedRuntimeDir,
+            seedFile: resolveAgainst(rootDir, 'db/postgres-seed.sql'),
+            ...base('db/postgres'),
+        };
+    }
     return null;
 }
 /** @deprecated Use resolveDb(userConfig, ...) instead. */
@@ -90,6 +104,64 @@ export function resolveLocalDb(sqliteDb, rootDir, outDir, runtimeDir) {
 function resolveAgainst(root, p) {
     return isAbsolute(p) ? p : resolve(root, p);
 }
+async function createPostgresClient(resolved) {
+    if (resolved.mode === 'url') {
+        const { Client } = await import('pg');
+        const client = new Client({ connectionString: resolved.connectionString });
+        await client.connect();
+        return Object.assign(client, {
+            __connectionString: resolved.connectionString,
+        });
+    }
+    if (!resolved.pgliteDir) {
+        throw new Error('PGlite Postgres resolution is missing pgliteDir.');
+    }
+    mkdirSync(dirname(resolved.pgliteDir), { recursive: true });
+    const db = await createEmbeddedPostgres(resolved.pgliteDir);
+    return pgliteAsClient(db);
+}
+async function createEmbeddedPostgres(dataDir) {
+    const [{ PGlite }, { pgcrypto }] = await Promise.all([
+        import('@electric-sql/pglite'),
+        import('@electric-sql/pglite/contrib/pgcrypto'),
+    ]);
+    return new PGlite({
+        ...(dataDir ? { dataDir } : {}),
+        extensions: {
+            pgcrypto,
+        },
+    });
+}
+function pgliteAsClient(db) {
+    return {
+        query: (sql, params) => db.query(sql, params),
+        exec: (sql) => db.exec(sql),
+        __pglite: db,
+        end: async () => {
+            if (!db.closed) {
+                await db.close();
+            }
+        },
+    };
+}
+async function withPostgresClient(resolved, run) {
+    const client = await createPostgresClient(resolved);
+    try {
+        return await run(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function loadCoercionPlugin(coercionFile) {
+    try {
+        const mod = await import(coercionFile);
+        return mod.coercionMap;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function migrateAndCodegen(resolved) {
     let migrateResult;
     let codegenResult;
@@ -120,13 +192,9 @@ export async function migrateAndCodegen(resolved) {
         }
     }
     else {
-        // Postgres
-        const introspector = new PostgresIntrospector(resolved.connectionString);
-        await introspector.connect();
-        try {
-            const { Client } = await import('pg');
-            const client = new Client({ connectionString: resolved.connectionString });
-            await client.connect();
+        await withPostgresClient(resolved, async (client) => {
+            const introspector = new PostgresIntrospector(client);
+            await introspector.connect();
             try {
                 const executor = new PostgresMigrationExecutor(client);
                 migrateResult = await migrate(executor, resolved.migrationsDir);
@@ -142,12 +210,9 @@ export async function migrateAndCodegen(resolved) {
                 });
             }
             finally {
-                await client.end();
+                await introspector.close();
             }
-        }
-        finally {
-            await introspector.close();
-        }
+        });
     }
     const zodResult = generateZodTypes({
         schemaFile: resolved.schemaFile,
@@ -169,26 +234,74 @@ export async function migrateAndCodegen(resolved) {
 }
 // ─── SQLite-only operations ───────────────────────────────────────────────────
 export async function seed(resolved) {
-    const runtime = await loadSqliteRuntime();
-    const db = runtime.open(resolved.dbFile);
-    try {
-        return runSeed(db, resolved.seedFile);
+    if (resolved.dialect === 'sqlite') {
+        const runtime = await loadSqliteRuntime();
+        const db = runtime.open(resolved.dbFile);
+        try {
+            return runSeed(db, resolved.seedFile);
+        }
+        finally {
+            db.close();
+        }
     }
-    finally {
-        db.close();
+    if (!existsSync(resolved.seedFile)) {
+        return { applied: false, bytes: 0 };
+    }
+    const sql = readFileSync(resolved.seedFile, 'utf8');
+    if (sql.trim().length === 0) {
+        return { applied: false, bytes: 0 };
     }
+    await withPostgresClient(resolved, async (client) => {
+        if (typeof client.exec === 'function') {
+            await client.exec(sql);
+        }
+        else {
+            await client.query(sql);
+        }
+    });
+    return { applied: true, bytes: Buffer.byteLength(sql) };
 }
-export function reset(resolved, rootDir) {
+export async function reset(resolved, rootDir) {
     if (process.env.NODE_ENV === 'production') {
         throw new Error(`pikku db reset refused: NODE_ENV=production. This command only runs in dev.`);
     }
-    const rel = relative(resolved.runtimeDir, resolved.dbFile);
-    if (rel.startsWith('..') || isAbsolute(rel)) {
-        throw new Error(`pikku db reset refused: resolved DB file (${resolved.dbFile}) is outside the runtime directory (${resolved.runtimeDir}). Override sqliteDb or set runtimeDir correctly.`);
-    }
-    if (existsSync(resolved.dbFile)) {
-        rmSync(resolved.dbFile);
+    if (resolved.dialect === 'sqlite') {
+        const rel = relative(resolved.runtimeDir, resolved.dbFile);
+        if (rel.startsWith('..') || isAbsolute(rel)) {
+            throw new Error(`pikku db reset refused: resolved DB file (${resolved.dbFile}) is outside the runtime directory (${resolved.runtimeDir}). Override sqliteDb or set runtimeDir correctly.`);
+        }
+        if (existsSync(resolved.dbFile)) {
+            rmSync(resolved.dbFile);
+        }
+        return;
     }
+    if (resolved.mode === 'pglite') {
+        if (!resolved.pgliteDir) {
+            throw new Error('PGlite Postgres resolution is missing pgliteDir.');
+        }
+        const rel = relative(resolved.runtimeDir, resolved.pgliteDir);
+        if (rel.startsWith('..') || isAbsolute(rel)) {
+            throw new Error(`pikku db reset refused: resolved PGlite dir (${resolved.pgliteDir}) is outside the runtime directory (${resolved.runtimeDir}).`);
+        }
+        if (existsSync(resolved.pgliteDir)) {
+            rmSync(resolved.pgliteDir, { recursive: true, force: true });
+        }
+        return;
+    }
+    await withPostgresClient(resolved, async (client) => {
+        const result = await client.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog')
+        AND schema_name NOT LIKE 'pg_toast%'
+        AND schema_name NOT LIKE 'pg_temp_%'
+    `);
+        for (const { schema_name: schemaName } of result.rows) {
+            const quoted = `"${schemaName.replace(/"/g, '""')}"`;
+            await client.query(`DROP SCHEMA IF EXISTS ${quoted} CASCADE`);
+        }
+        await client.query('CREATE SCHEMA IF NOT EXISTS public');
+    });
 }
 // ── Classification sync ───────────────────────────────────────────────────────
 /**
@@ -281,20 +394,40 @@ function compileClassifications(classificationsFile, genJsonFile) {
     return false;
 }
 export async function createKysely(resolved) {
-    mkdirSync(dirname(resolved.dbFile), { recursive: true });
-    const runtime = await loadSqliteRuntime();
-    let coercionMap;
-    try {
-        const mod = await import(resolved.coercionFile);
-        coercionMap = mod.coercionMap;
+    const coercionMap = await loadCoercionPlugin(resolved.coercionFile);
+    const plugins = coercionMap
+        ? [createCoercionPlugin({ map: coercionMap })]
+        : [];
+    if (resolved.dialect === 'sqlite') {
+        mkdirSync(dirname(resolved.dbFile), { recursive: true });
+        const runtime = await loadSqliteRuntime();
+        return createSqliteKysely({
+            db: runtime.open(resolved.dbFile),
+            camelCase: resolved.camelCase,
+            plugins,
+        });
     }
-    catch {
-        // coercion.gen.ts not yet generated — run `pikku db migrate` first
+    if (resolved.mode === 'url') {
+        const { Pool } = await import('pg');
+        const pool = new Pool({
+            connectionString: resolved.connectionString,
+            max: 10,
+        });
+        return new Kysely({
+            dialect: new PostgresDialect({ pool }),
+            plugins: resolved.camelCase
+                ? [new CamelCasePlugin(), ...plugins]
+                : plugins,
+        });
     }
-    return createSqliteKysely({
-        db: runtime.open(resolved.dbFile),
+    if (!resolved.pgliteDir) {
+        throw new Error('PGlite Postgres resolution is missing pgliteDir.');
+    }
+    mkdirSync(dirname(resolved.pgliteDir), { recursive: true });
+    return createPGliteKysely({
+        db: await createEmbeddedPostgres(resolved.pgliteDir),
         camelCase: resolved.camelCase,
-        plugins: coercionMap ? [createCoercionPlugin({ map: coercionMap })] : [],
+        plugins,
     });
 }
 async function introspectorToMap(intro) {
@@ -308,8 +441,19 @@ async function introspectorToMap(intro) {
 function diffSchemas(desired, actual) {
     const missingTables = [];
     const missingColumns = [];
+    const findSchemaQualifiedMatch = (table) => {
+        if (table.includes('.'))
+            return undefined;
+        const matches = [...actual.entries()].filter(([actualTable]) => {
+            const parts = actualTable.split('.');
+            return parts.length === 2 && parts[1] === table;
+        });
+        if (matches.length !== 1)
+            return undefined;
+        return matches[0][1];
+    };
     for (const [table, cols] of desired) {
-        const actualCols = actual.get(table);
+        const actualCols = actual.get(table) ?? findSchemaQualifiedMatch(table);
         if (!actualCols) {
             missingTables.push(table);
             continue;
@@ -323,60 +467,99 @@ function diffSchemas(desired, actual) {
 function isPostgresAuthDatabase(options) {
     return options.database?.type === 'postgres';
 }
-function createScratchPostgresSchemaName() {
+function createScratchPostgresDatabaseName(prefix) {
     const random = Math.random().toString(36).slice(2, 10);
-    return `pikku_auth_${Date.now().toString(36)}_${random}`;
+    return `${prefix}_${Date.now().toString(36)}_${random}`.slice(0, 63);
+}
+function quotePgIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
 }
-async function postgresSchemaToMap(connectionString, schema) {
+function withPostgresDatabase(connectionString, databaseName) {
+    const url = new URL(connectionString);
+    url.pathname = `/${databaseName}`;
+    return url.toString();
+}
+function getPostgresAdminConnectionString(connectionString) {
+    return withPostgresDatabase(connectionString, 'postgres');
+}
+async function withScratchPostgresDatabase(resolved, prefix, run) {
+    if (resolved.mode === 'pglite') {
+        const scratchDb = await createEmbeddedPostgres();
+        try {
+            return await run(pgliteAsClient(scratchDb));
+        }
+        finally {
+            if (!scratchDb.closed) {
+                await scratchDb.close();
+            }
+        }
+    }
     const { Client } = await import('pg');
-    const client = new Client({ connectionString });
-    await client.connect();
+    const databaseName = createScratchPostgresDatabaseName(prefix);
+    const adminConnectionString = getPostgresAdminConnectionString(resolved.connectionString);
+    const adminClient = new Client({ connectionString: adminConnectionString });
+    await adminClient.connect();
     try {
-        const tablesResult = await client.query(`SELECT table_name
-       FROM information_schema.tables
-       WHERE table_schema = $1
-         AND table_type = 'BASE TABLE'
-       ORDER BY table_name`, [schema]);
-        const map = new Map();
-        for (const { table_name } of tablesResult.rows) {
-            const columnsResult = await client.query(`SELECT column_name
-         FROM information_schema.columns
-         WHERE table_schema = $1
-           AND table_name = $2
-         ORDER BY ordinal_position`, [schema, table_name]);
-            map.set(table_name, new Set(columnsResult.rows.map((c) => c.column_name)));
-        }
-        return map;
+        await adminClient.query(`CREATE DATABASE ${quotePgIdentifier(databaseName)}`);
     }
     finally {
-        await client.end();
+        await adminClient.end();
     }
-}
-async function desiredPostgresAuthSchema(resolved, rootDir, srcDirectories, logger) {
-    const { Pool } = await import('pg');
-    const schema = createScratchPostgresSchemaName();
-    const pool = new Pool({
-        connectionString: resolved.connectionString,
-        max: 1,
-    });
+    const scratchConnectionString = withPostgresDatabase(resolved.connectionString, databaseName);
     try {
-        const admin = await pool.connect();
+        const scratchClient = Object.assign(new Client({ connectionString: scratchConnectionString }), { __connectionString: scratchConnectionString });
+        await scratchClient.connect();
+        try {
+            return await run(scratchClient);
+        }
+        finally {
+            await scratchClient.end();
+        }
+    }
+    finally {
+        const cleanupClient = new Client({
+            connectionString: adminConnectionString,
+        });
+        await cleanupClient.connect();
         try {
-            await admin.query(`CREATE SCHEMA "${schema}"`);
-            await admin.query(`SET search_path TO "${schema}"`);
+            await cleanupClient.query(`SELECT pg_terminate_backend(pid)
+         FROM pg_stat_activity
+         WHERE datname = $1
+           AND pid <> pg_backend_pid()`, [databaseName]);
+            await cleanupClient.query(`DROP DATABASE IF EXISTS ${quotePgIdentifier(databaseName)}`);
         }
         finally {
-            admin.release();
+            await cleanupClient.end();
         }
-        const kysely = new Kysely({
-            dialect: new PostgresDialect({
-                pool,
-                onReserveConnection: async (connection) => {
-                    await connection.executeQuery(CompiledQuery.raw(`SET search_path TO "${schema}"`));
-                },
-            }),
-            plugins: [new CamelCasePlugin()],
-        }).withSchema(schema);
+    }
+}
+async function postgresDatabaseToMap(client) {
+    const intro = new PostgresIntrospector(client);
+    await intro.connect();
+    try {
+        return await introspectorToMap(intro);
+    }
+    finally {
+        await intro.close();
+    }
+}
+async function desiredPostgresAuthSchema(resolved, rootDir, srcDirectories, logger) {
+    return withScratchPostgresDatabase(resolved, 'pikku_auth', async (scratchDb) => {
+        const { Pool } = await import('pg');
+        const kysely = resolved.mode === 'url'
+            ? new Kysely({
+                dialect: new PostgresDialect({
+                    pool: new Pool({
+                        connectionString: scratchDb.__connectionString,
+                        max: 1,
+                    }),
+                }),
+                plugins: [new CamelCasePlugin()],
+            })
+            : createPGliteKysely({
+                db: scratchDb.__pglite,
+                camelCase: true,
+            });
         try {
             const options = await loadAuthOptions({
                 rootDir,
@@ -388,26 +571,14 @@ async function desiredPostgresAuthSchema(resolved, rootDir, srcDirectories, logg
                 return null;
             const { runMigrations, compileMigrations } = await getAuthMigrations(options);
             await runMigrations();
-            const tables = await postgresSchemaToMap(resolved.connectionString, schema);
+            const tables = await postgresDatabaseToMap(scratchDb);
             const sql = await compileMigrations();
             return { tables, sql };
         }
         finally {
             await kysely.destroy();
         }
-    }
-    finally {
-        const cleanup = new Pool({
-            connectionString: resolved.connectionString,
-            max: 1,
-        });
-        try {
-            await cleanup.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
-        }
-        finally {
-            await cleanup.end();
-        }
-    }
+    });
 }
 export async function desiredAuthSchema(resolved, rootDir, srcDirectories, logger) {
     const runtime = await loadSqliteRuntime();
@@ -449,14 +620,16 @@ export async function introspectSchema(resolved) {
             db.close();
         }
     }
-    const intro = new PostgresIntrospector(resolved.connectionString);
-    await intro.connect();
-    try {
-        return await introspectorToMap(intro);
-    }
-    finally {
-        await intro.close();
-    }
+    return withPostgresClient(resolved, async (client) => {
+        const intro = new PostgresIntrospector(client);
+        await intro.connect();
+        try {
+            return await introspectorToMap(intro);
+        }
+        finally {
+            await intro.close();
+        }
+    });
 }
 async function coveredSqliteSchema(migrationsDir) {
     const runtime = await loadSqliteRuntime();
@@ -469,6 +642,12 @@ async function coveredSqliteSchema(migrationsDir) {
         db.close();
     }
 }
+async function coveredPostgresSchema(resolved, migrationsDir) {
+    return withScratchPostgresDatabase(resolved, 'pikku_migrate', async (client) => {
+        await migrate(new PostgresMigrationExecutor(client), migrationsDir);
+        return postgresDatabaseToMap(client);
+    });
+}
 export async function computeAuthDrift(resolved, rootDir, srcDirectories, logger) {
     const desired = await desiredAuthSchema(resolved, rootDir, srcDirectories, logger);
     if (!desired) {
@@ -505,12 +684,12 @@ function nextMigrationFile(migrationsDir, label) {
     return join(migrationsDir, `${num}-${label}.sql`);
 }
 export async function generateAuthMigration(resolved, rootDir, srcDirectories, logger) {
-    if (resolved.dialect !== 'sqlite')
-        return { status: 'unsupported-dialect' };
     const desired = await desiredAuthSchema(resolved, rootDir, srcDirectories, logger);
     if (!desired)
         return { status: 'no-auth' };
-    const covered = await coveredSqliteSchema(resolved.migrationsDir);
+    const covered = resolved.dialect === 'sqlite'
+        ? await coveredSqliteSchema(resolved.migrationsDir)
+        : await coveredPostgresSchema(resolved, resolved.migrationsDir);
     const { missingTables, missingColumns } = diffSchemas(desired.tables, covered);
     if (missingTables.length === 0 && missingColumns.length === 0) {
         return { status: 'up-to-date' };

package/dist/src/functions/db/postgres/pglite-kysely.d.ts

@@ -0,0 +1,8 @@
+import { Kysely, type KyselyPlugin } from 'kysely';
+import type { PGlite } from '@electric-sql/pglite';
+export interface CreatePGliteKyselyOptions {
+    db: PGlite;
+    camelCase?: boolean;
+    plugins?: KyselyPlugin[];
+}
+export declare function createPGliteKysely<DB>(options: CreatePGliteKyselyOptions): Kysely<DB>;

package/dist/src/functions/db/postgres/pglite-kysely.js

@@ -0,0 +1,79 @@
+import { CamelCasePlugin, Kysely, PostgresAdapter, PostgresIntrospector, PostgresQueryCompiler, } from 'kysely';
+export function createPGliteKysely(options) {
+    const plugins = [];
+    if (options.camelCase ?? true)
+        plugins.push(new CamelCasePlugin());
+    if (options.plugins)
+        plugins.push(...options.plugins);
+    return new Kysely({
+        dialect: new PGliteDialect(options.db),
+        plugins,
+    });
+}
+class PGliteDialect {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createAdapter() {
+        return new PostgresAdapter();
+    }
+    createDriver() {
+        return new PGliteDriver(this.db);
+    }
+    createQueryCompiler() {
+        return new PostgresQueryCompiler();
+    }
+    createIntrospector(db) {
+        return new PostgresIntrospector(db);
+    }
+}
+class PGliteDriver {
+    connection;
+    constructor(db) {
+        this.connection = new PGliteConnection(db);
+    }
+    async init() { }
+    async acquireConnection() {
+        return this.connection;
+    }
+    async beginTransaction(conn) {
+        await conn.executeRaw('BEGIN');
+    }
+    async commitTransaction(conn) {
+        await conn.executeRaw('COMMIT');
+    }
+    async rollbackTransaction(conn) {
+        await conn.executeRaw('ROLLBACK');
+    }
+    async releaseConnection() { }
+    async destroy() {
+        await this.connection.close();
+    }
+}
+class PGliteConnection {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async executeQuery(query) {
+        const result = await this.db.query(query.sql, [...query.parameters]);
+        return {
+            rows: result.rows,
+            numAffectedRows: result.affectedRows !== undefined
+                ? BigInt(result.affectedRows)
+                : undefined,
+        };
+    }
+    async *streamQuery(query) {
+        yield await this.executeQuery(query);
+    }
+    async executeRaw(sql) {
+        await this.db.exec(sql);
+    }
+    async close() {
+        if (!this.db.closed) {
+            await this.db.close();
+        }
+    }
+}

package/dist/src/functions/db/postgres/postgres-introspector.d.ts

@@ -7,6 +7,7 @@ interface QueryClient {
 }
 export declare class PostgresIntrospector implements DbIntrospector {
     private client;
+    private ownsClient;
     constructor(clientOrConnectionString: QueryClient | string);
     connect(): Promise<void>;
     listTables(): Promise<string[]>;

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -1,15 +1,18 @@
 import { Pool } from 'pg';
 export class PostgresIntrospector {
     client;
+    ownsClient;
     constructor(clientOrConnectionString) {
         if (typeof clientOrConnectionString === 'string') {
             this.client = new Pool({
                 connectionString: clientOrConnectionString,
                 max: 10,
             });
+            this.ownsClient = true;
         }
         else {
             this.client = clientOrConnectionString;
+            this.ownsClient = false;
         }
     }
     async connect() {
@@ -106,6 +109,8 @@ export class PostgresIntrospector {
         }));
     }
     async close() {
-        await this.client.end();
+        if (this.ownsClient) {
+            await this.client.end();
+        }
     }
 }

package/dist/src/functions/db/postgres/postgres-migrator.d.ts

@@ -1,8 +1,13 @@
-import type { Client } from 'pg';
 import type { MigrationExecutor, AppliedMigration } from '../db-migrator.js';
+export interface PostgresMigrationClient {
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    exec?(sql: string): Promise<unknown>;
+}
 export declare class PostgresMigrationExecutor implements MigrationExecutor {
     private readonly client;
-    constructor(client: Client);
+    constructor(client: PostgresMigrationClient);
     ensureTrackingTable(): Promise<void>;
     getApplied(): Promise<AppliedMigration[]>;
     runMigration(sql: string, name: string, hash: string): Promise<void>;