;
+};
+
+function renderContract(c: ContractIR): string {
+ const models = Object.entries(c.models)
+ .map(([name, model]) => {
+ const tableName = model.storage.table;
+ const tableRelations = c.relations[tableName] ?? {};
+
+ const fields = Object.entries(model.fields)
+ .map(([fieldName, field]) => {
+ return `
+
+ ${fieldName}
+ → ${field?.column}
+
+ `;
+ })
+ .join('');
+
+ const relations = Object.entries(tableRelations)
+ .map(([relName, rel]) => {
+ const arrow = rel.cardinality === '1:N' ? '⇉' : '→';
+ return `
+
+ ${arrow} ${relName}
+ ${rel.cardinality} → ${rel.to}
+
+ `;
+ })
+ .join('');
+
+ return `
+
+
+ 🧩 ${name}
+ table: ${tableName}
+
+
+ ${fields}
+ ${relations ? `
${relations}
` : ''}
+
+
+ ${isPk ? '🔑 ' : ''}${colName}
+ ${col.nativeType}
+ ${nullable}
+
+ `;
+ })
+ .join('');
+
+ const fks = (table.foreignKeys ?? [])
+ .map(
+ (fk) =>
+ `→ ${fk.columns.join(', ')}→ ${fk.references.table}(${fk.references.columns.join(', ')})
`,
+ )
+ .join('');
+
+ return `
+
+
+ 📦 ${name}
+ PK: ${pk.join(', ')}
+
+
${columns}${fks}
+
+ Contract Hash:
+ ${c.coreHash}
+
+
+
+
+
+
Capabilities
+
${caps || 'None'}
+
+
Extensions
+
${extensions || 'None'}
+
>(
+ sql: string,
+ _params?: readonly unknown[],
+ ): Promise<{ readonly rows: Row[] }> {
+ const stmt = db.prepare(sql);
+ const returnsRows = stmt.columns().length > 0;
+ if (!returnsRows) {
+ stmt.run();
+ return { rows: [] };
+ }
+ return { rows: stmt.all() as Row[] };
+ },
+ async close(): Promise {
+ db.close();
+ },
+ };
+}
+
+describe('SqliteControlAdapter', () => {
+ it('introspects primary keys as NOT NULL and encodes implicit autoincrement defaults', async () => {
+ const db = new DatabaseSync(':memory:');
+ db.exec(`
+ create table user (
+ id integer primary key,
+ email text not null,
+ createdAt text not null default (CURRENT_TIMESTAMP)
+ );
+ `);
+
+ const driver = createTestDriver(db);
+ const adapter = new SqliteControlAdapter();
+ const schema = await adapter.introspect(driver);
+
+ const user = schema.tables['user'];
+ expect(user).toBeDefined();
+ expect(user?.primaryKey?.columns).toEqual(['id']);
+ expect(user?.columns['id']).toMatchObject({
+ nativeType: 'integer',
+ nullable: false,
+ default: 'autoincrement()',
+ });
+ expect(user?.columns['createdAt']).toMatchObject({
+ nullable: false,
+ default: 'CURRENT_TIMESTAMP',
+ });
+ });
+});
diff --git a/packages/3-targets/6-adapters/sqlite/test/dml.lowering.test.ts b/packages/3-targets/6-adapters/sqlite/test/dml.lowering.test.ts
new file mode 100644
index 0000000000..9259e33dce
--- /dev/null
+++ b/packages/3-targets/6-adapters/sqlite/test/dml.lowering.test.ts
@@ -0,0 +1,113 @@
+import { validateContract } from '@prisma-next/sql-contract-ts/contract';
+import type { DeleteAst, InsertAst, UpdateAst } from '@prisma-next/sql-relational-core/ast';
+import { describe, expect, it } from 'vitest';
+
+import { createSqliteAdapter } from '../src/core/adapter';
+import type { SqliteContract } from '../src/core/types';
+
+const contract = Object.freeze(
+ validateContract({
+ target: 'sqlite',
+ targetFamily: 'sql' as const,
+ coreHash: 'sha256:test-core',
+ profileHash: 'sha256:test-profile',
+ storage: {
+ tables: {
+ user: {
+ columns: {
+ id: { codecId: 'sqlite/int@1', nativeType: 'integer', nullable: false },
+ email: { codecId: 'sqlite/text@1', nativeType: 'text', nullable: false },
+ },
+ primaryKey: { columns: ['id'] },
+ uniques: [],
+ indexes: [],
+ foreignKeys: [],
+ },
+ },
+ },
+ models: {},
+ relations: {},
+ mappings: {},
+ capabilities: {},
+ extensionPacks: {},
+ meta: {},
+ sources: {},
+ }),
+);
+
+describe('SQLite DML lowering', () => {
+ it('lowers INSERT ... RETURNING', () => {
+ const adapter = createSqliteAdapter();
+
+ const ast: InsertAst = {
+ kind: 'insert',
+ table: { kind: 'table', name: 'user' },
+ values: {
+ email: { kind: 'param', index: 1, name: 'email' },
+ },
+ returning: [
+ { kind: 'col', table: 'user', column: 'id' },
+ { kind: 'col', table: 'user', column: 'email' },
+ ],
+ };
+
+ const lowered = adapter.lower(ast, { contract, params: ['a@b.com'] });
+ expect(lowered.body.sql).toBe(
+ 'INSERT INTO "user" ("email") VALUES (?1) RETURNING "user"."id", "user"."email"',
+ );
+ expect(lowered.body.params).toEqual(['a@b.com']);
+ });
+
+ it('lowers UPDATE ... RETURNING', () => {
+ const adapter = createSqliteAdapter();
+
+ const ast: UpdateAst = {
+ kind: 'update',
+ table: { kind: 'table', name: 'user' },
+ set: {
+ email: { kind: 'param', index: 1, name: 'email' },
+ },
+ where: {
+ kind: 'bin',
+ op: 'eq',
+ left: { kind: 'col', table: 'user', column: 'id' },
+ right: { kind: 'param', index: 2, name: 'userId' },
+ },
+ returning: [
+ { kind: 'col', table: 'user', column: 'id' },
+ { kind: 'col', table: 'user', column: 'email' },
+ ],
+ };
+
+ const lowered = adapter.lower(ast, { contract, params: ['new@b.com', 1] });
+ expect(lowered.body.sql).toBe(
+ 'UPDATE "user" SET "email" = ?1 WHERE "user"."id" = ?2 RETURNING "user"."id", "user"."email"',
+ );
+ expect(lowered.body.params).toEqual(['new@b.com', 1]);
+ });
+
+ it('lowers DELETE ... RETURNING', () => {
+ const adapter = createSqliteAdapter();
+
+ const ast: DeleteAst = {
+ kind: 'delete',
+ table: { kind: 'table', name: 'user' },
+ where: {
+ kind: 'bin',
+ op: 'eq',
+ left: { kind: 'col', table: 'user', column: 'id' },
+ right: { kind: 'param', index: 1, name: 'userId' },
+ },
+ returning: [
+ { kind: 'col', table: 'user', column: 'id' },
+ { kind: 'col', table: 'user', column: 'email' },
+ ],
+ };
+
+ const lowered = adapter.lower(ast, { contract, params: [1] });
+ expect(lowered.body.sql).toBe(
+ 'DELETE FROM "user" WHERE "user"."id" = ?1 RETURNING "user"."id", "user"."email"',
+ );
+ expect(lowered.body.params).toEqual([1]);
+ });
+});
diff --git a/packages/3-targets/6-adapters/sqlite/tsconfig.build.json b/packages/3-targets/6-adapters/sqlite/tsconfig.build.json
new file mode 100644
index 0000000000..671541c1a3
--- /dev/null
+++ b/packages/3-targets/6-adapters/sqlite/tsconfig.build.json
@@ -0,0 +1,12 @@
+{
+ "extends": "./tsconfig.json",
+ "compilerOptions": {
+ "rootDir": "src",
+ "outDir": "dist",
+ "declaration": true,
+ "declarationMap": true,
+ "emitDeclarationOnly": true
+ },
+ "include": ["src/**/*.ts"],
+ "exclude": ["test", "dist"]
+}
diff --git a/packages/3-targets/6-adapters/sqlite/tsconfig.json b/packages/3-targets/6-adapters/sqlite/tsconfig.json
new file mode 100644
index 0000000000..7afa587436
--- /dev/null
+++ b/packages/3-targets/6-adapters/sqlite/tsconfig.json
@@ -0,0 +1,9 @@
+{
+ "extends": ["@prisma-next/tsconfig/base"],
+ "compilerOptions": {
+ "rootDir": ".",
+ "outDir": "dist"
+ },
+ "include": ["src/**/*.ts", "test/**/*.ts"],
+ "exclude": ["dist"]
+}
diff --git a/packages/3-targets/6-adapters/sqlite/tsup.config.ts b/packages/3-targets/6-adapters/sqlite/tsup.config.ts
new file mode 100644
index 0000000000..078c165997
--- /dev/null
+++ b/packages/3-targets/6-adapters/sqlite/tsup.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+ entry: {
+ 'exports/adapter': 'src/exports/adapter.ts',
+ 'exports/types': 'src/exports/types.ts',
+ 'exports/codec-types': 'src/exports/codec-types.ts',
+ 'exports/column-types': 'src/exports/column-types.ts',
+ 'exports/control': 'src/exports/control.ts',
+ 'exports/runtime': 'src/exports/runtime.ts',
+ },
+ outDir: 'dist',
+ format: ['esm'],
+ sourcemap: true,
+ dts: false,
+ clean: true,
+ target: 'es2022',
+ minify: false,
+});
diff --git a/packages/3-targets/6-adapters/sqlite/vitest.config.ts b/packages/3-targets/6-adapters/sqlite/vitest.config.ts
new file mode 100644
index 0000000000..ae09da78f5
--- /dev/null
+++ b/packages/3-targets/6-adapters/sqlite/vitest.config.ts
@@ -0,0 +1,32 @@
+import { timeouts } from '@prisma-next/test-utils';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+ test: {
+ globals: true,
+ environment: 'node',
+ testTimeout: timeouts.default,
+ hookTimeout: timeouts.default,
+ coverage: {
+ provider: 'v8',
+ reporter: ['text', 'json', 'html'],
+ include: ['src/**/*.ts'],
+ exclude: [
+ 'dist/**',
+ 'test/**',
+ '**/*.test.ts',
+ '**/*.test-d.ts',
+ '**/*.config.ts',
+ '**/exports/**',
+ '**/types.ts',
+ 'src/core/descriptor-meta.ts',
+ ],
+ thresholds: {
+ lines: 92,
+ branches: 87,
+ functions: 95,
+ statements: 92,
+ },
+ },
+ },
+});
diff --git a/packages/3-targets/7-drivers/sqlite/README.md b/packages/3-targets/7-drivers/sqlite/README.md
new file mode 100644
index 0000000000..a128a03cef
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/README.md
@@ -0,0 +1,101 @@
+# @prisma-next/driver-sqlite
+
+SQLite driver for Prisma Next.
+
+## Package Classification
+
+- **Domain**: targets
+- **Layer**: drivers
+- **Plane**: multi-plane (migration, runtime)
+
+## Overview
+
+The SQLite driver provides transport and connection management for SQLite databases (file-backed). It implements the `SqlDriver` interface for executing SQL statements, explaining queries, and managing connections.
+
+Drivers are transport-agnostic: they own pooling, connection management, and transport protocol (TCP, HTTP, etc.), but contain no dialect-specific logic. All dialect behavior lives in adapters.
+
+This package spans multiple planes:
+- **Migration plane** (`src/exports/control.ts`): Control plane entry point for driver descriptors
+- **Runtime plane** (`src/exports/runtime.ts`): Runtime entry point for driver implementation
+
+## Purpose
+
+Provide SQLite transport and connection management. Execute SQL statements and manage connections without dialect-specific logic.
+
+## Responsibilities
+
+- **Connection Management**: Acquire and release database connections
+- **Statement Execution**: Execute SQL statements with parameters
+- **Query Explanation**: Execute EXPLAIN queries for query analysis
+- **Connection Pooling**: Manage connection pools (when applicable)
+- **Transport**: Open and manage SQLite database handles (file-backed)
+
+**Non-goals:**
+- Dialect-specific SQL lowering (adapters)
+- Query compilation (sql-query)
+- Runtime execution (runtime)
+
+## Architecture
+
+```mermaid
+flowchart TD
+ subgraph "Runtime"
+ RT[Runtime]
+ ADAPTER[Adapter]
+ end
+
+ subgraph "SQLite Driver"
+ DRIVER[Driver]
+ DBFILE[(DB File)]
+ end
+
+ RT --> ADAPTER
+ ADAPTER --> DRIVER
+ DRIVER --> DBFILE
+ DRIVER --> RT
+```
+
+## Components
+
+### Driver (`sqlite-driver.ts`)
+- Main driver implementation
+- Implements `SqlDriver` interface
+- Manages connections and executes statements
+- Manages a SQLite database handle
+
+## Dependencies
+
+- **`@prisma-next/sql-contract`**: SQL contract types (via `@prisma-next/sql-contract/types`)
+
+## Related Subsystems
+
+- **[Adapters & Targets](../../docs/architecture%20docs/subsystems/5.%20Adapters%20&%20Targets.md)**: Driver specification
+
+## Related ADRs
+
+- [ADR 005 - Thin Core Fat Targets](../../docs/architecture%20docs/adrs/ADR%20005%20-%20Thin%20Core%20Fat%20Targets.md)
+- [ADR 016 - Adapter SPI for Lowering](../../docs/architecture%20docs/adrs/ADR%20016%20-%20Adapter%20SPI%20for%20Lowering.md)
+
+## Usage
+
+```typescript
+import { createSqliteDriver } from '@prisma-next/driver-sqlite/runtime';
+import { createRuntime } from '@prisma-next/sql-runtime';
+
+const driver = createSqliteDriver({ connectionString: process.env.DATABASE_URL });
+
+const runtime = createRuntime({
+ contract,
+ adapter: sqliteAdapter,
+ driver,
+});
+```
+
+## Exports
+
+- `./runtime`: Runtime entry point for driver implementation
+ - `createSqliteDriver({ connectionString | filename, ... })`: Convenience creator
+ - `createSqliteDriverFromOptions(options)`: Create driver from a `SqliteDriverOptions` object
+ - Types: `SqliteDriverOptions`, `CreateSqliteDriverOptions`
+- `./control`: Control plane entry point for driver descriptors
+ - Default export: `DriverDescriptor` for use in `prisma-next.config.ts`
diff --git a/packages/3-targets/7-drivers/sqlite/biome.jsonc b/packages/3-targets/7-drivers/sqlite/biome.jsonc
new file mode 100644
index 0000000000..b8994a7330
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/biome.jsonc
@@ -0,0 +1,4 @@
+{
+ "$schema": "https://biomejs.dev/schemas/2.3.11/schema.json",
+ "extends": "//"
+}
diff --git a/packages/3-targets/7-drivers/sqlite/package.json b/packages/3-targets/7-drivers/sqlite/package.json
new file mode 100644
index 0000000000..02d1f3fd07
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/package.json
@@ -0,0 +1,48 @@
+{
+ "name": "@prisma-next/driver-sqlite",
+ "version": "0.0.1",
+ "type": "module",
+ "sideEffects": false,
+ "scripts": {
+ "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+ "test": "vitest run",
+ "test:coverage": "vitest run --coverage",
+ "typecheck": "tsc --project tsconfig.json --noEmit",
+ "lint": "biome check . --error-on-warnings",
+ "lint:fix": "biome check --write .",
+ "lint:fix:unsafe": "biome check --write --unsafe .",
+ "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
+ },
+ "dependencies": {
+ "@prisma-next/contract": "workspace:*",
+ "@prisma-next/core-control-plane": "workspace:*",
+ "@prisma-next/core-execution-plane": "workspace:*",
+ "@prisma-next/sql-contract": "workspace:*",
+ "@prisma-next/sql-errors": "workspace:*",
+ "@prisma-next/sql-operations": "workspace:*",
+ "@prisma-next/sql-relational-core": "workspace:*",
+ "@prisma-next/utils": "workspace:*",
+ "arktype": "^2.0.0"
+ },
+ "devDependencies": {
+ "@prisma-next/test-utils": "workspace:*",
+ "@prisma-next/tsconfig": "workspace:*",
+ "tsup": "catalog:",
+ "typescript": "catalog:",
+ "vitest": "catalog:"
+ },
+ "files": [
+ "dist",
+ "src"
+ ],
+ "exports": {
+ "./control": {
+ "types": "./dist/exports/control.d.ts",
+ "import": "./dist/exports/control.js"
+ },
+ "./runtime": {
+ "types": "./dist/exports/runtime.d.ts",
+ "import": "./dist/exports/runtime.js"
+ }
+ }
+}
diff --git a/packages/3-targets/7-drivers/sqlite/src/bun-sqlite.ts b/packages/3-targets/7-drivers/sqlite/src/bun-sqlite.ts
new file mode 100644
index 0000000000..970968382f
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/bun-sqlite.ts
@@ -0,0 +1,53 @@
+import { createRequire } from 'node:module';
+
+// Keep this in a helper module so we have a single place to dynamically load bun:sqlite.
+//
+// This package is built for Node (tsup/esbuild) and must not have a static dependency on
+// `bun:sqlite` (which Node cannot resolve). We therefore load it via `require()` with a
+// runtime-built specifier, similar to the `node:sqlite` workaround in node-sqlite.ts.
+
+type BunSqliteModule = {
+ readonly Database: new (filename: string, options?: Record) => BunDatabase;
+};
+
+export type BunStatement = {
+ readonly columnNames: readonly string[];
+ all: (...params: unknown[]) => unknown[];
+ iterate: (...params: unknown[]) => Iterable;
+ run: (...params: unknown[]) => { readonly changes: number; readonly lastInsertRowid: number };
+ get: (...params: unknown[]) => unknown;
+};
+
+export type BunDatabase = {
+ prepare: (sql: string) => BunStatement;
+ exec: (sql: string) => void;
+ close: () => void;
+};
+
+const require = createRequire(import.meta.url);
+
+function loadBunSqlite(): BunSqliteModule {
+ // Avoid a literal `bun:sqlite` string to reduce the chance of build-time rewriting.
+ const bun = String.fromCharCode(98, 117, 110); // "bun"
+ const sqlite = String.fromCharCode(115, 113, 108, 105, 116, 101); // "sqlite"
+ return require(`${bun}:${sqlite}`) as BunSqliteModule;
+}
+
+export type BunDatabaseOptions = {
+ readonly readonly?: boolean;
+ readonly create?: boolean;
+ readonly readwrite?: boolean;
+};
+
+export function createBunDatabase(filename: string, options?: BunDatabaseOptions): BunDatabase {
+ const { Database } = loadBunSqlite();
+ // Bun requires specifying a mode when passing options. Default to readwrite.
+ const open = options
+ ? Object.freeze({
+ readwrite: options.readwrite ?? !options.readonly,
+ readonly: options.readonly ?? false,
+ create: options.create ?? true,
+ })
+ : undefined;
+ return (open ? new Database(filename, open) : new Database(filename)) as BunDatabase;
+}
diff --git a/packages/3-targets/7-drivers/sqlite/src/core/descriptor-meta.ts b/packages/3-targets/7-drivers/sqlite/src/core/descriptor-meta.ts
new file mode 100644
index 0000000000..37440a5cf3
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/core/descriptor-meta.ts
@@ -0,0 +1,8 @@
+export const sqliteDriverDescriptorMeta = {
+ kind: 'driver',
+ familyId: 'sql',
+ targetId: 'sqlite',
+ id: 'sqlite',
+ version: '0.0.1',
+ capabilities: {},
+} as const;
diff --git a/packages/3-targets/7-drivers/sqlite/src/exports/control.ts b/packages/3-targets/7-drivers/sqlite/src/exports/control.ts
new file mode 100644
index 0000000000..ba62d52288
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/exports/control.ts
@@ -0,0 +1,202 @@
+import { errorRuntime } from '@prisma-next/core-control-plane/errors';
+import type {
+ ControlDriverDescriptor,
+ ControlDriverInstance,
+} from '@prisma-next/core-control-plane/types';
+import { SqlQueryError } from '@prisma-next/sql-errors';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';
+import type { BunDatabase } from '../bun-sqlite';
+import { createBunDatabase } from '../bun-sqlite';
+import { sqliteDriverDescriptorMeta } from '../core/descriptor-meta';
+import type { DatabaseSync } from '../node-sqlite';
+import { createDatabaseSync } from '../node-sqlite';
+import { normalizeSqliteError } from '../normalize-error';
+import { resolveSqliteFilename } from '../resolve-filename';
+
+type SqliteEngine = 'node' | 'bun';
+type SqliteDatabase = DatabaseSync | BunDatabase;
+
+function isBunRuntime(): boolean {
+ const bun = (globalThis as { Bun?: unknown }).Bun;
+ return typeof bun === 'object' && bun !== null;
+}
+
+function parseVersion(version: string): readonly [number, number, number] {
+ const [major, minor, patch] = version.split('.', 3).map((s) => Number.parseInt(s ?? '0', 10));
+ return Object.freeze([major || 0, minor || 0, patch || 0]);
+}
+
+function isVersionGte(
+ a: readonly [number, number, number],
+ b: readonly [number, number, number],
+): boolean {
+ const [amaj, amin, apat] = a;
+ const [bmaj, bmin, bpat] = b;
+
+ if (amaj !== bmaj) {
+ return amaj > bmaj;
+ }
+ if (amin !== bmin) {
+ return amin > bmin;
+ }
+ return apat >= bpat;
+}
+
+function ensureMinimumSqlite(db: SqliteDatabase): void {
+ try {
+ const row = db.prepare('select sqlite_version() as v').get() as
+ | { readonly v?: unknown }
+ | undefined;
+ const version = typeof row?.v === 'string' ? row.v : String(row?.v ?? '');
+ const parsed = parseVersion(version);
+ const required = Object.freeze([3, 38, 0] as const);
+ if (!isVersionGte(parsed, required)) {
+ throw new Error(`SQLite ${required.join('.')}+ is required (detected ${version})`);
+ }
+
+ // JSON1 is required for includeMany lowering + sqlite-vector.
+ db.prepare("select json_object('a', 1) as j").get();
+ db.prepare(
+ 'select json_group_array(value) as a from (select 1 as value union all select 2 as value)',
+ ).get();
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+}
+
+function toNumericBindings(params?: readonly unknown[]): Record | undefined {
+ if (!params || params.length === 0) {
+ return undefined;
+ }
+ const bindings: Record = {};
+ for (let i = 0; i < params.length; i++) {
+ bindings[String(i + 1)] = params[i];
+ }
+ return bindings;
+}
+
+function normalizeSqlitePlaceholders(sql: string): string {
+ // Prisma Next raw lane emits $1, $2, ... placeholders. SQLite uses ?1, ?2, ...
+ return sql.replace(/\$(\d+)/g, '?$1');
+}
+
+type StatementRunResult = {
+ readonly changes: number | bigint;
+ readonly lastInsertRowid?: number | bigint;
+};
+
+type StatementLike = {
+ all: (...params: unknown[]) => unknown[];
+ run: (...params: unknown[]) => StatementRunResult;
+} & ({ columns: () => readonly unknown[] } | { readonly columnNames: readonly string[] });
+
+function statementReturnsRows(stmt: StatementLike): boolean {
+ return 'columns' in stmt ? stmt.columns().length > 0 : stmt.columnNames.length > 0;
+}
+
+/**
+ * SQLite control driver instance for control-plane operations.
+ * Implements ControlDriverInstance<'sql', 'sqlite'> for database queries.
+ */
+export class SqliteControlDriver implements ControlDriverInstance<'sql', 'sqlite'> {
+ readonly familyId = 'sql' as const;
+ readonly targetId = 'sqlite' as const;
+ /**
+ * @deprecated Use targetId instead
+ */
+ readonly target = 'sqlite' as const;
+
+ constructor(
+ private readonly engine: SqliteEngine,
+ private readonly db: SqliteDatabase,
+ ) {}
+
+ async query>(
+ sql: string,
+ params?: readonly unknown[],
+ ): Promise<{ readonly rows: Row[] }> {
+ try {
+ const normalizedSql = normalizeSqlitePlaceholders(sql);
+ const stmt = this.db.prepare(normalizedSql) as StatementLike;
+ const usesNumericPlaceholders = /\?\d/.test(normalizedSql);
+ const bindings =
+ this.engine === 'node' && usesNumericPlaceholders ? toNumericBindings(params) : undefined;
+ const returnsRows = statementReturnsRows(stmt);
+
+ if (!returnsRows) {
+ if (this.engine === 'node' && usesNumericPlaceholders) {
+ bindings ? stmt.run(bindings) : stmt.run();
+ return { rows: [] };
+ }
+
+ if (params && params.length > 0) {
+ stmt.run(...params);
+ return { rows: [] };
+ }
+
+ stmt.run();
+ return { rows: [] };
+ }
+
+ const rows = (
+ this.engine === 'node' && usesNumericPlaceholders
+ ? bindings
+ ? stmt.all(bindings)
+ : stmt.all()
+ : params && params.length > 0
+ ? stmt.all(...params)
+ : stmt.all()
+ ) as Row[];
+ return { rows };
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ async close(): Promise {
+ this.db.close();
+ }
+}
+
+/**
+ * SQLite driver descriptor for CLI config.
+ */
+const sqliteDriverDescriptor: ControlDriverDescriptor<'sql', 'sqlite', SqliteControlDriver> = {
+ ...sqliteDriverDescriptorMeta,
+ async create(url: string): Promise {
+ const filename = resolveSqliteFilename(url);
+
+ try {
+ const engine: SqliteEngine = isBunRuntime() ? 'bun' : 'node';
+ const db: SqliteDatabase =
+ engine === 'node' ? createDatabaseSync(filename) : createBunDatabase(filename);
+ // Default safety: enforce FK constraints unless explicitly disabled by app.
+ db.exec('PRAGMA foreign_keys = ON');
+ ensureMinimumSqlite(db);
+ return new SqliteControlDriver(engine, db);
+ } catch (error) {
+ const normalized = normalizeSqliteError(error);
+ const redacted = redactDatabaseUrl(url);
+
+ const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : undefined;
+ const code =
+ codeFromSqlState ??
+ ('cause' in normalized && normalized.cause
+ ? ((normalized.cause as { code?: unknown }).code as string | undefined)
+ : undefined);
+
+ throw errorRuntime('Database connection failed', {
+ why: normalized.message,
+ fix: 'Verify the sqlite file path (prefer a file: URL), ensure the directory exists, and confirm file permissions',
+ meta: {
+ ...ifDefined('code', code),
+ ...redacted,
+ ...(!Object.keys(redacted).length ? { filename } : {}),
+ },
+ });
+ }
+ },
+};
+
+export default sqliteDriverDescriptor;
diff --git a/packages/3-targets/7-drivers/sqlite/src/exports/runtime.ts b/packages/3-targets/7-drivers/sqlite/src/exports/runtime.ts
new file mode 100644
index 0000000000..ee9a250df2
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/exports/runtime.ts
@@ -0,0 +1,30 @@
+import type {
+ RuntimeDriverDescriptor,
+ RuntimeDriverInstance,
+} from '@prisma-next/core-execution-plane/types';
+import type { SqlDriver } from '@prisma-next/sql-relational-core/ast';
+import { sqliteDriverDescriptorMeta } from '../core/descriptor-meta';
+import type { SqliteDriverOptions } from '../sqlite-driver';
+import { createSqliteDriverFromOptions } from '../sqlite-driver';
+
+/**
+ * SQLite runtime driver instance interface.
+ * SqlDriver provides SQL-specific methods (execute, explain, close).
+ * RuntimeDriverInstance provides target identification (familyId, targetId).
+ */
+export type SqliteRuntimeDriver = RuntimeDriverInstance<'sql', 'sqlite'> & SqlDriver;
+
+/**
+ * SQLite driver descriptor for runtime plane.
+ */
+const sqliteRuntimeDriverDescriptor: RuntimeDriverDescriptor<'sql', 'sqlite', SqliteRuntimeDriver> =
+ {
+ ...sqliteDriverDescriptorMeta,
+ create(options: SqliteDriverOptions): SqliteRuntimeDriver {
+ return createSqliteDriverFromOptions(options) as SqliteRuntimeDriver;
+ },
+ };
+
+export default sqliteRuntimeDriverDescriptor;
+export type { CreateSqliteDriverOptions, SqliteDriverOptions } from '../sqlite-driver';
+export { createSqliteDriver, createSqliteDriverFromOptions } from '../sqlite-driver';
diff --git a/packages/3-targets/7-drivers/sqlite/src/node-sqlite.ts b/packages/3-targets/7-drivers/sqlite/src/node-sqlite.ts
new file mode 100644
index 0000000000..fb9dd26dcb
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/node-sqlite.ts
@@ -0,0 +1,31 @@
+import type { PathLike } from 'node:fs';
+import { createRequire } from 'node:module';
+
+// Keep this in a helper module so we have a single place to work around bundler behavior.
+//
+// esbuild (used by tsup) strips the `node:` prefix from builtin imports. For `node:sqlite`
+// that produces `sqlite`, which Node does NOT treat as a builtin module specifier.
+//
+// To avoid that rewrite, we load the module via `require()` with a runtime-built specifier.
+
+type NodeSqliteModule = typeof import('node:sqlite');
+
+export type DatabaseSync = import('node:sqlite').DatabaseSync;
+export type DatabaseSyncOptions = import('node:sqlite').DatabaseSyncOptions;
+
+const require = createRequire(import.meta.url);
+
+function loadNodeSqlite(): NodeSqliteModule {
+ // Avoid a literal `node:sqlite` string to prevent build-time rewriting.
+ const name = String.fromCharCode(115, 113, 108, 105, 116, 101); // "sqlite"
+ return require(`node:${name}`) as NodeSqliteModule;
+}
+
+export function createDatabaseSync(path: PathLike, options?: DatabaseSyncOptions): DatabaseSync {
+ const { DatabaseSync: DatabaseSyncCtor } = loadNodeSqlite();
+ // node:sqlite is strict about the constructor arity. Passing `undefined` as the 2nd
+ // argument throws; omit it when unset.
+ return (
+ options === undefined ? new DatabaseSyncCtor(path) : new DatabaseSyncCtor(path, options)
+ ) as DatabaseSync;
+}
diff --git a/packages/3-targets/7-drivers/sqlite/src/normalize-error.ts b/packages/3-targets/7-drivers/sqlite/src/normalize-error.ts
new file mode 100644
index 0000000000..5cc64473f5
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/normalize-error.ts
@@ -0,0 +1,87 @@
+import { SqlConnectionError, SqlQueryError } from '@prisma-next/sql-errors';
+
+interface NodeSqliteError extends Error {
+ readonly code: string;
+ readonly errcode: number;
+ readonly errstr?: string;
+}
+
+interface BunSqliteError extends Error {
+ readonly errno: number;
+ readonly byteOffset?: number;
+}
+
+function isNodeSqliteError(error: unknown): error is NodeSqliteError {
+ if (!(error instanceof Error)) {
+ return false;
+ }
+ const record = error as Record;
+ return (
+ typeof record.code === 'string' &&
+ record.code === 'ERR_SQLITE_ERROR' &&
+ typeof record.errcode === 'number'
+ );
+}
+
+function isBunSqliteError(error: unknown): error is BunSqliteError {
+ if (!(error instanceof Error)) {
+ return false;
+ }
+ if (error.name !== 'SQLiteError') {
+ return false;
+ }
+ const record = error as Record;
+ return typeof record.errno === 'number';
+}
+
+function isConnectionErrcode(errcode: number): boolean {
+ // SQLite primary error codes, see sqlite3.h:
+ // 14: SQLITE_CANTOPEN
+ // 26: SQLITE_NOTADB
+ // 10: SQLITE_IOERR
+ // 23: SQLITE_AUTH
+ // 13: SQLITE_FULL
+ // 8: SQLITE_READONLY
+ return (
+ errcode === 14 ||
+ errcode === 26 ||
+ errcode === 10 ||
+ errcode === 23 ||
+ errcode === 13 ||
+ errcode === 8
+ );
+}
+
+function isTransientErrcode(errcode: number): boolean {
+ // 5: SQLITE_BUSY, 6: SQLITE_LOCKED, 10: SQLITE_IOERR
+ // Note: node:sqlite returns extended errcodes as well (e.g. 2067 for UNIQUE constraint).
+ return errcode === 5 || errcode === 6 || errcode === 10;
+}
+
+export function normalizeSqliteError(error: unknown): SqlQueryError | SqlConnectionError | Error {
+ if (!(error instanceof Error)) {
+ return new Error(String(error));
+ }
+
+ const errcode = isNodeSqliteError(error)
+ ? error.errcode
+ : isBunSqliteError(error)
+ ? error.errno
+ : undefined;
+ if (errcode === undefined) {
+ return error;
+ }
+ const sqlState = `SQLITE_${errcode}`;
+
+ if (isConnectionErrcode(errcode)) {
+ return new SqlConnectionError(error.message, {
+ cause: error,
+ transient: isTransientErrcode(errcode),
+ });
+ }
+
+ return new SqlQueryError(error.message, {
+ cause: error,
+ sqlState,
+ });
+}
diff --git a/packages/3-targets/7-drivers/sqlite/src/resolve-filename.ts b/packages/3-targets/7-drivers/sqlite/src/resolve-filename.ts
new file mode 100644
index 0000000000..32b7806915
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/resolve-filename.ts
@@ -0,0 +1,32 @@
+import { resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Resolve SQLite "connection strings" to a filename.
+ *
+ * Supports:
+ * - Absolute/relative paths (returned as-is / resolved by callers when desired)
+ * - Standard file URLs: file:///absolute/path.db
+ * - Prisma-style file URLs: file:./dev.db (resolved relative to process.cwd())
+ */
+export function resolveSqliteFilename(urlOrPath: string): string {
+ if (!urlOrPath.startsWith('file:')) {
+ return urlOrPath;
+ }
+
+ // Standard file URLs (file:///...) should be handled by the URL parser.
+ if (urlOrPath.startsWith('file://')) {
+ return fileURLToPath(new URL(urlOrPath));
+ }
+
+ // Prisma-style: file:./dev.db or file:../dev.db. The URL constructor incorrectly
+ // normalizes these to file:///dev.db, so we treat them as "file:" + path.
+ const rest = urlOrPath.slice('file:'.length);
+ const pathPart = rest.split('?', 1)[0] ?? rest;
+ if (pathPart === ':memory:') {
+ return ':memory:';
+ }
+
+ // Resolve relative paths from the current working directory.
+ return resolvePath(process.cwd(), decodeURIComponent(pathPart));
+}
diff --git a/packages/3-targets/7-drivers/sqlite/src/sqlite-driver.ts b/packages/3-targets/7-drivers/sqlite/src/sqlite-driver.ts
new file mode 100644
index 0000000000..b30094310d
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/src/sqlite-driver.ts
@@ -0,0 +1,537 @@
+import { existsSync } from 'node:fs';
+import type {
+ SqlConnection,
+ SqlDriver,
+ SqlExecuteRequest,
+ SqlExplainResult,
+ SqlQueryable,
+ SqlQueryResult,
+ SqlTransaction,
+} from '@prisma-next/sql-relational-core/ast';
+import type { BunDatabase } from './bun-sqlite';
+import { createBunDatabase } from './bun-sqlite';
+import type { DatabaseSync } from './node-sqlite';
+import { createDatabaseSync } from './node-sqlite';
+import { normalizeSqliteError } from './normalize-error';
+import { resolveSqliteFilename } from './resolve-filename';
+
+export type SqliteEngine = 'node' | 'bun';
+export type SqliteEngineMode = SqliteEngine | 'auto';
+
+export type SqliteConnectOptions = {
+ readonly readonly?: boolean;
+ readonly fileMustExist?: boolean;
+ readonly timeoutMs?: number;
+};
+
+type SqliteUserFunction = { bivarianceHack(...args: unknown[]): unknown }['bivarianceHack'];
+
+export interface SqliteDriverOptions {
+ /**
+ * Driver backend implementation.
+ *
+ * - `auto` (default): use bun:sqlite when running under Bun, otherwise node:sqlite.
+ * - `node`: force node:sqlite (Node runtime only)
+ * - `bun`: force bun:sqlite (Bun runtime only)
+ */
+ readonly engine?: SqliteEngineMode | undefined;
+ readonly connect:
+ | {
+ readonly filename: string;
+ readonly options?: SqliteConnectOptions | undefined;
+ }
+ | {
+ /**
+ * Alias for filename that matches other drivers/configs.
+ * Supports `file:` URLs (including Prisma-style `file:./dev.db`).
+ */
+ readonly connectionString: string;
+ readonly options?: SqliteConnectOptions | undefined;
+ }
+ | { readonly database: DatabaseSync };
+ /**
+ * Pragmas to apply when opening the connection (e.g., foreign_keys, journal_mode).
+ *
+ * Note: Keep this minimal; policy/production tuning belongs in app config.
+ */
+ readonly pragmas?: Record | undefined;
+ /**
+ * Optional user-defined functions to register on the connection.
+ *
+ * This is intentionally generic: callers can use it for extension packs or app-specific helpers.
+ */
+ readonly functions?: Record | undefined;
+}
+
+export interface CreateSqliteDriverOptions {
+ /**
+ * Back-compat convenience option. Prefer `connectionString`.
+ *
+ * Accepts either a filesystem path or a `file:` connection string.
+ */
+ readonly filename?: string;
+ /**
+ * Accepts either a filesystem path or a `file:` connection string.
+ */
+ readonly connectionString?: string;
+ readonly engine?: SqliteDriverOptions['engine'];
+ readonly options?: SqliteConnectOptions | undefined;
+ readonly pragmas?: SqliteDriverOptions['pragmas'];
+ readonly functions?: SqliteDriverOptions['functions'];
+}
+
+type SqliteDatabase = DatabaseSync | BunDatabase;
+type ConnectionOptions = {
+ readonly owned: boolean;
+ readonly engine: SqliteEngine;
+ readonly db: SqliteDatabase;
+};
+
+function normalizeSqlitePlaceholders(sql: string): string {
+ // Prisma Next raw lane emits $1, $2, ... placeholders. SQLite uses ?1, ?2, ...
+ return sql.replace(/\$(\d+)/g, '?$1');
+}
+
+function isBunRuntime(): boolean {
+ const bun = (globalThis as { Bun?: unknown }).Bun;
+ return typeof bun === 'object' && bun !== null;
+}
+
+function resolveEngine(mode: SqliteEngineMode | undefined): SqliteEngine {
+ if (mode && mode !== 'auto') {
+ if (mode === 'bun' && !isBunRuntime()) {
+ throw new Error('SqliteDriverOptions.engine is "bun" but this runtime is not Bun');
+ }
+ return mode;
+ }
+
+ return isBunRuntime() ? 'bun' : 'node';
+}
+
+function inferEngineFromDatabase(db: SqliteDatabase): SqliteEngine {
+ // node:sqlite exposes db.function(). bun:sqlite does not.
+ const record = db as { readonly function?: unknown };
+ return typeof record.function === 'function' ? 'node' : 'bun';
+}
+
+function parseVersion(version: string): readonly [number, number, number] {
+ const [major, minor, patch] = version.split('.', 3).map((s) => Number.parseInt(s ?? '0', 10));
+ return Object.freeze([major || 0, minor || 0, patch || 0]);
+}
+
+function isVersionGte(
+ a: readonly [number, number, number],
+ b: readonly [number, number, number],
+): boolean {
+ const [amaj, amin, apat] = a;
+ const [bmaj, bmin, bpat] = b;
+
+ if (amaj !== bmaj) {
+ return amaj > bmaj;
+ }
+ if (amin !== bmin) {
+ return amin > bmin;
+ }
+ return apat >= bpat;
+}
+
+function ensureMinimumSqlite(db: SqliteDatabase): void {
+ try {
+ const row = db.prepare('select sqlite_version() as v').get() as
+ | { readonly v?: unknown }
+ | undefined;
+ const version = typeof row?.v === 'string' ? row.v : String(row?.v ?? '');
+ const parsed = parseVersion(version);
+ const required = Object.freeze([3, 38, 0] as const);
+ if (!isVersionGte(parsed, required)) {
+ throw new Error(`SQLite ${required.join('.')}+ is required (detected ${version})`);
+ }
+
+ // JSON1 is required for includeMany lowering + sqlite-vector.
+ db.prepare("select json_object('a', 1) as j").get();
+ db.prepare(
+ 'select json_group_array(value) as a from (select 1 as value union all select 2 as value)',
+ ).get();
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+}
+
+type StatementRunResult = {
+ readonly changes: number | bigint;
+ readonly lastInsertRowid?: number | bigint;
+};
+
+type StatementLike = {
+ all: (...params: unknown[]) => unknown[];
+ iterate: (...params: unknown[]) => Iterable;
+ run: (...params: unknown[]) => StatementRunResult;
+ get: (...params: unknown[]) => unknown;
+} & ({ columns: () => readonly unknown[] } | { readonly columnNames: readonly string[] });
+
+function statementReturnsRows(stmt: StatementLike): boolean {
+ return 'columns' in stmt ? stmt.columns().length > 0 : stmt.columnNames.length > 0;
+}
+
+abstract class SqliteQueryable implements SqlQueryable {
+ protected abstract getDb(): SqliteDatabase;
+ protected abstract getEngine(): SqliteEngine;
+
+ async *execute>(request: SqlExecuteRequest): AsyncIterable {
+ const db = this.getDb();
+ const engine = this.getEngine();
+ const sql = normalizeSqlitePlaceholders(request.sql);
+ const usesNumericPlaceholders = /\?\d/.test(sql);
+ const params = request.params;
+ const bindings =
+ engine === 'node' && usesNumericPlaceholders ? toNumericBindings(params) : undefined;
+
+ try {
+ const stmt = db.prepare(sql) as StatementLike;
+ const returnsRows = statementReturnsRows(stmt);
+
+ if (returnsRows) {
+ const iterator =
+ engine === 'node' && usesNumericPlaceholders
+ ? bindings
+ ? stmt.iterate(bindings)
+ : stmt.iterate()
+ : params && params.length > 0
+ ? stmt.iterate(...params)
+ : stmt.iterate();
+ for (const row of iterator) {
+ yield row as Row;
+ }
+ return;
+ }
+
+ if (engine === 'node' && usesNumericPlaceholders) {
+ bindings ? stmt.run(bindings) : stmt.run();
+ return;
+ }
+
+ if (params && params.length > 0) {
+ stmt.run(...params);
+ return;
+ }
+
+ stmt.run();
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ async explain(requestOrSql: SqlExecuteRequest): Promise;
+ async explain(sql: string, params?: readonly unknown[]): Promise;
+ async explain(
+ requestOrSql: SqlExecuteRequest | string,
+ params?: readonly unknown[],
+ ): Promise {
+ const request: SqlExecuteRequest =
+ typeof requestOrSql === 'string'
+ ? params
+ ? { sql: requestOrSql, params }
+ : { sql: requestOrSql }
+ : requestOrSql;
+
+ const db = this.getDb();
+ const engine = this.getEngine();
+ const sql = normalizeSqlitePlaceholders(request.sql);
+ const usesNumericPlaceholders = /\?\d/.test(sql);
+ const requestParams = request.params;
+ const bindings =
+ engine === 'node' && usesNumericPlaceholders ? toNumericBindings(requestParams) : undefined;
+
+ try {
+ const stmt = db.prepare(`EXPLAIN QUERY PLAN ${sql}`) as StatementLike;
+ const rows = (
+ engine === 'node' && usesNumericPlaceholders
+ ? bindings
+ ? stmt.all(bindings)
+ : stmt.all()
+ : requestParams && requestParams.length > 0
+ ? stmt.all(...requestParams)
+ : stmt.all()
+ ) as Array>;
+ return { rows };
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ async query>(
+ sql: string,
+ params?: readonly unknown[],
+ ): Promise> {
+ const db = this.getDb();
+ const engine = this.getEngine();
+ const normalizedSql = normalizeSqlitePlaceholders(sql);
+ const usesNumericPlaceholders = /\?\d/.test(normalizedSql);
+ const bindings =
+ engine === 'node' && usesNumericPlaceholders ? toNumericBindings(params) : undefined;
+
+ try {
+ const stmt = db.prepare(normalizedSql) as StatementLike;
+ const returnsRows = statementReturnsRows(stmt);
+
+ if (returnsRows) {
+ const rows = (
+ engine === 'node' && usesNumericPlaceholders
+ ? bindings
+ ? stmt.all(bindings)
+ : stmt.all()
+ : params && params.length > 0
+ ? stmt.all(...params)
+ : stmt.all()
+ ) as Row[];
+ return { rows, rowCount: rows.length };
+ }
+
+ const result =
+ engine === 'node' && usesNumericPlaceholders
+ ? bindings
+ ? stmt.run(bindings)
+ : stmt.run()
+ : params && params.length > 0
+ ? stmt.run(...params)
+ : stmt.run();
+ return {
+ rows: [],
+ rowCount: typeof result.changes === 'bigint' ? Number(result.changes) : result.changes,
+ lastInsertRowid:
+ typeof result.lastInsertRowid === 'bigint'
+ ? Number(result.lastInsertRowid)
+ : result.lastInsertRowid,
+ };
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+}
+
+class SqliteConnectionImpl extends SqliteQueryable implements SqlConnection {
+ constructor(
+ private readonly engine: SqliteEngine,
+ private readonly db: SqliteDatabase,
+ ) {
+ super();
+ }
+
+ protected getDb(): SqliteDatabase {
+ return this.db;
+ }
+
+ protected getEngine(): SqliteEngine {
+ return this.engine;
+ }
+
+ async beginTransaction(): Promise {
+ try {
+ // Use IMMEDIATE to acquire a write lock early (single writer).
+ this.db.exec('BEGIN IMMEDIATE');
+ return new SqliteTransactionImpl(this.engine, this.db);
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ async release(): Promise {
+ // Single-connection driver; no-op.
+ }
+}
+
+class SqliteTransactionImpl extends SqliteQueryable implements SqlTransaction {
+ constructor(
+ private readonly engine: SqliteEngine,
+ private readonly db: SqliteDatabase,
+ ) {
+ super();
+ }
+
+ protected getDb(): SqliteDatabase {
+ return this.db;
+ }
+
+ protected getEngine(): SqliteEngine {
+ return this.engine;
+ }
+
+ async commit(): Promise {
+ try {
+ this.db.exec('COMMIT');
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ async rollback(): Promise {
+ try {
+ this.db.exec('ROLLBACK');
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+}
+
+class SqliteDriverImpl extends SqliteQueryable implements SqlDriver {
+ constructor(private readonly conn: ConnectionOptions) {
+ super();
+ }
+
+ protected getDb(): SqliteDatabase {
+ return this.conn.db;
+ }
+
+ protected getEngine(): SqliteEngine {
+ return this.conn.engine;
+ }
+
+ async connect(): Promise {
+ // No-op: connection is established at construction time.
+ }
+
+ async acquireConnection(): Promise {
+ return new SqliteConnectionImpl(this.conn.engine, this.conn.db);
+ }
+
+ async close(): Promise {
+ if (this.conn.owned) {
+ this.conn.db.close();
+ }
+ }
+}
+
+function applyPragmas(db: SqliteDatabase, pragmas: SqliteDriverOptions['pragmas']): void {
+ if (!pragmas) {
+ return;
+ }
+
+ for (const [key, value] of Object.entries(pragmas)) {
+ if (value === undefined) {
+ continue;
+ }
+
+ const normalized =
+ value === null
+ ? 'NULL'
+ : typeof value === 'boolean'
+ ? value
+ ? 'ON'
+ : 'OFF'
+ : typeof value === 'number'
+ ? String(value)
+ : `'${String(value).replace(/'/g, "''")}'`;
+
+ db.exec(`PRAGMA ${key} = ${normalized}`);
+ }
+}
+
+function registerFunctions(
+ engine: SqliteEngine,
+ db: SqliteDatabase,
+ functions: SqliteDriverOptions['functions'],
+): void {
+ if (!functions) {
+ return;
+ }
+
+ if (engine !== 'node') {
+ throw new Error('SQLite driver functions are only supported on the node:sqlite backend');
+ }
+
+ for (const [name, fn] of Object.entries(functions)) {
+ (db as DatabaseSync).function(name, fn);
+ }
+}
+
+function toNumericBindings(params?: readonly unknown[]): Record | undefined {
+ if (!params || params.length === 0) {
+ return undefined;
+ }
+ const bindings: Record = {};
+ for (let i = 0; i < params.length; i++) {
+ bindings[String(i + 1)] = params[i];
+ }
+ return bindings;
+}
+
+export function createSqliteDriverFromOptions(options: SqliteDriverOptions): SqlDriver {
+ if ('database' in options.connect) {
+ const inferred = inferEngineFromDatabase(options.connect.database);
+ if (options.engine && options.engine !== 'auto' && options.engine !== inferred) {
+ throw new Error(
+ `SqliteDriverOptions.engine is "${options.engine}" but the provided database handle looks like "${inferred}"`,
+ );
+ }
+ const engine = inferred;
+ try {
+ applyPragmas(options.connect.database, options.pragmas);
+ registerFunctions(engine, options.connect.database, options.functions);
+ ensureMinimumSqlite(options.connect.database);
+ return Object.freeze(
+ new SqliteDriverImpl({ owned: false, engine, db: options.connect.database }),
+ );
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+ }
+
+ const engine = resolveEngine(options.engine);
+ const connectionString =
+ 'connectionString' in options.connect
+ ? options.connect.connectionString
+ : options.connect.filename;
+ const filename = resolveSqliteFilename(connectionString);
+ if (options.connect.options?.fileMustExist && filename !== ':memory:' && !existsSync(filename)) {
+ // Mirror sqlite open errors as closely as we can for nicer envelopes.
+ const error = new Error(`SQLite database file does not exist: ${filename}`);
+ (error as { code?: string }).code = 'ERR_SQLITE_ERROR';
+ (error as { errcode?: number }).errcode = 14; // SQLITE_CANTOPEN
+ throw normalizeSqliteError(error);
+ }
+
+ try {
+ const db =
+ engine === 'node'
+ ? createDatabaseSync(filename, {
+ readOnly: options.connect.options?.readonly ?? false,
+ timeout: options.connect.options?.timeoutMs,
+ })
+ : createBunDatabase(filename, {
+ readonly: options.connect.options?.readonly ?? false,
+ readwrite: !(options.connect.options?.readonly ?? false),
+ create: !(options.connect.options?.fileMustExist ?? false),
+ });
+
+ // Default safety: enforce FK constraints unless explicitly disabled.
+ applyPragmas(
+ db,
+ Object.freeze({
+ foreign_keys: 'ON',
+ ...(options.connect.options?.timeoutMs
+ ? { busy_timeout: options.connect.options.timeoutMs }
+ : {}),
+ ...options.pragmas,
+ }),
+ );
+ registerFunctions(engine, db, options.functions);
+ ensureMinimumSqlite(db);
+
+ return Object.freeze(new SqliteDriverImpl({ owned: true, engine, db }));
+ } catch (error) {
+ throw normalizeSqliteError(error);
+ }
+}
+
+export function createSqliteDriver(options: CreateSqliteDriverOptions): SqlDriver {
+ const connectionString = options.connectionString ?? options.filename;
+ if (!connectionString) {
+ throw new Error('createSqliteDriver requires connectionString or filename');
+ }
+ return createSqliteDriverFromOptions({
+ engine: options.engine,
+ connect: { connectionString, options: options.options },
+ pragmas: options.pragmas,
+ functions: options.functions,
+ });
+}
diff --git a/packages/3-targets/7-drivers/sqlite/test/driver.basic.test.ts b/packages/3-targets/7-drivers/sqlite/test/driver.basic.test.ts
new file mode 100644
index 0000000000..e20e8dc9cf
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/test/driver.basic.test.ts
@@ -0,0 +1,95 @@
+import { SqlConnectionError, SqlQueryError } from '@prisma-next/sql-errors';
+import { describe, expect, it } from 'vitest';
+import { createSqliteDriverFromOptions } from '../src/sqlite-driver';
+
+describe('@prisma-next/driver-sqlite', () => {
+ it('queries and binds numeric params', async () => {
+ const driver = createSqliteDriverFromOptions({
+ connect: { filename: ':memory:' },
+ });
+
+ const result = await driver.query<{ v: number }>('select ?1 as v', [42]);
+ expect(result.rows).toEqual([{ v: 42 }]);
+
+ await driver.close();
+ });
+
+ it('streams rows via execute()', async () => {
+ const driver = createSqliteDriverFromOptions({
+ connect: { filename: ':memory:' },
+ });
+
+ await driver.query('create table items(id integer primary key, name text not null)');
+ await driver.query('insert into items(name) values (?1), (?2)', ['a', 'b']);
+
+ const rows: Array<{ id: number; name: string }> = [];
+ for await (const row of driver.execute<{ id: number; name: string }>({
+ sql: 'select id, name from items order by id asc',
+ })) {
+ rows.push(row);
+ }
+
+ expect(rows).toEqual([
+ { id: 1, name: 'a' },
+ { id: 2, name: 'b' },
+ ]);
+
+ await driver.close();
+ });
+
+ it('supports transactions (commit + rollback)', async () => {
+ const driver = createSqliteDriverFromOptions({
+ connect: { filename: ':memory:' },
+ });
+
+ await driver.query('create table items(id integer primary key, name text not null)');
+
+ // Rollback
+ const conn1 = await driver.acquireConnection();
+ const tx1 = await conn1.beginTransaction();
+ await tx1.query('insert into items(name) values (?1)', ['a']);
+ await tx1.rollback();
+ await conn1.release();
+
+ const countAfterRollback = await driver.query<{ c: number }>('select count(*) as c from items');
+ expect(countAfterRollback.rows[0]?.c).toBe(0);
+
+ // Commit
+ const conn2 = await driver.acquireConnection();
+ const tx2 = await conn2.beginTransaction();
+ await tx2.query('insert into items(name) values (?1)', ['b']);
+ await tx2.commit();
+ await conn2.release();
+
+ const countAfterCommit = await driver.query<{ c: number }>('select count(*) as c from items');
+ expect(countAfterCommit.rows[0]?.c).toBe(1);
+
+ await driver.close();
+ });
+
+ it('normalizes connection errors', async () => {
+ expect(() =>
+ createSqliteDriverFromOptions({
+ connect: { filename: '/this/does/not/exist/sqlite.db' },
+ }),
+ ).toThrowError(SqlConnectionError);
+ });
+
+ it('normalizes query errors', async () => {
+ const driver = createSqliteDriverFromOptions({
+ connect: { filename: ':memory:' },
+ });
+
+ await driver.query('create table items(id integer primary key, name text unique)');
+ await driver.query('insert into items(name) values (?1)', ['a']);
+
+ try {
+ await driver.query('insert into items(name) values (?1)', ['a']);
+ throw new Error('expected unique constraint error');
+ } catch (error) {
+ expect(error).toBeInstanceOf(SqlQueryError);
+ } finally {
+ await driver.close();
+ }
+ });
+});
diff --git a/packages/3-targets/7-drivers/sqlite/tsconfig.build.json b/packages/3-targets/7-drivers/sqlite/tsconfig.build.json
new file mode 100644
index 0000000000..671541c1a3
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/tsconfig.build.json
@@ -0,0 +1,12 @@
+{
+ "extends": "./tsconfig.json",
+ "compilerOptions": {
+ "rootDir": "src",
+ "outDir": "dist",
+ "declaration": true,
+ "declarationMap": true,
+ "emitDeclarationOnly": true
+ },
+ "include": ["src/**/*.ts"],
+ "exclude": ["test", "dist"]
+}
diff --git a/packages/3-targets/7-drivers/sqlite/tsconfig.json b/packages/3-targets/7-drivers/sqlite/tsconfig.json
new file mode 100644
index 0000000000..7afa587436
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/tsconfig.json
@@ -0,0 +1,9 @@
+{
+ "extends": ["@prisma-next/tsconfig/base"],
+ "compilerOptions": {
+ "rootDir": ".",
+ "outDir": "dist"
+ },
+ "include": ["src/**/*.ts", "test/**/*.ts"],
+ "exclude": ["dist"]
+}
diff --git a/packages/3-targets/7-drivers/sqlite/tsup.config.ts b/packages/3-targets/7-drivers/sqlite/tsup.config.ts
new file mode 100644
index 0000000000..7ed6b29770
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/tsup.config.ts
@@ -0,0 +1,28 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+ entry: {
+ 'exports/control': 'src/exports/control.ts',
+ 'exports/runtime': 'src/exports/runtime.ts',
+ },
+ outDir: 'dist',
+ format: ['esm'],
+ sourcemap: true,
+ dts: false,
+ clean: true,
+ target: 'es2022',
+ minify: false,
+ esbuildPlugins: [
+ {
+ // esbuild strips the `node:` prefix from builtin imports. For `node:sqlite` that
+ // produces `sqlite`, which is not a valid builtin module specifier in Node.
+ name: 'keep-node-sqlite',
+ setup(build) {
+ build.onResolve({ filter: /^sqlite$/ }, () => ({
+ path: 'node:sqlite',
+ external: true,
+ }));
+ },
+ },
+ ],
+});
diff --git a/packages/3-targets/7-drivers/sqlite/vitest.config.ts b/packages/3-targets/7-drivers/sqlite/vitest.config.ts
new file mode 100644
index 0000000000..cf1e80a584
--- /dev/null
+++ b/packages/3-targets/7-drivers/sqlite/vitest.config.ts
@@ -0,0 +1,30 @@
+import { timeouts } from '@prisma-next/test-utils';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+ test: {
+ globals: true,
+ environment: 'node',
+ testTimeout: timeouts.default,
+ hookTimeout: timeouts.default,
+ coverage: {
+ provider: 'v8',
+ reporter: ['text', 'json', 'html'],
+ include: ['src/**/*.ts'],
+ exclude: [
+ 'dist/**',
+ 'test/**',
+ '**/*.test.ts',
+ '**/*.test-d.ts',
+ '**/*.config.ts',
+ '**/exports/**',
+ ],
+ thresholds: {
+ lines: 94,
+ branches: 89,
+ functions: 100,
+ statements: 94,
+ },
+ },
+ },
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a753b9432f..904d2337db 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -184,6 +184,100 @@ importers:
specifier: 'catalog:'
version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ examples/prisma-next-demo-sqlite:
+ dependencies:
+ '@prisma-next/adapter-sqlite':
+ specifier: workspace:*
+ version: link:../../packages/3-targets/6-adapters/sqlite
+ '@prisma-next/contract':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/1-core/shared/contract
+ '@prisma-next/core-execution-plane':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/1-core/runtime/execution-plane
+ '@prisma-next/driver-sqlite':
+ specifier: workspace:*
+ version: link:../../packages/3-targets/7-drivers/sqlite
+ '@prisma-next/extension-sqlite-vector':
+ specifier: workspace:*
+ version: link:../../packages/3-extensions/sqlite-vector
+ '@prisma-next/family-sql':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/3-tooling/family
+ '@prisma-next/integration-kysely':
+ specifier: workspace:*
+ version: link:../../packages/3-extensions/integration-kysely
+ '@prisma-next/sql-contract':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/1-core/contract
+ '@prisma-next/sql-contract-ts':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/2-authoring/contract-ts
+ '@prisma-next/sql-lane':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/4-lanes/sql-lane
+ '@prisma-next/sql-orm-lane':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/4-lanes/orm-lane
+ '@prisma-next/sql-relational-core':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/4-lanes/relational-core
+ '@prisma-next/sql-runtime':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/5-runtime
+ '@prisma-next/target-sqlite':
+ specifier: workspace:*
+ version: link:../../packages/3-targets/3-targets/sqlite
+ arktype:
+ specifier: ^2.1.29
+ version: 2.1.29
+ dotenv:
+ specifier: ^16.4.5
+ version: 16.6.1
+ kysely:
+ specifier: 'catalog:'
+ version: 0.28.10
+ devDependencies:
+ '@prisma-next/cli':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/3-tooling/cli
+ '@prisma-next/core-control-plane':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/1-core/migration/control-plane
+ '@prisma-next/emitter':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/3-tooling/emitter
+ '@prisma-next/sql-contract-emitter':
+ specifier: workspace:*
+ version: link:../../packages/2-sql/3-tooling/emitter
+ '@prisma-next/test-utils':
+ specifier: workspace:*
+ version: link:../../test/utils
+ '@prisma-next/tsconfig':
+ specifier: workspace:*
+ version: link:../../packages/0-config/tsconfig
+ '@prisma-next/vite-plugin-contract-emit':
+ specifier: workspace:*
+ version: link:../../packages/1-framework/3-tooling/vite-plugin-contract-emit
+ '@types/node':
+ specifier: 'catalog:'
+ version: 24.10.4
+ tsup:
+ specifier: 'catalog:'
+ version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.1)
+ tsx:
+ specifier: ^4.19.2
+ version: 4.20.6
+ typescript:
+ specifier: 'catalog:'
+ version: 5.9.3
+ vite:
+ specifier: 'catalog:'
+ version: 7.3.1(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ vitest:
+ specifier: 'catalog:'
+ version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+
examples/prisma-orm-demo:
dependencies:
'@prisma-next/adapter-postgres':
@@ -1340,6 +1434,46 @@ importers:
specifier: 'catalog:'
version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ packages/3-extensions/sqlite-vector:
+ dependencies:
+ '@prisma-next/contract':
+ specifier: workspace:*
+ version: link:../../1-framework/1-core/shared/contract
+ '@prisma-next/contract-authoring':
+ specifier: workspace:*
+ version: link:../../1-framework/2-authoring/contract
+ '@prisma-next/family-sql':
+ specifier: workspace:*
+ version: link:../../2-sql/3-tooling/family
+ '@prisma-next/sql-operations':
+ specifier: workspace:*
+ version: link:../../2-sql/1-core/operations
+ '@prisma-next/sql-relational-core':
+ specifier: workspace:*
+ version: link:../../2-sql/4-lanes/relational-core
+ '@prisma-next/sql-runtime':
+ specifier: workspace:*
+ version: link:../../2-sql/5-runtime
+ devDependencies:
+ '@prisma-next/operations':
+ specifier: workspace:*
+ version: link:../../1-framework/1-core/shared/operations
+ '@prisma-next/test-utils':
+ specifier: workspace:*
+ version: link:../../../test/utils
+ '@prisma-next/tsconfig':
+ specifier: workspace:*
+ version: link:../../0-config/tsconfig
+ tsup:
+ specifier: 'catalog:'
+ version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.1)
+ typescript:
+ specifier: 'catalog:'
+ version: 5.9.3
+ vitest:
+ specifier: 'catalog:'
+ version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+
packages/3-targets/3-targets/postgres:
dependencies:
'@prisma-next/cli':
@@ -1395,6 +1529,61 @@ importers:
specifier: 'catalog:'
version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ packages/3-targets/3-targets/sqlite:
+ dependencies:
+ '@prisma-next/cli':
+ specifier: workspace:*
+ version: link:../../../1-framework/3-tooling/cli
+ '@prisma-next/contract':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/contract
+ '@prisma-next/core-control-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/migration/control-plane
+ '@prisma-next/core-execution-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/runtime/execution-plane
+ '@prisma-next/family-sql':
+ specifier: workspace:*
+ version: link:../../../2-sql/3-tooling/family
+ '@prisma-next/sql-contract':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/contract
+ '@prisma-next/sql-errors':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/errors
+ '@prisma-next/sql-schema-ir':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/schema-ir
+ '@prisma-next/utils':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/utils
+ arktype:
+ specifier: ^2.0.0
+ version: 2.1.29
+ devDependencies:
+ '@prisma-next/adapter-sqlite':
+ specifier: workspace:*
+ version: link:../../6-adapters/sqlite
+ '@prisma-next/driver-sqlite':
+ specifier: workspace:*
+ version: link:../../7-drivers/sqlite
+ '@prisma-next/test-utils':
+ specifier: workspace:*
+ version: link:../../../../test/utils
+ '@prisma-next/tsconfig':
+ specifier: workspace:*
+ version: link:../../../0-config/tsconfig
+ tsup:
+ specifier: 'catalog:'
+ version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.1)
+ typescript:
+ specifier: 'catalog:'
+ version: 5.9.3
+ vitest:
+ specifier: 'catalog:'
+ version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+
packages/3-targets/6-adapters/postgres:
dependencies:
'@prisma-next/cli':
@@ -1453,6 +1642,64 @@ importers:
specifier: 'catalog:'
version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ packages/3-targets/6-adapters/sqlite:
+ dependencies:
+ '@prisma-next/cli':
+ specifier: workspace:*
+ version: link:../../../1-framework/3-tooling/cli
+ '@prisma-next/contract':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/contract
+ '@prisma-next/contract-authoring':
+ specifier: workspace:*
+ version: link:../../../1-framework/2-authoring/contract
+ '@prisma-next/core-control-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/migration/control-plane
+ '@prisma-next/core-execution-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/runtime/execution-plane
+ '@prisma-next/family-sql':
+ specifier: workspace:*
+ version: link:../../../2-sql/3-tooling/family
+ '@prisma-next/sql-contract':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/contract
+ '@prisma-next/sql-contract-ts':
+ specifier: workspace:*
+ version: link:../../../2-sql/2-authoring/contract-ts
+ '@prisma-next/sql-operations':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/operations
+ '@prisma-next/sql-relational-core':
+ specifier: workspace:*
+ version: link:../../../2-sql/4-lanes/relational-core
+ '@prisma-next/sql-schema-ir':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/schema-ir
+ '@prisma-next/utils':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/utils
+ arktype:
+ specifier: ^2.0.0
+ version: 2.1.29
+ devDependencies:
+ '@prisma-next/test-utils':
+ specifier: workspace:*
+ version: link:../../../../test/utils
+ '@prisma-next/tsconfig':
+ specifier: workspace:*
+ version: link:../../../0-config/tsconfig
+ tsup:
+ specifier: 'catalog:'
+ version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.1)
+ typescript:
+ specifier: 'catalog:'
+ version: 5.9.3
+ vitest:
+ specifier: 'catalog:'
+ version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+
packages/3-targets/7-drivers/postgres:
dependencies:
'@prisma-next/contract':
@@ -1514,6 +1761,52 @@ importers:
specifier: 'catalog:'
version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+ packages/3-targets/7-drivers/sqlite:
+ dependencies:
+ '@prisma-next/contract':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/contract
+ '@prisma-next/core-control-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/migration/control-plane
+ '@prisma-next/core-execution-plane':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/runtime/execution-plane
+ '@prisma-next/sql-contract':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/contract
+ '@prisma-next/sql-errors':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/errors
+ '@prisma-next/sql-operations':
+ specifier: workspace:*
+ version: link:../../../2-sql/1-core/operations
+ '@prisma-next/sql-relational-core':
+ specifier: workspace:*
+ version: link:../../../2-sql/4-lanes/relational-core
+ '@prisma-next/utils':
+ specifier: workspace:*
+ version: link:../../../1-framework/1-core/shared/utils
+ arktype:
+ specifier: ^2.0.0
+ version: 2.1.29
+ devDependencies:
+ '@prisma-next/test-utils':
+ specifier: workspace:*
+ version: link:../../../../test/utils
+ '@prisma-next/tsconfig':
+ specifier: workspace:*
+ version: link:../../../0-config/tsconfig
+ tsup:
+ specifier: 'catalog:'
+ version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.1)
+ typescript:
+ specifier: 'catalog:'
+ version: 5.9.3
+ vitest:
+ specifier: 'catalog:'
+ version: 4.0.17(@types/node@24.10.4)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.1)
+
test/e2e/framework:
dependencies:
'@prisma-next/adapter-postgres':
diff --git a/tsconfig.base.json b/tsconfig.base.json
index 0d84e954d4..3d38206eff 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -38,9 +38,14 @@
{ "path": "./packages/3-extensions/compat-prisma" },
{ "path": "./packages/3-extensions/pgvector" },
+ { "path": "./packages/3-extensions/sqlite-vector" },
{ "path": "./packages/3-targets/3-targets/postgres" },
{ "path": "./packages/3-targets/6-adapters/postgres" },
- { "path": "./packages/3-targets/7-drivers/postgres" }
+ { "path": "./packages/3-targets/7-drivers/postgres" },
+
+ { "path": "./packages/3-targets/3-targets/sqlite" },
+ { "path": "./packages/3-targets/6-adapters/sqlite" },
+ { "path": "./packages/3-targets/7-drivers/sqlite" }
]
}