@flightdev/db 0.0.2

package/src/supabase.ts

@@ -0,0 +1,136 @@
+/**
+ * @flightdev/db/supabase - Supabase Database Driver
+ * 
+ * Uses @supabase/supabase-js for Supabase PostgreSQL.
+ * Includes RLS (Row Level Security) support out of the box.
+ * 
+ * @example
+ * ```typescript
+ * import { supabase } from '@flightdev/db/supabase';
+ * import { createDb } from '@flightdev/db';
+ * 
+ * const db = createDb(supabase({
+ *   url: process.env.SUPABASE_URL,
+ *   key: process.env.SUPABASE_ANON_KEY, // or SERVICE_ROLE_KEY for admin
+ * }));
+ * 
+ * // Use Supabase's query builder
+ * const { data, error } = await db.from('users').select('*');
+ * ```
+ */
+
+import type { DatabaseDriver, QueryResult, ExecuteResult, Transaction } from './index.js';
+
+export interface SupabaseConfig {
+    /** Supabase project URL */
+    url: string;
+    /** Supabase API key (anon or service_role) */
+    key: string;
+    /** Optional schema (default: public) */
+    schema?: string;
+}
+
+/**
+ * Create a Supabase driver
+ */
+export function supabase(config: SupabaseConfig): DatabaseDriver & {
+    /** Access Supabase client directly for advanced features */
+    readonly client: any;
+    /** Query builder (Supabase style) */
+    from: (table: string) => any;
+} {
+    let client: any = null;
+
+    async function getClient() {
+        if (!client) {
+            const { createClient } = await import('@supabase/supabase-js');
+            client = createClient(config.url, config.key, {
+                db: { schema: config.schema ?? 'public' },
+            });
+        }
+        return client;
+    }
+
+    const driver = {
+        name: 'supabase',
+
+        get client() {
+            return client;
+        },
+
+        async from(table: string) {
+            const c = await getClient();
+            return c.from(table);
+        },
+
+        async query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>> {
+            const c = await getClient();
+
+            // Use Supabase's RPC for raw SQL
+            // Note: This requires creating an RPC function in Supabase
+            // For simpler cases, use the query builder via .from()
+            const { data, error } = await c.rpc('flight_raw_query', {
+                query_text: sql,
+                query_params: params ?? [],
+            });
+
+            if (error) {
+                throw new Error(`Supabase query error: ${error.message}`);
+            }
+
+            return {
+                rows: (data ?? []) as T[],
+                rowCount: data?.length ?? 0,
+                raw: { data, error },
+            };
+        },
+
+        async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+            const c = await getClient();
+
+            const { data, error } = await c.rpc('flight_raw_execute', {
+                query_text: sql,
+                query_params: params ?? [],
+            });
+
+            if (error) {
+                throw new Error(`Supabase execute error: ${error.message}`);
+            }
+
+            return {
+                rowsAffected: data?.affected_rows ?? 0,
+                insertId: data?.insert_id,
+                raw: { data, error },
+            };
+        },
+
+        async transaction<T>(_fn: (tx: Transaction) => Promise<T>): Promise<T> {
+            // Supabase doesn't support client-side transactions
+            // Use RPC functions with SECURITY DEFINER for transactional logic
+            throw new Error(
+                'Supabase does not support client-side transactions. ' +
+                'Use RPC functions with SECURITY DEFINER for transactional operations.'
+            );
+        },
+
+        async close(): Promise<void> {
+            // Supabase client doesn't need explicit closing
+            client = null;
+        },
+
+        async ping(): Promise<boolean> {
+            try {
+                const c = await getClient();
+                const { error } = await c.from('_flight_ping').select('1').limit(1);
+                // Table might not exist, but connection works if no network error
+                return !error || error.code === 'PGRST116'; // 42P01 = table not found
+            } catch {
+                return false;
+            }
+        },
+    };
+
+    return driver;
+}
+
+export default supabase;

package/src/turso.ts

@@ -0,0 +1,150 @@
+/**
+ * @flightdev/db/turso - Turso/SQLite Driver
+ * 
+ * Uses @libsql/client for Turso cloud and local SQLite.
+ * 
+ * @example
+ * ```typescript
+ * import { turso } from '@flightdev/db/turso';
+ * import { createDb } from '@flightdev/db';
+ * 
+ * // Turso Cloud
+ * const db = createDb(turso({
+ *   url: 'libsql://your-db.turso.io',
+ *   authToken: process.env.TURSO_AUTH_TOKEN,
+ * }));
+ * 
+ * // Local SQLite
+ * const localDb = createDb(turso({
+ *   url: 'file:local.db',
+ * }));
+ * ```
+ */
+
+import type { DatabaseDriver, QueryResult, ExecuteResult, Transaction } from './index.js';
+
+export interface TursoConfig {
+    /** Database URL (libsql://... or file:...) */
+    url: string;
+    /** Auth token for Turso cloud */
+    authToken?: string;
+    /** Sync URL for embedded replicas */
+    syncUrl?: string;
+}
+
+/**
+ * Create a Turso/SQLite driver
+ */
+export function turso(config: TursoConfig): DatabaseDriver {
+    let client: any = null;
+
+    async function getClient() {
+        if (!client) {
+            const { createClient } = await import('@libsql/client');
+            client = createClient({
+                url: config.url,
+                authToken: config.authToken,
+                syncUrl: config.syncUrl,
+            });
+        }
+        return client;
+    }
+
+    return {
+        name: 'turso',
+
+        async query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>> {
+            const c = await getClient();
+            const result = await c.execute({ sql, args: params ?? [] });
+
+            // Convert libsql rows to plain objects
+            const rows = result.rows.map((row: any) => {
+                const obj: Record<string, unknown> = {};
+                for (const [key, value] of Object.entries(row)) {
+                    obj[key] = value;
+                }
+                return obj;
+            }) as T[];
+
+            return {
+                rows,
+                rowCount: result.rows.length,
+                raw: result,
+            };
+        },
+
+        async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+            const c = await getClient();
+            const result = await c.execute({ sql, args: params ?? [] });
+            return {
+                rowsAffected: result.rowsAffected,
+                insertId: result.lastInsertRowid ? Number(result.lastInsertRowid) : undefined,
+                raw: result,
+            };
+        },
+
+        async transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T> {
+            const c = await getClient();
+            const libsqlTx = await c.transaction('write');
+
+            try {
+                const tx: Transaction = {
+                    async query<R = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<R>> {
+                        const result = await libsqlTx.execute({ sql, args: params ?? [] });
+                        const rows = result.rows.map((row: any) => {
+                            const obj: Record<string, unknown> = {};
+                            for (const [key, value] of Object.entries(row)) {
+                                obj[key] = value;
+                            }
+                            return obj;
+                        }) as R[];
+                        return { rows, rowCount: result.rows.length, raw: result };
+                    },
+
+                    async execute(sql: string, params?: unknown[]): Promise<ExecuteResult> {
+                        const result = await libsqlTx.execute({ sql, args: params ?? [] });
+                        return {
+                            rowsAffected: result.rowsAffected,
+                            insertId: result.lastInsertRowid ? Number(result.lastInsertRowid) : undefined,
+                            raw: result,
+                        };
+                    },
+
+                    async commit() {
+                        await libsqlTx.commit();
+                    },
+
+                    async rollback() {
+                        await libsqlTx.rollback();
+                    },
+                };
+
+                const result = await fn(tx);
+                await libsqlTx.commit();
+                return result;
+            } catch (error) {
+                await libsqlTx.rollback();
+                throw error;
+            }
+        },
+
+        async close(): Promise<void> {
+            if (client) {
+                client.close();
+                client = null;
+            }
+        },
+
+        async ping(): Promise<boolean> {
+            try {
+                const c = await getClient();
+                await c.execute('SELECT 1');
+                return true;
+            } catch {
+                return false;
+            }
+        },
+    };
+}
+
+export default turso;

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src",
+        "noEmit": false,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: [
+        'src/index.ts',
+        'src/postgres.ts',
+        'src/supabase.ts',
+        'src/turso.ts',
+        'src/neon.ts',
+        'src/d1.ts',
+    ],
+    format: ['esm'],
+    dts: {
+        compilerOptions: {
+            skipLibCheck: true,
+        },
+    },
+    clean: true,
+    target: 'node20',
+    external: [
+        'pg',
+        '@supabase/supabase-js',
+        '@libsql/client',
+        '@neondatabase/serverless',
+    ],
+});