feat(drivers): ✨ add Deno and @db/sqlite support

Add Deno-compatible npm imports and a synchronous JSR SQLite driver with statement cleanup, typed rows, blobs, bigint values, and insert IDs.

Use the existing WASM workflow and add focused documentation, examples, and tests. The Deno example runs and regenerates without Node.js.

Validated 31 generator tests, four SQLite integration tests, Deno checks for all four npm drivers, and WASM output with sqlc 1.24.0 and 1.31.1.

Author: touzoku

.github/workflows/ci.yml

@@ -18,7 +18,14 @@ jobs:
     - run: chmod +x javy-x86_64-linux-v1.2.0
     - run: npm install
     - run: npx tsc --noEmit
+    - run: npm test
     - run: npx esbuild --bundle src/app.ts --tree-shaking=true --format=esm --target=es2020 --outfile=out.js
     - run: ./javy-x86_64-linux-v1.2.0 compile out.js -o examples/plugin.wasm
     - run: sqlc -f sqlc.dev.yaml diff
-      working-directory: examples
+      working-directory: examples
+    - uses: denoland/setup-deno@v2
+      with:
+        deno-version: v2.x
+    - run: node tests/check-deno.mjs
+    - run: make test-deno
+    - run: git diff --exit-code -- examples/deno-db-sqlite

.gitignore

@@ -2,4 +2,3 @@ node_modules
 out.js
 *.wasm
 javy
-tests

Makefile

@@ -1,4 +1,4 @@
-.PHONY: generate
+.PHONY: generate test test-deno
 
 generate: examples/plugin.wasm examples/sqlc.dev.yaml
 	cd examples && sqlc-dev -f sqlc.dev.yaml generate
@@ -13,3 +13,11 @@ out.js: src/app.ts $(wildcard src/drivers/*.ts) src/gen/plugin/codegen_pb.ts
 
 src/gen/plugin/codegen_pb.ts: buf.gen.yaml
 	buf generate --template buf.gen.yaml buf.build/sqlc/sqlc --path plugin/
+
+test:
+	npx tsc --noEmit
+	npm test
+
+test-deno:
+	test -f examples/plugin.wasm
+	cd examples/deno-db-sqlite && deno task generate && deno task check && deno task test && deno task start

README.md

@@ -28,7 +28,18 @@ sql:
 
 - PostgreSQL via [pg](https://www.npmjs.com/package/pg) or [postgres](https://www.npmjs.com/package/postgres).
 - MySQL via [mysql2](https://www.npmjs.com/package/mysql2).
-- SQLite via [sqlite3](https://www.npmjs.com/package/better-sqlite3).
+- SQLite via [better-sqlite3](https://www.npmjs.com/package/better-sqlite3) or
+  Deno's [@db/sqlite](https://jsr.io/@db/sqlite).
+
+Set `runtime` to `node`, `bun`, or `deno`. Deno output imports npm drivers with
+`npm:` specifiers, such as `npm:pg`, `npm:postgres`, `npm:mysql2`, and
+`npm:better-sqlite3`. The `@db/sqlite` driver requires `runtime: deno` and imports
+`jsr:@db/sqlite`. `driver: "jsr:@db/sqlite"` is an alias for `driver: "@db/sqlite"`.
+
+Deno and `@db/sqlite` support require a build from this source tree; the released
+`0.1.3` WASM plugin shown in the existing configurations does not include them.
+See [Deno and @db/sqlite](#deno-and-dbsqlite) for local build instructions and a
+complete configuration.
 
 ## Getting started
 
@@ -37,8 +48,9 @@ This tutorial assumes that the latest version of sqlc is
 
 We'll generate TypeScript here, but other [language
 plugins](https://docs.sqlc.dev/en/latest/reference/language-support.html) are
-available. You'll need Bun (or Node.js) installed if you want to build and run a
-program with the code sqlc generates, but sqlc itself has no dependencies.
+available. This tutorial uses Bun (or Node.js) to run the generated program.
+For Deno, use the [Deno SQLite example](examples/deno-db-sqlite/README.md).
+sqlc itself has no dependencies.
 
 We'll also rely on sqlc's [managed databases](https://docs.sqlc.dev/en/latest/howto/managed-databases.html),
 which require a sqlc Cloud project and auth token. You can get those from
@@ -334,6 +346,37 @@ sql:
       driver: better-sqlite3 # npm package name
 ```
 
+### Deno and @db/sqlite
+
+Use a WASM plugin built from this source tree, following the
+[development instructions](#development). Set its absolute path in `sqlc.yaml`:
+
+```yaml
+version: "2"
+plugins:
+- name: ts
+  wasm:
+    url: file:///absolute/path/to/sqlc-gen-typescript/examples/plugin.wasm
+sql:
+- schema: "schema.sql"
+  queries: "query.sql"
+  engine: sqlite
+  codegen:
+  - out: db
+    plugin: ts
+    options:
+      runtime: deno
+      driver: "@db/sqlite"
+```
+
+The generated code runs with Deno alone. It imports `jsr:@db/sqlite` and emits
+synchronous functions that work inside `database.transaction` callbacks. Each
+call finalizes its prepared statement. Integer types allow `number | bigint`;
+open the database with `{ int64: true }` to preserve large SQLite integers.
+
+The [Deno example](examples/deno-db-sqlite/README.md) includes a pinned driver,
+a runnable program, query tests, and generation instructions.
+
 ## Development
 
 If you want to build and test sqlc-gen-typescript locally, follow these steps:
@@ -389,5 +432,8 @@ Check the `Makefile` for details.
    sqlc generate
    ```
 
+After building `examples/plugin.wasm`, run `make test-deno` with Deno 2 and
+sqlc installed to regenerate, check, test, and run the Deno example.
+
 For more details on sqlc development, refer to the sqlc core development guide. This guide provides additional information on setting up and working with sqlc in general, which may be useful for contributors to this project.  
 https://docs.sqlc.dev/en/latest/guides/development.html

examples/deno-db-sqlite/README.md

@@ -0,0 +1,45 @@
+# Deno and @db/sqlite
+
+This example runs the shared SQLite author queries with Deno 2 and
+[`@db/sqlite`](https://jsr.io/@db/sqlite). It uses an in-memory database and
+needs no database server. `deno.json` pins the driver to version `0.13.0`.
+
+To run the checked-in generated code, install Deno 2, then run from this folder:
+
+```sh
+deno task check
+deno task start
+deno task test
+```
+
+Node.js and sqlc are not needed to run the example. To regenerate its code,
+install sqlc and build the WASM plugin from this source tree. The released
+`0.1.3` plugin does not include Deno or `@db/sqlite` support. The source build
+uses the repository's existing Node.js/npm and Javy toolchain. Place the
+[Javy v1.2.0 executable](https://github.com/bytecodealliance/javy/releases/tag/v1.2.0)
+at `./javy`, then run from the repository root:
+
+```sh
+npm install
+make examples/plugin.wasm
+cd examples/deno-db-sqlite
+deno task generate
+```
+
+`sqlc.yaml` uses the local `../plugin.wasm` build. Once built, generating code
+requires only sqlc; the plugin runs as WASM.
+
+The `start` and `test` tasks use `-A` because the driver loads a native SQLite
+library through Deno's FFI. On the first run, the driver also downloads and
+caches that library. See the
+[driver's permission notes](https://jsr.io/@db/sqlite) for more detail.
+
+Generated functions are synchronous, so they work inside `database.transaction`
+callbacks. They finalize each prepared statement, return `null` when a `:one`
+query finds no row, and return camelCase properties for SQL column names such as
+`display_name`. Blobs use `Uint8Array`. The example opens its database with
+`{ int64: true }` so large SQLite integers retain their value; generated integer
+types allow `number | bigint`.
+
+The tests cover author CRUD, missing rows, nullable values, camelCase results,
+blobs, large integers, inserted row IDs, and rollback after a failed query.

examples/deno-db-sqlite/deno.json

@@ -0,0 +1,11 @@
+{
+  "imports": {
+    "jsr:@db/sqlite": "jsr:@db/sqlite@0.13.0"
+  },
+  "tasks": {
+    "generate": "sqlc generate",
+    "check": "deno check src/main.ts tests/queries_test.ts",
+    "start": "deno run -A src/main.ts",
+    "test": "deno test -A tests/"
+  }
+}

examples/deno-db-sqlite/deno.lock

@@ -0,0 +1,24 @@
+version: "2"
+plugins:
+- name: ts
+  wasm:
+    url: file://../plugin.wasm
+sql:
+- schema: "../authors/sqlite/schema.sql"
+  queries: "../authors/sqlite/query.sql"
+  engine: sqlite
+  codegen:
+  - plugin: ts
+    out: src/db
+    options:
+      runtime: deno
+      driver: "@db/sqlite"
+- schema: "tests/fixtures/schema.sql"
+  queries: "tests/fixtures/query.sql"
+  engine: sqlite
+  codegen:
+  - plugin: ts
+    out: tests/db
+    options:
+      runtime: deno
+      driver: "jsr:@db/sqlite"

examples/deno-db-sqlite/sqlc.yaml

@@ -0,0 +1,109 @@
+// Code generated by sqlc. DO NOT EDIT.
+
+import type { Database } from "jsr:@db/sqlite";
+
+export const getAuthorQuery = `-- name: GetAuthor :one
+SELECT id, name, bio FROM authors
+WHERE id = ? LIMIT 1`;
+
+export interface GetAuthorArgs {
+    id: number | bigint;
+}
+
+export interface GetAuthorRow {
+    id: number | bigint;
+    name: string;
+    bio: string | null;
+}
+
+export function getAuthor(database: Database, args: GetAuthorArgs): GetAuthorRow | null {
+    const stmt = database.prepare(getAuthorQuery);
+    try {
+        const row = stmt.value<[
+            number | bigint,
+            string,
+            string | null
+        ]>(args.id);
+        if (row === undefined) {
+            return null;
+        }
+        return {
+            id: row[0],
+            name: row[1],
+            bio: row[2]
+        };
+    }
+    finally {
+        stmt.finalize();
+    }
+}
+
+export const listAuthorsQuery = `-- name: ListAuthors :many
+SELECT id, name, bio FROM authors
+ORDER BY name`;
+
+export interface ListAuthorsRow {
+    id: number | bigint;
+    name: string;
+    bio: string | null;
+}
+
+export function listAuthors(database: Database): ListAuthorsRow[] {
+    const stmt = database.prepare(listAuthorsQuery);
+    try {
+        const rows = stmt.values<[
+            number | bigint,
+            string,
+            string | null
+        ]>();
+        return rows.map(row => ({
+            id: row[0],
+            name: row[1],
+            bio: row[2]
+        }));
+    }
+    finally {
+        stmt.finalize();
+    }
+}
+
+export const createAuthorQuery = `-- name: CreateAuthor :exec
+INSERT INTO authors (
+  name, bio
+) VALUES (
+  ?, ?
+)`;
+
+export interface CreateAuthorArgs {
+    name: string;
+    bio: string | null;
+}
+
+export function createAuthor(database: Database, args: CreateAuthorArgs): void {
+    const stmt = database.prepare(createAuthorQuery);
+    try {
+        stmt.run(args.name, args.bio);
+    }
+    finally {
+        stmt.finalize();
+    }
+}
+
+export const deleteAuthorQuery = `-- name: DeleteAuthor :exec
+DELETE FROM authors
+WHERE id = ?`;
+
+export interface DeleteAuthorArgs {
+    id: number | bigint;
+}
+
+export function deleteAuthor(database: Database, args: DeleteAuthorArgs): void {
+    const stmt = database.prepare(deleteAuthorQuery);
+    try {
+        stmt.run(args.id);
+    }
+    finally {
+        stmt.finalize();
+    }
+}
+