@pikku/cli 0.12.37 → 0.12.39

package/dist/src/functions/db/better-auth-schema.js

@@ -3,6 +3,7 @@ import { pathToFileURL } from 'node:url';
 import { readdirSync, statSync, readFileSync, existsSync } from 'node:fs';
 import { join, extname, dirname } from 'node:path';
 import { PIKKU_BETTER_AUTH } from '@pikku/better-auth';
+import { LocalSecretService, LocalVariablesService } from '@pikku/core/services';
 import { loadUserModule } from '../commands/load-user-project.js';
 let cachedGetMigrations = null;
 async function loadGetMigrations() {
@@ -87,24 +88,43 @@ async function loadAuthFactory(sourceFile) {
     return null;
 }
 function schemaServicesStub(kysely, logger) {
-    const dummy = 'x'.repeat(32);
-    const fromKeys = (keys) => Object.fromEntries(keys.map((k) => [k, dummy]));
+    const variables = new LocalVariablesService();
+    const secrets = new LocalSecretService(variables);
     const base = {
         kysely,
         logger,
-        secrets: {
-            getSecret: async () => dummy,
-            getSecrets: async (keys) => fromKeys(keys),
-        },
-        variables: {
-            getVariable: async () => dummy,
-            getVariables: async (keys) => fromKeys(keys),
-        },
+        secrets,
+        variables,
     };
     return new Proxy(base, {
         get: (target, prop) => typeof prop === 'string' && prop in target ? target[prop] : undefined,
     });
 }
+function findUserConfigFactoryFile(rootDir, srcDirectories) {
+    for (const srcDir of srcDirectories) {
+        for (const name of ['config.ts', 'config.js']) {
+            const candidate = join(rootDir, srcDir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    for (const name of ['config.ts', 'config.js']) {
+        const candidate = join(rootDir, name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+async function loadAuthConfig(opts) {
+    const configFactoryFile = findUserConfigFactoryFile(opts.rootDir, opts.srcDirectories);
+    if (!configFactoryFile)
+        return undefined;
+    const configModule = await loadUserModule(configFactoryFile);
+    const userCreateConfig = configModule.createConfig;
+    if (typeof userCreateConfig !== 'function')
+        return undefined;
+    return userCreateConfig(new LocalVariablesService());
+}
 export async function loadAuthOptions(opts) {
     const sourceFile = findAuthSourceFile(opts.rootDir, opts.srcDirectories);
     if (!sourceFile)
@@ -112,7 +132,9 @@ export async function loadAuthOptions(opts) {
     const factory = await loadAuthFactory(sourceFile);
     if (!factory)
         return null;
-    const instance = await factory(schemaServicesStub(opts.kysely, opts.logger));
+    const services = schemaServicesStub(opts.kysely, opts.logger);
+    services.config = await loadAuthConfig(opts);
+    const instance = await factory(services);
     const options = instance.options;
     return options ?? null;
 }

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

@@ -28,6 +28,12 @@ function snakeToPascal(name) {
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
         .join('');
 }
+function tableToInterfaceName(name) {
+    return name
+        .split('.')
+        .map((part) => snakeToPascal(part))
+        .join('');
+}
 function snakeToCamel(name) {
     return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
@@ -110,9 +116,7 @@ function columnTypeExpression(col, annotation, classification) {
             return wrap(nullable ? 'Uuid | null' : 'Uuid');
         }
         if (annotation?.tsType) {
-            const base = nullable
-                ? `${annotation.tsType} | null`
-                : annotation.tsType;
+            const base = nullable ? `${annotation.tsType} | null` : annotation.tsType;
             return wrap(base);
         }
         if (annotation?.kind === 'json') {
@@ -146,7 +150,7 @@ function bareTableName(name) {
     return dot >= 0 ? name.slice(dot + 1) : name;
 }
 function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByName, formatHints, warnings) {
-    const ifaceName = snakeToPascal(table.name);
+    const ifaceName = tableToInterfaceName(table.name);
     const bare = bareTableName(table.name);
     const tableCols = explicitAnnotations[bare] ?? {};
     const fields = table.columns
@@ -352,7 +356,7 @@ export async function generateSchemaTypes(introspector, options) {
         const safe = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableKey)
             ? tableKey
             : JSON.stringify(tableKey);
-        return `  ${safe}: ${snakeToPascal(t.name)}`;
+        return `  ${safe}: ${tableToInterfaceName(t.name)}`;
     })
         .join('\n');
     const schemaBody = [

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

@@ -1,4 +1,4 @@
-import type { Kysely } from 'kysely';
+import { Kysely } from 'kysely';
 import { type MigrateResult } from './db-migrator.js';
 import { type CodegenResult } from './db-codegen.js';
 import { type ZodCodegenResult } from './zod-codegen.js';
@@ -58,7 +58,7 @@ export interface DesiredAuthSchema {
     tables: SchemaMap;
     sql: string;
 }
-export declare function desiredAuthSchema(rootDir: string, srcDirectories: string[], logger: {
+export declare function desiredAuthSchema(resolved: ResolvedDb, rootDir: string, srcDirectories: string[], logger: {
     error: (msg: string) => void;
 }): Promise<DesiredAuthSchema | null>;
 export declare function introspectSchema(resolved: ResolvedDb): Promise<SchemaMap>;

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';
@@ -307,8 +308,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;
@@ -319,14 +331,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 +481,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 +518,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.37
+ * This file was generated by @pikku/cli@0.12.39
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.37",
+  "version": "0.12.39",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {