@flightdev/db 0.0.2

package/.turbo/turbo-build.log

@@ -0,0 +1,26 @@
+
+> @flightdev/db@0.0.2 build E:\testear framework\Flight\packages\db
+> tsup
+
+CLI Building entry: src/d1.ts, src/index.ts, src/neon.ts, src/postgres.ts, src/supabase.ts, src/turso.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: E:\testear framework\Flight\packages\db\tsup.config.ts
+CLI Target: node20
+CLI Cleaning output folder
+ESM Build start
+ESM dist\index.js    402.00 B
+ESM dist\postgres.js 2.39 KB
+ESM dist\neon.js     2.96 KB
+ESM dist\supabase.js 1.93 KB
+ESM dist\d1.js       2.51 KB
+ESM dist\turso.js    2.70 KB
+ESM ⚡️ Build success in 23ms
+DTS Build start
+DTS ⚡️ Build success in 6371ms
+DTS dist\d1.d.ts       1.53 KB
+DTS dist\neon.d.ts     857.00 B
+DTS dist\postgres.d.ts 907.00 B
+DTS dist\supabase.d.ts 1.16 KB
+DTS dist\turso.d.ts    916.00 B
+DTS dist\index.d.ts    2.92 KB

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @flight-framework/db@0.0.2 typecheck E:\testear framework\Flight\packages\db
+> tsc --noEmit
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @flight-framework/db
+
+## 0.0.2
+
+### Patch Changes
+
+- 379f5ee: Update

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Flight Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @flight-framework/db
+
+Database abstraction layer for Flight Framework. Connect to any database with a unified, type-safe API.
+
+## Installation
+
+```bash
+npm install @flight-framework/db
+```
+
+Install the driver for your database:
+
+```bash
+# PostgreSQL
+npm install pg
+
+# Turso / SQLite
+npm install @libsql/client
+
+# Neon Serverless
+npm install @neondatabase/serverless
+
+# Supabase
+npm install @supabase/supabase-js
+```
+
+## Quick Start
+
+```typescript
+import { createDb } from '@flight-framework/db';
+import { postgres } from '@flight-framework/db/postgres';
+
+const db = createDb(postgres({
+  connectionString: process.env.DATABASE_URL,
+}));
+
+// Query with type inference
+const users = await db.query<{ id: string; email: string }>(
+  'SELECT * FROM users WHERE active = $1',
+  [true]
+);
+
+console.log(users.rows);
+```
+
+## Drivers
+
+### PostgreSQL
+
+Standard PostgreSQL driver using `pg` with connection pooling.
+
+```typescript
+import { postgres } from '@flight-framework/db/postgres';
+
+const driver = postgres({
+  connectionString: 'postgresql://user:pass@localhost:5432/mydb',
+  // Or use individual options:
+  host: 'localhost',
+  port: 5432,
+  database: 'mydb',
+  user: 'user',
+  password: 'pass',
+  ssl: true,
+  poolSize: 10,
+  timeout: 30000,
+});
+```
+
+### Turso / SQLite
+
+Cloud SQLite with Turso or local SQLite files.
+
+```typescript
+import { turso } from '@flight-framework/db/turso';
+
+// Turso Cloud
+const cloud = turso({
+  url: 'libsql://your-db.turso.io',
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+
+// Local SQLite
+const local = turso({
+  url: 'file:local.db',
+});
+```
+
+### Neon Serverless
+
+Edge-compatible PostgreSQL for serverless environments.
+
+```typescript
+import { neon } from '@flight-framework/db/neon';
+
+// HTTP mode (recommended for serverless)
+const http = neon({
+  connectionString: process.env.NEON_DATABASE_URL,
+  mode: 'http',
+});
+
+// WebSocket mode (for transactions)
+const ws = neon({
+  connectionString: process.env.NEON_DATABASE_URL,
+  mode: 'websocket',
+});
+```
+
+### Supabase
+
+Direct database access with Supabase's query builder.
+
+```typescript
+import { supabase } from '@flight-framework/db/supabase';
+
+const driver = supabase({
+  url: process.env.SUPABASE_URL,
+  key: process.env.SUPABASE_ANON_KEY,
+  schema: 'public',
+});
+```
+
+### Cloudflare D1
+
+Native Cloudflare D1 support for edge SQLite.
+
+```typescript
+import { d1 } from '@flight-framework/db/d1';
+
+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);
+  }
+};
+```
+
+## API Reference
+
+### Database Interface
+
+```typescript
+interface Database {
+  // Run a query that returns rows
+  query<T>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+
+  // Execute a statement (INSERT, UPDATE, DELETE)
+  execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+
+  // Run operations in a transaction
+  transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
+
+  // Close the connection
+  close(): Promise<void>;
+
+  // Check connection health
+  ping(): Promise<boolean>;
+}
+```
+
+### Query Result
+
+```typescript
+interface QueryResult<T> {
+  rows: T[];
+  rowCount: number;
+  raw?: unknown;
+}
+```
+
+### Execute Result
+
+```typescript
+interface ExecuteResult {
+  rowsAffected: number;
+  insertId?: string | number;
+  raw?: unknown;
+}
+```
+
+## Transactions
+
+All drivers support transactions with automatic rollback on error.
+
+```typescript
+const result = await db.transaction(async (tx) => {
+  const user = await tx.execute(
+    'INSERT INTO users (email) VALUES ($1) RETURNING id',
+    ['user@example.com']
+  );
+
+  await tx.execute(
+    'INSERT INTO profiles (user_id, name) VALUES ($1, $2)',
+    [user.insertId, 'John Doe']
+  );
+
+  return user.insertId;
+});
+```
+
+## Type Safety
+
+Define your row types for compile-time safety.
+
+```typescript
+interface User {
+  id: string;
+  email: string;
+  name: string;
+  created_at: Date;
+}
+
+const users = await db.query<User>('SELECT * FROM users');
+// users.rows is typed as User[]
+```
+
+## Best Practices
+
+1. **Use connection pooling** - All drivers support connection pools by default.
+2. **Parameterize queries** - Always use parameterized queries to prevent SQL injection.
+3. **Handle errors** - Wrap database operations in try-catch blocks.
+4. **Close connections** - Call `db.close()` when shutting down your application.
+
+## License
+
+MIT

package/dist/d1.d.ts

@@ -0,0 +1,60 @@
+import { Driver as DatabaseDriver } from './index.js';
+
+/**
+ * @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);
+ *   }
+ * };
+ * ```
+ */
+
+/** D1 Database binding from Cloudflare Workers */
+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;
+}
+interface D1Config {
+    /** D1 database binding from env */
+    binding: D1Database;
+}
+/**
+ * Create a Cloudflare D1 driver
+ */
+declare function d1(config: D1Config): DatabaseDriver;
+
+export { type D1Config, type D1Database, d1, d1 as default };

package/dist/d1.js

@@ -0,0 +1,97 @@
+// src/d1.ts
+function d1(config) {
+  const db = config.binding;
+  return {
+    name: "d1",
+    async query(sql, params) {
+      let stmt = db.prepare(sql);
+      if (params?.length) {
+        stmt = stmt.bind(...params);
+      }
+      const result = await stmt.all();
+      return {
+        rows: result.results ?? [],
+        rowCount: result.results?.length ?? 0,
+        raw: result
+      };
+    },
+    async execute(sql, params) {
+      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(fn) {
+      const statements = [];
+      const results = [];
+      const tx = {
+        async query(sql, params) {
+          let stmt = db.prepare(sql);
+          if (params?.length) {
+            stmt = stmt.bind(...params);
+          }
+          statements.push(stmt);
+          const placeholder = { rows: [], rowCount: 0 };
+          results.push(placeholder);
+          return placeholder;
+        },
+        async execute(sql, params) {
+          let stmt = db.prepare(sql);
+          if (params?.length) {
+            stmt = stmt.bind(...params);
+          }
+          statements.push(stmt);
+          const placeholder = { rowsAffected: 0 };
+          results.push(placeholder);
+          return placeholder;
+        },
+        async commit() {
+          const batchResults = await db.batch(statements);
+          batchResults.forEach((result, i) => {
+            const placeholder = results[i];
+            if (placeholder && "rows" in placeholder) {
+              placeholder.rows = result.results ?? [];
+              placeholder.rowCount = result.results?.length ?? 0;
+            } else if (placeholder) {
+              placeholder.rowsAffected = result.meta.changes;
+              placeholder.insertId = result.meta.last_row_id;
+            }
+          });
+        },
+        async rollback() {
+          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() {
+    },
+    async ping() {
+      try {
+        await db.prepare("SELECT 1").first();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var d1_default = d1;
+export {
+  d1,
+  d1_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @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']);
+ * ```
+ */
+/** Result of a database query */
+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) */
+interface ExecuteResult {
+    rowsAffected: number;
+    insertId?: string | number;
+    raw?: unknown;
+}
+/** Transaction interface */
+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 */
+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 */
+interface Database extends DatabaseDriver {
+    /** The underlying driver */
+    readonly driver: DatabaseDriver;
+    /** Infer types from database (Better Auth style) */
+    readonly $Infer: {
+        Query: QueryResult;
+        Execute: ExecuteResult;
+    };
+}
+/**
+ * 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 }));
+ * ```
+ */
+declare function createDb(driver: DatabaseDriver): Database;
+/** Infer row type from a query */
+type InferRow<T extends QueryResult> = T['rows'][number];
+/** Database configuration base */
+interface DatabaseConfig {
+    /** Connection string */
+    connectionString?: string;
+    /** Pool size */
+    poolSize?: number;
+    /** Connection timeout in ms */
+    timeout?: number;
+}
+
+export { type Database, type DatabaseConfig, type DatabaseDriver, type DatabaseDriver as Driver, type ExecuteResult, type InferRow, type QueryResult, type Transaction, createDb };

package/dist/index.js

@@ -0,0 +1,19 @@
+// src/index.ts
+function createDb(driver) {
+  return {
+    name: driver.name,
+    driver,
+    query: (sql, params) => driver.query(sql, params),
+    execute: (sql, params) => driver.execute(sql, params),
+    transaction: (fn) => driver.transaction(fn),
+    close: () => driver.close(),
+    ping: () => driver.ping(),
+    $Infer: {
+      Query: {},
+      Execute: {}
+    }
+  };
+}
+export {
+  createDb
+};

package/dist/neon.d.ts

@@ -0,0 +1,32 @@
+import { Driver as DatabaseDriver } from './index.js';
+
+/**
+ * @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
+ * }));
+ * ```
+ */
+
+interface NeonConfig {
+    /** Neon connection string */
+    connectionString: string;
+    /** Connection mode */
+    mode?: 'http' | 'websocket';
+}
+/**
+ * Create a Neon Serverless driver
+ */
+declare function neon(config: NeonConfig): DatabaseDriver;
+
+export { type NeonConfig, neon as default, neon };

package/dist/neon.js

@@ -0,0 +1,117 @@
+// src/neon.ts
+function neon(config) {
+  const mode = config.mode ?? "http";
+  let sql = null;
+  let pool = null;
+  async function getSql() {
+    if (!sql) {
+      const neonModule = await import("@neondatabase/serverless");
+      if (mode === "http") {
+        sql = neonModule.neon(config.connectionString);
+      } else {
+        const { Pool } = neonModule;
+        pool = new Pool({ connectionString: config.connectionString });
+        sql = pool;
+      }
+    }
+    return { sql, pool };
+  }
+  return {
+    name: "neon",
+    async query(sqlQuery, params) {
+      const { sql: client } = await getSql();
+      if (mode === "http") {
+        const rows = await client(sqlQuery, params ?? []);
+        return {
+          rows,
+          rowCount: rows.length,
+          raw: rows
+        };
+      } else {
+        const result = await client.query(sqlQuery, params);
+        return {
+          rows: result.rows,
+          rowCount: result.rowCount ?? 0,
+          raw: result
+        };
+      }
+    },
+    async execute(sqlQuery, params) {
+      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(fn) {
+      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 = {
+          async query(sqlQuery, params) {
+            const result2 = await client.query(sqlQuery, params);
+            return {
+              rows: result2.rows,
+              rowCount: result2.rowCount ?? 0,
+              raw: result2
+            };
+          },
+          async execute(sqlQuery, params) {
+            const result2 = await client.query(sqlQuery, 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;
+      }
+      sql = null;
+    },
+    async ping() {
+      try {
+        await this.query("SELECT 1");
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var neon_default = neon;
+export {
+  neon_default as default,
+  neon
+};