@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/database/universal-postgres.js

@@ -0,0 +1,526 @@
+/**
+ * Universal PostgreSQL Adapter for RevealUI CMS
+ *
+ * Supports multiple PostgreSQL providers:
+ * - Neon Database (https://neon.tech)
+ * - Supabase (https://supabase.com)
+ * - Vercel Postgres (https://vercel.com/storage/postgres)
+ *
+ * Automatically detects the provider based on connection string or environment.
+ *
+ * WARNING: This module uses Node.js-specific database drivers.
+ * Do NOT import in client-side code or edge runtime.
+ */
+import { defaultLogger } from '../instance/logger.js';
+import { logger } from '../observability/logger.js';
+import { getSSLConfig } from './ssl-config.js';
+/**
+ * Worker-isolated PGlite instances for parallel test execution
+ * Each Vitest worker thread gets its own isolated database instance
+ * Key: worker ID (from VITEST_WORKER_ID env var)
+ * Value: PGlite instance for that worker
+ */
+const workerPGliteInstances = new Map();
+/**
+ * Worker-isolated table creation promises
+ * Each worker tracks its own pending table creations
+ */
+const workerPendingTableCreations = new Map();
+/**
+ * Worker-isolated table tracking
+ * Each worker tracks which tables it has created
+ */
+const workerCreatedTables = new Map();
+/**
+ * Get the current worker ID for test isolation
+ * In tests: Uses VITEST_WORKER_ID to isolate per worker thread
+ * In production: Uses 'main' for single shared instance
+ */
+function getWorkerID() {
+    return process.env.VITEST_WORKER_ID || 'main';
+}
+/**
+ * Get or create worker-specific PGlite instance
+ */
+function getWorkerPGliteInstance() {
+    const workerID = getWorkerID();
+    return workerPGliteInstances.get(workerID) || null;
+}
+/**
+ * Set worker-specific PGlite instance
+ */
+function setWorkerPGliteInstance(instance) {
+    const workerID = getWorkerID();
+    workerPGliteInstances.set(workerID, instance);
+}
+/**
+ * Get worker-specific pending table creations
+ */
+function getWorkerPendingTableCreations() {
+    const workerID = getWorkerID();
+    if (!workerPendingTableCreations.has(workerID)) {
+        workerPendingTableCreations.set(workerID, []);
+    }
+    return workerPendingTableCreations.get(workerID);
+}
+/**
+ * Get worker-specific created tables set
+ */
+function getWorkerCreatedTables() {
+    const workerID = getWorkerID();
+    if (!workerCreatedTables.has(workerID)) {
+        workerCreatedTables.set(workerID, new Set());
+    }
+    return workerCreatedTables.get(workerID);
+}
+/**
+ * Detects the PostgreSQL provider from connection string
+ */
+function detectProvider(connectionString) {
+    const url = connectionString.toLowerCase();
+    if (url.includes('.neon.tech') || url.includes('neon.tech')) {
+        return 'neon';
+    }
+    if (url.includes('.supabase.co') || url.includes('supabase')) {
+        return 'supabase';
+    }
+    if (url.includes('electric') || process.env.ELECTRIC_ENV) {
+        return 'electric';
+    }
+    return 'generic';
+}
+/**
+ * Creates a universal PostgreSQL adapter that works with Neon, Supabase, and Electric Postgres
+ */
+export function universalPostgresAdapter(config = {}) {
+    let queryFn;
+    let provider = 'generic';
+    const initializeConnection = async () => {
+        // Allow explicit electric provider without a connection string (PGlite local)
+        let connectionString;
+        if (config.provider === 'electric') {
+            provider = 'electric';
+        }
+        else {
+            // Get connection string from config or environment
+            connectionString =
+                config.connectionString ||
+                    process.env[config.envVar || 'DATABASE_URL'] ||
+                    process.env.POSTGRES_URL ||
+                    process.env.SUPABASE_DATABASE_URI ||
+                    process.env.DATABASE_URL;
+            if (!connectionString) {
+                throw new Error('Database connection string not found. Set DATABASE_URL, POSTGRES_URL, or SUPABASE_DATABASE_URI environment variable.');
+            }
+            // Detect provider if not explicitly set
+            provider = config.provider || detectProvider(connectionString);
+        }
+        // Initialize provider-specific query function
+        // Note: connectionString is guaranteed defined for non-electric providers (throws at line 81 if undefined)
+        switch (provider) {
+            case 'neon': {
+                // Use pg library for Neon (more compatible with parameterized queries)
+                // Neon serverless has limitations with $1, $2 style parameters
+                // Using pg ensures full PostgreSQL compatibility
+                const neonConnectionString = connectionString;
+                queryFn = async (queryString, values = []) => {
+                    try {
+                        // Use pg library for best compatibility with parameterized queries
+                        const { Pool } = await import('pg');
+                        const pool = new Pool({
+                            connectionString: neonConnectionString,
+                            ssl: getSSLConfig(neonConnectionString),
+                        });
+                        const client = await pool.connect();
+                        try {
+                            const result = await client.query(queryString, values);
+                            return {
+                                rows: result.rows,
+                                rowCount: result.rowCount || 0,
+                            };
+                        }
+                        finally {
+                            client.release();
+                        }
+                    }
+                    catch (error) {
+                        defaultLogger.error('Neon database query error:', error);
+                        throw error;
+                    }
+                };
+                break;
+            }
+            case 'supabase': {
+                // CRITICAL: For Supabase transaction pooling (port 6543), we use pg library
+                // Transaction pooling works fine with pg - no special configuration needed
+                // Reference: https://supabase.com/docs/guides/database/connecting-to-postgres
+                const supabaseConnectionString = connectionString;
+                const isTransactionPooling = supabaseConnectionString.includes(':6543');
+                if (isTransactionPooling) {
+                    // For transaction pooling: Use pg library with parameterized queries
+                    // pg supports $1, $2 style parameters without prepared statements
+                    const { Pool } = await import('pg');
+                    const pool = new Pool({
+                        connectionString: supabaseConnectionString,
+                        ssl: getSSLConfig(supabaseConnectionString),
+                    });
+                    queryFn = async (queryString, values = []) => {
+                        const client = await pool.connect();
+                        try {
+                            const result = await client.query(queryString, values);
+                            return {
+                                rows: result.rows,
+                                rowCount: result.rowCount || 0,
+                            };
+                        }
+                        finally {
+                            client.release();
+                        }
+                    };
+                }
+                else {
+                    // Use pg library for session pooling or direct connections (port 5432)
+                    const { Pool } = await import('pg');
+                    const pool = new Pool({
+                        connectionString: supabaseConnectionString,
+                        ssl: getSSLConfig(supabaseConnectionString),
+                    });
+                    queryFn = async (queryString, values = []) => {
+                        try {
+                            const client = await pool.connect();
+                            try {
+                                const result = await client.query(queryString, values);
+                                return {
+                                    rows: result.rows,
+                                    rowCount: result.rowCount || 0,
+                                };
+                            }
+                            finally {
+                                client.release();
+                            }
+                        }
+                        catch (error) {
+                            defaultLogger.error('Supabase database query error:', error);
+                            throw error;
+                        }
+                    };
+                }
+                break;
+            }
+            case 'electric': {
+                // Use worker-isolated PGlite instance for parallel test execution
+                // Each Vitest worker gets its own database instance to prevent race conditions
+                let db = getWorkerPGliteInstance();
+                if (!db) {
+                    const { PGlite } = await import('@electric-sql/pglite');
+                    db = new PGlite();
+                    setWorkerPGliteInstance(db);
+                }
+                queryFn = async (queryString, values = []) => {
+                    const result = await db.query(queryString, values);
+                    return {
+                        rows: result.rows,
+                        rowCount: result.rowCount || 0,
+                    };
+                };
+                break;
+            }
+            default: {
+                // Generic PostgreSQL using pg (node-postgres)
+                const genericConnectionString = connectionString;
+                const { Pool } = await import('pg');
+                const pool = new Pool({
+                    connectionString: genericConnectionString,
+                    ssl: getSSLConfig(genericConnectionString),
+                });
+                queryFn = async (queryString, values = []) => {
+                    try {
+                        const client = await pool.connect();
+                        try {
+                            const result = await client.query(queryString, values);
+                            return {
+                                rows: result.rows,
+                                rowCount: result.rowCount || 0,
+                            };
+                        }
+                        finally {
+                            client.release();
+                        }
+                    }
+                    catch (error) {
+                        defaultLogger.error('PostgreSQL query error:', error);
+                        throw error;
+                    }
+                };
+                break;
+            }
+        }
+    };
+    let initialized = false;
+    return {
+        async init() {
+            // Initialize connection for PGlite
+            if (!initialized) {
+                await initializeConnection();
+                initialized = true;
+            }
+        },
+        async connect() {
+            if (!initialized) {
+                await initializeConnection();
+                initialized = true;
+            }
+            // Wait for all pending table creation promises to complete
+            const pendingCreations = getWorkerPendingTableCreations();
+            if (pendingCreations.length > 0) {
+                try {
+                    await Promise.all(pendingCreations);
+                    // Clear promises after successful execution
+                    pendingCreations.length = 0;
+                }
+                catch (error) {
+                    defaultLogger.error('Failed to create tables:', error);
+                    throw error;
+                }
+            }
+            // Test connection
+            try {
+                await queryFn('SELECT 1', []);
+            }
+            catch (error) {
+                defaultLogger.error(`Failed to connect to ${provider} database:`, error);
+                throw error;
+            }
+        },
+        async disconnect() {
+            // Connection pooling is handled by the provider libraries
+            // No explicit disconnect needed for most providers
+            if (provider === 'supabase' || provider === 'generic') {
+                // pg Pool cleanup would go here if needed
+                // Most providers handle connection cleanup automatically
+            }
+            await Promise.resolve();
+        },
+        async query(queryString, values = []) {
+            if (!initialized) {
+                await initializeConnection();
+                initialized = true;
+            }
+            // Wait for any pending table creations before executing queries
+            const pendingCreations = getWorkerPendingTableCreations();
+            if (pendingCreations.length > 0) {
+                logger.debug('[PGlite] Query intercepted: waiting for pending table creations', {
+                    pendingCount: pendingCreations.length,
+                });
+                try {
+                    await Promise.all(pendingCreations);
+                    logger.debug('[PGlite] All table creations completed', {
+                        count: pendingCreations.length,
+                    });
+                    // Clear promises after successful execution
+                    pendingCreations.length = 0;
+                }
+                catch (error) {
+                    logger.error('[PGlite] Table creation failed', error instanceof Error ? error : new Error(String(error)));
+                    defaultLogger.error('Failed to create tables before query:', error);
+                    throw error;
+                }
+            }
+            return queryFn(queryString, values);
+        },
+        // Create table schema for PGlite provider
+        // For other providers, tables should be created via migrations
+        createTable: config.provider === 'electric' ||
+            !(config.connectionString ||
+                config.envVar ||
+                process.env.DATABASE_URL ||
+                process.env.POSTGRES_URL ||
+                process.env.SUPABASE_DATABASE_URI)
+            ? (tableName, fields) => {
+                const createdTables = getWorkerCreatedTables();
+                // Skip if table was already created in this worker
+                if (createdTables.has(tableName)) {
+                    return;
+                }
+                // Mark as created to prevent duplicates in this worker
+                createdTables.add(tableName);
+                // Build CREATE TABLE SQL statement
+                const columns = [
+                    'id TEXT PRIMARY KEY', // TEXT to support both string IDs (rvl_*) and integer IDs
+                    'created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+                    'updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+                    '_status TEXT', // Draft/published status
+                    '_json JSONB', // Store complex field types (arrays, relationships with hasMany, etc.)
+                ];
+                // Add fields from collection definition
+                // Skip reserved columns (id, created_at, updated_at) as they're already added
+                const reservedColumns = ['id', 'created_at', 'updated_at', 'createdAt', 'updatedAt'];
+                for (const field of fields) {
+                    if ('name' in field && field.name && !reservedColumns.includes(field.name)) {
+                        let columnType = 'TEXT';
+                        // Map field types to PostgreSQL types
+                        if ('type' in field) {
+                            switch (field.type) {
+                                case 'number':
+                                    columnType = 'NUMERIC';
+                                    break;
+                                case 'checkbox':
+                                    columnType = 'BOOLEAN';
+                                    break;
+                                case 'date':
+                                    columnType = 'TIMESTAMP';
+                                    break;
+                                case 'json':
+                                case 'richText':
+                                case 'array':
+                                case 'blocks':
+                                    columnType = 'JSONB';
+                                    break;
+                                case 'relationship':
+                                    columnType = 'INTEGER'; // Foreign key
+                                    break;
+                                default:
+                                    columnType = 'TEXT';
+                            }
+                        }
+                        const required = 'required' in field && field.required ? 'NOT NULL' : '';
+                        columns.push(`"${field.name}" ${columnType} ${required}`.trim());
+                    }
+                }
+                const createTableSQL = `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.join(', ')})`;
+                // Debug: log SQL
+                logger.debug('[PGlite] CREATE TABLE SQL', { tableName, sql: createTableSQL });
+                // Execute CREATE TABLE and store promise for awaiting before queries
+                // Don't catch errors here - let them propagate when the promise is awaited
+                const workerCreatedTables = getWorkerCreatedTables();
+                const createPromise = (async () => {
+                    logger.debug('[PGlite] Worker executing CREATE TABLE', {
+                        workerId: getWorkerID(),
+                        tableName,
+                    });
+                    try {
+                        const result = await queryFn(createTableSQL, []);
+                        logger.debug('[PGlite] Worker successfully created table', {
+                            workerId: getWorkerID(),
+                            tableName,
+                            result,
+                        });
+                    }
+                    catch (error) {
+                        // Remove from created set on failure so it can be retried
+                        workerCreatedTables.delete(tableName);
+                        logger.error('[PGlite] Worker FAILED to create table', error instanceof Error ? error : new Error(String(error)), { workerId: getWorkerID(), tableName });
+                        defaultLogger.error(`Failed to create table ${tableName}:`, error);
+                        defaultLogger.error('SQL:', createTableSQL);
+                        throw error;
+                    }
+                })();
+                const pendingCreations = getWorkerPendingTableCreations();
+                logger.debug('[PGlite] Worker added promise to pending queue', {
+                    workerId: getWorkerID(),
+                    tableName,
+                    totalPending: pendingCreations.length + 1,
+                });
+                pendingCreations.push(createPromise);
+            }
+            : undefined,
+        // Create global table schema for PGlite provider
+        createGlobalTable: config.provider === 'electric' ||
+            !(config.connectionString ||
+                config.envVar ||
+                process.env.DATABASE_URL ||
+                process.env.POSTGRES_URL ||
+                process.env.SUPABASE_DATABASE_URI)
+            ? (globalSlug, fields) => {
+                const tableName = `global_${globalSlug}`;
+                const createdTables = getWorkerCreatedTables();
+                // Skip if table was already created in this worker
+                if (createdTables.has(tableName)) {
+                    return;
+                }
+                // Mark as created to prevent duplicates in this worker
+                createdTables.add(tableName);
+                // Build CREATE TABLE SQL statement for global
+                const columns = [
+                    'id TEXT PRIMARY KEY', // TEXT to support both string IDs (rvl_*) and integer IDs
+                    'created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+                    'updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+                    '_status TEXT', // Draft/published status
+                    '_json JSONB', // Store complex field types (arrays, relationships with hasMany, etc.)
+                ];
+                // Add fields from global definition
+                // Skip reserved columns (id, created_at, updated_at) as they're already added
+                const reservedColumns = ['id', 'created_at', 'updated_at', 'createdAt', 'updatedAt'];
+                for (const field of fields) {
+                    if ('name' in field && field.name && !reservedColumns.includes(field.name)) {
+                        let columnType = 'TEXT';
+                        // Map field types to PostgreSQL types
+                        if ('type' in field) {
+                            switch (field.type) {
+                                case 'number':
+                                    columnType = 'NUMERIC';
+                                    break;
+                                case 'checkbox':
+                                    columnType = 'BOOLEAN';
+                                    break;
+                                case 'date':
+                                    columnType = 'TIMESTAMP';
+                                    break;
+                                case 'json':
+                                case 'richText':
+                                case 'array':
+                                case 'blocks':
+                                    columnType = 'JSONB';
+                                    break;
+                                default:
+                                    columnType = 'TEXT';
+                            }
+                        }
+                        const required = 'required' in field && field.required ? 'NOT NULL' : '';
+                        columns.push(`"${field.name}" ${columnType} ${required}`.trim());
+                    }
+                }
+                const createTableSQL = `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.join(', ')})`;
+                // Execute CREATE TABLE and store promise for awaiting before queries
+                // Don't catch errors here - let them propagate when the promise is awaited
+                const workerCreatedTables = getWorkerCreatedTables();
+                const createPromise = (async () => {
+                    try {
+                        await queryFn(createTableSQL, []);
+                    }
+                    catch (error) {
+                        // Remove from created set on failure so it can be retried
+                        workerCreatedTables.delete(tableName);
+                        defaultLogger.error(`Failed to create global table ${tableName}:`, error);
+                        defaultLogger.error('SQL:', createTableSQL);
+                        throw error;
+                    }
+                })();
+                const pendingCreations = getWorkerPendingTableCreations();
+                pendingCreations.push(createPromise);
+            }
+            : undefined,
+    };
+}
+/**
+ * Clear all worker-specific PGlite instances and state (useful for test cleanup)
+ * Only affects electric provider
+ * Can optionally clear just the current worker or all workers
+ */
+export function clearGlobalPGlite(clearAllWorkers = false) {
+    if (clearAllWorkers) {
+        // Clear all workers (for global cleanup)
+        workerPGliteInstances.clear();
+        workerPendingTableCreations.clear();
+        workerCreatedTables.clear();
+    }
+    else {
+        // Clear only current worker (for test isolation)
+        const workerID = getWorkerID();
+        workerPGliteInstances.delete(workerID);
+        workerPendingTableCreations.delete(workerID);
+        workerCreatedTables.delete(workerID);
+    }
+}
+// Export as default for convenience
+export default universalPostgresAdapter;

package/dist/dataloader.d.ts

@@ -0,0 +1,26 @@
+import DataLoader from 'dataloader';
+import type { RevealPaginatedResult, TypedFallbackLocale } from './index.js';
+import type { PopulateType, RevealFindOptions, RevealRequest, SelectType, TypeWithID } from './types/index.js';
+interface ExtendedDataLoader extends DataLoader<string, TypeWithID> {
+    find: (args: RevealFindOptions & {
+        collection: string;
+    }) => Promise<RevealPaginatedResult>;
+}
+export declare const getDataLoader: (req: RevealRequest) => ExtendedDataLoader;
+type CreateCacheKeyArgs = {
+    collectionSlug: string;
+    currentDepth: number;
+    depth: number;
+    docID: number | string;
+    draft: boolean;
+    fallbackLocale: TypedFallbackLocale;
+    locale: string | string[];
+    overrideAccess: boolean;
+    populate?: PopulateType;
+    select?: SelectType;
+    showHiddenFields: boolean;
+    transactionID: number | Promise<number | string> | string | undefined;
+};
+export declare const createDataloaderCacheKey: ({ collectionSlug, currentDepth, depth, docID, draft, fallbackLocale, locale, overrideAccess, populate, select, showHiddenFields, transactionID, }: CreateCacheKeyArgs) => string;
+export {};
+//# sourceMappingURL=dataloader.d.ts.map

package/dist/dataloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataloader.d.ts","sourceRoot":"","sources":["../src/dataloader.ts"],"names":[],"mappings":"AAEA,OAAO,UAAU,MAAM,YAAY,CAAA;AAEnC,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,UAAU,EACX,MAAM,kBAAkB,CAAA;AA8LzB,UAAU,kBAAmB,SAAQ,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC;IACjE,IAAI,EAAE,CAAC,IAAI,EAAE,iBAAiB,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;CAC3F;AAED,eAAO,MAAM,aAAa,GAAI,KAAK,aAAa,KAAG,kBAmBlD,CAAA;AA6CD,KAAK,kBAAkB,GAAG;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,mBAAmB,CAAA;IACnC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzB,cAAc,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS,CAAA;CACtE,CAAA;AACD,eAAO,MAAM,wBAAwB,GAAI,mJAatC,kBAAkB,KAAG,MAcpB,CAAA"}