@basicbenframework/core 0.1.5 → 0.1.7

package/README.md

@@ -27,7 +27,7 @@ Most JS frameworks make one of two mistakes: they do too much (Next.js, Remix) o
 
 ## Requirements
 
-- Node.js 24.14+
+- Node.js 25.8.1+
 - npm 9+
 
 ---

package/create-basicben-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basicbenframework/create",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Create a new BasicBen application",
   "type": "module",
   "bin": {
@@ -25,6 +25,6 @@
     "url": "https://github.com/BasicBenFramework/core"
   },
   "engines": {
-    "node": ">=24.14.0"
+    "node": ">=25.8.1"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basicbenframework/core",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A full-stack framework for React. Minimal dependencies, maximum clarity.",
   "author": "ctmakes",
   "repository": {
@@ -24,7 +24,7 @@
     "./db": "./src/db/index.js"
   },
   "engines": {
-    "node": ">=24.14.0"
+    "node": ">=25.8.1"
   },
   "scripts": {
     "test": "node --test src/**/*.test.js",
@@ -45,6 +45,9 @@
     "minimal"
   ],
   "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^12.6.2"
+  },
   "peerDependencies": {
     "@vitejs/plugin-react": ">=5",
     "react": ">=18",
@@ -52,10 +55,6 @@
     "vite": ">=7"
   },
   "optionalDependencies": {
-    "@libsql/client": ">=0.17",
-    "@neondatabase/serverless": ">=1.0",
-    "@planetscale/database": ">=1",
-    "better-sqlite3": "^12.6.2",
     "pg": ">=8"
   }
 }

package/src/db/adapters/sqlite.js

@@ -1,27 +1,10 @@
 /**
- * SQLite adapter using better-sqlite3.
+ * SQLite adapter using Node.js built-in node:sqlite.
  * Provides synchronous API wrapped for consistency with async Postgres adapter.
+ * Requires Node.js 25+ (release candidate).
  */
 
-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'
-    )
-  }
-}
+import { DatabaseSync } from 'node:sqlite'
 
 /**
  * Create SQLite adapter
@@ -30,19 +13,15 @@ async function loadDriver() {
  * @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')
+  const db = new DatabaseSync(dbPath, {
+    enableForeignKeyConstraints: true
+  })
 
   // Enable WAL mode for better concurrency
   if (options.wal !== false) {
-    db.pragma('journal_mode = WAL')
+    db.exec('PRAGMA journal_mode = WAL')
   }
 
   return {
@@ -91,8 +70,15 @@ export async function createSqliteAdapter(url, options = {}) {
      * Run function in transaction
      */
     transaction(fn) {
-      const transaction = db.transaction(fn)
-      return transaction()
+      db.exec('BEGIN TRANSACTION')
+      try {
+        const result = fn()
+        db.exec('COMMIT')
+        return result
+      } catch (error) {
+        db.exec('ROLLBACK')
+        throw error
+      }
     },
 
     /**
@@ -103,7 +89,7 @@ export async function createSqliteAdapter(url, options = {}) {
     },
 
     /**
-     * Get underlying better-sqlite3 instance
+     * Get underlying DatabaseSync instance
      */
     get raw() {
       return db

package/src/db/index.js

@@ -1,6 +1,6 @@
 /**
  * Database adapter loader.
- * Provides a unified interface for SQLite, Postgres, Turso, PlanetScale, and Neon.
+ * Provides a unified interface for SQLite and Postgres.
  */
 
 import { loadConfig } from '../server/loader.js'
@@ -34,8 +34,7 @@ export async function getDb() {
   const url = dbConfig.url || process.env.DATABASE_URL || './database.sqlite'
 
   switch (driver) {
-    case 'sqlite':
-    case 'better-sqlite3': {
+    case 'sqlite': {
       const { createSqliteAdapter } = await import('./adapters/sqlite.js')
       dbInstance = await createSqliteAdapter(url, dbConfig)
       break
@@ -48,30 +47,10 @@ export async function getDb() {
       break
     }
 
-    case 'turso':
-    case 'libsql': {
-      const { createTursoAdapter } = await import('./adapters/turso.js')
-      dbInstance = await createTursoAdapter(url, dbConfig)
-      break
-    }
-
-    case 'planetscale':
-    case 'mysql': {
-      const { createPlanetScaleAdapter } = await import('./adapters/planetscale.js')
-      dbInstance = await createPlanetScaleAdapter(url, dbConfig)
-      break
-    }
-
-    case 'neon': {
-      const { createNeonAdapter } = await import('./adapters/neon.js')
-      dbInstance = await createNeonAdapter(url, dbConfig)
-      break
-    }
-
     default:
       throw new Error(
         `Unknown database driver: ${driver}\n` +
-        'Supported drivers: sqlite, postgres, turso, planetscale, neon'
+        'Supported drivers: sqlite, postgres'
       )
   }
 

package/src/db/adapters/neon.js

@@ -1,170 +0,0 @@
-/**
- * Neon adapter using @neondatabase/serverless.
- * Provides serverless Postgres with WebSocket support.
- */
-
-let neon = null
-
-/**
- * Load @neondatabase/serverless dynamically
- */
-async function loadDriver() {
-  if (neon) return neon
-
-  try {
-    neon = await import('@neondatabase/serverless')
-    return neon
-  } catch {
-    throw new Error(
-      '@neondatabase/serverless is required for Neon support.\n' +
-      'Install it with: npm install @neondatabase/serverless'
-    )
-  }
-}
-
-/**
- * Create Neon adapter
- *
- * @param {string} url - Neon connection string (postgres://...)
- * @param {Object} options - Additional options
- */
-export async function createNeonAdapter(url, options = {}) {
-  const { neon: createNeon, neonConfig } = await loadDriver()
-
-  // Configure for serverless environment
-  if (options.fetchConnectionCache !== undefined) {
-    neonConfig.fetchConnectionCache = options.fetchConnectionCache
-  }
-
-  const sql = createNeon(url)
-
-  return {
-    /**
-     * Driver name for query builder
-     */
-    driver: 'neon',
-
-    /**
-     * Run INSERT/UPDATE/DELETE
-     */
-    async run(sqlStr, params = []) {
-      const normalizedParams = normalizeParams(params)
-      const result = await sql(sqlStr, normalizedParams)
-
-      // Try to get lastInsertRowid from RETURNING clause
-      let lastInsertRowid = null
-      if (result[0] && result[0].id !== undefined) {
-        lastInsertRowid = result[0].id
-      }
-
-      return {
-        lastInsertRowid,
-        changes: result.count || 0
-      }
-    },
-
-    /**
-     * Get single row
-     */
-    async get(sqlStr, params = []) {
-      const normalizedParams = normalizeParams(params)
-      const result = await sql(sqlStr, normalizedParams)
-      return result[0] || undefined
-    },
-
-    /**
-     * Get all rows
-     */
-    async all(sqlStr, params = []) {
-      const normalizedParams = normalizeParams(params)
-      return sql(sqlStr, normalizedParams)
-    },
-
-    /**
-     * Execute raw SQL
-     */
-    async exec(sqlStr) {
-      // Split by semicolon and execute each statement
-      const statements = sqlStr
-        .split(';')
-        .map(s => s.trim())
-        .filter(s => s.length > 0)
-
-      for (const statement of statements) {
-        await sql(statement)
-      }
-    },
-
-    /**
-     * Run function in transaction
-     */
-    async transaction(fn) {
-      const { Pool } = await loadDriver()
-      const pool = new Pool({ connectionString: url })
-      const client = await pool.connect()
-
-      try {
-        await client.query('BEGIN')
-
-        const txAdapter = {
-          async run(sqlStr, params = []) {
-            const result = await client.query(sqlStr, 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(sqlStr, params = []) {
-            const result = await client.query(sqlStr, normalizeParams(params))
-            return result.rows[0]
-          },
-          async all(sqlStr, params = []) {
-            const result = await client.query(sqlStr, normalizeParams(params))
-            return result.rows
-          },
-          async exec(sqlStr) {
-            await client.query(sqlStr)
-          }
-        }
-
-        const result = await fn(txAdapter)
-        await client.query('COMMIT')
-        return result
-      } catch (err) {
-        await client.query('ROLLBACK')
-        throw err
-      } finally {
-        client.release()
-        await pool.end()
-      }
-    },
-
-    /**
-     * Close connection (no-op for serverless)
-     */
-    async close() {
-      // Serverless connections are stateless
-    },
-
-    /**
-     * Get underlying sql function
-     */
-    get raw() {
-      return sql
-    }
-  }
-}
-
-/**
- * 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/planetscale.js

@@ -1,146 +0,0 @@
-/**
- * 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/turso.js

@@ -1,165 +0,0 @@
-/**
- * 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]
-}