@basicbenframework/core 0.1.0

package/src/db/adapters/planetscale.js

@@ -0,0 +1,146 @@
+/**
+ * PlanetScale adapter using @planetscale/database.
+ * Provides serverless MySQL-compatible database.
+ */
+
+let planetscale = null
+
+/**
+ * Load @planetscale/database dynamically
+ */
+async function loadDriver() {
+  if (planetscale) return planetscale
+
+  try {
+    planetscale = await import('@planetscale/database')
+    return planetscale
+  } catch {
+    throw new Error(
+      '@planetscale/database is required for PlanetScale support.\n' +
+      'Install it with: npm install @planetscale/database'
+    )
+  }
+}
+
+/**
+ * Create PlanetScale adapter
+ *
+ * @param {string} url - PlanetScale connection string
+ * @param {Object} options - Additional options
+ */
+export async function createPlanetScaleAdapter(url, options = {}) {
+  const { connect } = await loadDriver()
+
+  // Parse connection string or use options
+  const config = url.startsWith('mysql://')
+    ? { url }
+    : {
+        host: options.host || process.env.PLANETSCALE_HOST,
+        username: options.username || process.env.PLANETSCALE_USERNAME,
+        password: options.password || process.env.PLANETSCALE_PASSWORD
+      }
+
+  const conn = connect(config)
+
+  return {
+    /**
+     * Driver name for query builder
+     */
+    driver: 'planetscale',
+
+    /**
+     * Run INSERT/UPDATE/DELETE
+     */
+    async run(sql, params = []) {
+      const result = await conn.execute(sql, normalizeParams(params))
+
+      return {
+        lastInsertRowid: result.insertId ? Number(result.insertId) : null,
+        changes: result.rowsAffected
+      }
+    },
+
+    /**
+     * Get single row
+     */
+    async get(sql, params = []) {
+      const result = await conn.execute(sql, normalizeParams(params))
+      return result.rows[0] || undefined
+    },
+
+    /**
+     * Get all rows
+     */
+    async all(sql, params = []) {
+      const result = await conn.execute(sql, normalizeParams(params))
+      return result.rows
+    },
+
+    /**
+     * Execute raw SQL
+     * Note: PlanetScale doesn't support multiple statements in one call
+     */
+    async exec(sql) {
+      // Split by semicolon and execute each statement
+      const statements = sql
+        .split(';')
+        .map(s => s.trim())
+        .filter(s => s.length > 0)
+
+      for (const statement of statements) {
+        await conn.execute(statement)
+      }
+    },
+
+    /**
+     * Run function in transaction
+     * Note: PlanetScale serverless doesn't support traditional transactions
+     * This provides a pseudo-transaction for API consistency
+     */
+    async transaction(fn) {
+      // PlanetScale serverless driver doesn't support transactions
+      // We execute sequentially and hope for the best
+      // For true ACID, use PlanetScale's Boost or a connection pooler
+      console.warn(
+        'Warning: PlanetScale serverless does not support transactions. ' +
+        'Operations will run sequentially without ACID guarantees.'
+      )
+
+      const txAdapter = {
+        run: this.run.bind(this),
+        get: this.get.bind(this),
+        all: this.all.bind(this),
+        exec: this.exec.bind(this)
+      }
+
+      return fn(txAdapter)
+    },
+
+    /**
+     * Close connection (no-op for serverless)
+     */
+    async close() {
+      // Serverless connections are stateless
+    },
+
+    /**
+     * Get underlying connection
+     */
+    get raw() {
+      return conn
+    }
+  }
+}
+
+/**
+ * Normalize params to array format
+ */
+function normalizeParams(params) {
+  if (Array.isArray(params)) {
+    return params
+  }
+  if (params === undefined || params === null) {
+    return []
+  }
+  return [params]
+}

package/src/db/adapters/postgres.js

@@ -0,0 +1,166 @@
+/**
+ * Postgres adapter using pg (node-postgres).
+ * Provides async interface matching the SQLite adapter.
+ */
+
+let pg = null
+
+/**
+ * Load pg dynamically
+ */
+async function loadDriver() {
+  if (pg) return pg
+
+  try {
+    pg = await import('pg')
+    return pg
+  } catch {
+    throw new Error(
+      'pg is required for Postgres support.\n' +
+      'Install it with: npm install pg'
+    )
+  }
+}
+
+/**
+ * Create Postgres adapter
+ *
+ * @param {string} url - Postgres connection string
+ * @param {Object} options - Additional options
+ */
+export async function createPostgresAdapter(url, options = {}) {
+  const { Pool } = await loadDriver()
+
+  const pool = new Pool({
+    connectionString: url,
+    max: options.poolSize || 10,
+    idleTimeoutMillis: options.idleTimeout || 30000,
+    connectionTimeoutMillis: options.connectionTimeout || 2000
+  })
+
+  // Test connection
+  try {
+    const client = await pool.connect()
+    client.release()
+  } catch (err) {
+    throw new Error(`Failed to connect to Postgres: ${err.message}`)
+  }
+
+  return {
+    /**
+     * Driver name for query builder
+     */
+    driver: 'postgres',
+
+    /**
+     * Run INSERT/UPDATE/DELETE
+     */
+    async run(sql, params = []) {
+      const result = await pool.query(sql, normalizeParams(params))
+
+      // Try to get lastInsertRowid from RETURNING clause
+      let lastInsertRowid = null
+      if (result.rows && result.rows[0] && result.rows[0].id !== undefined) {
+        lastInsertRowid = result.rows[0].id
+      }
+
+      return {
+        lastInsertRowid,
+        changes: result.rowCount
+      }
+    },
+
+    /**
+     * Get single row
+     */
+    async get(sql, params = []) {
+      const result = await pool.query(sql, normalizeParams(params))
+      return result.rows[0]
+    },
+
+    /**
+     * Get all rows
+     */
+    async all(sql, params = []) {
+      const result = await pool.query(sql, normalizeParams(params))
+      return result.rows
+    },
+
+    /**
+     * Execute raw SQL
+     */
+    async exec(sql) {
+      await pool.query(sql)
+    },
+
+    /**
+     * Run function in transaction
+     */
+    async transaction(fn) {
+      const client = await pool.connect()
+
+      try {
+        await client.query('BEGIN')
+
+        // Create a transaction-scoped adapter
+        const txAdapter = {
+          async run(sql, params = []) {
+            const result = await client.query(sql, normalizeParams(params))
+            let lastInsertRowid = null
+            if (result.rows && result.rows[0] && result.rows[0].id !== undefined) {
+              lastInsertRowid = result.rows[0].id
+            }
+            return { lastInsertRowid, changes: result.rowCount }
+          },
+          async get(sql, params = []) {
+            const result = await client.query(sql, normalizeParams(params))
+            return result.rows[0]
+          },
+          async all(sql, params = []) {
+            const result = await client.query(sql, normalizeParams(params))
+            return result.rows
+          },
+          async exec(sql) {
+            await client.query(sql)
+          }
+        }
+
+        const result = await fn(txAdapter)
+        await client.query('COMMIT')
+        return result
+      } catch (err) {
+        await client.query('ROLLBACK')
+        throw err
+      } finally {
+        client.release()
+      }
+    },
+
+    /**
+     * Close connection pool
+     */
+    async close() {
+      await pool.end()
+    },
+
+    /**
+     * Get underlying pool
+     */
+    get raw() {
+      return pool
+    }
+  }
+}
+
+/**
+ * Normalize params to array format
+ */
+function normalizeParams(params) {
+  if (Array.isArray(params)) {
+    return params
+  }
+  if (params === undefined || params === null) {
+    return []
+  }
+  return [params]
+}

package/src/db/adapters/sqlite.js

@@ -0,0 +1,125 @@
+/**
+ * SQLite adapter using better-sqlite3.
+ * Provides synchronous API wrapped for consistency with async Postgres adapter.
+ */
+
+let Database = null
+
+/**
+ * Load better-sqlite3 dynamically
+ */
+async function loadDriver() {
+  if (Database) return Database
+
+  try {
+    const module = await import('better-sqlite3')
+    Database = module.default
+    return Database
+  } catch {
+    throw new Error(
+      'better-sqlite3 is required for SQLite support.\n' +
+      'Install it with: npm install better-sqlite3'
+    )
+  }
+}
+
+/**
+ * Create SQLite adapter
+ *
+ * @param {string} url - Path to SQLite database file
+ * @param {Object} options - Additional options
+ */
+export async function createSqliteAdapter(url, options = {}) {
+  const SqliteDatabase = await loadDriver()
+
+  const dbPath = url.replace('sqlite://', '').replace('file://', '')
+  const db = new SqliteDatabase(dbPath, {
+    verbose: options.verbose ? console.log : undefined
+  })
+
+  // Enable foreign keys by default
+  db.pragma('foreign_keys = ON')
+
+  // Enable WAL mode for better concurrency
+  if (options.wal !== false) {
+    db.pragma('journal_mode = WAL')
+  }
+
+  return {
+    /**
+     * Driver name for query builder
+     */
+    driver: 'sqlite',
+
+    /**
+     * Run INSERT/UPDATE/DELETE
+     */
+    run(sql, params = []) {
+      const stmt = db.prepare(sql)
+      const result = stmt.run(...normalizeParams(params))
+
+      return {
+        lastInsertRowid: result.lastInsertRowid,
+        changes: result.changes
+      }
+    },
+
+    /**
+     * Get single row
+     */
+    get(sql, params = []) {
+      const stmt = db.prepare(sql)
+      return stmt.get(...normalizeParams(params))
+    },
+
+    /**
+     * Get all rows
+     */
+    all(sql, params = []) {
+      const stmt = db.prepare(sql)
+      return stmt.all(...normalizeParams(params))
+    },
+
+    /**
+     * Execute raw SQL (multiple statements)
+     */
+    exec(sql) {
+      db.exec(sql)
+    },
+
+    /**
+     * Run function in transaction
+     */
+    transaction(fn) {
+      const transaction = db.transaction(fn)
+      return transaction()
+    },
+
+    /**
+     * Close database connection
+     */
+    close() {
+      db.close()
+    },
+
+    /**
+     * Get underlying better-sqlite3 instance
+     */
+    get raw() {
+      return db
+    }
+  }
+}
+
+/**
+ * Normalize params to array format
+ */
+function normalizeParams(params) {
+  if (Array.isArray(params)) {
+    return params
+  }
+  if (params === undefined || params === null) {
+    return []
+  }
+  return [params]
+}

package/src/db/adapters/turso.js

@@ -0,0 +1,165 @@
+/**
+ * Turso adapter using @libsql/client.
+ * Provides edge-ready distributed SQLite.
+ */
+
+let libsql = null
+
+/**
+ * Load @libsql/client dynamically
+ */
+async function loadDriver() {
+  if (libsql) return libsql
+
+  try {
+    libsql = await import('@libsql/client')
+    return libsql
+  } catch {
+    throw new Error(
+      '@libsql/client is required for Turso support.\n' +
+      'Install it with: npm install @libsql/client'
+    )
+  }
+}
+
+/**
+ * Create Turso adapter
+ *
+ * @param {string} url - Turso database URL (libsql://...)
+ * @param {Object} options - Additional options
+ * @param {string} options.authToken - Turso auth token
+ */
+export async function createTursoAdapter(url, options = {}) {
+  const { createClient } = await loadDriver()
+
+  const client = createClient({
+    url,
+    authToken: options.authToken || process.env.TURSO_AUTH_TOKEN
+  })
+
+  return {
+    /**
+     * Driver name for query builder
+     */
+    driver: 'turso',
+
+    /**
+     * Run INSERT/UPDATE/DELETE
+     */
+    async run(sql, params = []) {
+      const result = await client.execute({
+        sql,
+        args: normalizeParams(params)
+      })
+
+      return {
+        lastInsertRowid: Number(result.lastInsertRowid) || null,
+        changes: result.rowsAffected
+      }
+    },
+
+    /**
+     * Get single row
+     */
+    async get(sql, params = []) {
+      const result = await client.execute({
+        sql,
+        args: normalizeParams(params)
+      })
+
+      return result.rows[0] || undefined
+    },
+
+    /**
+     * Get all rows
+     */
+    async all(sql, params = []) {
+      const result = await client.execute({
+        sql,
+        args: normalizeParams(params)
+      })
+
+      return result.rows
+    },
+
+    /**
+     * Execute raw SQL (multiple statements)
+     */
+    async exec(sql) {
+      await client.executeMultiple(sql)
+    },
+
+    /**
+     * Run function in transaction
+     */
+    async transaction(fn) {
+      const tx = await client.transaction('write')
+
+      try {
+        const txAdapter = {
+          async run(sql, params = []) {
+            const result = await tx.execute({
+              sql,
+              args: normalizeParams(params)
+            })
+            return {
+              lastInsertRowid: Number(result.lastInsertRowid) || null,
+              changes: result.rowsAffected
+            }
+          },
+          async get(sql, params = []) {
+            const result = await tx.execute({
+              sql,
+              args: normalizeParams(params)
+            })
+            return result.rows[0] || undefined
+          },
+          async all(sql, params = []) {
+            const result = await tx.execute({
+              sql,
+              args: normalizeParams(params)
+            })
+            return result.rows
+          },
+          async exec(sql) {
+            await tx.executeMultiple(sql)
+          }
+        }
+
+        const result = await fn(txAdapter)
+        await tx.commit()
+        return result
+      } catch (err) {
+        await tx.rollback()
+        throw err
+      }
+    },
+
+    /**
+     * Close client connection
+     */
+    async close() {
+      client.close()
+    },
+
+    /**
+     * Get underlying client
+     */
+    get raw() {
+      return client
+    }
+  }
+}
+
+/**
+ * Normalize params to array format
+ */
+function normalizeParams(params) {
+  if (Array.isArray(params)) {
+    return params
+  }
+  if (params === undefined || params === null) {
+    return []
+  }
+  return [params]
+}