@revealui/core 0.0.1-pre.4 → 0.2.1

package/dist/collections/operations/find.js

@@ -0,0 +1,124 @@
+/**
+ * Find Operation
+ *
+ * Finds multiple documents with pagination, filtering, sorting, and relationship population.
+ */
+import { afterRead } from '../../fields/hooks/afterRead/index.js';
+import { buildWhereClause } from '../../queries/queryBuilder.js';
+import { deserializeJsonFields } from '../../utils/json-parsing.js';
+export async function find(config, db, options) {
+    const { where, limit = 10, page = 1, sort, depth = 0, req, populate: populateOption } = options;
+    // Validate depth
+    if (depth < 0 || depth > 3) {
+        throw new Error(`Depth must be between 0 and 3, got ${depth}`);
+    }
+    // Build query based on database adapter
+    if (db?.query) {
+        const offset = (page - 1) * limit;
+        const tableName = config.slug;
+        // Build WHERE clause using query builder
+        const params = [];
+        const whereClause = buildWhereClause(where, params, {
+            parameterStyle: 'postgres',
+            includeWhereKeyword: false,
+            quoteFields: true,
+        });
+        // Build ORDER BY clause
+        let orderByClause = '';
+        if (sort) {
+            const sortConditions = [];
+            Object.entries(sort).forEach(([key, direction]) => {
+                sortConditions.push(`"${key}" ${direction === '-1' ? 'DESC' : 'ASC'}`);
+            });
+            orderByClause = sortConditions.length > 0 ? `ORDER BY ${sortConditions.join(', ')}` : '';
+        }
+        // Execute count query (PostgreSQL)
+        // whereClause should never start with "WHERE" when includeWhereKeyword: false
+        // Add validation to catch any bugs
+        if (whereClause?.trim().toUpperCase().startsWith('WHERE')) {
+            throw new Error(`WHERE clause unexpectedly starts with "WHERE" keyword. This indicates a bug in buildWhereClause. Clause: ${whereClause}`);
+        }
+        const countQuery = whereClause
+            ? `SELECT COUNT(*) as total FROM "${tableName}" WHERE ${whereClause}`
+            : `SELECT COUNT(*) as total FROM "${tableName}"`;
+        const countResult = await db.query(countQuery, params);
+        const totalDocs = Number(countResult.rows[0]?.total) || 0;
+        // Execute data query (PostgreSQL uses $1, $2 for parameters)
+        // whereClause should never start with "WHERE" when includeWhereKeyword: false
+        // Add validation to catch any bugs
+        if (whereClause?.trim().toUpperCase().startsWith('WHERE')) {
+            throw new Error(`WHERE clause unexpectedly starts with "WHERE" keyword. This indicates a bug in buildWhereClause. Clause: ${whereClause}`);
+        }
+        // Verify parameter count matches placeholder count
+        const wherePlaceholderCount = (whereClause.match(/\$\d+/g) || []).length;
+        const limitOffsetPlaceholders = 2; // LIMIT and OFFSET
+        const totalPlaceholderCount = wherePlaceholderCount + limitOffsetPlaceholders;
+        const totalParamCount = params.length + 2; // params from WHERE + limit + offset
+        if (totalPlaceholderCount !== totalParamCount) {
+            throw new Error(`Parameter count mismatch: Expected ${totalPlaceholderCount} placeholders (${wherePlaceholderCount} from WHERE + ${limitOffsetPlaceholders} for LIMIT/OFFSET), but got ${totalParamCount} parameters (${params.length} from WHERE + 2 for LIMIT/OFFSET). WHERE clause: ${whereClause}`);
+        }
+        const limitParam = params.length + 1;
+        const offsetParam = params.length + 2;
+        const dataQuery = `SELECT * FROM "${tableName}" ${whereClause ? `WHERE ${whereClause}` : ''} ${orderByClause} LIMIT $${limitParam} OFFSET $${offsetParam}`;
+        const docsResult = await db.query(dataQuery, [...params, limit, offset]);
+        let docs = docsResult.rows.map((row) => {
+            return deserializeJsonFields(row, tableName);
+        });
+        // Apply relationship population if depth > 0
+        if (req && depth > 0) {
+            // RevealCollectionConfig extends CollectionConfig, which matches SanitizedCollectionConfig structure
+            const sanitizedConfig = {
+                ...config,
+                fields: config.fields,
+                flattenedFields: config.fields,
+                endpoints: config.endpoints === false ? undefined : config.endpoints,
+            };
+            docs = await Promise.all(docs.map(async (doc) => {
+                return await afterRead({
+                    collection: sanitizedConfig,
+                    context: req.context || {},
+                    currentDepth: 1,
+                    depth,
+                    doc,
+                    draft: false,
+                    fallbackLocale: req.fallbackLocale || 'en',
+                    findMany: true,
+                    flattenLocales: true,
+                    global: null,
+                    locale: req.locale || 'en',
+                    overrideAccess: false,
+                    populate: populateOption,
+                    req,
+                    select: undefined,
+                    showHiddenFields: false,
+                });
+            }));
+        }
+        const totalPages = Math.ceil(totalDocs / limit);
+        return {
+            docs,
+            totalDocs,
+            limit,
+            totalPages,
+            page,
+            pagingCounter: offset + 1,
+            hasPrevPage: page > 1,
+            hasNextPage: page < totalPages,
+            prevPage: page > 1 ? page - 1 : null,
+            nextPage: page < totalPages ? page + 1 : null,
+        };
+    }
+    // Fallback for no database
+    return {
+        docs: [],
+        totalDocs: 0,
+        limit,
+        totalPages: 0,
+        page,
+        pagingCounter: 0,
+        hasPrevPage: false,
+        hasNextPage: false,
+        prevPage: null,
+        nextPage: null,
+    };
+}

package/dist/collections/operations/findById.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Find By ID Operation
+ *
+ * Finds a single document by ID with optional relationship population.
+ */
+import type { DatabaseResult, PopulateType, RevealCollectionConfig, RevealDocument, RevealRequest } from '../../types/index.js';
+export declare function findByID(config: RevealCollectionConfig, db: {
+    query: (query: string, values?: unknown[]) => Promise<DatabaseResult>;
+} | null, options: {
+    id: string | number;
+    depth?: number;
+    req?: RevealRequest;
+    populate?: PopulateType;
+}): Promise<RevealDocument | null>;
+//# sourceMappingURL=findById.d.ts.map

package/dist/collections/operations/findById.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findById.d.ts","sourceRoot":"","sources":["../../../src/collections/operations/findById.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,cAAc,EACd,aAAa,EAEd,MAAM,sBAAsB,CAAA;AAG7B,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,sBAAsB,EAC9B,EAAE,EAAE;IACF,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;CACtE,GAAG,IAAI,EACR,OAAO,EAAE;IACP,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,aAAa,CAAA;IACnB,QAAQ,CAAC,EAAE,YAAY,CAAA;CACxB,GACA,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA2DhC"}

package/dist/collections/operations/findById.js

@@ -0,0 +1,59 @@
+/**
+ * Find By ID Operation
+ *
+ * Finds a single document by ID with optional relationship population.
+ */
+import { afterRead } from '../../fields/hooks/afterRead/index.js';
+import { deserializeJsonFields } from '../../utils/json-parsing.js';
+export async function findByID(config, db, options) {
+    const { id, depth = 0, req, populate: populateOption } = options;
+    // Validate depth
+    if (depth < 0 || depth > 3) {
+        throw new Error(`Depth must be between 0 and 3, got ${depth}`);
+    }
+    if (db?.query) {
+        const tableName = config.slug;
+        // Ensure id is a string for consistent comparison
+        const idString = String(id);
+        const query = `SELECT * FROM "${tableName}" WHERE id = $1 LIMIT 1`;
+        const result = await db.query(query, [idString]);
+        const rawDoc = result.rows[0];
+        if (!rawDoc) {
+            // Don't throw here, just return null as expected
+            return null;
+        }
+        // Deserialize JSON strings back to objects/arrays for SQLite compatibility
+        const doc = deserializeJsonFields(rawDoc, `${tableName}.id=${id}`);
+        // Use afterRead hook system for relationship population
+        if (req && depth > 0) {
+            // Adapt collection config to sanitized format
+            // RevealCollectionConfig extends CollectionConfig, which matches SanitizedCollectionConfig structure
+            const sanitizedConfig = {
+                ...config,
+                fields: config.fields,
+                flattenedFields: config.fields,
+                endpoints: config.endpoints === false ? undefined : config.endpoints,
+            };
+            return await afterRead({
+                collection: sanitizedConfig,
+                context: req.context || {},
+                currentDepth: 1,
+                depth,
+                doc,
+                draft: false,
+                fallbackLocale: req.fallbackLocale || 'en',
+                findMany: false,
+                flattenLocales: true,
+                global: null,
+                locale: req.locale || 'en',
+                overrideAccess: false,
+                populate: populateOption,
+                req,
+                select: undefined,
+                showHiddenFields: false,
+            });
+        }
+        return doc;
+    }
+    return null;
+}

package/dist/collections/operations/update.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Update Operation
+ *
+ * Updates an existing document with validation, password hashing, and JSON field handling.
+ */
+import type { DatabaseResult, RevealCollectionConfig, RevealDocument, RevealUpdateOptions } from '../../types/index.js';
+export declare function update(config: RevealCollectionConfig, db: {
+    query: (query: string, values?: unknown[]) => Promise<DatabaseResult>;
+} | null, options: RevealUpdateOptions): Promise<RevealDocument>;
+//# sourceMappingURL=update.d.ts.map

package/dist/collections/operations/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/collections/operations/update.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,cAAc,EAEd,mBAAmB,EACpB,MAAM,sBAAsB,CAAA;AAM7B,wBAAsB,MAAM,CAC1B,MAAM,EAAE,sBAAsB,EAC9B,EAAE,EAAE;IACF,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;CACtE,GAAG,IAAI,EACR,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAgJzB"}

package/dist/collections/operations/update.js

@@ -0,0 +1,134 @@
+/**
+ * Update Operation
+ *
+ * Updates an existing document with validation, password hashing, and JSON field handling.
+ */
+import bcrypt from 'bcryptjs';
+import { defaultLogger } from '../../instance/logger.js';
+import { collectJsonFields, serializeValueForDatabase } from '../../utils/json-parsing.js';
+import { flattenFields, isJsonFieldType } from '../../utils/type-guards.js';
+import { runBeforeFieldHooks } from './fieldHooks.js';
+import { findByID } from './findById.js';
+export async function update(config, db, options) {
+    const { id, data } = options;
+    // Run beforeValidate field hooks before validation so they can transform values.
+    await runBeforeFieldHooks(config, data, 'update', 'beforeValidate');
+    // Validate email format if email field is being updated
+    if (config.fields) {
+        for (const field of config.fields) {
+            // Skip fields without a name (should not happen, but TypeScript requires this check)
+            if (!field.name) {
+                continue;
+            }
+            // Validate email format if field type is email OR field name is "email"
+            // This handles cases where field is named "email" but type might be "text"
+            const isEmailField = field.type === 'email' || field.name.toLowerCase() === 'email';
+            if (isEmailField &&
+                field.name in data &&
+                data[field.name] !== null &&
+                data[field.name] !== undefined) {
+                const emailValue = data[field.name];
+                if (typeof emailValue !== 'string') {
+                    throw new Error(`Field '${field.name}' must be a string`);
+                }
+                // Stricter email validation regex (RFC 5322 compliant subset)
+                // Allows: alphanumeric, dots, hyphens, plus signs, underscores before @
+                // Requires: valid domain with at least one dot (TLD required)
+                const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/;
+                if (!emailRegex.test(emailValue)) {
+                    throw new Error(`Field '${field.name}' must be a valid email address`);
+                }
+            }
+        }
+    }
+    // Run beforeChange field hooks after validation but before the DB write.
+    await runBeforeFieldHooks(config, data, 'update', 'beforeChange');
+    // Hash password if present and not already hashed (doesn't start with $2a$ or $2b$)
+    if (data.password && typeof data.password === 'string' && !data.password.startsWith('$2')) {
+        const saltRounds = 10;
+        data.password = await bcrypt.hash(data.password, saltRounds);
+    }
+    if (db?.query) {
+        const tableName = config.slug;
+        // Build UPDATE query (PostgreSQL uses $1, $2 style)
+        // Serialize complex values (objects, arrays) to JSON strings for SQLite
+        // Filter out fields that should be stored as JSON (not as columns)
+        const jsonFieldNames = new Set(flattenFields(config.fields || [])
+            .filter((field) => isJsonFieldType(field) && field.name)
+            .map((field) => field.name)
+            .filter((name) => typeof name === 'string'));
+        const keys = Object.keys(data).filter((k) => k !== 'id' && !jsonFieldNames.has(k));
+        const jsonKeys = Object.keys(data).filter((k) => k !== 'id' && jsonFieldNames.has(k));
+        // Collect JSON fields to update using collectJsonFields utility
+        const jsonUpdates = collectJsonFields(data, jsonFieldNames);
+        // Fetch existing _json to merge with updates (single query instead of two)
+        // Also verify document exists by checking if row exists
+        // If collection has JSON fields, we always fetch _json to preserve existing JSON when updating non-JSON fields
+        let existingJson = {};
+        if (jsonFieldNames.size > 0) {
+            // Fetch _json to preserve existing JSON fields (even when only updating non-JSON fields)
+            const rawQuery = `SELECT _json FROM "${tableName}" WHERE id = $1 LIMIT 1`;
+            const rawResult = await db.query(rawQuery, [String(id)]);
+            if (!rawResult.rows[0]) {
+                throw new Error(`Document with id ${id} not found`);
+            }
+            if (rawResult.rows[0]._json !== null && rawResult.rows[0]._json !== undefined) {
+                try {
+                    const rawJson = rawResult.rows[0]._json;
+                    if (typeof rawJson === 'string') {
+                        const parsed = JSON.parse(rawJson);
+                        existingJson =
+                            parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                                ? parsed
+                                : {};
+                    }
+                    else if (rawJson && typeof rawJson === 'object' && !Array.isArray(rawJson)) {
+                        existingJson = rawJson;
+                    }
+                }
+                catch (error) {
+                    // Log JSON parse error for debugging
+                    defaultLogger.warn(`[CollectionOperations] Failed to parse _json for ${tableName}.id=${id}:`, error);
+                    existingJson = {};
+                }
+            }
+        }
+        else if (keys.length > 0) {
+            // No JSON fields in collection - just verify document exists
+            const checkQuery = `SELECT id FROM "${tableName}" WHERE id = $1 LIMIT 1`;
+            const checkResult = await db.query(checkQuery, [String(id)]);
+            if (!checkResult.rows[0]) {
+                throw new Error(`Document with id ${id} not found`);
+            }
+        }
+        // Merge existing JSON with updates (only if we have JSON fields)
+        let mergedJson = {};
+        if (jsonFieldNames.size > 0) {
+            mergedJson = { ...existingJson, ...jsonUpdates };
+            // Only include _json in UPDATE if there are actual changes or existing JSON to preserve
+            if (jsonKeys.length > 0 || Object.keys(existingJson).length > 0) {
+                keys.push('_json');
+            }
+        }
+        const setClause = keys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
+        const values = keys.map((key) => {
+            if (key === '_json') {
+                // Serialize merged JSON fields object to JSON string
+                return serializeValueForDatabase(mergedJson);
+            }
+            // Serialize non-primitive values to JSON strings for SQLite compatibility
+            return serializeValueForDatabase(data[key]);
+        });
+        // Ensure id is a string for consistent comparison
+        const idString = String(id);
+        const query = `UPDATE "${tableName}" SET ${setClause} WHERE id = $${keys.length + 1}`;
+        await db.query(query, [...values, idString]);
+        // Return updated document (use idString for consistency)
+        const updatedDoc = await findByID(config, db, { id: idString });
+        if (!updatedDoc) {
+            throw new Error(`Document with id ${idString} not found after update`);
+        }
+        return updatedDoc;
+    }
+    return { ...data, id };
+}

package/dist/config/index.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from '../types/index.js';
+/**
+ * Build and validate a RevealUI configuration
+ *
+ * Generic type T allows accepting both base Config and extended types (like RevealConfig)
+ * while preserving the specific type through the return value.
+ */
+export declare function buildConfig<T extends Config>(config: T): T;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAG/C;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAyD1D"}

package/dist/config/index.js

@@ -0,0 +1,61 @@
+import { ConfigValidationError, validateConfigStructure } from '@revealui/contracts/cms';
+import { deepMerge } from './utils.js';
+/**
+ * Build and validate a RevealUI configuration
+ *
+ * Generic type T allows accepting both base Config and extended types (like RevealConfig)
+ * while preserving the specific type through the return value.
+ */
+export function buildConfig(config) {
+    // Validate the configuration structure using ConfigContract
+    // This provides runtime validation with detailed error messages
+    const validationResult = validateConfigStructure(config);
+    if (!validationResult.success) {
+        // Use ConfigValidationError for structured error reporting
+        throw new ConfigValidationError(validationResult.errors, 'config');
+    }
+    // Type narrowing: after validation, we know the structure is valid
+    // The validated config structure matches ConfigContractType
+    const validatedConfig = validationResult.data;
+    // Apply default values
+    // Use validatedConfig as base to ensure type safety
+    const defaultConfig = {
+        serverURL: process.env.REVEALUI_PUBLIC_SERVER_URL || '',
+        admin: {
+            importMap: {
+                autoGenerate: true,
+            },
+            ...validatedConfig.admin,
+        },
+        typescript: {
+            autoGenerate: true,
+            outputFile: 'src/types/revealui.ts',
+            ...validatedConfig.typescript,
+        },
+        localization: {
+            locales: ['en'],
+            defaultLocale: 'en',
+            fallback: true,
+            ...(typeof validatedConfig.localization === 'object' ? validatedConfig.localization : {}),
+        },
+        collections: validatedConfig.collections || [],
+        globals: validatedConfig.globals || [],
+        plugins: validatedConfig.plugins || [],
+    };
+    // Merge with user config (use original config to preserve function contracts)
+    const finalConfig = deepMerge(defaultConfig, config);
+    // Apply plugins
+    if (Array.isArray(finalConfig.plugins)) {
+        for (const plugin of finalConfig.plugins) {
+            if (typeof plugin === 'function') {
+                const pluginFn = plugin;
+                const result = pluginFn(finalConfig);
+                if (result && typeof result.then === 'function') {
+                    throw new Error('Async plugins are not supported in buildConfig.');
+                }
+                Object.assign(finalConfig, result);
+            }
+        }
+    }
+    return finalConfig;
+}

package/dist/config/runtime.d.ts

@@ -0,0 +1,22 @@
+import type { Config as ContractsConfig } from '@revealui/contracts/cms';
+import type { RevealConfig, RevealUIInstance } from '../types/index.js';
+/** Accepted config types for getRevealUI */
+type AcceptedConfig = RevealConfig | ContractsConfig | Record<string, unknown>;
+/**
+ * Creates or returns a cached RevealUI instance
+ *
+ * @param options.config - RevealUI configuration object. Accepts:
+ *   - `RevealConfig`: Framework configuration type (preferred for type safety)
+ *   - `Config` from @revealui/contracts/cms: CMS configuration from buildConfig()
+ *   - `Record<string, unknown>`: Loose typing for flexibility
+ *
+ * Note: Generated Config types have a different structure (collections as record vs array)
+ * but are runtime-compatible. The function accepts both for convenience.
+ *
+ * @returns A RevealUI instance that provides CMS functionality
+ */
+export declare function getRevealUI(options: {
+    config: AcceptedConfig;
+}): Promise<RevealUIInstance>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/config/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/config/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAEvE,4CAA4C;AAC5C,KAAK,cAAc,GAAG,YAAY,GAAG,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAK9E;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoBhG"}

package/dist/config/runtime.js

@@ -0,0 +1,32 @@
+let revealInstance = null;
+let configInstance = null;
+/**
+ * Creates or returns a cached RevealUI instance
+ *
+ * @param options.config - RevealUI configuration object. Accepts:
+ *   - `RevealConfig`: Framework configuration type (preferred for type safety)
+ *   - `Config` from @revealui/contracts/cms: CMS configuration from buildConfig()
+ *   - `Record<string, unknown>`: Loose typing for flexibility
+ *
+ * Note: Generated Config types have a different structure (collections as record vs array)
+ * but are runtime-compatible. The function accepts both for convenience.
+ *
+ * @returns A RevealUI instance that provides CMS functionality
+ */
+export async function getRevealUI(options) {
+    // In development, always create a new instance to support HMR
+    if (process.env.NODE_ENV === 'development') {
+        revealInstance = null;
+        configInstance = null;
+    }
+    if (revealInstance && configInstance === options.config) {
+        return revealInstance;
+    }
+    // Import the RevealUI implementation
+    const { createRevealUIInstance } = await import('../revealui.js');
+    // Type assertion is safe here: generated Config types are runtime-compatible with RevealConfig
+    // even though TypeScript sees them as structurally different types
+    revealInstance = await createRevealUIInstance(options.config);
+    configInstance = options.config;
+    return revealInstance;
+}

package/dist/config/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function deepMerge<T extends object>(target: Partial<T>, source: T): T;
+/**
+ * @deprecated This function is deprecated. Use ConfigContract validation instead.
+ * Validation is now handled by the contract system in @revealui/contracts/cms.
+ * This function is kept for backward compatibility but should not be used in new code.
+ */
+export declare function validateConfig(config: {
+    secret?: string;
+    collections?: unknown[];
+    globals?: unknown[];
+}): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/config/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/config/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAuB5E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,EAAE,CAAA;IACvB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;CACpB,GAAG,IAAI,CAQP"}

package/dist/config/utils.js

@@ -0,0 +1,34 @@
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const s = source[key];
+        const t = target[key];
+        if (Array.isArray(s)) {
+            result[key] = s;
+        }
+        else if (s !== null &&
+            typeof s === 'object' &&
+            t !== null &&
+            typeof t === 'object' &&
+            !Array.isArray(t)) {
+            result[key] = deepMerge(t, s);
+        }
+        else {
+            result[key] = s;
+        }
+    }
+    return result;
+}
+/**
+ * @deprecated This function is deprecated. Use ConfigContract validation instead.
+ * Validation is now handled by the contract system in @revealui/contracts/cms.
+ * This function is kept for backward compatibility but should not be used in new code.
+ */
+export function validateConfig(config) {
+    if (!config.secret) {
+        throw new Error('RevealUI config requires a secret');
+    }
+    if (!(config.collections || config.globals)) {
+        throw new Error('RevealUI config must have at least one collection or global');
+    }
+}

package/dist/database/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/database/index.ts"],"names":[],"mappings":""}

package/dist/database/index.js

@@ -0,0 +1,6 @@
+"use strict";
+// Re-export database adapters and types (PostgreSQL/PGlite only)
+// Temporarily commented out to get CMS running
+// export type { DatabaseResult } from '../types/index.js'
+// export type { UniversalPostgresAdapterConfig } from './universal-postgres.js'
+// export { universalPostgresAdapter } from './universal-postgres.js'

package/dist/database/safe-parse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Safe row parsing for database results.
+ *
+ * Database drivers return untyped rows — this module provides a type guard
+ * that filters out malformed rows (missing `id`) before they reach the application.
+ * All RevealUI tables have `id` as a non-nullable primary key, so filtering these
+ * out prevents crashes from unexpected driver behavior or schema migrations.
+ */
+import type { RevealDocument } from '../types/index.js';
+/**
+ * Validate that a raw database row is a valid RevealDocument.
+ *
+ * Checks only the structural requirement: the row must be a non-null object
+ * with an `id` field of type string or number. All other fields are passed
+ * through as-is (trusting the database schema).
+ *
+ * @param row - Raw value from database driver (unknown type)
+ * @returns The row typed as RevealDocument, or null if malformed
+ */
+export declare function safeParseRevealDocument(row: unknown): RevealDocument | null;
+/**
+ * Parse an array of raw database rows into RevealDocument[], filtering out
+ * any malformed rows and logging warnings for each one skipped.
+ */
+export declare function safeParseRevealDocuments(rows: unknown[]): RevealDocument[];
+//# sourceMappingURL=safe-parse.d.ts.map

package/dist/database/safe-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-parse.d.ts","sourceRoot":"","sources":["../../src/database/safe-parse.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAgB3E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,CAI1E"}

package/dist/database/safe-parse.js

@@ -0,0 +1,42 @@
+/**
+ * Safe row parsing for database results.
+ *
+ * Database drivers return untyped rows — this module provides a type guard
+ * that filters out malformed rows (missing `id`) before they reach the application.
+ * All RevealUI tables have `id` as a non-nullable primary key, so filtering these
+ * out prevents crashes from unexpected driver behavior or schema migrations.
+ */
+import { defaultLogger } from '../instance/logger.js';
+/**
+ * Validate that a raw database row is a valid RevealDocument.
+ *
+ * Checks only the structural requirement: the row must be a non-null object
+ * with an `id` field of type string or number. All other fields are passed
+ * through as-is (trusting the database schema).
+ *
+ * @param row - Raw value from database driver (unknown type)
+ * @returns The row typed as RevealDocument, or null if malformed
+ */
+export function safeParseRevealDocument(row) {
+    if (row === null || typeof row !== 'object') {
+        defaultLogger.warn('Database row is not an object — skipping', { row });
+        return null;
+    }
+    const r = row;
+    if (typeof r.id !== 'string' && typeof r.id !== 'number') {
+        defaultLogger.warn('Database row missing required id field — skipping', {
+            keys: Object.keys(r),
+        });
+        return null;
+    }
+    return r;
+}
+/**
+ * Parse an array of raw database rows into RevealDocument[], filtering out
+ * any malformed rows and logging warnings for each one skipped.
+ */
+export function safeParseRevealDocuments(rows) {
+    return rows
+        .map((row) => safeParseRevealDocument(row))
+        .filter((doc) => doc !== null);
+}

package/dist/database/ssl-config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SSL Configuration Utility
+ *
+ * Re-exports from @revealui/utils to maintain backward compatibility.
+ * The actual implementation has been moved to @revealui/utils to break circular dependencies.
+ */
+export type { SSLConfig } from '@revealui/utils/database';
+export { getSSLConfig, validateSSLConfig } from '@revealui/utils/database';
+//# sourceMappingURL=ssl-config.d.ts.map

package/dist/database/ssl-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssl-config.d.ts","sourceRoot":"","sources":["../../src/database/ssl-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/database/ssl-config.js

@@ -0,0 +1,7 @@
+/**
+ * SSL Configuration Utility
+ *
+ * Re-exports from @revealui/utils to maintain backward compatibility.
+ * The actual implementation has been moved to @revealui/utils to break circular dependencies.
+ */
+export { getSSLConfig, validateSSLConfig } from '@revealui/utils/database';