@hesed/psql 0.2.1 → 0.3.0

package/dist/commands/psql/indexes.js

@@ -1,5 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { closeConnections, getPgConfig, setConfigDir, showIndexes } from '../../psql/index.js';
+import { closeConnections, showIndexes } from '../../psql/index.js';
 export default class PostgresIndexes extends Command {
     static args = {
         table: Args.string({ description: 'Table name to show indexes for', required: true }),
@@ -19,15 +19,7 @@ export default class PostgresIndexes extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(PostgresIndexes);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getPgConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await showIndexes(profile, args.table, flags.format);
+        const result = await showIndexes(this.config, args.table, flags.profile, flags.format);
         await closeConnections();
         if (result.success) {
             this.log(result.result ?? '');

package/dist/commands/psql/query.js

@@ -1,5 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { closeConnections, executeQuery, getPgConfig, setConfigDir } from '../../psql/index.js';
+import { closeConnections, executeQuery } from '../../psql/index.js';
 export default class PostgresQuery extends Command {
     static args = {
         query: Args.string({ description: 'SQL query to execute', required: true }),
@@ -24,15 +24,7 @@ export default class PostgresQuery extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(PostgresQuery);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getPgConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await executeQuery(args.query, profile, flags.format, flags['skip-confirmation']);
+        const result = await executeQuery(this.config, args.query, flags.profile, flags.format, flags['skip-confirmation']);
         await closeConnections();
         if (result.success) {
             this.log(result.result ?? '');

package/dist/commands/psql/tables.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { closeConnections, getPgConfig, listTables, setConfigDir } from '../../psql/index.js';
+import { closeConnections, listTables } from '../../psql/index.js';
 export default class PostgresTables extends Command {
     static description = 'List all tables in the current PostgreSQL database';
     static examples = [
@@ -11,15 +11,7 @@ export default class PostgresTables extends Command {
     };
     async run() {
         const { flags } = await this.parse(PostgresTables);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getPgConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await listTables(profile);
+        const result = await listTables(this.config, flags.profile);
         await closeConnections();
         if (result.success) {
             this.logJson(result.tables);

package/dist/psql/config-loader.d.ts

@@ -1,28 +1,22 @@
 import type { ClientConfig } from 'pg';
-import type { DatabaseProfile } from '../config.js';
-/**
- * Safety configuration for query execution
- */
 interface SafetyConfig {
     blacklistedOperations: string[];
     defaultLimit: number;
     requireConfirmationFor: string[];
 }
-/**
- * Main configuration structure
- */
+export interface DatabaseProfile {
+    database: string;
+    host: string;
+    password: string;
+    port: number;
+    ssl?: boolean;
+    user: string;
+}
 export interface PgConfig {
     defaultFormat: 'csv' | 'json' | 'table' | 'toon';
     defaultProfile: string;
     profiles: Record<string, DatabaseProfile>;
     safety: SafetyConfig;
 }
-/**
- * Get PostgreSQL connection options for a specific profile
- *
- * @param config - Configuration object
- * @param profileName - Profile name
- * @returns pg ClientConfig options
- */
 export declare function getPgConnectionOptions(config: PgConfig, profileName: string): ClientConfig;
 export {};

package/dist/psql/config-loader.js

@@ -1,10 +1,3 @@
-/**
- * Get PostgreSQL connection options for a specific profile
- *
- * @param config - Configuration object
- * @param profileName - Profile name
- * @returns pg ClientConfig options
- */
 export function getPgConnectionOptions(config, profileName) {
     const profile = config.profiles[profileName];
     if (!profile) {

package/dist/psql/formatters.d.ts

@@ -0,0 +1,8 @@
+import type { OutputFormat } from './database.js';
+export type PgRow = Record<string, unknown>;
+export type PgField = {
+    name: string;
+};
+type Formatter = (rows: PgRow[], fields: PgField[]) => string;
+export declare const FORMATTERS: Record<OutputFormat, Formatter>;
+export {};

package/dist/psql/formatters.js

@@ -0,0 +1,76 @@
+import { encode } from '@toon-format/toon';
+function formatAsCsv(rows, fields) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const columnNames = fields.map((f) => f.name);
+    let csv = columnNames.join(',') + '\n';
+    for (const row of rows) {
+        const values = columnNames.map((name) => {
+            const value = row[name] ?? '';
+            const str = String(value);
+            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+                return '"' + str.replaceAll('"', '""') + '"';
+            }
+            return str;
+        });
+        csv += values.join(',') + '\n';
+    }
+    return csv;
+}
+function formatAsJson(rows) {
+    return JSON.stringify(rows, null, 2);
+}
+function formatAsTable(rows, fields) {
+    if (!rows || rows.length === 0) {
+        return 'No results';
+    }
+    const columnNames = fields.map((f) => f.name);
+    const columnWidths = columnNames.map((name) => {
+        const dataWidth = Math.max(...rows.map((row) => String(row[name] ?? '').length));
+        return Math.max(name.length, dataWidth, 3);
+    });
+    let table = '┌' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐\n';
+    table += '│ ' + columnNames.map((name, i) => name.padEnd(columnWidths[i])).join(' │ ') + ' │\n';
+    table += '├' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤\n';
+    for (const row of rows) {
+        table +=
+            '│ ' +
+                columnNames
+                    .map((name, i) => {
+                    const value = row[name] ?? 'NULL';
+                    return String(value).padEnd(columnWidths[i]);
+                })
+                    .join(' │ ') +
+                ' │\n';
+    }
+    table += '└' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
+    return table;
+}
+function formatAsToon(rows) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const serializedRows = rows.map((row) => {
+        const serialized = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (value instanceof Date) {
+                serialized[key] = Number.isNaN(value.getTime()) ? null : value.toISOString();
+            }
+            else if (Buffer.isBuffer(value)) {
+                serialized[key] = value.toString('base64');
+            }
+            else {
+                serialized[key] = value;
+            }
+        }
+        return serialized;
+    });
+    return encode(serializedRows);
+}
+export const FORMATTERS = {
+    csv: formatAsCsv,
+    json: formatAsJson,
+    table: formatAsTable,
+    toon: formatAsToon,
+};

package/dist/psql/index.d.ts

@@ -1,3 +1,2 @@
-export type { PgJsonConfig } from '../config.js';
 export type { ConnectionTestResult } from './database.js';
-export { closeConnections, describeTable, executeQuery, explainQuery, getPgConfig, listDatabases, listTables, setConfigDir, showIndexes, testDirectConnection, } from './postgres-client.js';
+export { closeConnections, describeTable, executeQuery, explainQuery, listDatabases, listTables, showIndexes, testDirectConnection, } from './postgres-client.js';

package/dist/psql/index.js

@@ -1 +1 @@
-export { closeConnections, describeTable, executeQuery, explainQuery, getPgConfig, listDatabases, listTables, setConfigDir, showIndexes, testDirectConnection, } from './postgres-client.js';
+export { closeConnections, describeTable, executeQuery, explainQuery, listDatabases, listTables, showIndexes, testDirectConnection, } from './postgres-client.js';

package/dist/psql/postgres-client.d.ts

@@ -1,60 +1,11 @@
-import type { DatabaseProfile } from '../config.js';
-import type { PgConfig } from './config-loader.js';
+import type { Config } from '@oclif/core';
+import type { DatabaseProfile } from './config-loader.js';
 import type { ConnectionTestResult, DatabaseListResult, ExplainResult, IndexResult, OutputFormat, QueryResult, TableListResult, TableStructureResult } from './database.js';
-/**
- * Set the config directory for the singleton client
- * @param dir - Oclif config directory path
- */
-export declare function setConfigDir(dir: string): void;
-/**
- * Get the loaded PostgreSQL config, initializing if needed
- */
-export declare function getPgConfig(): Promise<PgConfig>;
-/**
- * Execute SQL query
- * @param query - SQL query to execute
- * @param profile - Database profile name
- * @param format - Output format
- * @param skipConfirmation - Skip confirmation for destructive operations
- */
-export declare function executeQuery(query: string, profile: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
-/**
- * List all databases
- * @param profile - Database profile name
- */
-export declare function listDatabases(profile: string): Promise<DatabaseListResult>;
-/**
- * List all tables in current database
- * @param profile - Database profile name
- */
-export declare function listTables(profile: string): Promise<TableListResult>;
-/**
- * Describe table structure
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export declare function describeTable(profile: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
-/**
- * Show table indexes
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export declare function showIndexes(profile: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
-/**
- * Explain query execution plan
- * @param profile - Database profile name
- * @param query - SQL query to explain
- * @param format - Output format
- */
-export declare function explainQuery(profile: string, query: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
-/**
- * Test a connection directly with profile options (without loading JSON config)
- * @param profile - Database connection profile options
- */
+export declare function executeQuery(config: Config, query: string, profile?: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
+export declare function listDatabases(config: Config, profile?: string): Promise<DatabaseListResult>;
+export declare function listTables(config: Config, profile?: string): Promise<TableListResult>;
+export declare function describeTable(config: Config, table: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
+export declare function showIndexes(config: Config, table: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
+export declare function explainQuery(config: Config, query: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
 export declare function testDirectConnection(profile: DatabaseProfile): Promise<ConnectionTestResult>;
-/**
- * Close all connections
- */
 export declare function closeConnections(): Promise<void>;

package/dist/psql/postgres-client.js

@@ -1,127 +1,70 @@
-import { readConfig } from '../config.js';
+import { createProfileManager } from '@hesed/plugin-lib';
 import { PostgreSQLUtil } from './postgres-utils.js';
 let pgUtil = null;
 let cachedConfig = null;
-let cachedConfigDir;
-/**
- * Set the config directory for the singleton client
- * @param dir - Oclif config directory path
- */
-export function setConfigDir(dir) {
-    cachedConfigDir = dir;
-}
-/**
- * Initialize (or return cached) PostgreSQLUtil
- */
-async function initPg() {
+const DEFAULT_SAFETY_CONFIG = {
+    blacklistedOperations: ['DROP DATABASE'],
+    defaultLimit: 100,
+    requireConfirmationFor: ['DELETE', 'UPDATE', 'DROP', 'TRUNCATE', 'ALTER'],
+};
+async function initPg(config) {
     if (pgUtil)
         return pgUtil;
-    if (!cachedConfigDir) {
-        throw new Error('PostgreSQL client not initialized. Call setConfigDir() before running commands.');
+    const pm = createProfileManager(config);
+    const profiles = await pm.readProfiles();
+    if (!profiles) {
+        throw new Error('No profile found.');
     }
-    const jsonConfig = await readConfig(cachedConfigDir, console.error);
-    if (!jsonConfig) {
-        throw new Error('Missing connection config. Run "pg psql auth add" to create a config.');
+    const defaultProfile = await pm.getDefaultProfile();
+    if (!defaultProfile) {
+        throw new Error('Missing default profile.');
     }
     cachedConfig = {
         defaultFormat: 'table',
-        defaultProfile: jsonConfig.defaultProfile,
-        profiles: jsonConfig.profiles,
-        safety: {
-            blacklistedOperations: ['DROP DATABASE'],
-            defaultLimit: 100,
-            requireConfirmationFor: ['DELETE', 'UPDATE', 'DROP', 'TRUNCATE', 'ALTER'],
-        },
+        defaultProfile,
+        profiles,
+        safety: DEFAULT_SAFETY_CONFIG,
     };
     pgUtil = new PostgreSQLUtil(cachedConfig);
     return pgUtil;
 }
-/**
- * Get the loaded PostgreSQL config, initializing if needed
- */
-export async function getPgConfig() {
-    if (!cachedConfig) {
-        await initPg();
-    }
-    return cachedConfig;
-}
-/**
- * Execute SQL query
- * @param query - SQL query to execute
- * @param profile - Database profile name
- * @param format - Output format
- * @param skipConfirmation - Skip confirmation for destructive operations
- */
-export async function executeQuery(query, profile, format = 'table', skipConfirmation = false) {
-    return (await initPg()).executeQuery(profile, query, format, skipConfirmation);
+// eslint-disable-next-line max-params
+export async function executeQuery(config, query, profile, format = 'table', skipConfirmation = false) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).executeQuery(profileName, query, format, skipConfirmation);
 }
-/**
- * List all databases
- * @param profile - Database profile name
- */
-export async function listDatabases(profile) {
-    return (await initPg()).listDatabases(profile);
+export async function listDatabases(config, profile) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).listDatabases(profileName);
 }
-/**
- * List all tables in current database
- * @param profile - Database profile name
- */
-export async function listTables(profile) {
-    return (await initPg()).listTables(profile);
+export async function listTables(config, profile) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).listTables(profileName);
 }
-/**
- * Describe table structure
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export async function describeTable(profile, table, format = 'table') {
-    return (await initPg()).describeTable(profile, table, format);
+export async function describeTable(config, table, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).describeTable(profileName, table, format);
 }
-/**
- * Show table indexes
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export async function showIndexes(profile, table, format = 'table') {
-    return (await initPg()).showIndexes(profile, table, format);
+export async function showIndexes(config, table, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).showIndexes(profileName, table, format);
 }
-/**
- * Explain query execution plan
- * @param profile - Database profile name
- * @param query - SQL query to explain
- * @param format - Output format
- */
-export async function explainQuery(profile, query, format = 'table') {
-    return (await initPg()).explainQuery(profile, query, format);
+export async function explainQuery(config, query, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initPg(config)).explainQuery(profileName, query, format);
 }
-/**
- * Test a connection directly with profile options (without loading JSON config)
- * @param profile - Database connection profile options
- */
 export async function testDirectConnection(profile) {
-    const tempConfig = {
+    const testConfig = {
         defaultFormat: 'table',
-        defaultProfile: '_auth',
-        profiles: { _auth: profile },
-        safety: {
-            blacklistedOperations: [],
-            defaultLimit: 100,
-            requireConfirmationFor: [],
-        },
+        defaultProfile: 'default',
+        profiles: { default: profile },
+        safety: DEFAULT_SAFETY_CONFIG,
     };
-    const tempUtil = new PostgreSQLUtil(tempConfig);
-    try {
-        return await tempUtil.testConnection('_auth');
-    }
-    finally {
-        await tempUtil.closeAll();
-    }
+    const util = new PostgreSQLUtil(testConfig);
+    const result = await util.testConnection('default');
+    await util.closeAll();
+    return result;
 }
-/**
- * Close all connections
- */
 export async function closeConnections() {
     if (pgUtil) {
         await pgUtil.closeAll();

package/dist/psql/postgres-utils.d.ts

@@ -1,72 +1,18 @@
 import type { PgConfig } from './config-loader.js';
 import type { ConnectionTestResult, DatabaseListResult, DatabaseUtil, ExplainResult, IndexResult, OutputFormat, QueryResult, TableListResult, TableStructureResult } from './database.js';
-type PgRow = Record<string, unknown>;
-type PgField = {
-    name: string;
-};
-/**
- * PostgreSQL Database Utility
- * Provides core database operations with safety validation and formatting
- */
 export declare class PostgreSQLUtil implements DatabaseUtil {
     private config;
-    private connectionPool;
+    private connections;
     constructor(config: PgConfig);
-    /**
-     * Close all connections
-     */
     closeAll(): Promise<void>;
-    /**
-     * Describe table structure
-     */
     describeTable(profileName: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
-    /**
-     * Validate and execute a SQL query
-     */
     executeQuery(profileName: string, query: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
-    /**
-     * Explain query execution plan
-     */
     explainQuery(profileName: string, query: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
-    /**
-     * Format query results as CSV
-     */
-    formatAsCsv(rows: PgRow[], fields: PgField[]): string;
-    /**
-     * Format query results as JSON
-     */
-    formatAsJson(rows: PgRow[]): string;
-    /**
-     * Format query results as table
-     */
-    formatAsTable(rows: PgRow[], fields: PgField[]): string;
-    /**
-     * Format query results as TOON
-     */
-    formatAsToon(rows: PgRow[]): string;
-    /**
-     * List all databases
-     */
     listDatabases(profileName: string): Promise<DatabaseListResult>;
-    /**
-     * List all tables in current database
-     */
     listTables(profileName: string): Promise<TableListResult>;
-    /**
-     * Show table indexes
-     */
     showIndexes(profileName: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
-    /**
-     * Test database connection
-     */
     testConnection(profileName: string): Promise<ConnectionTestResult>;
-    /**
-     * Format rows for SELECT/EXPLAIN query result
-     */
+    private formatRows;
     private formatSelectResult;
-    /**
-     * Get or create PostgreSQL client for a profile
-     */
     private getConnection;
 }
-export {};