@flightdev/db 0.0.2

package/src/d1.ts

@@ -0,0 +1,177 @@
+/**
+ * @flightdev/db/d1 - Cloudflare D1 Driver
+ * 
+ * Native Cloudflare D1 support for edge SQLite.
+ * 
+ * @example
+ * ```typescript
+ * // In your Cloudflare Worker
+ * import { d1 } from '@flightdev/db/d1';
+ * import { createDb } from '@flightdev/db';
+ * 
+ * export default {
+ *   async fetch(request, env) {
+ *     const db = createDb(d1({ binding: env.DB }));
+ *     const users = await db.query('SELECT * FROM users');
+ *     return Response.json(users.rows);
+ *   }
+ * };
+ * ```
+ */
+
+import type { DatabaseDriver, QueryResult, ExecuteResult, Transaction } from './index.js';
+
+/** D1 Database binding from Cloudflare Workers */
+export interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+    batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+    exec(query: string): Promise<D1ExecResult>;
+}
+
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    first<T = unknown>(colName?: string): Promise<T>;
+    run(): Promise<D1Result>;
+    all<T = unknown>(): Promise<D1Result<T>>;
+    raw<T = unknown>(): Promise<T[]>;
+}
+
+interface D1Result<T = unknown> {
+    results?: T[];
+    success: boolean;
+    error?: string;
+    meta: {
+        changes: number;
+        last_row_id: number;
+        duration: number;
+    };
+}
+
+interface D1ExecResult {
+    count: number;
+    duration: number;
+}
+
+export interface D1Config {
+    /** D1 database binding from env */
+    binding: D1Database;
+}
+
+/**
+ * Create a Cloudflare D1 driver
+ */
+export function d1(config: D1Config): DatabaseDriver {
+    const db = config.binding;
+
+    return {
+        name: 'd1',
+
+        async query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>> {
+            let stmt = db.prepare(sql);
+            if (params?.length) {
+                stmt = stmt.bind(...params);
+            }
+
+            const result = await stmt.all<T>();
+
+            return {
+                rows: result.results ?? [],
+                rowCount: result.results?.length ?? 0,
+                raw: result,
+            };
+        },
+
+        async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+            let stmt = db.prepare(sql);
+            if (params?.length) {
+                stmt = stmt.bind(...params);
+            }
+
+            const result = await stmt.run();
+
+            return {
+                rowsAffected: result.meta.changes,
+                insertId: result.meta.last_row_id,
+                raw: result,
+            };
+        },
+
+        async transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T> {
+            // D1 supports batch operations which are atomic
+            const statements: D1PreparedStatement[] = [];
+            const results: Array<QueryResult | ExecuteResult> = [];
+
+            const tx: Transaction = {
+                async query<R = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<R>> {
+                    let stmt = db.prepare(sql);
+                    if (params?.length) {
+                        stmt = stmt.bind(...params);
+                    }
+                    statements.push(stmt);
+                    // Return placeholder - actual results come from batch
+                    const placeholder: QueryResult<R> = { rows: [], rowCount: 0 };
+                    results.push(placeholder as QueryResult);
+                    return placeholder;
+                },
+
+                async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+                    let stmt = db.prepare(sql);
+                    if (params?.length) {
+                        stmt = stmt.bind(...params);
+                    }
+                    statements.push(stmt);
+                    const placeholder: ExecuteResult = { rowsAffected: 0 };
+                    results.push(placeholder);
+                    return placeholder;
+                },
+
+                async commit() {
+                    // D1 batch is atomic
+                    const batchResults = await db.batch(statements);
+
+                    // Update placeholders with real results
+                    batchResults.forEach((result, i) => {
+                        const placeholder = results[i];
+                        if (placeholder && 'rows' in placeholder) {
+                            (placeholder as QueryResult).rows = (result.results ?? []) as Record<string, unknown>[];
+                            (placeholder as QueryResult).rowCount = result.results?.length ?? 0;
+                        } else if (placeholder) {
+                            (placeholder as ExecuteResult).rowsAffected = result.meta.changes;
+                            (placeholder as ExecuteResult).insertId = result.meta.last_row_id;
+                        }
+                    });
+                },
+
+                async rollback() {
+                    // D1 batch is all-or-nothing, so just clear statements
+                    statements.length = 0;
+                    results.length = 0;
+                },
+            };
+
+            try {
+                const result = await fn(tx);
+                await tx.commit();
+                return result;
+            } catch (error) {
+                await tx.rollback();
+                throw error;
+            }
+        },
+
+        async close(): Promise<void> {
+            // D1 bindings don't need closing
+        },
+
+        async ping(): Promise<boolean> {
+            try {
+                await db.prepare('SELECT 1').first();
+                return true;
+            } catch {
+                return false;
+            }
+        },
+    };
+}
+
+export default d1;

package/src/index.ts

@@ -0,0 +1,140 @@
+/**
+ * @flightdev/db - Agnostic Database Layer
+ * 
+ * Universal database abstraction with pluggable drivers.
+ * Inspired by Drizzle ORM's driver pattern but framework-agnostic.
+ * 
+ * @example
+ * ```typescript
+ * import { createDb } from '@flightdev/db';
+ * import { postgres } from '@flightdev/db/postgres';
+ * 
+ * const db = createDb(postgres({ connectionString: process.env.DATABASE_URL }));
+ * 
+ * const users = await db.query('SELECT * FROM users');
+ * await db.execute('INSERT INTO users (name) VALUES (?)', ['John']);
+ * ```
+ */
+
+// ============================================================================
+// Core Types
+// ============================================================================
+
+/** Result of a database query */
+export interface QueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    rowCount: number;
+    /** Raw result from underlying driver (for advanced use) */
+    raw?: unknown;
+}
+
+/** Result of a database execute (INSERT, UPDATE, DELETE) */
+export interface ExecuteResult {
+    rowsAffected: number;
+    insertId?: string | number;
+    raw?: unknown;
+}
+
+/** Transaction interface */
+export interface Transaction {
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+
+/** Database connection interface - what drivers must implement */
+export interface DatabaseDriver {
+    /** Driver name for identification */
+    readonly name: string;
+
+    /** Query that returns rows */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+
+    /** Execute that doesn't return rows (INSERT, UPDATE, DELETE) */
+    execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+
+    /** Begin a transaction */
+    transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
+
+    /** Close the connection */
+    close(): Promise<void>;
+
+    /** Check if connection is alive */
+    ping(): Promise<boolean>;
+}
+
+/** Database instance with full API */
+export interface Database extends DatabaseDriver {
+    /** The underlying driver */
+    readonly driver: DatabaseDriver;
+
+    /** Infer types from database (Better Auth style) */
+    readonly $Infer: {
+        Query: QueryResult;
+        Execute: ExecuteResult;
+    };
+}
+
+// ============================================================================
+// Database Factory
+// ============================================================================
+
+/**
+ * Create a database instance from a driver
+ * 
+ * @example
+ * ```typescript
+ * import { createDb } from '@flightdev/db';
+ * import { postgres } from '@flightdev/db/postgres';
+ * 
+ * const db = createDb(postgres({ connectionString: process.env.DATABASE_URL }));
+ * ```
+ */
+export function createDb(driver: DatabaseDriver): Database {
+    return {
+        name: driver.name,
+        driver,
+
+        query: <T = Record<string, unknown>>(sql: string, params?: unknown[]) =>
+            driver.query<T>(sql, params),
+
+        execute: (sql: string, params?: unknown[]) =>
+            driver.execute(sql, params),
+
+        transaction: <T>(fn: (tx: Transaction) => Promise<T>) =>
+            driver.transaction(fn),
+
+        close: () => driver.close(),
+
+        ping: () => driver.ping(),
+
+        $Infer: {
+            Query: {} as QueryResult,
+            Execute: {} as ExecuteResult,
+        },
+    };
+}
+
+// ============================================================================
+// Helper Types (for type inference)
+// ============================================================================
+
+/** Infer row type from a query */
+export type InferRow<T extends QueryResult> = T['rows'][number];
+
+/** Database configuration base */
+export interface DatabaseConfig {
+    /** Connection string */
+    connectionString?: string;
+    /** Pool size */
+    poolSize?: number;
+    /** Connection timeout in ms */
+    timeout?: number;
+}
+
+// ============================================================================
+// Re-exports for convenience
+// ============================================================================
+
+export type { DatabaseDriver as Driver };

package/src/neon.ts

@@ -0,0 +1,164 @@
+/**
+ * @flightdev/db/neon - Neon Serverless Driver
+ * 
+ * Uses @neondatabase/serverless for edge-compatible PostgreSQL.
+ * Supports both HTTP (single queries) and WebSocket (transactions) modes.
+ * 
+ * @example
+ * ```typescript
+ * import { neon } from '@flightdev/db/neon';
+ * import { createDb } from '@flightdev/db';
+ * 
+ * const db = createDb(neon({
+ *   connectionString: process.env.NEON_DATABASE_URL,
+ *   mode: 'http', // 'http' for serverless, 'websocket' for transactions
+ * }));
+ * ```
+ */
+
+import type { DatabaseDriver, QueryResult, ExecuteResult, Transaction } from './index.js';
+
+export interface NeonConfig {
+    /** Neon connection string */
+    connectionString: string;
+    /** Connection mode */
+    mode?: 'http' | 'websocket';
+}
+
+/**
+ * Create a Neon Serverless driver
+ */
+export function neon(config: NeonConfig): DatabaseDriver {
+    const mode = config.mode ?? 'http';
+    let sql: any = null;
+    let pool: any = null;
+
+    async function getSql() {
+        if (!sql) {
+            const neonModule = await import('@neondatabase/serverless');
+
+            if (mode === 'http') {
+                // HTTP mode - stateless, perfect for edge
+                sql = neonModule.neon(config.connectionString);
+            } else {
+                // WebSocket mode - for transactions
+                const { Pool } = neonModule;
+                pool = new Pool({ connectionString: config.connectionString });
+                sql = pool;
+            }
+        }
+        return { sql, pool };
+    }
+
+    return {
+        name: 'neon',
+
+        async query<T = Record<string, unknown>>(sqlQuery: string, params?: unknown[]): Promise<QueryResult<T>> {
+            const { sql: client } = await getSql();
+
+            if (mode === 'http') {
+                // HTTP mode returns array directly
+                const rows = await client(sqlQuery, params ?? []);
+                return {
+                    rows: rows as T[],
+                    rowCount: rows.length,
+                    raw: rows,
+                };
+            } else {
+                // WebSocket mode uses pg-like API
+                const result = await client.query(sqlQuery, params);
+                return {
+                    rows: result.rows as T[],
+                    rowCount: result.rowCount ?? 0,
+                    raw: result,
+                };
+            }
+        },
+
+        async execute(sqlQuery: string, params?: unknown[]): Promise<ExecuteResult> {
+            const { sql: client } = await getSql();
+
+            if (mode === 'http') {
+                const result = await client(sqlQuery, params ?? []);
+                return {
+                    rowsAffected: result.length ?? 0,
+                    raw: result,
+                };
+            } else {
+                const result = await client.query(sqlQuery, params);
+                return {
+                    rowsAffected: result.rowCount ?? 0,
+                    raw: result,
+                };
+            }
+        },
+
+        async transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T> {
+            if (mode === 'http') {
+                throw new Error('Transactions require websocket mode. Use neon({ mode: "websocket" })');
+            }
+
+            const { pool: p } = await getSql();
+            const client = await p.connect();
+
+            try {
+                await client.query('BEGIN');
+
+                const tx: Transaction = {
+                    async query<R = Record<string, unknown>>(sqlQuery: string, params?: unknown[]): Promise<QueryResult<R>> {
+                        const result = await client.query(sqlQuery, params);
+                        return {
+                            rows: result.rows as R[],
+                            rowCount: result.rowCount ?? 0,
+                            raw: result,
+                        };
+                    },
+
+                    async execute(sqlQuery: string, params?: unknown[]): Promise<ExecuteResult> {
+                        const result = await client.query(sqlQuery, params);
+                        return {
+                            rowsAffected: result.rowCount ?? 0,
+                            raw: result,
+                        };
+                    },
+
+                    async commit() {
+                        await client.query('COMMIT');
+                    },
+
+                    async rollback() {
+                        await client.query('ROLLBACK');
+                    },
+                };
+
+                const result = await fn(tx);
+                await client.query('COMMIT');
+                return result;
+            } catch (error) {
+                await client.query('ROLLBACK');
+                throw error;
+            } finally {
+                client.release();
+            }
+        },
+
+        async close(): Promise<void> {
+            if (pool) {
+                await pool.end();
+                pool = null;
+            }
+            sql = null;
+        },
+
+        async ping(): Promise<boolean> {
+            try {
+                await this.query('SELECT 1');
+                return true;
+            } catch {
+                return false;
+            }
+        },
+    };
+}
+
+export default neon;

package/src/postgres.ts

@@ -0,0 +1,145 @@
+/**
+ * @flightdev/db/postgres - PostgreSQL Driver
+ * 
+ * Uses 'pg' (node-postgres) for maximum compatibility.
+ * 
+ * @example
+ * ```typescript
+ * import { postgres } from '@flightdev/db/postgres';
+ * import { createDb } from '@flightdev/db';
+ * 
+ * const db = createDb(postgres({
+ *   connectionString: process.env.DATABASE_URL,
+ *   // OR individual options:
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'user',
+ *   password: 'pass',
+ * }));
+ * ```
+ */
+
+import type { DatabaseDriver, QueryResult, ExecuteResult, Transaction, DatabaseConfig } from './index.js';
+
+export interface PostgresConfig extends DatabaseConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean | object;
+}
+
+/**
+ * Create a PostgreSQL driver
+ */
+export function postgres(config: PostgresConfig): DatabaseDriver {
+    // Import Pool type from pg module (declared in ambient.d.ts)
+    let pool: import('pg').Pool | null = null;
+
+    async function getPool(): Promise<import('pg').Pool> {
+        if (!pool) {
+            const { Pool } = await import('pg');
+            pool = new Pool({
+                connectionString: config.connectionString,
+                host: config.host,
+                port: config.port,
+                database: config.database,
+                user: config.user,
+                password: config.password,
+                ssl: config.ssl,
+                max: config.poolSize ?? 10,
+                connectionTimeoutMillis: config.timeout ?? 30000,
+            });
+        }
+        return pool;
+    }
+
+    return {
+        name: 'postgres',
+
+        async query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>> {
+            const p = await getPool();
+            const result = await p.query(sql, params);
+            return {
+                rows: result.rows as T[],
+                rowCount: result.rowCount ?? 0,
+                raw: result,
+            };
+        },
+
+        async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+            const p = await getPool();
+            const result = await p.query(sql, params);
+            return {
+                rowsAffected: result.rowCount ?? 0,
+                raw: result,
+            };
+        },
+
+        async transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T> {
+            const p = await getPool();
+            const client = await p.connect();
+
+            try {
+                await client.query('BEGIN');
+
+                const tx: Transaction = {
+                    async query<R = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<R>> {
+                        const result = await client.query(sql, params);
+                        return {
+                            rows: result.rows as R[],
+                            rowCount: result.rowCount ?? 0,
+                            raw: result,
+                        };
+                    },
+
+                    async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+                        const result = await client.query(sql, params);
+                        return {
+                            rowsAffected: result.rowCount ?? 0,
+                            raw: result,
+                        };
+                    },
+
+                    async commit() {
+                        await client.query('COMMIT');
+                    },
+
+                    async rollback() {
+                        await client.query('ROLLBACK');
+                    },
+                };
+
+                const result = await fn(tx);
+                await client.query('COMMIT');
+                return result;
+            } catch (error) {
+                await client.query('ROLLBACK');
+                throw error;
+            } finally {
+                client.release();
+            }
+        },
+
+        async close(): Promise<void> {
+            if (pool) {
+                await pool.end();
+                pool = null;
+            }
+        },
+
+        async ping(): Promise<boolean> {
+            try {
+                const p = await getPool();
+                await p.query('SELECT 1');
+                return true;
+            } catch {
+                return false;
+            }
+        },
+    };
+}
+
+export default postgres;