@bernierllc/database-adapter-postgresql 1.0.0

package/dist/PostgreSQLAdapter.js

@@ -0,0 +1,252 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLAdapter = void 0;
+const pg_1 = require("pg");
+const supabase_js_1 = require("@supabase/supabase-js");
+const database_adapter_core_1 = require("@bernierllc/database-adapter-core");
+const retry_policy_1 = require("@bernierllc/retry-policy");
+const logger_1 = require("@bernierllc/logger");
+const PostgreSQLTransaction_1 = require("./PostgreSQLTransaction");
+/**
+ * PostgreSQL database adapter with Supabase support
+ * Implements connection pooling, RLS, and real-time features
+ */
+class PostgreSQLAdapter extends database_adapter_core_1.BaseDatabaseAdapter {
+    constructor(config) {
+        super(config);
+        this.pool = null;
+        this.supabase = null;
+        this.rlsManager = new database_adapter_core_1.RLSContextManager();
+        this.logger = (0, logger_1.createLogger)({ context: { component: 'PostgreSQLAdapter' } });
+        // Initialize Supabase client if configured
+        if (config.supabaseUrl && config.supabaseAnonKey) {
+            this.supabase = (0, supabase_js_1.createClient)(config.supabaseUrl, config.supabaseAnonKey, {
+                auth: {
+                    autoRefreshToken: true,
+                    persistSession: true,
+                    detectSessionInUrl: false
+                }
+            });
+        }
+    }
+    /**
+     * Connect to PostgreSQL with connection pooling
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        this.pool = new pg_1.Pool({
+            host: this.config.host,
+            port: this.config.port || 5432,
+            database: this.config.database,
+            user: this.config.username,
+            password: this.config.password,
+            ssl: this.config.ssl,
+            min: this.config.pooling?.min || 2,
+            max: this.config.pooling?.max || 10,
+            idleTimeoutMillis: this.config.pooling?.idleTimeoutMs || 30000,
+            connectionTimeoutMillis: this.config.connectionTimeoutMs || 5000
+        });
+        // Test connection with retry
+        let attempt = 0;
+        const maxRetries = 3;
+        while (attempt < maxRetries) {
+            try {
+                const client = await this.pool.connect();
+                await client.query('SELECT NOW()');
+                client.release();
+                this.connected = true;
+                this.logger.info('PostgreSQL connection established', {
+                    database: this.config.database,
+                    host: this.config.host,
+                    poolMin: this.config.pooling?.min || 2,
+                    poolMax: this.config.pooling?.max || 10
+                });
+                return;
+            }
+            catch (error) {
+                attempt++;
+                if ((0, retry_policy_1.shouldRetry)(attempt, error, { maxRetries })) {
+                    const delay = (0, retry_policy_1.calculateRetryDelay)(attempt, {
+                        initialDelayMs: 1000,
+                        maxDelayMs: 5000,
+                        jitter: true
+                    });
+                    this.logger.warn('PostgreSQL connection failed, retrying', {
+                        attempt,
+                        maxRetries,
+                        delayMs: delay,
+                        error: this.sanitizeError(error)
+                    });
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+                else {
+                    throw this.sanitizeError(error);
+                }
+            }
+        }
+        throw new Error('Failed to connect to PostgreSQL after retries');
+    }
+    /**
+     * Disconnect and close pool
+     */
+    async disconnect() {
+        if (!this.pool)
+            return;
+        await this.pool.end();
+        this.pool = null;
+        this.connected = false;
+        this.logger.info('PostgreSQL connection closed');
+    }
+    /**
+     * Execute query with RLS context
+     */
+    async query(sql, params) {
+        this.ensureConnected();
+        const startTime = Date.now();
+        const client = await this.pool.connect();
+        try {
+            // Set RLS context if available
+            const rlsStatements = this.rlsManager.generateRLSStatements();
+            for (const stmt of rlsStatements) {
+                await client.query(stmt);
+            }
+            // Execute query
+            const result = await client.query(sql, params);
+            const duration = Date.now() - startTime;
+            this.logger.debug('Query executed', {
+                duration,
+                rowCount: result.rowCount,
+                command: result.command
+            });
+            return {
+                rows: result.rows,
+                rowCount: result.rowCount || 0,
+                fields: result.fields.map(f => ({
+                    name: f.name,
+                    dataTypeID: f.dataTypeID,
+                    dataTypeName: this.getDataTypeName(f.dataTypeID),
+                    nullable: true // PostgreSQL doesn't expose this easily
+                })),
+                command: result.command
+            };
+        }
+        catch (error) {
+            const sanitized = this.sanitizeError(error);
+            this.logger.error('Query execution failed', sanitized, {
+                duration: Date.now() - startTime
+            });
+            throw sanitized;
+        }
+        finally {
+            client.release();
+        }
+    }
+    /**
+     * Begin transaction with RLS context
+     */
+    async beginTransaction() {
+        this.ensureConnected();
+        const client = await this.pool.connect();
+        // Set RLS context for transaction
+        const rlsStatements = this.rlsManager.generateRLSStatements();
+        for (const stmt of rlsStatements) {
+            await client.query(stmt);
+        }
+        await client.query('BEGIN');
+        this.logger.debug('Transaction started');
+        return new PostgreSQLTransaction_1.PostgreSQLTransaction(client, this.rlsManager, this.logger);
+    }
+    /**
+     * Health check with connection pool stats
+     */
+    async healthCheck() {
+        if (!this.connected || !this.pool) {
+            return {
+                connected: false,
+                latencyMs: -1,
+                version: 'unknown'
+            };
+        }
+        const start = Date.now();
+        try {
+            const result = await this.pool.query('SELECT version()');
+            const latencyMs = Date.now() - start;
+            return {
+                connected: true,
+                latencyMs,
+                version: result.rows[0].version,
+                activeConnections: this.pool.totalCount,
+                maxConnections: this.pool.options.max
+            };
+        }
+        catch (error) {
+            const sanitized = this.sanitizeError(error);
+            this.logger.error('Health check failed', sanitized);
+            return {
+                connected: false,
+                latencyMs: -1,
+                version: 'error'
+            };
+        }
+    }
+    /**
+     * Get Supabase client for real-time features
+     */
+    getSupabaseClient() {
+        return this.supabase;
+    }
+    /**
+     * Set RLS context for current operation
+     */
+    setRLSContext(userId, userRole, tenantId) {
+        this.rlsManager.setContext({ userId, userRole, tenantId });
+        this.logger.debug('RLS context set', { userId, userRole, tenantId });
+    }
+    /**
+     * Clear RLS context
+     */
+    clearRLSContext() {
+        this.rlsManager.clearContext();
+        this.logger.debug('RLS context cleared');
+    }
+    /**
+     * Get current connection pool statistics
+     */
+    getPoolStats() {
+        if (!this.pool)
+            return null;
+        return {
+            total: this.pool.totalCount,
+            idle: this.pool.idleCount,
+            waiting: this.pool.waitingCount
+        };
+    }
+    /**
+     * Map PostgreSQL data type OID to name
+     */
+    getDataTypeName(oid) {
+        const typeMap = {
+            16: 'BOOL',
+            20: 'BIGINT',
+            21: 'SMALLINT',
+            23: 'INTEGER',
+            25: 'TEXT',
+            114: 'JSON',
+            1043: 'VARCHAR',
+            1082: 'DATE',
+            1114: 'TIMESTAMP',
+            1184: 'TIMESTAMPTZ',
+            3802: 'JSONB'
+        };
+        return typeMap[oid] || 'UNKNOWN';
+    }
+}
+exports.PostgreSQLAdapter = PostgreSQLAdapter;

package/dist/PostgreSQLTransaction.d.ts

@@ -0,0 +1,46 @@
+import { PoolClient } from 'pg';
+import { ITransaction, IQueryResult, RLSContextManager } from '@bernierllc/database-adapter-core';
+import { Logger } from '@bernierllc/logger';
+/**
+ * PostgreSQL transaction implementation with RLS context support
+ */
+export declare class PostgreSQLTransaction implements ITransaction {
+    private client;
+    private _rlsManager;
+    id: string;
+    private active;
+    private logger?;
+    constructor(client: PoolClient, _rlsManager: RLSContextManager, logger?: Logger);
+    /**
+     * Execute query within transaction
+     */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<IQueryResult<T>>;
+    /**
+     * Commit transaction and release client
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback transaction and release client
+     */
+    rollback(): Promise<void>;
+    /**
+     * Create a savepoint within the transaction
+     */
+    savepoint(name: string): Promise<void>;
+    /**
+     * Rollback to a savepoint
+     */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /**
+     * Release a savepoint
+     */
+    releaseSavepoint(name: string): Promise<void>;
+    /**
+     * Check if transaction is still active
+     */
+    isActive(): boolean;
+    /**
+     * Map PostgreSQL data type OID to name
+     */
+    private getDataTypeName;
+}

package/dist/PostgreSQLTransaction.js

@@ -0,0 +1,199 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLTransaction = void 0;
+/**
+ * PostgreSQL transaction implementation with RLS context support
+ */
+class PostgreSQLTransaction {
+    constructor(client, 
+    // @ts-expect-error - Reserved for future RLS context support in transactions
+    _rlsManager, logger) {
+        this.client = client;
+        this._rlsManager = _rlsManager;
+        this.active = true;
+        this.id = `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.logger = logger;
+        if (this.logger) {
+            this.logger.debug('Transaction created', { id: this.id });
+        }
+    }
+    /**
+     * Execute query within transaction
+     */
+    async query(sql, params) {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        const startTime = Date.now();
+        try {
+            const result = await this.client.query(sql, params);
+            const duration = Date.now() - startTime;
+            if (this.logger) {
+                this.logger.debug('Transaction query executed', {
+                    transactionId: this.id,
+                    duration,
+                    rowCount: result.rowCount,
+                    command: result.command
+                });
+            }
+            return {
+                rows: result.rows,
+                rowCount: result.rowCount || 0,
+                fields: result.fields.map(f => ({
+                    name: f.name,
+                    dataTypeID: f.dataTypeID,
+                    dataTypeName: this.getDataTypeName(f.dataTypeID),
+                    nullable: true
+                })),
+                command: result.command
+            };
+        }
+        catch (error) {
+            if (this.logger) {
+                this.logger.error('Transaction query failed', error instanceof Error ? error : new Error(String(error)), {
+                    transactionId: this.id,
+                    duration: Date.now() - startTime
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Commit transaction and release client
+     */
+    async commit() {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        const startTime = Date.now();
+        try {
+            await this.client.query('COMMIT');
+            this.active = false;
+            if (this.logger) {
+                this.logger.debug('Transaction committed', {
+                    transactionId: this.id,
+                    duration: Date.now() - startTime
+                });
+            }
+        }
+        catch (error) {
+            if (this.logger) {
+                this.logger.error('Transaction commit failed', error instanceof Error ? error : new Error(String(error)), {
+                    transactionId: this.id
+                });
+            }
+            throw error;
+        }
+        finally {
+            this.client.release();
+        }
+    }
+    /**
+     * Rollback transaction and release client
+     */
+    async rollback() {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        const startTime = Date.now();
+        try {
+            await this.client.query('ROLLBACK');
+            this.active = false;
+            if (this.logger) {
+                this.logger.debug('Transaction rolled back', {
+                    transactionId: this.id,
+                    duration: Date.now() - startTime
+                });
+            }
+        }
+        catch (error) {
+            if (this.logger) {
+                this.logger.error('Transaction rollback failed', error instanceof Error ? error : new Error(String(error)), {
+                    transactionId: this.id
+                });
+            }
+            throw error;
+        }
+        finally {
+            this.client.release();
+        }
+    }
+    /**
+     * Create a savepoint within the transaction
+     */
+    async savepoint(name) {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        await this.client.query(`SAVEPOINT ${name}`);
+        if (this.logger) {
+            this.logger.debug('Savepoint created', {
+                transactionId: this.id,
+                savepoint: name
+            });
+        }
+    }
+    /**
+     * Rollback to a savepoint
+     */
+    async rollbackToSavepoint(name) {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        await this.client.query(`ROLLBACK TO SAVEPOINT ${name}`);
+        if (this.logger) {
+            this.logger.debug('Rolled back to savepoint', {
+                transactionId: this.id,
+                savepoint: name
+            });
+        }
+    }
+    /**
+     * Release a savepoint
+     */
+    async releaseSavepoint(name) {
+        if (!this.active) {
+            throw new Error('Transaction is not active');
+        }
+        await this.client.query(`RELEASE SAVEPOINT ${name}`);
+        if (this.logger) {
+            this.logger.debug('Savepoint released', {
+                transactionId: this.id,
+                savepoint: name
+            });
+        }
+    }
+    /**
+     * Check if transaction is still active
+     */
+    isActive() {
+        return this.active;
+    }
+    /**
+     * Map PostgreSQL data type OID to name
+     */
+    getDataTypeName(oid) {
+        const typeMap = {
+            16: 'BOOL',
+            20: 'BIGINT',
+            21: 'SMALLINT',
+            23: 'INTEGER',
+            25: 'TEXT',
+            114: 'JSON',
+            1043: 'VARCHAR',
+            1082: 'DATE',
+            1114: 'TIMESTAMP',
+            1184: 'TIMESTAMPTZ',
+            3802: 'JSONB'
+        };
+        return typeMap[oid] || 'UNKNOWN';
+    }
+}
+exports.PostgreSQLTransaction = PostgreSQLTransaction;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { PostgreSQLAdapter, ISupabaseConfig } from './PostgreSQLAdapter';
+export { PostgreSQLTransaction } from './PostgreSQLTransaction';
+export { RLSPolicyGenerator } from './rls/RLSPolicyGenerator';
+export { ClerkIntegration } from './rls/ClerkIntegration';
+export { RealtimeManager, RealtimePayload, RealtimeCallbacks, PresenceData } from './realtime/RealtimeManager';
+export { FullTextSearchManager, SearchResult, SearchOptions } from './search/FullTextSearchManager';
+export { migration_001_initial_schema } from './migrations/001_initial_schema';

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migration_001_initial_schema = exports.FullTextSearchManager = exports.RealtimeManager = exports.ClerkIntegration = exports.RLSPolicyGenerator = exports.PostgreSQLTransaction = exports.PostgreSQLAdapter = void 0;
+// Main adapter
+var PostgreSQLAdapter_1 = require("./PostgreSQLAdapter");
+Object.defineProperty(exports, "PostgreSQLAdapter", { enumerable: true, get: function () { return PostgreSQLAdapter_1.PostgreSQLAdapter; } });
+var PostgreSQLTransaction_1 = require("./PostgreSQLTransaction");
+Object.defineProperty(exports, "PostgreSQLTransaction", { enumerable: true, get: function () { return PostgreSQLTransaction_1.PostgreSQLTransaction; } });
+// RLS components
+var RLSPolicyGenerator_1 = require("./rls/RLSPolicyGenerator");
+Object.defineProperty(exports, "RLSPolicyGenerator", { enumerable: true, get: function () { return RLSPolicyGenerator_1.RLSPolicyGenerator; } });
+var ClerkIntegration_1 = require("./rls/ClerkIntegration");
+Object.defineProperty(exports, "ClerkIntegration", { enumerable: true, get: function () { return ClerkIntegration_1.ClerkIntegration; } });
+// Real-time
+var RealtimeManager_1 = require("./realtime/RealtimeManager");
+Object.defineProperty(exports, "RealtimeManager", { enumerable: true, get: function () { return RealtimeManager_1.RealtimeManager; } });
+// Search
+var FullTextSearchManager_1 = require("./search/FullTextSearchManager");
+Object.defineProperty(exports, "FullTextSearchManager", { enumerable: true, get: function () { return FullTextSearchManager_1.FullTextSearchManager; } });
+// Migrations
+var _001_initial_schema_1 = require("./migrations/001_initial_schema");
+Object.defineProperty(exports, "migration_001_initial_schema", { enumerable: true, get: function () { return _001_initial_schema_1.migration_001_initial_schema; } });

package/dist/migrations/001_initial_schema.d.ts

@@ -0,0 +1,2 @@
+import { IMigration } from '@bernierllc/database-adapter-core';
+export declare const migration_001_initial_schema: IMigration;

package/dist/migrations/001_initial_schema.js

@@ -0,0 +1,91 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migration_001_initial_schema = void 0;
+exports.migration_001_initial_schema = {
+    id: '001_initial_schema',
+    name: 'Create initial content management schema',
+    async up(adapter) {
+        await adapter.query(`
+      -- Enable extensions
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+      CREATE EXTENSION IF NOT EXISTS "pg_trgm";
+
+      -- Users table (Clerk integration)
+      CREATE TABLE IF NOT EXISTS users (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        clerk_id VARCHAR(255) UNIQUE NOT NULL,
+        email VARCHAR(255) UNIQUE NOT NULL,
+        username VARCHAR(100),
+        full_name VARCHAR(255),
+        avatar_url TEXT,
+        role VARCHAR(50) DEFAULT 'user',
+        tenant_id UUID,
+        preferences JSONB DEFAULT '{}',
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_users_clerk_id ON users(clerk_id);
+      CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+
+      -- Content table
+      CREATE TABLE IF NOT EXISTS content (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+        title VARCHAR(500) NOT NULL,
+        slug VARCHAR(500) UNIQUE,
+        body TEXT NOT NULL,
+        excerpt TEXT,
+        type VARCHAR(50) DEFAULT 'blog',
+        format VARCHAR(50) DEFAULT 'markdown',
+        status VARCHAR(50) DEFAULT 'draft',
+        workflow_stage VARCHAR(100),
+        assigned_to UUID REFERENCES users(id),
+        ai_reviewed BOOLEAN DEFAULT FALSE,
+        ai_review_score DECIMAL(3,2),
+        keywords JSONB DEFAULT '[]',
+        view_count INTEGER DEFAULT 0,
+        share_count INTEGER DEFAULT 0,
+        version INTEGER DEFAULT 1,
+        published_at TIMESTAMPTZ,
+        scheduled_for TIMESTAMPTZ,
+        deleted_at TIMESTAMPTZ,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      -- Content versions
+      CREATE TABLE IF NOT EXISTS content_versions (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        content_id UUID REFERENCES content(id) ON DELETE CASCADE,
+        version_number INTEGER NOT NULL,
+        title VARCHAR(500),
+        body TEXT NOT NULL,
+        change_summary TEXT,
+        is_autosave BOOLEAN DEFAULT FALSE,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        created_by UUID REFERENCES users(id),
+        UNIQUE(content_id, version_number)
+      );
+
+      -- Enable RLS
+      ALTER TABLE users ENABLE ROW LEVEL SECURITY;
+      ALTER TABLE content ENABLE ROW LEVEL SECURITY;
+      ALTER TABLE content_versions ENABLE ROW LEVEL SECURITY;
+    `);
+    },
+    async down(adapter) {
+        await adapter.query(`
+      DROP TABLE IF EXISTS content_versions CASCADE;
+      DROP TABLE IF EXISTS content CASCADE;
+      DROP TABLE IF EXISTS users CASCADE;
+    `);
+    }
+};