@promptbook/cli 0.112.0-95 → 0.112.0-97

package/apps/agents-server/src/database/$provideDatabaseAdminExecutor.ts

@@ -0,0 +1,252 @@
+import type { StudioBFFSqlLintDetails, StudioBFFSqlLintResult } from '@prisma/studio-core/data/bff';
+import type { Pool, PoolClient } from 'pg';
+import { $providePostgresPool } from './$providePostgresPool';
+import { isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
+import {
+    $provideAgentsServerSqliteDatabase,
+    type AgentsServerSqliteDatabase,
+} from './sqlite/$provideAgentsServerSqliteDatabase';
+
+/**
+ * Query shape sent by Embedded Prisma Studio adapters.
+ *
+ * @private internal utility of Agents Server database admin
+ */
+export type DatabaseAdminQuery = {
+    readonly sql: string;
+    readonly parameters?: ReadonlyArray<unknown>;
+    readonly transformations?: Partial<Record<string, 'json-parse'>>;
+};
+
+/**
+ * SQL executor surface required by the Embedded Prisma Studio BFF endpoint.
+ *
+ * @private internal utility of Agents Server database admin
+ */
+export type DatabaseAdminExecutor = {
+    readonly execute: (query: DatabaseAdminQuery) => Promise<Array<Record<string, unknown>>>;
+    readonly executeTransaction: (
+        queries: ReadonlyArray<DatabaseAdminQuery>,
+    ) => Promise<Array<Array<Record<string, unknown>>>>;
+    readonly lintSql: (details: StudioBFFSqlLintDetails) => Promise<StudioBFFSqlLintResult>;
+};
+
+/**
+ * Provides a raw SQL executor for the configured Agents Server database backend.
+ *
+ * @returns Database admin executor for the active database mode.
+ *
+ * @private exported from Agents Server database utilities
+ */
+export function $provideDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    return isAgentsServerSqliteMode() ? $provideSqliteDatabaseAdminExecutor() : $providePostgresDatabaseAdminExecutor();
+}
+
+/**
+ * Provides the PostgreSQL raw SQL executor used by Embedded Prisma Studio.
+ *
+ * @returns PostgreSQL-backed database admin executor.
+ */
+function $providePostgresDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    const pool = $providePostgresPool();
+
+    return {
+        execute: (query) => executePostgresDatabaseAdminQuery(pool, query),
+        executeTransaction: (queries) => executePostgresDatabaseAdminTransaction(pool, queries),
+        lintSql: (details) => Promise.resolve({ diagnostics: [], schemaVersion: details.schemaVersion }),
+    };
+}
+
+/**
+ * Provides the SQLite raw SQL executor used by Embedded Prisma Studio.
+ *
+ * @returns SQLite-backed database admin executor.
+ */
+function $provideSqliteDatabaseAdminExecutor(): DatabaseAdminExecutor {
+    const database = $provideAgentsServerSqliteDatabase();
+
+    return {
+        execute: (query) => Promise.resolve(executeSqliteDatabaseAdminQuery(database, query)),
+        executeTransaction: (queries) =>
+            Promise.resolve(
+                database.transaction((transactionQueries: ReadonlyArray<DatabaseAdminQuery>) =>
+                    transactionQueries.map((query) => executeSqliteDatabaseAdminQuery(database, query)),
+                )(queries),
+            ),
+        lintSql: (details) => Promise.resolve({ diagnostics: [], schemaVersion: details.schemaVersion }),
+    };
+}
+
+/**
+ * Executes one PostgreSQL query for Embedded Prisma Studio.
+ *
+ * @param client - PostgreSQL pool or transaction client.
+ * @param query - SQL query generated by Embedded Prisma Studio.
+ * @returns JSON-safe result rows.
+ */
+async function executePostgresDatabaseAdminQuery(
+    client: Pick<Pool | PoolClient, 'query'>,
+    query: DatabaseAdminQuery,
+): Promise<Array<Record<string, unknown>>> {
+    const result = await client.query(query.sql, normalizeDatabaseAdminParameters(query.parameters));
+    return normalizeDatabaseAdminRows(query, result.rows as Array<Record<string, unknown>>);
+}
+
+/**
+ * Executes PostgreSQL queries inside one database transaction.
+ *
+ * @param pool - Shared PostgreSQL pool.
+ * @param queries - SQL queries generated by Embedded Prisma Studio.
+ * @returns Ordered result sets for each query.
+ */
+async function executePostgresDatabaseAdminTransaction(
+    pool: Pool,
+    queries: ReadonlyArray<DatabaseAdminQuery>,
+): Promise<Array<Array<Record<string, unknown>>>> {
+    const client = await pool.connect();
+
+    try {
+        await client.query('BEGIN');
+        const results: Array<Array<Record<string, unknown>>> = [];
+
+        for (const query of queries) {
+            results.push(await executePostgresDatabaseAdminQuery(client, query));
+        }
+
+        await client.query('COMMIT');
+        return results;
+    } catch (error) {
+        await client.query('ROLLBACK').catch(() => undefined);
+        throw error;
+    } finally {
+        client.release();
+    }
+}
+
+/**
+ * Executes one SQLite query for Embedded Prisma Studio.
+ *
+ * @param database - Shared SQLite database.
+ * @param query - SQL query generated by Embedded Prisma Studio.
+ * @returns JSON-safe result rows.
+ */
+function executeSqliteDatabaseAdminQuery(
+    database: AgentsServerSqliteDatabase,
+    query: DatabaseAdminQuery,
+): Array<Record<string, unknown>> {
+    const statement = database.prepare(query.sql);
+    const parameters = normalizeDatabaseAdminParameters(query.parameters);
+    const isReader = statement.reader === true;
+    const rows = isReader ? statement.all(...parameters) : [];
+
+    if (!isReader) {
+        statement.run(...parameters);
+    }
+
+    return normalizeDatabaseAdminRows(query, rows);
+}
+
+/**
+ * Normalizes query parameters before passing them into SQL drivers.
+ *
+ * @param parameters - Query parameters generated by Embedded Prisma Studio.
+ * @returns Parameters safe to bind to PostgreSQL or SQLite.
+ */
+function normalizeDatabaseAdminParameters(parameters: ReadonlyArray<unknown> = []): Array<unknown> {
+    return parameters.map((value) => (value === undefined ? null : value));
+}
+
+/**
+ * Applies Studio result transformations and converts rows into JSON-safe objects.
+ *
+ * @param query - SQL query whose transformations should be applied.
+ * @param rows - Raw database rows.
+ * @returns JSON-safe transformed rows.
+ */
+function normalizeDatabaseAdminRows(
+    query: DatabaseAdminQuery,
+    rows: ReadonlyArray<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+    return rows.map((row) => normalizeDatabaseAdminRow(applyDatabaseAdminQueryTransformations(query, row)));
+}
+
+/**
+ * Applies one query's declared result transformations to a row.
+ *
+ * @param query - SQL query whose transformations should be applied.
+ * @param row - Raw database row.
+ * @returns Transformed row.
+ */
+function applyDatabaseAdminQueryTransformations(
+    query: DatabaseAdminQuery,
+    row: Record<string, unknown>,
+): Record<string, unknown> {
+    const transformations = query.transformations;
+
+    if (!transformations || Object.keys(transformations).length === 0) {
+        return row;
+    }
+
+    const transformedRow = { ...row };
+
+    for (const [column, transformation] of Object.entries(transformations)) {
+        if (transformation !== 'json-parse' || typeof transformedRow[column] !== 'string') {
+            continue;
+        }
+
+        try {
+            transformedRow[column] = JSON.parse(transformedRow[column] as string);
+        } catch (error) {
+            console.error(`Failed to JSON.parse database admin column "${column}".`, error);
+        }
+    }
+
+    return transformedRow;
+}
+
+/**
+ * Converts one database row into values that can be returned via `NextResponse.json`.
+ *
+ * @param row - Database row.
+ * @returns JSON-safe row.
+ */
+function normalizeDatabaseAdminRow(row: Record<string, unknown>): Record<string, unknown> {
+    return Object.fromEntries(
+        Object.entries(row).map(([key, value]) => [key, normalizeDatabaseAdminValue(value)]),
+    ) as Record<string, unknown>;
+}
+
+/**
+ * Converts one database value into a JSON-safe representation.
+ *
+ * @param value - Database value.
+ * @returns JSON-safe value.
+ */
+function normalizeDatabaseAdminValue(value: unknown): unknown {
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+        return value.toString('base64');
+    }
+
+    if (Array.isArray(value)) {
+        return value.map(normalizeDatabaseAdminValue);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(
+            Object.entries(value as Record<string, unknown>).map(([key, childValue]) => [
+                key,
+                normalizeDatabaseAdminValue(childValue),
+            ]),
+        );
+    }
+
+    return value;
+}

package/apps/agents-server/src/database/$providePostgresPool.ts

@@ -0,0 +1,27 @@
+import { Pool } from 'pg';
+import { resolvePostgresConnectionString } from './resolvePostgresConnectionString';
+
+/**
+ * Shared PostgreSQL pool reused across the Agents Server process.
+ *
+ * @private internal singleton of Agents Server database layer
+ */
+let postgresPool: Pool | null = null;
+
+/**
+ * Provides the shared PostgreSQL pool used by raw SQL helpers and local PostgreSQL adapters.
+ *
+ * @returns Shared PostgreSQL pool.
+ *
+ * @private exported from Agents Server database utilities
+ */
+export function $providePostgresPool(): Pool {
+    if (!postgresPool) {
+        postgresPool = new Pool({
+            connectionString: resolvePostgresConnectionString(),
+            ssl: { rejectUnauthorized: false },
+        });
+    }
+
+    return postgresPool;
+}

package/apps/agents-server/src/database/$provideSupabaseForServer.ts

@@ -1,9 +1,12 @@
+import { createRequire } from 'module';
 import { $isRunningInNode } from '@promptbook-local/utils';
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
-import { isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
+import { isAgentsServerPostgresMode, isAgentsServerSqliteMode } from './agentsServerDatabaseMode';
 import { $provideLocalSqliteSupabase } from './sqlite/$provideLocalSqliteSupabase';
 import { AgentsServerDatabase } from './schema';
 
+const requirePostgresSupabase = createRequire(__filename);
+
 /**
  * Internal cache for `$provideSupabaseForServer`
  *
@@ -32,6 +35,13 @@ export function $provideSupabaseForServer(): SupabaseClient<AgentsServerDatabase
         return $provideLocalSqliteSupabase() as SupabaseClient<AgentsServerDatabase>;
     }
 
+    if (isAgentsServerPostgresMode()) {
+        const { $provideLocalPostgresSupabase } = requirePostgresSupabase(
+            './postgres/$provideLocalPostgresSupabase',
+        ) as typeof import('./postgres/$provideLocalPostgresSupabase');
+        return $provideLocalPostgresSupabase() as SupabaseClient<AgentsServerDatabase>;
+    }
+
     if (!supabase) {
         // Create a single supabase client for interacting with your database
         supabase = createClient<AgentsServerDatabase>(

package/apps/agents-server/src/database/agentsServerDatabaseMode.ts

@@ -11,7 +11,7 @@ export const AGENTS_SERVER_SQLITE_PATH_ENV_NAME = 'PTBK_AGENTS_SERVER_SQLITE_PAT
 /**
  * Supported Agents Server database backends.
  */
-export type AgentsServerDatabaseMode = 'supabase' | 'sqlite';
+export type AgentsServerDatabaseMode = 'supabase' | 'sqlite' | 'postgres';
 
 /**
  * Resolves the configured Agents Server database backend.
@@ -23,6 +23,10 @@ export function resolveAgentsServerDatabaseMode(): AgentsServerDatabaseMode {
         return 'sqlite';
     }
 
+    if (rawMode === 'postgres' || rawMode === 'postgresql') {
+        return 'postgres';
+    }
+
     return 'supabase';
 }
 
@@ -32,3 +36,18 @@ export function resolveAgentsServerDatabaseMode(): AgentsServerDatabaseMode {
 export function isAgentsServerSqliteMode(): boolean {
     return resolveAgentsServerDatabaseMode() === 'sqlite';
 }
+
+/**
+ * Returns whether the Agents Server is using the standalone PostgreSQL backend.
+ */
+export function isAgentsServerPostgresMode(): boolean {
+    return resolveAgentsServerDatabaseMode() === 'postgres';
+}
+
+/**
+ * Returns whether the Agents Server is using a standalone local database backend.
+ */
+export function isAgentsServerStandaloneMode(): boolean {
+    const databaseMode = resolveAgentsServerDatabaseMode();
+    return databaseMode === 'sqlite' || databaseMode === 'postgres';
+}