@flightdev/db 0.0.2

package/dist/postgres.d.ts

@@ -0,0 +1,38 @@
+import { DatabaseConfig, Driver as DatabaseDriver } from './index.js';
+
+/**
+ * @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',
+ * }));
+ * ```
+ */
+
+interface PostgresConfig extends DatabaseConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean | object;
+}
+/**
+ * Create a PostgreSQL driver
+ */
+declare function postgres(config: PostgresConfig): DatabaseDriver;
+
+export { type PostgresConfig, postgres as default, postgres };

package/dist/postgres.js

@@ -0,0 +1,99 @@
+// src/postgres.ts
+function postgres(config) {
+  let pool = null;
+  async function getPool() {
+    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 ?? 3e4
+      });
+    }
+    return pool;
+  }
+  return {
+    name: "postgres",
+    async query(sql, params) {
+      const p = await getPool();
+      const result = await p.query(sql, params);
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount ?? 0,
+        raw: result
+      };
+    },
+    async execute(sql, params) {
+      const p = await getPool();
+      const result = await p.query(sql, params);
+      return {
+        rowsAffected: result.rowCount ?? 0,
+        raw: result
+      };
+    },
+    async transaction(fn) {
+      const p = await getPool();
+      const client = await p.connect();
+      try {
+        await client.query("BEGIN");
+        const tx = {
+          async query(sql, params) {
+            const result2 = await client.query(sql, params);
+            return {
+              rows: result2.rows,
+              rowCount: result2.rowCount ?? 0,
+              raw: result2
+            };
+          },
+          async execute(sql, params) {
+            const result2 = await client.query(sql, params);
+            return {
+              rowsAffected: result2.rowCount ?? 0,
+              raw: result2
+            };
+          },
+          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() {
+      if (pool) {
+        await pool.end();
+        pool = null;
+      }
+    },
+    async ping() {
+      try {
+        const p = await getPool();
+        await p.query("SELECT 1");
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var postgres_default = postgres;
+export {
+  postgres_default as default,
+  postgres
+};

package/dist/supabase.d.ts

@@ -0,0 +1,42 @@
+import { Driver as DatabaseDriver } from './index.js';
+
+/**
+ * @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('*');
+ * ```
+ */
+
+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
+ */
+declare function supabase(config: SupabaseConfig): DatabaseDriver & {
+    /** Access Supabase client directly for advanced features */
+    readonly client: any;
+    /** Query builder (Supabase style) */
+    from: (table: string) => any;
+};
+
+export { type SupabaseConfig, supabase as default, supabase };

package/dist/supabase.js

@@ -0,0 +1,76 @@
+// src/supabase.ts
+function supabase(config) {
+  let client = 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) {
+      const c = await getClient();
+      return c.from(table);
+    },
+    async query(sql, params) {
+      const c = await getClient();
+      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 ?? [],
+        rowCount: data?.length ?? 0,
+        raw: { data, error }
+      };
+    },
+    async execute(sql, params) {
+      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(_fn) {
+      throw new Error(
+        "Supabase does not support client-side transactions. Use RPC functions with SECURITY DEFINER for transactional operations."
+      );
+    },
+    async close() {
+      client = null;
+    },
+    async ping() {
+      try {
+        const c = await getClient();
+        const { error } = await c.from("_flight_ping").select("1").limit(1);
+        return !error || error.code === "PGRST116";
+      } catch {
+        return false;
+      }
+    }
+  };
+  return driver;
+}
+var supabase_default = supabase;
+export {
+  supabase_default as default,
+  supabase
+};

package/dist/turso.d.ts

@@ -0,0 +1,39 @@
+import { Driver as DatabaseDriver } from './index.js';
+
+/**
+ * @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',
+ * }));
+ * ```
+ */
+
+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
+ */
+declare function turso(config: TursoConfig): DatabaseDriver;
+
+export { type TursoConfig, turso as default, turso };

package/dist/turso.js

@@ -0,0 +1,102 @@
+// src/turso.ts
+function turso(config) {
+  let client = 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(sql, params) {
+      const c = await getClient();
+      const result = await c.execute({ sql, args: params ?? [] });
+      const rows = result.rows.map((row) => {
+        const obj = {};
+        for (const [key, value] of Object.entries(row)) {
+          obj[key] = value;
+        }
+        return obj;
+      });
+      return {
+        rows,
+        rowCount: result.rows.length,
+        raw: result
+      };
+    },
+    async execute(sql, params) {
+      const c = await getClient();
+      const result = await c.execute({ sql, args: params ?? [] });
+      return {
+        rowsAffected: result.rowsAffected,
+        insertId: result.lastInsertRowid ? Number(result.lastInsertRowid) : void 0,
+        raw: result
+      };
+    },
+    async transaction(fn) {
+      const c = await getClient();
+      const libsqlTx = await c.transaction("write");
+      try {
+        const tx = {
+          async query(sql, params) {
+            const result2 = await libsqlTx.execute({ sql, args: params ?? [] });
+            const rows = result2.rows.map((row) => {
+              const obj = {};
+              for (const [key, value] of Object.entries(row)) {
+                obj[key] = value;
+              }
+              return obj;
+            });
+            return { rows, rowCount: result2.rows.length, raw: result2 };
+          },
+          async execute(sql, params) {
+            const result2 = await libsqlTx.execute({ sql, args: params ?? [] });
+            return {
+              rowsAffected: result2.rowsAffected,
+              insertId: result2.lastInsertRowid ? Number(result2.lastInsertRowid) : void 0,
+              raw: result2
+            };
+          },
+          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() {
+      if (client) {
+        client.close();
+        client = null;
+      }
+    },
+    async ping() {
+      try {
+        const c = await getClient();
+        await c.execute("SELECT 1");
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var turso_default = turso;
+export {
+  turso_default as default,
+  turso
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@flightdev/db",
+  "version": "0.0.2",
+  "description": "Flight Database Abstraction Layer - Agnostic database adapters",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres.d.ts",
+      "import": "./dist/postgres.js"
+    },
+    "./supabase": {
+      "types": "./dist/supabase.d.ts",
+      "import": "./dist/supabase.js"
+    },
+    "./turso": {
+      "types": "./dist/turso.d.ts",
+      "import": "./dist/turso.js"
+    },
+    "./neon": {
+      "types": "./dist/neon.d.ts",
+      "import": "./dist/neon.js"
+    },
+    "./d1": {
+      "types": "./dist/d1.d.ts",
+      "import": "./dist/d1.js"
+    }
+  },
+  "keywords": [
+    "flight",
+    "database",
+    "postgres",
+    "supabase",
+    "turso",
+    "neon",
+    "d1",
+    "agnostic"
+  ],
+  "author": "Flight Contributors",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "@libsql/client": ">=0.5.0",
+    "@neondatabase/serverless": ">=0.9.0",
+    "@supabase/supabase-js": ">=2.0.0",
+    "pg": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@libsql/client": {
+      "optional": true
+    },
+    "@neondatabase/serverless": {
+      "optional": true
+    },
+    "@supabase/supabase-js": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/ambient.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Type declarations for peer dependencies
+ * Following 2025 best practices: specific types instead of any
+ */
+
+// ============================================================================
+// PostgreSQL (pg)
+// ============================================================================
+
+declare module 'pg' {
+    export interface PoolConfig {
+        connectionString?: string;
+        host?: string;
+        port?: number;
+        database?: string;
+        user?: string;
+        password?: string;
+        ssl?: boolean | object;
+        max?: number;
+        connectionTimeoutMillis?: number;
+    }
+
+    export interface QueryResult<T = unknown> {
+        rows: T[];
+        rowCount: number | null;
+        command?: string;
+        oid?: number;
+        fields?: unknown[];
+    }
+
+    export interface PoolClient {
+        query<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+        release(): void;
+    }
+
+    export class Pool {
+        constructor(config?: PoolConfig);
+        query<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+        connect(): Promise<PoolClient>;
+        end(): Promise<void>;
+    }
+
+    export default { Pool };
+}
+
+// ============================================================================
+// Supabase
+// ============================================================================
+
+declare module '@supabase/supabase-js' {
+    export interface SupabaseClientOptions {
+        db?: { schema?: string };
+    }
+
+    export interface PostgrestResponse<T> {
+        data: T | null;
+        error: { message: string; code?: string } | null;
+    }
+
+    export interface SupabaseClient {
+        from(table: string): {
+            select(columns?: string): { limit(n: number): Promise<PostgrestResponse<unknown[]>> };
+        };
+        rpc(fn: string, params?: unknown): Promise<PostgrestResponse<unknown>>;
+        auth: {
+            getUser(token: string): Promise<{
+                data: { user: SupabaseUser | null };
+                error: { message: string } | null;
+            }>;
+            exchangeCodeForSession(code: string): Promise<{
+                data: { session: { access_token: string; expires_in: number } };
+                error: { message: string } | null;
+            }>;
+        };
+    }
+
+    export interface SupabaseUser {
+        id: string;
+        email?: string;
+        user_metadata?: Record<string, unknown>;
+        app_metadata?: Record<string, unknown>;
+        email_confirmed_at?: string;
+    }
+
+    export function createClient(
+        url: string,
+        key: string,
+        options?: SupabaseClientOptions
+    ): SupabaseClient;
+}
+
+// ============================================================================
+// libSQL / Turso
+// ============================================================================
+
+declare module '@libsql/client' {
+    export interface LibsqlConfig {
+        url: string;
+        authToken?: string;
+        syncUrl?: string;
+    }
+
+    export interface LibsqlResult {
+        rows: Array<Record<string, unknown>>;
+        rowsAffected: number;
+        lastInsertRowid?: bigint;
+    }
+
+    export interface LibsqlTransaction {
+        execute(query: { sql: string; args: unknown[] }): Promise<LibsqlResult>;
+        commit(): Promise<void>;
+        rollback(): Promise<void>;
+    }
+
+    export interface LibsqlClient {
+        execute(query: { sql: string; args: unknown[] } | string): Promise<LibsqlResult>;
+        transaction(mode: 'write' | 'read'): Promise<LibsqlTransaction>;
+        close(): void;
+    }
+
+    export function createClient(config: LibsqlConfig): LibsqlClient;
+}
+
+// ============================================================================
+// Neon Serverless
+// ============================================================================
+
+declare module '@neondatabase/serverless' {
+    export interface NeonQueryResult<T = unknown> {
+        rows: T[];
+        rowCount: number | null;
+    }
+
+    export interface NeonPoolConfig {
+        connectionString: string;
+    }
+
+    export interface NeonPoolClient {
+        query<T = unknown>(sql: string, params?: unknown[]): Promise<NeonQueryResult<T>>;
+        release(): void;
+    }
+
+    export class Pool {
+        constructor(config: NeonPoolConfig);
+        query<T = unknown>(sql: string, params?: unknown[]): Promise<NeonQueryResult<T>>;
+        connect(): Promise<NeonPoolClient>;
+        end(): Promise<void>;
+    }
+
+    export function neon(connectionString: string): <T = unknown>(
+        sql: string,
+        params?: unknown[]
+    ) => Promise<T[]>;
+}