@gjsify/sqlite 0.1.0

package/lib/types/types.d.ts

@@ -0,0 +1,31 @@
+export interface DatabaseSyncOptions {
+    open?: boolean;
+    readOnly?: boolean;
+    timeout?: number;
+    enableForeignKeyConstraints?: boolean;
+    enableDoubleQuotedStringLiterals?: boolean;
+    readBigInts?: boolean;
+    returnArrays?: boolean;
+    allowBareNamedParameters?: boolean;
+    allowUnknownNamedParameters?: boolean;
+    defensive?: boolean;
+    allowExtension?: boolean;
+}
+export interface StatementSyncOptions {
+    readBigInts?: boolean;
+    returnArrays?: boolean;
+    allowBareNamedParameters?: boolean;
+    allowUnknownNamedParameters?: boolean;
+}
+export interface RunResult {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface ColumnInfo {
+    column: string | null;
+    database: string | null;
+    name: string;
+    table: string | null;
+    type: string | null;
+}
+export type SQLiteValue = null | number | bigint | string | Uint8Array;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@gjsify/sqlite",
+  "version": "0.1.0",
+  "description": "Node.js sqlite module for Gjs using libgda",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "sqlite",
+    "libgda"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@girs/gda-6.0": "^6.0.0-4.0.0-beta.42",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/gobject-2.0": "^2.88.0-4.0.0-beta.42"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,101 @@
+// SQLite constants matching Node.js node:sqlite constants
+// Reference: Node.js lib/sqlite.js
+
+// Changeset conflict constants
+export const SQLITE_CHANGESET_OMIT = 0;
+export const SQLITE_CHANGESET_REPLACE = 1;
+export const SQLITE_CHANGESET_ABORT = 2;
+export const SQLITE_CHANGESET_DATA = 1;
+export const SQLITE_CHANGESET_NOTFOUND = 2;
+export const SQLITE_CHANGESET_CONFLICT = 3;
+export const SQLITE_CHANGESET_CONSTRAINT = 4;
+export const SQLITE_CHANGESET_FOREIGN_KEY = 5;
+
+// Authorization result constants
+export const SQLITE_OK = 0;
+export const SQLITE_DENY = 1;
+export const SQLITE_IGNORE = 2;
+
+// Authorization action code constants
+export const SQLITE_CREATE_INDEX = 1;
+export const SQLITE_CREATE_TABLE = 2;
+export const SQLITE_CREATE_TEMP_INDEX = 3;
+export const SQLITE_CREATE_TEMP_TABLE = 4;
+export const SQLITE_CREATE_TEMP_TRIGGER = 5;
+export const SQLITE_CREATE_TEMP_VIEW = 6;
+export const SQLITE_CREATE_TRIGGER = 7;
+export const SQLITE_CREATE_VIEW = 8;
+export const SQLITE_DELETE = 9;
+export const SQLITE_DROP_INDEX = 10;
+export const SQLITE_DROP_TABLE = 11;
+export const SQLITE_DROP_TEMP_INDEX = 12;
+export const SQLITE_DROP_TEMP_TABLE = 13;
+export const SQLITE_DROP_TEMP_TRIGGER = 14;
+export const SQLITE_DROP_TEMP_VIEW = 15;
+export const SQLITE_DROP_TRIGGER = 16;
+export const SQLITE_DROP_VIEW = 17;
+export const SQLITE_INSERT = 18;
+export const SQLITE_PRAGMA = 19;
+export const SQLITE_READ = 20;
+export const SQLITE_SELECT = 21;
+export const SQLITE_TRANSACTION = 22;
+export const SQLITE_UPDATE = 23;
+export const SQLITE_ATTACH = 24;
+export const SQLITE_DETACH = 25;
+export const SQLITE_ALTER_TABLE = 26;
+export const SQLITE_REINDEX = 27;
+export const SQLITE_ANALYZE = 28;
+export const SQLITE_CREATE_VTABLE = 29;
+export const SQLITE_DROP_VTABLE = 30;
+export const SQLITE_FUNCTION = 31;
+export const SQLITE_SAVEPOINT = 32;
+export const SQLITE_COPY = 0;
+export const SQLITE_RECURSIVE = 33;
+
+export const constants = {
+    SQLITE_CHANGESET_OMIT,
+    SQLITE_CHANGESET_REPLACE,
+    SQLITE_CHANGESET_ABORT,
+    SQLITE_CHANGESET_DATA,
+    SQLITE_CHANGESET_NOTFOUND,
+    SQLITE_CHANGESET_CONFLICT,
+    SQLITE_CHANGESET_CONSTRAINT,
+    SQLITE_CHANGESET_FOREIGN_KEY,
+    SQLITE_OK,
+    SQLITE_DENY,
+    SQLITE_IGNORE,
+    SQLITE_CREATE_INDEX,
+    SQLITE_CREATE_TABLE,
+    SQLITE_CREATE_TEMP_INDEX,
+    SQLITE_CREATE_TEMP_TABLE,
+    SQLITE_CREATE_TEMP_TRIGGER,
+    SQLITE_CREATE_TEMP_VIEW,
+    SQLITE_CREATE_TRIGGER,
+    SQLITE_CREATE_VIEW,
+    SQLITE_DELETE,
+    SQLITE_DROP_INDEX,
+    SQLITE_DROP_TABLE,
+    SQLITE_DROP_TEMP_INDEX,
+    SQLITE_DROP_TEMP_TABLE,
+    SQLITE_DROP_TEMP_TRIGGER,
+    SQLITE_DROP_TEMP_VIEW,
+    SQLITE_DROP_TRIGGER,
+    SQLITE_DROP_VIEW,
+    SQLITE_INSERT,
+    SQLITE_PRAGMA,
+    SQLITE_READ,
+    SQLITE_SELECT,
+    SQLITE_TRANSACTION,
+    SQLITE_UPDATE,
+    SQLITE_ATTACH,
+    SQLITE_DETACH,
+    SQLITE_ALTER_TABLE,
+    SQLITE_REINDEX,
+    SQLITE_ANALYZE,
+    SQLITE_CREATE_VTABLE,
+    SQLITE_DROP_VTABLE,
+    SQLITE_FUNCTION,
+    SQLITE_SAVEPOINT,
+    SQLITE_COPY,
+    SQLITE_RECURSIVE,
+};

package/src/data-model-reader.ts

@@ -0,0 +1,106 @@
+// Convert Gda.DataModel results to JavaScript objects/arrays
+// Reference: Node.js lib/sqlite.js
+// Reimplemented for GJS using Gda-6.0
+
+import Gda from '@girs/gda-6.0';
+import GObject from '@girs/gobject-2.0';
+import { OutOfRangeError } from './errors.ts';
+
+export interface ReadOptions {
+    readBigInts: boolean;
+    returnArrays: boolean;
+}
+
+function convertValue(value: unknown, readBigInts: boolean): unknown {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'number') {
+        if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+            if (!readBigInts) {
+                throw new OutOfRangeError(
+                    `Value is too large to be represented as a JavaScript number: ${value}`
+                );
+            }
+            return BigInt(value);
+        }
+        if (readBigInts && Number.isInteger(value)) {
+            return BigInt(value);
+        }
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        if (!readBigInts) {
+            if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(-Number.MAX_SAFE_INTEGER)) {
+                throw new OutOfRangeError(
+                    `Value is too large to be represented as a JavaScript number: ${value}`
+                );
+            }
+            return Number(value);
+        }
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    // Handle GLib.Bytes or Uint8Array (BLOB)
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    // GLib.Bytes from Gda
+    if (value && typeof (value as any).toArray === 'function') {
+        return new Uint8Array((value as any).toArray());
+    }
+    return value;
+}
+
+export function readRow(
+    model: Gda.DataModel,
+    row: number,
+    options: ReadOptions,
+): Record<string, unknown> | unknown[] | undefined {
+    const nCols = model.get_n_columns();
+
+    if (options.returnArrays) {
+        const arr: unknown[] = [];
+        for (let col = 0; col < nCols; col++) {
+            const val = model.get_value_at(col, row);
+            arr.push(convertValue(val, options.readBigInts));
+        }
+        return arr;
+    }
+
+    const obj = Object.create(null) as Record<string, unknown>;
+    for (let col = 0; col < nCols; col++) {
+        const name = model.get_column_name(col);
+        const val = model.get_value_at(col, row);
+        obj[name] = convertValue(val, options.readBigInts);
+    }
+    return obj;
+}
+
+export function readAllRows(
+    model: Gda.DataModel,
+    options: ReadOptions,
+): (Record<string, unknown> | unknown[])[] {
+    const nRows = model.get_n_rows();
+    const rows: (Record<string, unknown> | unknown[])[] = [];
+    for (let row = 0; row < nRows; row++) {
+        const r = readRow(model, row, options);
+        if (r !== undefined) {
+            rows.push(r);
+        }
+    }
+    return rows;
+}
+
+export function readFirstRow(
+    model: Gda.DataModel,
+    options: ReadOptions,
+): Record<string, unknown> | unknown[] | undefined {
+    const nRows = model.get_n_rows();
+    if (nRows === 0) {
+        return undefined;
+    }
+    return readRow(model, 0, options);
+}

package/src/data-types.spec.ts

@@ -0,0 +1,143 @@
+// Ported from refs/node-test/parallel/test-sqlite-data-types.js
+// Original: MIT license, Node.js contributors
+
+import { describe, it, expect } from '@gjsify/unit';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { mkdirSync, rmSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+
+let cnt = 0;
+const testDir = join(tmpdir(), 'gjsify-sqlite-types-test-' + Date.now());
+
+function setup() {
+    try { mkdirSync(testDir, { recursive: true }); } catch {}
+}
+
+function cleanup() {
+    try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+}
+
+function nextDb(): string {
+    return join(testDir, `database-${cnt++}.db`);
+}
+
+export default async () => {
+    setup();
+
+    await describe('sqlite data types', async () => {
+        await it('supports INTEGER, REAL, TEXT, BLOB, and NULL', async () => {
+            const u8a = new TextEncoder().encode('a☃b☃c');
+            const db = new DatabaseSync(nextDb());
+            db.exec(`
+                CREATE TABLE types(
+                    key INTEGER PRIMARY KEY,
+                    int INTEGER,
+                    double REAL,
+                    text TEXT,
+                    buf BLOB
+                ) STRICT;
+            `);
+            const stmt = db.prepare('INSERT INTO types (key, int, double, text, buf) VALUES (?, ?, ?, ?, ?)');
+
+            const r1 = stmt.run(1, 42, 3.14159, 'foo', u8a);
+            expect(r1.changes).toBe(1);
+            expect(r1.lastInsertRowid).toBe(1);
+
+            const r2 = stmt.run(2, null, null, null, null);
+            expect(r2.changes).toBe(1);
+            expect(r2.lastInsertRowid).toBe(2);
+
+            const query = db.prepare('SELECT * FROM types WHERE key = ?');
+
+            const row1 = query.get(1) as Record<string, unknown>;
+            expect(row1.key).toBe(1);
+            expect(row1.int).toBe(42);
+            expect(row1.double).toBe(3.14159);
+            expect(row1.text).toBe('foo');
+
+            const row2 = query.get(2) as Record<string, unknown>;
+            expect(row2.key).toBe(2);
+            expect(row2.int).toBeNull();
+            expect(row2.double).toBeNull();
+            expect(row2.text).toBeNull();
+            expect(row2.buf).toBeNull();
+
+            db.close();
+        });
+
+        await it('rejects unsupported data types', async () => {
+            const db = new DatabaseSync(nextDb());
+            db.exec('CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
+
+            const unsupported = [
+                undefined,
+                () => {},
+                Symbol(),
+                /foo/,
+                Promise.resolve(),
+                new Map(),
+                new Set(),
+            ];
+
+            for (const val of unsupported) {
+                expect(() => {
+                    db.prepare('INSERT INTO types (key, val) VALUES (?, ?)').run(1, val);
+                }).toThrow();
+            }
+
+            db.close();
+        });
+
+        await it('supports BigInt binding', async () => {
+            const db = new DatabaseSync(nextDb());
+            db.exec('CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
+            const stmt = db.prepare('INSERT INTO types (key, val) VALUES (?, ?)');
+            const result = stmt.run(4, 99n);
+            expect(result.changes).toBe(1);
+
+            const query = db.prepare('SELECT * FROM types WHERE key = ?');
+            const row = query.get(4) as Record<string, unknown>;
+            expect(row.val).toBe(99);
+            db.close();
+        });
+
+        await it('throws when binding a BigInt that is too large', async () => {
+            const max = 9223372036854775807n;
+            const db = new DatabaseSync(nextDb());
+            db.exec('CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
+            const stmt = db.prepare('INSERT INTO types (key, val) VALUES (?, ?)');
+
+            // Max should succeed
+            stmt.run(1, max);
+
+            // Max + 1 should throw
+            expect(() => {
+                stmt.run(2, max + 1n);
+            }).toThrow();
+            db.close();
+        });
+
+        await it('statements are unbound on each call', async () => {
+            const db = new DatabaseSync(nextDb());
+            db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;');
+            const stmt = db.prepare('INSERT INTO data (key, val) VALUES (?, ?)');
+
+            const r1 = stmt.run(1, 5);
+            expect(r1.changes).toBe(1);
+
+            // Second call without params — params should be unbound (NULL)
+            const r2 = stmt.run();
+            expect(r2.changes).toBe(1);
+
+            const rows = db.prepare('SELECT * FROM data ORDER BY key').all() as Record<string, unknown>[];
+            expect(rows.length).toBe(2);
+            expect(rows[0].key).toBe(1);
+            expect(rows[0].val).toBe(5);
+            expect(rows[1].val).toBeNull();
+            db.close();
+        });
+    });
+
+    cleanup();
+};

package/src/database-sync.spec.ts

@@ -0,0 +1,267 @@
+// Ported from refs/node-test/parallel/test-sqlite-database-sync.js
+// Original: MIT license, Node.js contributors
+
+import { describe, it, expect } from '@gjsify/unit';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+
+let cnt = 0;
+const testDir = join(tmpdir(), 'gjsify-sqlite-test-' + Date.now());
+
+function setup() {
+    try { mkdirSync(testDir, { recursive: true }); } catch {}
+}
+
+function cleanup() {
+    try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+}
+
+function nextDb(): string {
+    return join(testDir, `database-${cnt++}.db`);
+}
+
+export default async () => {
+    setup();
+
+    await describe('DatabaseSync() constructor', async () => {
+        await it('throws if database path is not a string, Uint8Array, or URL', async () => {
+            expect(() => {
+                new (DatabaseSync as any)();
+            }).toThrow();
+        });
+
+        await it('throws if the database location as string contains null bytes', async () => {
+            expect(() => {
+                new DatabaseSync('l\0cation');
+            }).toThrow();
+        });
+
+        await it('throws if options is provided but is not an object', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', null);
+            }).toThrow();
+        });
+
+        await it('throws if options.open is provided but is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { open: 5 });
+            }).toThrow();
+        });
+
+        await it('throws if options.readOnly is provided but is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { readOnly: 5 });
+            }).toThrow();
+        });
+
+        await it('throws if options.timeout is provided but is not an integer', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { timeout: .99 });
+            }).toThrow();
+        });
+
+        await it('throws if options.enableForeignKeyConstraints is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { enableForeignKeyConstraints: 5 });
+            }).toThrow();
+        });
+
+        await it('throws if options.enableDoubleQuotedStringLiterals is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { enableDoubleQuotedStringLiterals: 5 });
+            }).toThrow();
+        });
+
+        await it('throws if options.readBigInts is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { readBigInts: 42 });
+            }).toThrow();
+        });
+
+        await it('throws if options.returnArrays is not a boolean', async () => {
+            expect(() => {
+                new (DatabaseSync as any)('foo', { returnArrays: 42 });
+            }).toThrow();
+        });
+
+        await it('throws if the URL does not have the file: scheme', async () => {
+            expect(() => {
+                new DatabaseSync(new URL('http://example.com') as any);
+            }).toThrow();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.open()', async () => {
+        await it('opens a database connection', async () => {
+            const dbPath = nextDb();
+            const db = new DatabaseSync(dbPath, { open: false });
+            expect(db.isOpen).toBe(false);
+            db.open();
+            expect(db.isOpen).toBe(true);
+            db.close();
+        });
+
+        await it('throws if database is already open', async () => {
+            const dbPath = nextDb();
+            const db = new DatabaseSync(dbPath);
+            expect(db.isOpen).toBe(true);
+            expect(() => { db.open(); }).toThrow();
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.close()', async () => {
+        await it('closes an open database connection', async () => {
+            const db = new DatabaseSync(nextDb());
+            expect(db.isOpen).toBe(true);
+            db.close();
+            expect(db.isOpen).toBe(false);
+        });
+
+        await it('throws if database is not open', async () => {
+            const db = new DatabaseSync(nextDb(), { open: false });
+            expect(db.isOpen).toBe(false);
+            expect(() => { db.close(); }).toThrow();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.exec()', async () => {
+        await it('runs SQL and returns undefined', async () => {
+            const db = new DatabaseSync(nextDb());
+            const result = db.exec(`
+                CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
+                INSERT INTO data (key, val) VALUES (1, 2);
+                INSERT INTO data (key, val) VALUES (8, 9);
+            `);
+            expect(result).toBe(undefined);
+            const stmt = db.prepare('SELECT * FROM data ORDER BY key');
+            const rows = stmt.all();
+            expect(rows.length).toBe(2);
+            db.close();
+        });
+
+        await it('reports errors from SQLite', async () => {
+            const db = new DatabaseSync(nextDb());
+            expect(() => {
+                db.exec('CREATE TABLEEEE');
+            }).toThrow();
+            db.close();
+        });
+
+        await it('throws if database is not open', async () => {
+            const db = new DatabaseSync(nextDb(), { open: false });
+            expect(() => { db.exec('SELECT 1'); }).toThrow();
+        });
+
+        await it('throws if sql is not a string', async () => {
+            const db = new DatabaseSync(nextDb());
+            expect(() => { (db as any).exec(); }).toThrow();
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.prepare()', async () => {
+        await it('returns a prepared statement', async () => {
+            const db = new DatabaseSync(nextDb());
+            const stmt = db.prepare('CREATE TABLE webstorage(key TEXT)');
+            expect(stmt).toBeDefined();
+            db.close();
+        });
+
+        await it('throws if database is not open', async () => {
+            const db = new DatabaseSync(nextDb(), { open: false });
+            expect(() => { (db as any).prepare(); }).toThrow();
+        });
+
+        await it('throws if sql is not a string', async () => {
+            const db = new DatabaseSync(nextDb());
+            expect(() => { (db as any).prepare(); }).toThrow();
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync :memory: database', async () => {
+        await it('works with :memory: path', async () => {
+            const db = new DatabaseSync(':memory:');
+            expect(db.isOpen).toBe(true);
+            db.exec('CREATE TABLE t(id INTEGER PRIMARY KEY, val TEXT)');
+            db.exec("INSERT INTO t (id, val) VALUES (1, 'hello')");
+            const row = db.prepare('SELECT * FROM t').get();
+            expect(row).toBeDefined();
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.isTransaction', async () => {
+        await it('correctly detects a committed transaction', async () => {
+            const db = new DatabaseSync(':memory:');
+            expect(db.isTransaction).toBe(false);
+            db.exec('BEGIN');
+            expect(db.isTransaction).toBe(true);
+            db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
+            expect(db.isTransaction).toBe(true);
+            db.exec('COMMIT');
+            expect(db.isTransaction).toBe(false);
+            db.close();
+        });
+
+        await it('correctly detects a rolled back transaction', async () => {
+            const db = new DatabaseSync(':memory:');
+            expect(db.isTransaction).toBe(false);
+            db.exec('BEGIN');
+            expect(db.isTransaction).toBe(true);
+            db.exec('ROLLBACK');
+            expect(db.isTransaction).toBe(false);
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync.prototype.location()', async () => {
+        await it('throws if database is not open', async () => {
+            const db = new DatabaseSync(nextDb(), { open: false });
+            expect(() => { db.location(); }).toThrow();
+        });
+
+        await it('returns null for in-memory database', async () => {
+            const db = new DatabaseSync(':memory:');
+            expect(db.location()).toBeNull();
+            db.close();
+        });
+
+        await it('returns db path for persistent database', async () => {
+            const dbPath = nextDb();
+            const db = new DatabaseSync(dbPath);
+            expect(db.location()).toBe(dbPath);
+            db.close();
+        });
+    });
+
+    await describe('DatabaseSync foreign key constraints', async () => {
+        await it('enables foreign key constraints by default', async () => {
+            const db = new DatabaseSync(nextDb());
+            db.exec(`
+                CREATE TABLE foo (id INTEGER PRIMARY KEY);
+                CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
+            `);
+            expect(() => {
+                db.exec('INSERT INTO bar (foo_id) VALUES (1)');
+            }).toThrow();
+            db.close();
+        });
+
+        await it('allows disabling foreign key constraints', async () => {
+            const db = new DatabaseSync(nextDb(), { enableForeignKeyConstraints: false });
+            db.exec(`
+                CREATE TABLE foo (id INTEGER PRIMARY KEY);
+                CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
+            `);
+            // Should not throw
+            db.exec('INSERT INTO bar (foo_id) VALUES (1)');
+            db.close();
+        });
+    });
+
+    cleanup();
+};