restructure js bindings

bindings/javascript/packages/native/README.md

@@ -0,0 +1,129 @@
+<p align="center">
+  <h1 align="center">Turso Database for JavaScript</h1>
+</p>
+
+<p align="center">
+  <a title="JavaScript" target="_blank" href="https://www.npmjs.com/package/@tursodatabase/database"><img alt="npm" src="https://img.shields.io/npm/v/@tursodatabase/database"></a>
+  <a title="MIT" target="_blank" href="https://github.com/tursodatabase/turso/blob/main/LICENSE.md"><img src="http://img.shields.io/badge/license-MIT-orange.svg?style=flat-square"></a>
+</p>
+<p align="center">
+  <a title="Users Discord" target="_blank" href="https://tur.so/discord"><img alt="Chat with other users of Turso on Discord" src="https://img.shields.io/discord/933071162680958986?label=Discord&logo=Discord&style=social"></a>
+</p>
+
+---
+
+## About
+
+This package is the Turso embedded database library for JavaScript.
+
+> **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
+
+## Features
+
+- **SQLite compatible:** SQLite query language and file format support ([status](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)).
+- **In-process**: No network overhead, runs directly in your Node.js process
+- **TypeScript support**: Full TypeScript definitions included
+- **Cross-platform**: Supports Linux (x86 and arm64), macOS, Windows and browsers (through WebAssembly)
+
+## Installation
+
+```bash
+npm install @tursodatabase/database
+```
+
+## Getting Started
+
+### In-Memory Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+// Create an in-memory database
+const db = await connect(':memory:');
+
+// Create a table
+db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+// Insert data
+const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+insert.run('Alice', 'alice@example.com');
+insert.run('Bob', 'bob@example.com');
+
+// Query data
+const users = db.prepare('SELECT * FROM users').all();
+console.log(users);
+// Output: [
+//   { id: 1, name: 'Alice', email: 'alice@example.com' },
+//   { id: 2, name: 'Bob', email: 'bob@example.com' }
+// ]
+```
+
+### File-Based Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+// Create or open a database file
+const db = await connect('my-database.db');
+
+// Create a table
+db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Insert a post
+const insertPost = db.prepare('INSERT INTO posts (title, content) VALUES (?, ?)');
+const result = insertPost.run('Hello World', 'This is my first blog post!');
+
+console.log(`Inserted post with ID: ${result.lastInsertRowid}`);
+```
+
+### Transactions
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+const db = await connect('transactions.db');
+
+// Using transactions for atomic operations
+const transaction = db.transaction((users) => {
+  const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+  for (const user of users) {
+    insert.run(user.name, user.email);
+  }
+});
+
+// Execute transaction
+transaction([
+  { name: 'Alice', email: 'alice@example.com' },
+  { name: 'Bob', email: 'bob@example.com' }
+]);
+```
+
+### WebAssembly Support
+
+Turso Database can run in browsers using WebAssembly from separate package. Check the `@tursodatabase/database-browser` for more details.
+
+## API Reference
+
+For complete API documentation, see [JavaScript API Reference](../../../../docs/javascript-api-reference.md).
+
+## Related Packages
+
+* The [@tursodatabase/serverless](https://www.npmjs.com/package/@tursodatabase/serverless) package provides a serverless driver with the same API.
+* The [@tursodatabase/sync](https://www.npmjs.com/package/@tursodatabase/sync) package provides bidirectional sync between a local Turso database and Turso Cloud. 
+
+## License
+
+This project is licensed under the [MIT license](../../LICENSE.md).
+
+## Support
+
+- [GitHub Issues](https://github.com/tursodatabase/turso/issues)
+- [Documentation](https://docs.turso.tech)
+- [Discord Community](https://tur.so/discord)

bindings/javascript/packages/native/compat.test.ts

@@ -0,0 +1,67 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest'
+import { Database } from './compat.js'
+
+test('in-memory db', () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t(x)");
+    db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = new Database(path);
+        db1.exec("CREATE TABLE t(x)");
+        db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows1 = stmt1.all([1]);
+        expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+        db1.close();
+
+        const db2 = new Database(path);
+        const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows2 = stmt2.all([1]);
+        expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+        db2.close();
+    } finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+    }
+})
+
+test('attach', () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = new Database(path1);
+        db1.exec("CREATE TABLE t(x)");
+        db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const db2 = new Database(path2);
+        db2.exec("CREATE TABLE q(x)");
+        db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+        db1.exec(`ATTACH '${path2}' as secondary`);
+
+        const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+        expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows = stmt.all([1]);
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+    } finally {
+        unlinkSync(path1);
+        unlinkSync(`${path1}-wal`);
+        unlinkSync(path2);
+        unlinkSync(`${path2}-wal`);
+    }
+})
+
+test('blobs', () => {
+    const db = new Database(":memory:");
+    const rows = db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: Buffer.from([16, 32]) }])
+})

bindings/javascript/packages/native/compat.ts

@@ -0,0 +1,10 @@
+import { DatabaseCompat, NativeDatabase, SqliteError, DatabaseOpts } from "@tursodatabase/database-core"
+import { Database as NativeDB } from "#index";
+
+class Database extends DatabaseCompat {
+    constructor(path: string, opts: DatabaseOpts = {}) {
+        super(new NativeDB(path, { tracing: opts.tracing }) as unknown as NativeDatabase, opts)
+    }
+}
+
+export { Database, SqliteError }

bindings/javascript/packages/native/index.d.ts

@@ -0,0 +1,149 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/** A database connection. */
+export declare class Database {
+  /**
+   * Creates a new database instance.
+   *
+   * # Arguments
+   * * `path` - The path to the database file.
+   */
+  constructor(path: string, opts?: DatabaseOpts | undefined | null)
+  /** Returns whether the database is in memory-only mode. */
+  get memory(): boolean
+  /** Returns whether the database connection is open. */
+  get open(): boolean
+  /**
+   * Executes a batch of SQL statements on main thread
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statements to execute.
+   *
+   * # Returns
+   */
+  batchSync(sql: string): void
+  /**
+   * Executes a batch of SQL statements outside of main thread
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statements to execute.
+   *
+   * # Returns
+   */
+  batchAsync(sql: string): Promise<unknown>
+  /**
+   * Prepares a statement for execution.
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statement to prepare.
+   *
+   * # Returns
+   *
+   * A `Statement` instance.
+   */
+  prepare(sql: string): Statement
+  /**
+   * Returns the rowid of the last row inserted.
+   *
+   * # Returns
+   *
+   * The rowid of the last row inserted.
+   */
+  lastInsertRowid(): number
+  /**
+   * Returns the number of changes made by the last statement.
+   *
+   * # Returns
+   *
+   * The number of changes made by the last statement.
+   */
+  changes(): number
+  /**
+   * Returns the total number of changes made by all statements.
+   *
+   * # Returns
+   *
+   * The total number of changes made by all statements.
+   */
+  totalChanges(): number
+  /**
+   * Closes the database connection.
+   *
+   * # Returns
+   *
+   * `Ok(())` if the database is closed successfully.
+   */
+  close(): void
+  /**
+   * Sets the default safe integers mode for all statements from this database.
+   *
+   * # Arguments
+   *
+   * * `toggle` - Whether to use safe integers by default.
+   */
+  defaultSafeIntegers(toggle?: boolean | undefined | null): void
+  /** Runs the I/O loop synchronously. */
+  ioLoopSync(): void
+  /** Runs the I/O loop asynchronously, returning a Promise. */
+  ioLoopAsync(): Promise<void>
+}
+
+/** A prepared statement. */
+export declare class Statement {
+  reset(): void
+  /** Returns the number of parameters in the statement. */
+  parameterCount(): number
+  /**
+   * Returns the name of a parameter at a specific 1-based index.
+   *
+   * # Arguments
+   *
+   * * `index` - The 1-based parameter index.
+   */
+  parameterName(index: number): string | null
+  /**
+   * Binds a parameter at a specific 1-based index with explicit type.
+   *
+   * # Arguments
+   *
+   * * `index` - The 1-based parameter index.
+   * * `value_type` - The type constant (0=null, 1=int, 2=float, 3=text, 4=blob).
+   * * `value` - The value to bind.
+   */
+  bindAt(index: number, value: unknown): void
+  /**
+   * Step the statement and return result code (executed on the main thread):
+   * 1 = Row available, 2 = Done, 3 = I/O needed
+   */
+  stepSync(): number
+  /**
+   * Step the statement and return result code (executed on the background thread):
+   * 1 = Row available, 2 = Done, 3 = I/O needed
+   */
+  stepAsync(): Promise<unknown>
+  /** Get the current row data according to the presentation mode */
+  row(): unknown
+  /** Sets the presentation mode to raw. */
+  raw(raw?: boolean | undefined | null): void
+  /** Sets the presentation mode to pluck. */
+  pluck(pluck?: boolean | undefined | null): void
+  /**
+   * Sets safe integers mode for this statement.
+   *
+   * # Arguments
+   *
+   * * `toggle` - Whether to use safe integers.
+   */
+  safeIntegers(toggle?: boolean | undefined | null): void
+  /** Get column information for the statement */
+  columns(): unknown[]
+  /** Finalizes the statement. */
+  finalize(): void
+}
+
+export interface DatabaseOpts {
+  tracing?: string
+}

bindings/javascript/packages/native/index.js

@@ -0,0 +1,513 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-android-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-android-arm-eabi')
+        const bindingPackageVersion = require('@tursodatabase/database-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-x64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./turso.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-ia32-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-arm64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./turso.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@tursodatabase/database-darwin-universal')
+      const bindingPackageVersion = require('@tursodatabase/database-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-darwin-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-darwin-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-freebsd-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-freebsd-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-x64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-x64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-riscv64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./turso.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@tursodatabase/database-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./turso.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-linux-s390x-gnu')
+        const bindingPackageVersion = require('@tursodatabase/database-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./turso.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-arm')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.4' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.4 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./turso.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require('@tursodatabase/database-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
+    }
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      { cause: loadErrors }
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Database, Statement } = nativeBinding
+export { Database }
+export { Statement }

bindings/javascript/packages/native/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@tursodatabase/database",
+  "version": "0.1.5-pre.4",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "license": "MIT",
+  "module": "./dist/promise.js",
+  "main": "./dist/promise.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/promise.js",
+    "./compat": "./dist/compat.js"
+  },
+  "packageManager": "yarn@4.9.2",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.1.5",
+    "@napi-rs/wasm-runtime": "^1.0.3",
+    "@types/node": "^24.3.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "napi-build": "napi build --platform --release --esm --manifest-path ../../Cargo.toml --output-dir . && rm turso.wasi* wasi* browser.js",
+    "napi-dirs": "napi create-npm-dirs",
+    "napi-artifacts": "napi artifacts --output-dir .",
+    "tsc-build": "npm exec tsc",
+    "build": "npm run napi-build && npm run tsc-build",
+    "test": "vitest --run"
+  },
+  "napi": {
+    "binaryName": "turso",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "universal-apple-darwin",
+      "aarch64-unknown-linux-gnu",
+      "wasm32-wasip1-threads"
+    ]
+  },
+  "dependencies": {
+    "@tursodatabase/database-core": "^0.1.5-pre.4"
+  },
+  "imports": {
+    "#index": "./index.js"
+  }
+}

bindings/javascript/packages/native/promise.test.ts

@@ -0,0 +1,67 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest'
+import { connect } from './promise.js'
+
+test('in-memory db', async () => {
+    const db = await connect(":memory:");
+    await db.exec("CREATE TABLE t(x)");
+    await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', async () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows1 = await stmt1.all([1]);
+        expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+        db1.close();
+
+        const db2 = await connect(path);
+        const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows2 = await stmt2.all([1]);
+        expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+        db2.close();
+    } finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+    }
+})
+
+test('attach', async () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path1);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const db2 = await connect(path2);
+        await db2.exec("CREATE TABLE q(x)");
+        await db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+        await db1.exec(`ATTACH '${path2}' as secondary`);
+
+        const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+        expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows = await stmt.all([1]);
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+    } finally {
+        unlinkSync(path1);
+        unlinkSync(`${path1}-wal`);
+        unlinkSync(path2);
+        unlinkSync(`${path2}-wal`);
+    }
+})
+
+test('blobs', async () => {
+    const db = await connect(":memory:");
+    const rows = await db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: Buffer.from([16, 32]) }])
+})

bindings/javascript/packages/native/promise.ts

@@ -0,0 +1,21 @@
+import { DatabasePromise, NativeDatabase, SqliteError, DatabaseOpts } from "@tursodatabase/database-core"
+import { Database as NativeDB } from "#index";
+
+class Database extends DatabasePromise {
+    constructor(path: string, opts: DatabaseOpts = {}) {
+        super(new NativeDB(path, { tracing: opts.tracing }) as unknown as NativeDatabase, opts)
+    }
+}
+
+/**
+ * Creates a new database connection asynchronously.
+ * 
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(path: string, opts: any = {}): Promise<Database> {
+    return new Database(path, opts);
+}
+
+export { connect, Database, SqliteError }

bindings/javascript/packages/native/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "module": "nodenext",
+    "target": "esnext",
+    "outDir": "dist/",
+    "lib": [
+      "es2020"
+    ],
+    "paths": {
+      "#index": [
+        "./index.js"
+      ]
+    }
+  },
+  "include": [
+    "*"
+  ]
+}