@pikku/cli 0.12.36 → 0.12.38

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

@@ -3,6 +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 { migrate } from './db-migrator.js';
 import { loadAuthOptions, getAuthMigrations } from './better-auth-schema.js';
 import { generateSchemaTypes } from './db-codegen.js';
@@ -319,14 +320,114 @@ function diffSchemas(desired, actual) {
     }
     return { missingTables, missingColumns };
 }
-export async function desiredAuthSchema(rootDir, srcDirectories, logger) {
+function isPostgresAuthDatabase(options) {
+    return options.database?.type === 'postgres';
+}
+function createScratchPostgresSchemaName() {
+    const random = Math.random().toString(36).slice(2, 10);
+    return `pikku_auth_${Date.now().toString(36)}_${random}`;
+}
+async function postgresSchemaToMap(connectionString, schema) {
+    const { Client } = await import('pg');
+    const client = new Client({ connectionString });
+    await client.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;
+    }
+    finally {
+        await client.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,
+    });
+    try {
+        const admin = await pool.connect();
+        try {
+            await admin.query(`CREATE SCHEMA "${schema}"`);
+            await admin.query(`SET search_path TO "${schema}"`);
+        }
+        finally {
+            admin.release();
+        }
+        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);
+        try {
+            const options = await loadAuthOptions({
+                rootDir,
+                srcDirectories,
+                kysely,
+                logger,
+            });
+            if (!options)
+                return null;
+            const { runMigrations, compileMigrations } = await getAuthMigrations(options);
+            await runMigrations();
+            const tables = await postgresSchemaToMap(resolved.connectionString, schema);
+            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();
     const db = runtime.open(':memory:');
     try {
         const kysely = createSqliteKysely({ db, camelCase: true });
-        const options = await loadAuthOptions({ rootDir, srcDirectories, kysely, logger });
+        const options = await loadAuthOptions({
+            rootDir,
+            srcDirectories,
+            kysely,
+            logger,
+        });
         if (!options)
             return null;
+        if (isPostgresAuthDatabase(options)) {
+            if (resolved.dialect !== 'postgres') {
+                throw new Error('Better Auth database.type is postgres, but the resolved app database is not postgres.');
+            }
+            return desiredPostgresAuthSchema(resolved, rootDir, srcDirectories, logger);
+        }
         const { runMigrations, compileMigrations } = await getAuthMigrations(options);
         await runMigrations();
         const tables = await introspectorToMap(new SqliteIntrospector(db));
@@ -369,9 +470,14 @@ async function coveredSqliteSchema(migrationsDir) {
     }
 }
 export async function computeAuthDrift(resolved, rootDir, srcDirectories, logger) {
-    const desired = await desiredAuthSchema(rootDir, srcDirectories, logger);
+    const desired = await desiredAuthSchema(resolved, rootDir, srcDirectories, logger);
     if (!desired) {
-        return { hasAuth: false, inSync: true, missingTables: [], missingColumns: [] };
+        return {
+            hasAuth: false,
+            inSync: true,
+            missingTables: [],
+            missingColumns: [],
+        };
     }
     const actual = await introspectSchema(resolved);
     const { missingTables, missingColumns } = diffSchemas(desired.tables, actual);
@@ -401,7 +507,7 @@ function nextMigrationFile(migrationsDir, label) {
 export async function generateAuthMigration(resolved, rootDir, srcDirectories, logger) {
     if (resolved.dialect !== 'sqlite')
         return { status: 'unsupported-dialect' };
-    const desired = await desiredAuthSchema(rootDir, srcDirectories, logger);
+    const desired = await desiredAuthSchema(resolved, rootDir, srcDirectories, logger);
     if (!desired)
         return { status: 'no-auth' };
     const covered = await coveredSqliteSchema(resolved.migrationsDir);

package/dist/src/functions/db/sqlite/sqlite-runtime-node.js

@@ -15,7 +15,8 @@ class NodeSqliteStatement {
                     upper.startsWith('WITH') ||
                     upper.startsWith('PRAGMA') ||
                     upper.startsWith('EXPLAIN') ||
-                    upper.startsWith('VALUES');
+                    upper.startsWith('VALUES') ||
+                    /\bRETURNING\b/.test(upper);
         }
     }
     all(...parameters) {

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.36
+ * This file was generated by @pikku/cli@0.12.38
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.36",
+  "version": "0.12.38",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -26,13 +26,13 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/better-auth": "workspace:*",
+    "@pikku/better-auth": "^0.12.6",
     "@pikku/core": "^0.12.32",
     "@pikku/deploy-cloudflare": "^0.12.3",
     "@pikku/fetch": "^0.12.3",
     "@pikku/inspector": "^0.12.20",
-    "@pikku/kysely": "^0.12.14",
-    "@pikku/kysely-node-sqlite": "^0.12.1",
+    "@pikku/kysely": "^0.12.16",
+    "@pikku/kysely-node-sqlite": "^0.12.2",
     "@pikku/node-http-server": "^0.12.2",
     "@pikku/openapi-parser": "^0.12.10",
     "@pikku/schedule": "^0.12.0",