feat(db): use experimental node:sqlite if available

docs/nuxt.config.ts

@@ -32,6 +32,9 @@ export default defineNuxtConfig({
   },
 
   content: {
+    experimental: {
+      nativeSqlite: true,
+    },
     build: {
       markdown: {
         toc: {

playground/nuxt.config.ts

@@ -5,6 +5,9 @@ export default defineNuxtConfig({
     '@nuxthub/core',
   ],
   content: {
+    experimental: {
+      nativeSqlite: true,
+    },
     build: {
       markdown: {
         remarkPlugins: {

src/module.ts

@@ -81,6 +81,9 @@ export default defineNuxtModule<ModuleOptions>({
         json: true,
       },
     },
+    experimental: {
+      nativeSqlite: false,
+    },
   },
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url)
@@ -162,9 +165,10 @@ export default defineNuxtModule<ModuleOptions>({
       const preset = findPreset(nuxt)
       await preset.setupNitro(config, { manifest, resolver, moduleOptions: options })
 
+      const resolveOptions = { resolver, nativeSqlite: options.experimental?.nativeSqlite }
       config.alias ||= {}
-      config.alias['#content/adapter'] = resolveDatabaseAdapter(config.runtimeConfig!.content!.database?.type || options.database.type, resolver)
-      config.alias['#content/local-adapter'] = resolveDatabaseAdapter(options._localDatabase!.type || 'sqlite', resolver)
+      config.alias['#content/adapter'] = resolveDatabaseAdapter(config.runtimeConfig!.content!.database?.type || options.database.type, resolveOptions)
+      config.alias['#content/local-adapter'] = resolveDatabaseAdapter(options._localDatabase!.type || 'sqlite', resolveOptions)
 
       config.handlers ||= []
       config.handlers.push({
@@ -230,7 +234,7 @@ async function processCollectionItems(nuxt: Nuxt, collections: ResolvedCollectio
   const collectionDump: Record<string, string[]> = {}
   const collectionChecksum: Record<string, string> = {}
   const collectionChecksumStructure: Record<string, string> = {}
-  const db = await getLocalDatabase(options._localDatabase)
+  const db = await getLocalDatabase(options._localDatabase, { nativeSqlite: options.experimental?.nativeSqlite })
   const databaseContents = await db.fetchDevelopmentCache()
 
   const configHash = hash({

src/types/module.ts

@@ -179,6 +179,16 @@ export interface ModuleOptions {
       delimeter?: string
     }
   }
+
+  experimental?: {
+    /**
+     * Use Node.js native SQLite bindings instead of `better-sqlite3` if available
+     * Node.js SQLite introduced in v22.5.0
+     *
+     * @default false
+     */
+    nativeSqlite?: boolean
+  }
 }
 
 export interface RuntimeConfig {

src/utils/database.ts

@@ -8,22 +8,6 @@ import type { CacheEntry, D1DatabaseConfig, LocalDevelopmentDatabase, SqliteData
 import type { ModuleOptions } from '../types/module'
 import { logger } from './dev'
 
-function isSqlite3Available() {
-  if (!isWebContainer()) {
-    return false
-  }
-
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    require('sqlite3')
-    return true
-  }
-  catch {
-    logger.error('Nuxt Content requires `sqlite3` module to work in WebContainer environment. Please run `npm install sqlite3` to install it and try again.')
-    process.exit(1)
-  }
-}
-
 export async function refineDatabaseConfig(database: ModuleOptions['database'], opts: { rootDir: string, updateSqliteFileName?: boolean }) {
   if (database.type === 'd1') {
     if (!('bindingName' in database)) {
@@ -44,14 +28,11 @@ export async function refineDatabaseConfig(database: ModuleOptions['database'],
   }
 }
 
-export function getDefaultSqliteAdapter() {
-  return process.versions.bun ? 'bunsqlite' : 'sqlite'
-}
-
-export function resolveDatabaseAdapter(adapter: 'sqlite' | 'bunsqlite' | 'postgres' | 'libsql' | 'd1', resolver: Resolver) {
+export function resolveDatabaseAdapter(adapter: 'sqlite' | 'bunsqlite' | 'postgres' | 'libsql' | 'd1' | 'nodesqlite', opts: { resolver: Resolver, nativeSqlite?: boolean }) {
   const databaseConnectors = {
-    sqlite: isSqlite3Available() ? 'db0/connectors/sqlite3' : 'db0/connectors/better-sqlite3',
-    bunsqlite: resolver.resolve('./runtime/internal/connectors/bunsqlite'),
+    sqlite: findBestSqliteAdapter({ nativeSqlite: opts.nativeSqlite }),
+    nodesqlite: 'db0/connectors/node-sqlite',
+    bunsqlite: opts.resolver.resolve('./runtime/internal/connectors/bunsqlite'),
     postgres: 'db0/connectors/postgresql',
     libsql: 'db0/connectors/libsql/web',
     d1: 'db0/connectors/cloudflare-d1',
@@ -65,23 +46,22 @@ export function resolveDatabaseAdapter(adapter: 'sqlite' | 'bunsqlite' | 'postgr
   return databaseConnectors[adapter]
 }
 
-async function getDatabase(database: SqliteDatabaseConfig | D1DatabaseConfig): Promise<Connector> {
+async function getDatabase(database: SqliteDatabaseConfig | D1DatabaseConfig, opts: { nativeSqlite?: boolean }): Promise<Connector> {
   if (database.type === 'd1') {
     return cloudflareD1Connector({ bindingName: database.bindingName })
   }
 
-  const type = getDefaultSqliteAdapter()
-  return import(type === 'bunsqlite' ? 'db0/connectors/bun-sqlite' : (isSqlite3Available() ? 'db0/connectors/sqlite3' : 'db0/connectors/better-sqlite3'))
+  return import(findBestSqliteAdapter(opts))
     .then((m) => {
       const connector = (m.default || m) as (config: unknown) => Connector
       return connector({ path: database.filename })
     })
 }
 
 const _localDatabase: Record<string, Connector> = {}
-export async function getLocalDatabase(database: SqliteDatabaseConfig | D1DatabaseConfig, connector?: Connector): Promise<LocalDevelopmentDatabase> {
+export async function getLocalDatabase(database: SqliteDatabaseConfig | D1DatabaseConfig, { connector, nativeSqlite }: { connector?: Connector, nativeSqlite?: boolean } = {}): Promise<LocalDevelopmentDatabase> {
   const databaseLocation = database.type === 'sqlite' ? database.filename : database.bindingName
-  const db = _localDatabase[databaseLocation] || connector || await getDatabase(database)
+  const db = _localDatabase[databaseLocation] || connector || await getDatabase(database, { nativeSqlite })
 
   _localDatabase[databaseLocation] = db
   await db.exec('CREATE TABLE IF NOT EXISTS _development_cache (id TEXT PRIMARY KEY, checksum TEXT, parsedContent TEXT)')
@@ -128,3 +108,66 @@ export async function getLocalDatabase(database: SqliteDatabaseConfig | D1Databa
     dropContentTables,
   }
 }
+
+function findBestSqliteAdapter(opts: { nativeSqlite?: boolean }) {
+  if (process.versions.bun) {
+    return 'db0/connectors/bun-sqlite'
+  }
+
+  // if node:sqlite is available, use it
+  if (opts.nativeSqlite && isNodeSqliteAvailable()) {
+    return 'db0/connectors/node-sqlite'
+  }
+
+  return isSqlite3Available() ? 'db0/connectors/sqlite3' : 'db0/connectors/better-sqlite3'
+}
+
+function isNodeSqliteAvailable() {
+  try {
+    const module = globalThis.process?.getBuiltinModule?.('node:sqlite')
+
+    if (module) {
+      // When using the SQLite Node.js prints warnings about the experimental feature
+      // This is workaround to surpass the SQLite warning
+      // Inspired by Yarn https://github.com/yarnpkg/berry/blob/182046546379f3b4e111c374946b32d92be5d933/packages/yarnpkg-pnp/sources/loader/applyPatch.ts#L307-L328
+      const originalEmit = process.emit
+      // @ts-expect-error - TS complains about the return type of originalEmit.apply
+      process.emit = function (...args) {
+        const name = args[0]
+        const data = args[1] as { name: string, message: string }
+        if (
+          name === `warning`
+          && typeof data === `object`
+          && data.name === `ExperimentalWarning`
+          && data.message.includes(`SQLite is an experimental feature`)
+        ) {
+          return false
+        }
+        return originalEmit.apply(process, args as unknown as Parameters<typeof process.emit>)
+      }
+
+      return true
+    }
+
+    return false
+  }
+  catch {
+    return false
+  }
+}
+
+function isSqlite3Available() {
+  if (!isWebContainer()) {
+    return false
+  }
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require('sqlite3')
+    return true
+  }
+  catch {
+    logger.error('Nuxt Content requires `sqlite3` module to work in WebContainer environment. Please run `npm install sqlite3` to install it and try again.')
+    process.exit(1)
+  }
+}

src/utils/dev.ts

@@ -22,7 +22,7 @@ import { parseSourceBase } from './source'
 export const logger: ConsolaInstance = useLogger('@nuxt/content')
 
 export async function startSocketServer(nuxt: Nuxt, options: ModuleOptions, manifest: Manifest) {
-  const db = await getLocalDatabase(options._localDatabase)
+  const db = await getLocalDatabase(options._localDatabase, { nativeSqlite: options.experimental?.nativeSqlite })
 
   let websocket: ReturnType<typeof createWebSocket>
   let listener: Listener
@@ -89,7 +89,7 @@ export async function startSocketServer(nuxt: Nuxt, options: ModuleOptions, mani
 export async function watchContents(nuxt: Nuxt, options: ModuleOptions, manifest: Manifest, socket: Awaited<ReturnType<typeof startSocketServer>>) {
   const collectionParsers = {} as Record<string, Awaited<ReturnType<typeof createParser>>>
 
-  const db = await getLocalDatabase(options._localDatabase!)
+  const db = await getLocalDatabase(options._localDatabase!, { nativeSqlite: options.experimental?.nativeSqlite })
   const collections = manifest.collections
 
   const sourceMap = collections.flatMap((c) => {

test/basic.test.ts

@@ -58,7 +58,7 @@ describe('basic', async () => {
     })
 
     test('load database', async () => {
-      db = await getLocalDatabase({ type: 'sqlite', filename: fileURLToPath(new URL('./fixtures/basic/.data/content/contents.sqlite', import.meta.url)) })
+      db = await getLocalDatabase({ type: 'sqlite', filename: fileURLToPath(new URL('./fixtures/basic/.data/content/contents.sqlite', import.meta.url)) }, { nativeSqlite: true })
     })
 
     test('content table is created', async () => {

test/bun.test.ts

@@ -14,7 +14,7 @@ describe('Local database', () => {
   })
 
   test('load database', async () => {
-    db = await getLocalDatabase({ type: 'sqlite', filename: ':memory:' })
+    db = await getLocalDatabase({ type: 'sqlite', filename: ':memory:' }, { nativeSqlite: true })
     expect(db).toBeDefined()
   })
 

test/empty.test.ts

@@ -63,7 +63,7 @@ describe('empty', async () => {
     })
 
     test('load database', async () => {
-      db = await getLocalDatabase({ type: 'sqlite', filename: fileURLToPath(new URL('./fixtures/empty/.data/content/contents.sqlite', import.meta.url)) })
+      db = await getLocalDatabase({ type: 'sqlite', filename: fileURLToPath(new URL('./fixtures/empty/.data/content/contents.sqlite', import.meta.url)) }, { nativeSqlite: true })
     })
 
     test('content table is created', async () => {