@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/database/type-adapter.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Database Type Adapter
+ *
+ * Adapter between Database types (from @revealui/contracts) and RevealUI types.
+ * Ensures type safety across the database -> ORM -> Contracts -> RevealUI layers.
+ *
+ * @module revealui/core/database/type-adapter
+ */
+import type { Contract } from '@revealui/contracts/foundation';
+/**
+ * Convert database row to RevealUI document type
+ *
+ * @template TDoc - The RevealUI document type
+ * @template TDbRow - The database row type
+ * @param dbRow - The database row
+ * @returns RevealUI document
+ */
+export declare function dbRowToRevealUIDoc<TDoc, TDbRow>(dbRow: TDbRow): TDoc;
+/**
+ * Convert RevealUI document to database insert type
+ *
+ * @template TDoc - The RevealUI document type
+ * @template TInsert - The database insert type
+ * @param doc - The RevealUI document
+ * @returns Database insert type
+ */
+export declare function revealUIDocToDbInsert<TDoc, TInsert>(doc: TDoc): TInsert;
+/**
+ * Convert database row to contract-validated entity
+ *
+ * Uses the contract system to validate database data.
+ *
+ * @template TContract - The contract type
+ * @template TDbRow - The database row type
+ * @param contract - The contract to validate against
+ * @param dbRow - The database row
+ * @returns Contract-validated entity
+ */
+export declare function dbRowToContract<TContract, TDbRow>(contract: Contract<TContract>, dbRow: TDbRow): TContract;
+/**
+ * Type-safe table-to-contract mapping
+ *
+ * Maps database table names to their corresponding contracts for automatic validation.
+ */
+type DatabaseLike = {
+    public: {
+        Tables: Record<string, {
+            Row: unknown;
+            Insert: unknown;
+            Update: unknown;
+        }>;
+    };
+};
+export type TableContractMapping<T extends DatabaseLike> = {
+    [K in keyof T['public']['Tables']]?: T['public']['Tables'][K] extends {
+        Row: infer R;
+    } ? Contract<R> : never;
+};
+/**
+ * Create a type-safe adapter for a specific table
+ *
+ * @template T - The Database type
+ * @template N - The table name
+ * @param contract - Optional contract for validation
+ * @returns Adapter functions for the table
+ *
+ * @example
+ * ```typescript
+ * import type { Database } from '@revealui/contracts/generated'
+ * import { UserSchema } from '@revealui/contracts/entities'
+ *
+ * const userAdapter = createTableAdapter<Database, 'users'>(UserSchema)
+ *
+ * const dbUser = await db.query.users.findFirst()
+ * const validatedUser = userAdapter.toContract(dbUser)
+ * ```
+ */
+export declare function createTableAdapter<T extends DatabaseLike, N extends keyof T['public']['Tables']>(contract?: T['public']['Tables'][N] extends {
+    Row: infer R;
+} ? Contract<R> : never): {
+    /**
+     * Convert database row to contract-validated entity
+     *
+     * @note Type assertion is necessary here because TypeScript cannot narrow
+     * conditional types in runtime checks. The conditional type signature ensures
+     * that when `contract` is defined, it is always `Contract<RowType>`, but
+     * TypeScript's control flow analysis doesn't recognize this at runtime.
+     * The assertion is safe because the type system guarantees the contract type.
+     */
+    toContract(dbRow: T["public"]["Tables"][N] extends {
+        Row: infer R;
+    } ? R : never): T["public"]["Tables"][N] extends {
+        Row: infer R;
+    } ? R : never;
+    /**
+     * Convert contract-validated entity to database insert
+     */
+    toInsert(data: T["public"]["Tables"][N] extends {
+        Row: infer R;
+    } ? R : never): T["public"]["Tables"][N] extends {
+        Insert: infer I;
+    } ? I : never;
+    /**
+     * Convert contract-validated entity to database update
+     */
+    toUpdate(data: Partial<T["public"]["Tables"][N] extends {
+        Row: infer R;
+    } ? R : never>): T["public"]["Tables"][N] extends {
+        Update: infer U;
+    } ? U : never;
+};
+export {};
+//# sourceMappingURL=type-adapter.d.ts.map

package/dist/database/type-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-adapter.d.ts","sourceRoot":"","sources":["../../src/database/type-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAA;AAE9D;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAEvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAC/C,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC7B,KAAK,EAAE,MAAM,GACZ,SAAS,CAEX;AAED;;;;GAIG;AACH,KAAK,YAAY,GAAG;IAClB,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,GAAG,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,OAAO,CAAA;SAAE,CAAC,CAAA;KAC3E,CAAA;CACF,CAAA;AAED,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,YAAY,IAAI;KACxD,CAAC,IAAI,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;QAEpE,GAAG,EAAE,MAAM,CAAC,CAAA;KACb,GACG,QAAQ,CAAC,CAAC,CAAC,GACX,KAAK;CACV,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAC9F,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;IAE1C,GAAG,EAAE,MAAM,CAAC,CAAA;CACb,GACG,QAAQ,CAAC,CAAC,CAAC,GACX,KAAK;IAuBP;;;;;;;;OAQG;;aA1BE,MAAM,CAAC;;aAAP,MAAM,CAAC;;IAqCZ;;OAEG;;aAvCE,MAAM,CAAC;;gBAMJ,MAAM,CAAC;;IAsCf;;OAEG;mBACY,OAAO;aA/CjB,MAAM,CAAC;kBA+CmB;gBAnCvB,MAAM,CAAC;;EAuClB"}

package/dist/database/type-adapter.js

@@ -0,0 +1,97 @@
+/**
+ * Database Type Adapter
+ *
+ * Adapter between Database types (from @revealui/contracts) and RevealUI types.
+ * Ensures type safety across the database -> ORM -> Contracts -> RevealUI layers.
+ *
+ * @module revealui/core/database/type-adapter
+ */
+/**
+ * Convert database row to RevealUI document type
+ *
+ * @template TDoc - The RevealUI document type
+ * @template TDbRow - The database row type
+ * @param dbRow - The database row
+ * @returns RevealUI document
+ */
+export function dbRowToRevealUIDoc(dbRow) {
+    return dbRow;
+}
+/**
+ * Convert RevealUI document to database insert type
+ *
+ * @template TDoc - The RevealUI document type
+ * @template TInsert - The database insert type
+ * @param doc - The RevealUI document
+ * @returns Database insert type
+ */
+export function revealUIDocToDbInsert(doc) {
+    return doc;
+}
+/**
+ * Convert database row to contract-validated entity
+ *
+ * Uses the contract system to validate database data.
+ *
+ * @template TContract - The contract type
+ * @template TDbRow - The database row type
+ * @param contract - The contract to validate against
+ * @param dbRow - The database row
+ * @returns Contract-validated entity
+ */
+export function dbRowToContract(contract, dbRow) {
+    return contract.parse(dbRow);
+}
+/**
+ * Create a type-safe adapter for a specific table
+ *
+ * @template T - The Database type
+ * @template N - The table name
+ * @param contract - Optional contract for validation
+ * @returns Adapter functions for the table
+ *
+ * @example
+ * ```typescript
+ * import type { Database } from '@revealui/contracts/generated'
+ * import { UserSchema } from '@revealui/contracts/entities'
+ *
+ * const userAdapter = createTableAdapter<Database, 'users'>(UserSchema)
+ *
+ * const dbUser = await db.query.users.findFirst()
+ * const validatedUser = userAdapter.toContract(dbUser)
+ * ```
+ */
+export function createTableAdapter(contract) {
+    return {
+        /**
+         * Convert database row to contract-validated entity
+         *
+         * @note Type assertion is necessary here because TypeScript cannot narrow
+         * conditional types in runtime checks. The conditional type signature ensures
+         * that when `contract` is defined, it is always `Contract<RowType>`, but
+         * TypeScript's control flow analysis doesn't recognize this at runtime.
+         * The assertion is safe because the type system guarantees the contract type.
+         */
+        toContract(dbRow) {
+            if (contract) {
+                // TypeScript's conditional type ensures contract is Contract<RowType> when defined,
+                // but runtime narrowing doesn't preserve this. The assertion is type-safe.
+                const validated = contract.parse(dbRow);
+                return validated;
+            }
+            return dbRow;
+        },
+        /**
+         * Convert contract-validated entity to database insert
+         */
+        toInsert(data) {
+            return data;
+        },
+        /**
+         * Convert contract-validated entity to database update
+         */
+        toUpdate(data) {
+            return data;
+        },
+    };
+}

package/dist/database/universal-postgres.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 type { DatabaseAdapter } from '../types/index.js';
+export interface UniversalPostgresAdapterConfig {
+    /**
+     * Connection string for the database
+     * Examples:
+     * - Neon: postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require
+     * - Supabase: postgresql://postgres:pass@db.xxx.supabase.co:5432/postgres
+     * - Vercel: postgres://user:pass@host:5432/dbname
+     */
+    connectionString?: string;
+    /**
+     * Environment variable name for connection string
+     * Defaults to checking: DATABASE_URL, POSTGRES_URL, SUPABASE_DATABASE_URI
+     */
+    envVar?: string;
+    /**
+     * Force a specific provider (optional, auto-detected if not provided)
+     */
+    provider?: 'neon' | 'supabase' | 'electric';
+}
+/**
+ * Creates a universal PostgreSQL adapter that works with Neon, Supabase, and Electric Postgres
+ */
+export declare function universalPostgresAdapter(config?: UniversalPostgresAdapterConfig): DatabaseAdapter;
+/**
+ * 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 declare function clearGlobalPGlite(clearAllWorkers?: boolean): void;
+export default universalPostgresAdapter;
+//# sourceMappingURL=universal-postgres.d.ts.map

package/dist/database/universal-postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal-postgres.d.ts","sourceRoot":"","sources":["../../src/database/universal-postgres.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAkC,MAAM,mBAAmB,CAAA;AAGxF,MAAM,WAAW,8BAA8B;IAC7C;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAA;CAC5C;AAiGD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,8BAAmC,GAC1C,eAAe,CAucjB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,UAAQ,GAAG,IAAI,CAa/D;AAGD,eAAe,wBAAwB,CAAA"}