@pikku/cli 0.12.39 → 0.12.40

package/dist/src/functions/commands/db-shared.js

@@ -24,10 +24,8 @@ export async function loadUserConfigForDb(options) {
     const getFallbackConfig = () => {
         if (hasSqliteDbAssets)
             return { sqliteDb: '.pikku-runtime/dev.db' };
-        if (hasPostgresDbAssets) {
-            logger.error('Postgres assets detected but postgresUrl is not configured in createConfig.');
-            return null;
-        }
+        if (hasPostgresDbAssets)
+            return {};
         return null;
     };
     const configFactoryFile = findUserConfigFactoryFile(config.rootDir, config.srcDirectories);

package/dist/src/functions/commands/deploy-apply.js

@@ -179,6 +179,7 @@ export const deployApply = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             getEntryContext,
+            outDir: config.outDir,
             logger,
         });
         if (buildResult.manifest.units.length === 0) {

package/dist/src/functions/commands/deploy-plan.js

@@ -55,6 +55,7 @@ export const deployPlan = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             getEntryContext,
+            outDir: config.outDir,
             logger,
         });
         if (result.manifest.units.length === 0) {

package/dist/src/functions/commands/dev.js

@@ -113,7 +113,7 @@ export const dev = pikkuSessionlessFunc({
             ? parseDatabaseUrl(envDatabaseUrl)
             : userConfig;
         const resolvedDb = resolveDb(effectiveDbConfig, config.rootDir, config.outDir, config.runtimeDir);
-        const resolvedLocalDb = resolvedDb?.dialect === 'sqlite' ? resolvedDb : undefined;
+        const resolvedLocalDb = resolvedDb ?? undefined;
         const kysely = resolvedLocalDb
             ? await createKysely(resolvedLocalDb)
             : undefined;

package/dist/src/functions/db/local-db.d.ts

@@ -25,7 +25,11 @@ export interface ResolvedSqliteDb extends ResolvedDbBase {
 }
 export interface ResolvedPostgresDb extends ResolvedDbBase {
     dialect: 'postgres';
-    connectionString: string;
+    mode: 'url' | 'pglite';
+    connectionString?: string;
+    pgliteDir?: string;
+    runtimeDir: string;
+    seedFile: string;
 }
 export type ResolvedDb = ResolvedSqliteDb | ResolvedPostgresDb;
 /**
@@ -50,9 +54,9 @@ export interface MigrateAndCodegenOutcome {
     classificationsJsonWritten: boolean;
 }
 export declare function migrateAndCodegen(resolved: ResolvedDb): Promise<MigrateAndCodegenOutcome>;
-export declare function seed(resolved: ResolvedSqliteDb): Promise<SeedResult>;
-export declare function reset(resolved: ResolvedSqliteDb, rootDir: string): void;
-export declare function createKysely<DB>(resolved: ResolvedSqliteDb): Promise<Kysely<DB>>;
+export declare function seed(resolved: ResolvedDb): Promise<SeedResult>;
+export declare function reset(resolved: ResolvedDb, rootDir: string): Promise<void>;
+export declare function createKysely<DB>(resolved: ResolvedDb): Promise<Kysely<DB>>;
 type SchemaMap = Map<string, Set<string>>;
 export interface DesiredAuthSchema {
     tables: SchemaMap;
@@ -75,7 +79,7 @@ export declare function computeAuthDrift(resolved: ResolvedDb, rootDir: string,
     error: (msg: string) => void;
 }): Promise<AuthDriftResult>;
 export interface GenerateAuthResult {
-    status: 'no-auth' | 'up-to-date' | 'written' | 'incremental-unsupported' | 'unsupported-dialect';
+    status: 'no-auth' | 'up-to-date' | 'written' | 'incremental-unsupported';
     file?: string;
     missingTables?: string[];
     missingColumns?: {

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,
+        });
+    }
+    if (!resolved.pgliteDir) {
+        throw new Error('PGlite Postgres resolution is missing pgliteDir.');
     }
-    return createSqliteKysely({
-        db: runtime.open(resolved.dbFile),
+    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) {
@@ -334,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, '""')}"`;
+}
+function withPostgresDatabase(connectionString, databaseName) {
+    const url = new URL(connectionString);
+    url.pathname = `/${databaseName}`;
+    return url.toString();
 }
-async function postgresSchemaToMap(connectionString, schema) {
+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 {
-            await admin.query(`CREATE SCHEMA "${schema}"`);
-            await admin.query(`SET search_path TO "${schema}"`);
+            return await run(scratchClient);
         }
         finally {
-            admin.release();
+            await scratchClient.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);
+    }
+    finally {
+        const cleanupClient = new Client({
+            connectionString: adminConnectionString,
+        });
+        await cleanupClient.connect();
+        try {
+            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 {
+            await cleanupClient.end();
+        }
+    }
+}
+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,
@@ -399,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();
@@ -460,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();
@@ -480,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) {
@@ -516,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>;