chore: wip

Author: chrisbbreuer

packages/bun-query-builder/package.json

@@ -21,10 +21,12 @@
   ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },

packages/bun-query-builder/src/client.ts

@@ -4,7 +4,9 @@
 import type { SchemaMeta } from './meta'
 import type { DatabaseSchema } from './schema'
 import { config } from './config'
-import { bunSql, getOrCreateBunSql } from './db'
+import { bunSql, getOrCreateBunSql, resetConnection } from './db'
+
+export { resetConnection }
 
 // Type guard for raw SQL expressions
 interface RawExpression {

packages/bun-query-builder/src/config.ts

@@ -59,9 +59,48 @@ export const defaultConfig: QueryBuilderConfig = {
   },
 }
 
-// eslint-disable-next-line antfu/no-top-level-await
-export const config: QueryBuilderConfig = await loadConfig({
-  name: 'query-builder',
-  alias: 'qb',
-  defaultConfig,
-})
+// Lazy-loaded config to avoid top-level await (enables bun --compile)
+let _config: QueryBuilderConfig | null = null
+
+export async function getConfig(): Promise<QueryBuilderConfig> {
+  if (!_config) {
+    _config = await loadConfig({
+      name: 'query-builder',
+      alias: 'qb',
+      defaultConfig,
+    })
+  }
+  return _config
+}
+
+// For backwards compatibility - synchronous access with default fallback
+export const config: QueryBuilderConfig = defaultConfig
+
+/**
+ * Programmatically set/override the query builder configuration.
+ * This is useful when you want to configure bun-query-builder from
+ * your application code rather than using a config file.
+ */
+export function setConfig(userConfig: Partial<QueryBuilderConfig>): void {
+  // Merge user config with existing config
+  Object.assign(config, userConfig)
+
+  // Handle nested objects like database, timestamps, etc.
+  if (userConfig.database) {
+    config.database = { ...config.database, ...userConfig.database }
+  }
+  if (userConfig.timestamps) {
+    config.timestamps = { ...config.timestamps, ...userConfig.timestamps }
+  }
+  if (userConfig.pagination) {
+    config.pagination = { ...config.pagination, ...userConfig.pagination }
+  }
+  if (userConfig.softDeletes) {
+    config.softDeletes = { ...config.softDeletes, ...userConfig.softDeletes }
+  }
+
+  // Also update the cached config if it exists
+  if (_config) {
+    Object.assign(_config, config)
+  }
+}

packages/bun-query-builder/src/db.ts

@@ -78,22 +78,41 @@ export function getBunSql(): SQL {
   }
 }
 
-// Note: This is created once when the module loads
-// Using a fallback in-memory SQLite if main database is unavailable
+// Note: Connection is created lazily on first access, not at module load time
 let _bunSqlInstance: SQL | null = null
+let _currentDialect: string | null = null
+let _currentDatabase: string | null = null
 
 export function getOrCreateBunSql(forceNew = false): SQL {
-  // If forceNew is true or we don't have an instance, create a new one
-  if (forceNew || !_bunSqlInstance) {
+  // Check if config has changed since we created the connection
+  const configChanged = _bunSqlInstance !== null && (
+    _currentDialect !== config.dialect
+    || _currentDatabase !== config.database.database
+  )
+
+  // If forceNew is true, config changed, or we don't have an instance, create a new one
+  if (forceNew || configChanged || !_bunSqlInstance) {
     _bunSqlInstance = getBunSql()
+    _currentDialect = config.dialect
+    _currentDatabase = config.database.database
   }
   return _bunSqlInstance
 }
 
+/**
+ * Resets the cached database connection.
+ * Call this after changing config via setConfig() to ensure the new config is used.
+ */
+export function resetConnection(): void {
+  _bunSqlInstance = null
+  _currentDialect = null
+  _currentDatabase = null
+}
+
 // Wrapper that catches "Connection closed" errors and retries with a fresh connection
 export async function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T> {
   try {
-    return await fn(_bunSqlInstance || getOrCreateBunSql())
+    return await fn(getOrCreateBunSql())
   }
   catch (error: any) {
     // If connection is closed, create a fresh connection and retry once
@@ -106,7 +125,33 @@ export async function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Prom
   }
 }
 
-export const bunSql = getOrCreateBunSql()
+/**
+ * Lazy SQL connection proxy - connection is only created when first accessed.
+ * This allows setConfig() to be called before any database connection is made.
+ */
+function createLazyBunSql(): SQL {
+  // Create a proxy that lazily initializes the connection on first use
+  return new Proxy({} as SQL, {
+    get(_target, prop) {
+      // Get or create the actual SQL instance
+      const sql = getOrCreateBunSql()
+      const value = (sql as any)[prop]
+      // If it's a function, bind it to the sql instance
+      if (typeof value === 'function') {
+        return value.bind(sql)
+      }
+      return value
+    },
+    apply(_target, _thisArg, args) {
+      // Handle tagged template literal calls: bunSql`SELECT ...`
+      const sql = getOrCreateBunSql()
+      return (sql as any)(...args)
+    },
+  })
+}
+
+// Export a lazy proxy - no connection is made until first use
+export const bunSql: SQL = createLazyBunSql()
 
 // Add global error handler for unhandled rejections from SQL connections
 if (typeof process !== 'undefined' && process.on) {
@@ -123,7 +168,6 @@ if (typeof process !== 'undefined' && process.on) {
           || reason.code === '3D000')
       ) {
         // Suppress these errors - they're expected when database isn't available
-
       }
     }
     Object.defineProperty(sqlConnectionErrorHandler, 'name', { value: 'sqlConnectionErrorHandler' })