@bernierllc/database-adapter-postgresql 1.0.0

package/dist/realtime/RealtimeManager.d.ts

@@ -0,0 +1,76 @@
+import { PostgreSQLAdapter } from '../PostgreSQLAdapter';
+/**
+ * Payload types for real-time events
+ */
+export interface RealtimePayload {
+    schema: string;
+    table: string;
+    commit_timestamp: string;
+    eventType: 'INSERT' | 'UPDATE' | 'DELETE';
+    new: Record<string, unknown>;
+    old: Record<string, unknown>;
+    errors: string[] | null;
+}
+/**
+ * Callbacks for real-time subscriptions
+ */
+export interface RealtimeCallbacks {
+    onInsert?: (payload: RealtimePayload) => void;
+    onUpdate?: (payload: RealtimePayload) => void;
+    onDelete?: (payload: RealtimePayload) => void;
+}
+/**
+ * Presence data for collaborative editing
+ */
+export interface PresenceData {
+    userId: string;
+    cursorPosition?: {
+        line: number;
+        column: number;
+    };
+    timestamp: number;
+}
+/**
+ * Manages Supabase real-time subscriptions for collaborative editing
+ */
+export declare class RealtimeManager {
+    private adapter;
+    private channels;
+    private logger?;
+    constructor(adapter: PostgreSQLAdapter);
+    /**
+     * Subscribe to table changes for collaborative editing
+     */
+    subscribeToContent(contentId: string, callbacks: RealtimeCallbacks): () => void;
+    /**
+     * Subscribe to generic table changes
+     */
+    subscribeToTable(table: string, filter: string | null, callbacks: RealtimeCallbacks): () => void;
+    /**
+     * Broadcast presence for collaborative editing
+     */
+    broadcastPresence(contentId: string, userId: string, cursorPosition?: {
+        line: number;
+        column: number;
+    }): Promise<void>;
+    /**
+     * Get current presence state for a channel
+     */
+    getPresence(contentId: string): Record<string, PresenceData[]> | null;
+    /**
+     * Unsubscribe from a specific channel
+     */
+    unsubscribe(contentId: string): Promise<void>;
+    /**
+     * Unsubscribe from all channels
+     */
+    unsubscribeAll(): Promise<void>;
+    /**
+     * Get active channel count
+     */
+    getActiveChannelCount(): number;
+    /**
+     * Check if a channel is active
+     */
+    isChannelActive(contentId: string): boolean;
+}

package/dist/realtime/RealtimeManager.js

@@ -0,0 +1,243 @@
+"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.RealtimeManager = void 0;
+/**
+ * Manages Supabase real-time subscriptions for collaborative editing
+ */
+class RealtimeManager {
+    constructor(adapter) {
+        this.adapter = adapter;
+        this.channels = new Map();
+        // Access logger from adapter (it's a public property but typed generically)
+        this.logger = adapter.logger;
+    }
+    /**
+     * Subscribe to table changes for collaborative editing
+     */
+    subscribeToContent(contentId, callbacks) {
+        const supabase = this.adapter.getSupabaseClient();
+        if (!supabase) {
+            throw new Error('Supabase client not configured');
+        }
+        const channelName = `content:${contentId}`;
+        if (this.logger) {
+            this.logger.debug('Subscribing to real-time channel', {
+                channel: channelName,
+                contentId
+            });
+        }
+        const channel = supabase
+            .channel(channelName)
+            .on('postgres_changes', {
+            event: 'INSERT',
+            schema: 'public',
+            table: 'content_versions',
+            filter: `content_id=eq.${contentId}`
+        }, (payload) => {
+            if (callbacks.onInsert) {
+                callbacks.onInsert(payload);
+            }
+            if (this.logger) {
+                this.logger.debug('Real-time INSERT event', {
+                    channel: channelName,
+                    table: 'content_versions'
+                });
+            }
+        })
+            .on('postgres_changes', {
+            event: 'UPDATE',
+            schema: 'public',
+            table: 'content',
+            filter: `id=eq.${contentId}`
+        }, (payload) => {
+            if (callbacks.onUpdate) {
+                callbacks.onUpdate(payload);
+            }
+            if (this.logger) {
+                this.logger.debug('Real-time UPDATE event', {
+                    channel: channelName,
+                    table: 'content'
+                });
+            }
+        })
+            .on('postgres_changes', {
+            event: 'DELETE',
+            schema: 'public',
+            table: 'content',
+            filter: `id=eq.${contentId}`
+        }, (payload) => {
+            if (callbacks.onDelete) {
+                callbacks.onDelete(payload);
+            }
+            if (this.logger) {
+                this.logger.debug('Real-time DELETE event', {
+                    channel: channelName,
+                    table: 'content'
+                });
+            }
+        })
+            .subscribe();
+        this.channels.set(contentId, channel);
+        // Return unsubscribe function
+        return () => {
+            if (this.logger) {
+                this.logger.debug('Unsubscribing from real-time channel', {
+                    channel: channelName,
+                    contentId
+                });
+            }
+            channel.unsubscribe();
+            this.channels.delete(contentId);
+        };
+    }
+    /**
+     * Subscribe to generic table changes
+     */
+    subscribeToTable(table, filter, callbacks) {
+        const supabase = this.adapter.getSupabaseClient();
+        if (!supabase) {
+            throw new Error('Supabase client not configured');
+        }
+        const channelName = `table:${table}:${filter || 'all'}`;
+        if (this.logger) {
+            this.logger.debug('Subscribing to table changes', {
+                channel: channelName,
+                table,
+                filter
+            });
+        }
+        let channel = supabase.channel(channelName);
+        // Subscribe to INSERT events
+        if (callbacks.onInsert) {
+            channel = channel.on('postgres_changes', {
+                event: 'INSERT',
+                schema: 'public',
+                table,
+                ...(filter ? { filter } : {})
+            }, (payload) => {
+                callbacks.onInsert(payload);
+            });
+        }
+        // Subscribe to UPDATE events
+        if (callbacks.onUpdate) {
+            channel = channel.on('postgres_changes', {
+                event: 'UPDATE',
+                schema: 'public',
+                table,
+                ...(filter ? { filter } : {})
+            }, (payload) => {
+                callbacks.onUpdate(payload);
+            });
+        }
+        // Subscribe to DELETE events
+        if (callbacks.onDelete) {
+            channel = channel.on('postgres_changes', {
+                event: 'DELETE',
+                schema: 'public',
+                table,
+                ...(filter ? { filter } : {})
+            }, (payload) => {
+                callbacks.onDelete(payload);
+            });
+        }
+        channel.subscribe();
+        this.channels.set(channelName, channel);
+        // Return unsubscribe function
+        return () => {
+            if (this.logger) {
+                this.logger.debug('Unsubscribing from table changes', {
+                    channel: channelName
+                });
+            }
+            channel.unsubscribe();
+            this.channels.delete(channelName);
+        };
+    }
+    /**
+     * Broadcast presence for collaborative editing
+     */
+    async broadcastPresence(contentId, userId, cursorPosition) {
+        const supabase = this.adapter.getSupabaseClient();
+        if (!supabase) {
+            if (this.logger) {
+                this.logger.warn('Cannot broadcast presence: Supabase client not configured');
+            }
+            return;
+        }
+        const channel = this.channels.get(contentId);
+        if (!channel) {
+            throw new Error(`No channel found for content ${contentId}`);
+        }
+        const presenceData = {
+            userId,
+            cursorPosition,
+            timestamp: Date.now()
+        };
+        await channel.track(presenceData);
+        if (this.logger) {
+            this.logger.debug('Presence broadcasted', {
+                contentId,
+                userId,
+                cursorPosition
+            });
+        }
+    }
+    /**
+     * Get current presence state for a channel
+     */
+    getPresence(contentId) {
+        const channel = this.channels.get(contentId);
+        if (!channel) {
+            return null;
+        }
+        const state = channel.presenceState();
+        return state;
+    }
+    /**
+     * Unsubscribe from a specific channel
+     */
+    async unsubscribe(contentId) {
+        const channel = this.channels.get(contentId);
+        if (channel) {
+            if (this.logger) {
+                this.logger.debug('Unsubscribing from channel', { contentId });
+            }
+            await channel.unsubscribe();
+            this.channels.delete(contentId);
+        }
+    }
+    /**
+     * Unsubscribe from all channels
+     */
+    async unsubscribeAll() {
+        if (this.logger) {
+            this.logger.debug('Unsubscribing from all channels', {
+                count: this.channels.size
+            });
+        }
+        for (const [, channel] of this.channels) {
+            await channel.unsubscribe();
+        }
+        this.channels.clear();
+    }
+    /**
+     * Get active channel count
+     */
+    getActiveChannelCount() {
+        return this.channels.size;
+    }
+    /**
+     * Check if a channel is active
+     */
+    isChannelActive(contentId) {
+        return this.channels.has(contentId);
+    }
+}
+exports.RealtimeManager = RealtimeManager;

package/dist/rls/ClerkIntegration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Clerk JWT integration utilities for PostgreSQL RLS
+ */
+export declare class ClerkIntegration {
+    /**
+     * Generate SQL function for extracting Clerk user ID from JWT
+     */
+    static generateClerkUserIdFunction(): string;
+    /**
+     * Generate SQL function for getting internal user ID from Clerk ID
+     */
+    static generateUserIdFunction(): string;
+    /**
+     * Generate SQL function for checking if user is admin
+     */
+    static generateIsAdminFunction(): string;
+    /**
+     * Generate SQL function for getting user role
+     */
+    static generateUserRoleFunction(): string;
+    /**
+     * Generate SQL function for checking if user has specific role
+     */
+    static generateHasRoleFunction(): string;
+    /**
+     * Generate SQL function for getting user's tenant ID
+     */
+    static generateUserTenantIdFunction(): string;
+    /**
+     * Generate all Clerk integration functions
+     */
+    static generateAllFunctions(): string;
+    /**
+     * Generate SQL to create auth schema if not exists
+     */
+    static generateAuthSchema(): string;
+    /**
+     * Generate complete Clerk integration setup
+     */
+    static generateCompleteSetup(): string;
+}

package/dist/rls/ClerkIntegration.js

@@ -0,0 +1,161 @@
+"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.ClerkIntegration = void 0;
+/**
+ * Clerk JWT integration utilities for PostgreSQL RLS
+ */
+class ClerkIntegration {
+    /**
+     * Generate SQL function for extracting Clerk user ID from JWT
+     */
+    static generateClerkUserIdFunction() {
+        return `
+-- PostgreSQL function for Clerk JWT verification
+-- Extracts user_id from Clerk JWT token in request headers
+
+CREATE OR REPLACE FUNCTION auth.clerk_user_id()
+RETURNS TEXT
+LANGUAGE plpgsql
+SECURITY DEFINER
+AS $$
+DECLARE
+  jwt_claims JSONB;
+  clerk_user_id TEXT;
+BEGIN
+  -- Extract JWT claims from request
+  jwt_claims := current_setting('request.jwt.claims', true)::jsonb;
+
+  -- Get Clerk user ID from 'sub' claim
+  clerk_user_id := jwt_claims->>'sub';
+
+  RETURN clerk_user_id;
+EXCEPTION
+  WHEN OTHERS THEN
+    RETURN NULL;
+END;
+$$;
+    `;
+    }
+    /**
+     * Generate SQL function for getting internal user ID from Clerk ID
+     */
+    static generateUserIdFunction() {
+        return `
+-- Helper function to get internal user ID from Clerk ID
+CREATE OR REPLACE FUNCTION auth.user_id()
+RETURNS UUID
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+AS $$
+  SELECT id FROM users WHERE clerk_id = auth.clerk_user_id();
+$$;
+    `;
+    }
+    /**
+     * Generate SQL function for checking if user is admin
+     */
+    static generateIsAdminFunction() {
+        return `
+-- Helper function to check if user is admin
+CREATE OR REPLACE FUNCTION auth.is_admin()
+RETURNS BOOLEAN
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+AS $$
+  SELECT role = 'admin' FROM users WHERE clerk_id = auth.clerk_user_id();
+$$;
+    `;
+    }
+    /**
+     * Generate SQL function for getting user role
+     */
+    static generateUserRoleFunction() {
+        return `
+-- Helper function to get user role
+CREATE OR REPLACE FUNCTION auth.user_role()
+RETURNS VARCHAR(50)
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+AS $$
+  SELECT role FROM users WHERE clerk_id = auth.clerk_user_id();
+$$;
+    `;
+    }
+    /**
+     * Generate SQL function for checking if user has specific role
+     */
+    static generateHasRoleFunction() {
+        return `
+-- Helper function to check if user has specific role
+CREATE OR REPLACE FUNCTION auth.has_role(required_role VARCHAR)
+RETURNS BOOLEAN
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+AS $$
+  SELECT role = required_role FROM users WHERE clerk_id = auth.clerk_user_id();
+$$;
+    `;
+    }
+    /**
+     * Generate SQL function for getting user's tenant ID
+     */
+    static generateUserTenantIdFunction() {
+        return `
+-- Helper function to get user's tenant ID
+CREATE OR REPLACE FUNCTION auth.user_tenant_id()
+RETURNS UUID
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+AS $$
+  SELECT tenant_id FROM users WHERE clerk_id = auth.clerk_user_id();
+$$;
+    `;
+    }
+    /**
+     * Generate all Clerk integration functions
+     */
+    static generateAllFunctions() {
+        return [
+            this.generateClerkUserIdFunction(),
+            this.generateUserIdFunction(),
+            this.generateIsAdminFunction(),
+            this.generateUserRoleFunction(),
+            this.generateHasRoleFunction(),
+            this.generateUserTenantIdFunction()
+        ].join('\n\n');
+    }
+    /**
+     * Generate SQL to create auth schema if not exists
+     */
+    static generateAuthSchema() {
+        return `
+-- Create auth schema for Clerk integration functions
+CREATE SCHEMA IF NOT EXISTS auth;
+
+-- Grant usage on auth schema
+GRANT USAGE ON SCHEMA auth TO authenticated, anon;
+    `;
+    }
+    /**
+     * Generate complete Clerk integration setup
+     */
+    static generateCompleteSetup() {
+        return [
+            this.generateAuthSchema(),
+            this.generateAllFunctions()
+        ].join('\n\n');
+    }
+}
+exports.ClerkIntegration = ClerkIntegration;

package/dist/rls/RLSPolicyGenerator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * RLS policy generator for Supabase
+ * Creates policies for multi-tenant security with Clerk integration
+ */
+export declare class RLSPolicyGenerator {
+    /**
+     * Generate RLS policy for user-scoped access
+     */
+    static generateUserPolicy(table: string): string;
+    /**
+     * Generate admin bypass policy
+     */
+    static generateAdminPolicy(table: string): string;
+    /**
+     * Generate multi-tenant policy
+     */
+    static generateTenantPolicy(table: string): string;
+    /**
+     * Generate read-only policy for public data
+     */
+    static generatePublicReadPolicy(table: string, condition?: string): string;
+    /**
+     * Generate policy for shared resources
+     */
+    static generateSharedResourcePolicy(table: string, sharingTable?: string): string;
+    /**
+     * Generate policy for role-based access
+     */
+    static generateRoleBasedPolicy(table: string, allowedRoles: string[]): string;
+    /**
+     * Disable RLS on a table (use with caution)
+     */
+    static disableRLS(table: string): string;
+    /**
+     * Generate policy for time-based access (e.g., scheduled content)
+     */
+    static generateTimeBasedPolicy(table: string): string;
+}