@prisma-next/adapter-sqlite 0.0.1

package/README.md

@@ -0,0 +1,194 @@
+# @prisma-next/adapter-sqlite
+
+SQLite adapter for Prisma Next.
+
+## Package Classification
+
+- **Domain**: targets
+- **Layer**: adapters
+- **Plane**: multi-plane (shared, runtime)
+
+## Overview
+
+The SQLite adapter implements the adapter SPI for SQLite databases. It provides AST-to-SQL lowering, capability discovery, codec definitions, and error mapping for SQLite-specific behavior. It also exports runtime-plane adapter descriptors for config wiring.
+
+## Purpose
+
+Provide SQLite-specific adapter implementation, codecs, and capabilities. Enable SQLite dialect support in Prisma Next through the adapter SPI.
+
+## Responsibilities
+
+- **Adapter Implementation**: Implement `Adapter` SPI for SQLite
+  - Lower SQL ASTs to SQLite dialect SQL
+  - Render `includeMany` as correlated subquery with `json_group_array(json_object(...))` for nested array includes
+  - Advertise SQLite capabilities (`jsonAgg`, `returning`; no `lateral`, no `enums`)
+  - Provide target-specific marker SQL via `readMarkerStatement()` on `AdapterProfile`
+  - Map SQLite errors to `RuntimeError` envelope
+- **Codec Definitions**: Define SQLite codecs for type conversion
+  - 8 codecs: TEXT, INTEGER, REAL, BLOB, BOOLEAN (INTEGER 0/1), DATETIME (TEXT ISO8601), JSON (TEXT), BIGINT (INTEGER)
+  - Wire format to JavaScript type decoding
+  - JavaScript type to wire format encoding
+- **Codec Types**: Export TypeScript types for SQLite codecs
+- **Column Types**: Export column type descriptors with `as const` literal `codecId` types for contract authoring
+- **Descriptors**: Provide adapter descriptors declaring capabilities and codec type imports
+
+**Non-goals:**
+- Transport/pooling management (drivers)
+- Query compilation (sql-query)
+- Runtime execution (runtime)
+- Control-plane introspection and migration (future milestone)
+
+## Architecture
+
+This package spans multiple planes:
+
+- **Shared plane** (`src/core/**`): Core adapter implementation, codecs, and types that can be imported by both migration and runtime planes
+- **Runtime plane** (`src/exports/runtime.ts`): Runtime-plane entry point that exports the runtime adapter descriptor
+
+```mermaid
+flowchart TD
+    subgraph "Runtime"
+        RT[Runtime]
+        PLAN[Plan]
+    end
+
+    subgraph "SQLite Adapter"
+        ADAPTER[Adapter]
+        LOWERER[AST Lowering]
+        CODECS[Codecs]
+        CAPS[Capabilities]
+    end
+
+    subgraph "SQLite Driver"
+        DRIVER[Driver]
+        DB[(SQLite)]
+    end
+
+    subgraph "Descriptors"
+        RUNTIME_DESC[Runtime Descriptor]
+        CODECTYPES[Codec Types]
+        COLTYPES[Column Types]
+    end
+
+    RT --> PLAN
+    PLAN --> ADAPTER
+    ADAPTER --> LOWERER
+    ADAPTER --> CODECS
+    ADAPTER --> CAPS
+    ADAPTER --> DRIVER
+    DRIVER --> DB
+    RUNTIME_DESC --> RT
+    CODECTYPES --> RT
+    COLTYPES --> RT
+    CODECS --> CODECTYPES
+```
+
+## Components
+
+### Core (`src/core/`)
+
+**Adapter (`adapter.ts`)**
+- Main adapter implementation
+- Lowers SQL ASTs to SQLite SQL with `?` positional parameters
+- Renders joins (INNER, LEFT, RIGHT, FULL) with ON conditions
+- Renders `includeMany` as correlated subquery with `json_group_array(json_object(...))` for nested array includes
+- Renders DML operations (INSERT, UPDATE, DELETE) with RETURNING clauses
+- Renders ON CONFLICT (DO NOTHING / DO UPDATE SET) for upserts
+- Uses `CAST(expr AS type)` instead of Postgres `::type` syntax
+- Advertises SQLite capabilities (`returning`, `jsonAgg`)
+
+**Codecs (`codecs.ts`)**
+- SQLite codec definitions
+- Type conversion between wire format and JavaScript
+- SQL base codecs reused: `char`, `varchar`, `int`, `float`
+- SQLite-specific codecs: `text`, `integer`, `real`, `blob`, `boolean` (0/1), `datetime` (ISO8601), `json` (TEXT), `bigint`
+
+**SQL Utilities (`sql-utils.ts`)**
+- Identifier quoting with double quotes
+- String literal escaping with single-quote doubling
+- Null byte rejection for SQL injection prevention
+
+### Exports (`src/exports/`)
+
+**Runtime Entry Point (`runtime.ts`)**
+- Exports the runtime-plane adapter descriptor with codec registry
+
+**Codec Types Export (`codec-types.ts`)**
+- Exports TypeScript type definitions for SQLite codecs
+- Used in `contract.d.ts` generation
+
+**Column Types Export (`column-types.ts`)**
+- Exports column descriptors for built-in types: `textColumn`, `integerColumn`, `realColumn`, `blobColumn`, `booleanColumn`, `datetimeColumn`, `jsonColumn`, `bigintColumn`
+- Uses `as const` to preserve literal `codecId` types through the type system
+
+**Types Export (`types.ts`)**
+- Re-exports SQLite-specific types
+
+## Dependencies
+
+- **`@prisma-next/sql-contract`**: SQL contract types
+- **`@prisma-next/sql-relational-core`**: SQL AST types and codec registry
+- **`@prisma-next/sql-runtime`**: Runtime adapter descriptor types
+- **`@prisma-next/framework-components`**: Descriptor types
+
+## Related Subsystems
+
+- **[Adapters & Targets](../../../../docs/architecture%20docs/subsystems/5.%20Adapters%20&%20Targets.md)**: Detailed adapter 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)
+- [ADR 030 -- Result decoding & codecs registry](../../../../docs/architecture%20docs/adrs/ADR%20030%20-%20Result%20decoding%20&%20codecs%20registry.md)
+- [ADR 065 -- Adapter capability schema & negotiation v1](../../../../docs/architecture%20docs/adrs/ADR%20065%20-%20Adapter%20capability%20schema%20&%20negotiation%20v1.md)
+
+## Capabilities
+
+The adapter declares the following SQLite capabilities:
+
+- **`sql.orderBy: true`** -- Supports ORDER BY clauses
+- **`sql.limit: true`** -- Supports LIMIT clauses
+- **`sql.lateral: false`** -- No LATERAL join support; `includeMany` uses correlated subquery fallback
+- **`sql.jsonAgg: true`** -- Supports JSON aggregation via `json_group_array()` for `includeMany`
+- **`sql.returning: true`** -- Supports RETURNING clauses for DML operations (SQLite 3.35+)
+- **`sql.enums: false`** -- No native enum support
+
+## includeMany Support
+
+The adapter supports `includeMany` for nested array includes using SQLite's `json_group_array()` and `json_object()`:
+
+**Lowering Strategy:**
+- Renders `includeMany` as a correlated subquery with `json_group_array(json_object(...))` to aggregate child rows into a JSON array
+- Uses `COALESCE(..., '[]')` to handle empty results
+
+**Example SQL Output:**
+```sql
+SELECT "user"."id" AS "id",
+  COALESCE((SELECT json_group_array(json_object('id', "post"."id", 'title', "post"."title"))
+    FROM "post" WHERE "user"."id" = "post"."userId"), '[]') AS "posts"
+FROM "user"
+```
+
+## DML Operations with RETURNING
+
+The adapter supports RETURNING clauses for INSERT, UPDATE, and DELETE:
+
+**Example SQL Output:**
+```sql
+-- INSERT with RETURNING
+INSERT INTO "user" ("email") VALUES (?) RETURNING "user"."id", "user"."email"
+
+-- UPDATE with RETURNING
+UPDATE "user" SET "email" = ? WHERE "user"."id" = ? RETURNING "user"."id", "user"."email"
+
+-- DELETE with RETURNING
+DELETE FROM "user" WHERE "user"."id" = ? RETURNING "user"."id", "user"."email"
+```
+
+## Exports
+
+- `./codec-types`: SQLite codec types (`CodecTypes`, `JsonValue`, `dataTypes`)
+- `./column-types`: Column type descriptors (`textColumn`, `integerColumn`, `realColumn`, `blobColumn`, `booleanColumn`, `datetimeColumn`, `jsonColumn`, `bigintColumn`)
+- `./types`: SQLite-specific types
+- `./control`: Control-plane entry point (stubbed for future migration support)
+- `./runtime`: Runtime-plane entry point (runtime adapter descriptor)

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@prisma-next/adapter-sqlite",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "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/cli": "workspace:*",
+    "@prisma-next/contract": "workspace:*",
+    "@prisma-next/contract-authoring": "workspace:*",
+    "@prisma-next/framework-components": "workspace:*",
+    "@prisma-next/family-sql": "workspace:*",
+    "@prisma-next/ids": "workspace:*",
+    "@prisma-next/sql-contract": "workspace:*",
+    "@prisma-next/sql-contract-psl": "workspace:*",
+    "@prisma-next/sql-contract-ts": "workspace:*",
+    "@prisma-next/sql-operations": "workspace:*",
+    "@prisma-next/sql-relational-core": "workspace:*",
+    "@prisma-next/sql-runtime": "workspace:*",
+    "@prisma-next/sql-schema-ir": "workspace:*",
+    "@prisma-next/utils": "workspace:*",
+    "arktype": "^2.0.0"
+  },
+  "devDependencies": {
+    "@prisma-next/test-utils": "workspace:*",
+    "@prisma-next/tsconfig": "workspace:*",
+    "@prisma-next/tsdown": "workspace:*",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "exports": {
+    "./adapter": "./dist/adapter.mjs",
+    "./codec-types": "./dist/codec-types.mjs",
+    "./column-types": "./dist/column-types.mjs",
+    "./control": "./dist/control.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./types": "./dist/types.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-targets/6-adapters/sqlite"
+  }
+}

package/src/core/adapter.ts

@@ -0,0 +1,528 @@
+import {
+  type Adapter,
+  type AdapterProfile,
+  type AggregateExpr,
+  type AnyExpression,
+  type AnyFromSource,
+  type AnyQueryAst,
+  type BinaryExpr,
+  type CodecParamsDescriptor,
+  type ColumnRef,
+  createCodecRegistry,
+  type DeleteAst,
+  type InsertAst,
+  type InsertValue,
+  type JoinAst,
+  type JoinOnExpr,
+  type JsonArrayAggExpr,
+  type JsonObjectExpr,
+  type ListExpression,
+  type LiteralExpr,
+  type LowererContext,
+  type NullCheckExpr,
+  type OperationExpr,
+  type OrderByItem,
+  type ProjectionItem,
+  type SelectAst,
+  type SubqueryExpr,
+  type UpdateAst,
+} from '@prisma-next/sql-relational-core/ast';
+import { codecDefinitions } from './codecs';
+import { escapeLiteral, quoteIdentifier } from './sql-utils';
+import type { SqliteAdapterOptions, SqliteContract, SqliteLoweredStatement } from './types';
+
+const defaultCapabilities = Object.freeze({
+  sql: {
+    orderBy: true,
+    limit: true,
+    lateral: false,
+    jsonAgg: true,
+    returning: true,
+    enums: false,
+  },
+});
+
+class SqliteAdapterImpl implements Adapter<AnyQueryAst, SqliteContract, SqliteLoweredStatement> {
+  readonly familyId = 'sql' as const;
+  readonly targetId = 'sqlite' as const;
+
+  readonly profile: AdapterProfile<'sqlite'>;
+  private readonly codecRegistry = (() => {
+    const registry = createCodecRegistry();
+    for (const definition of Object.values(codecDefinitions)) {
+      registry.register(definition.codec);
+    }
+    return registry;
+  })();
+
+  constructor(options?: SqliteAdapterOptions) {
+    this.profile = Object.freeze({
+      id: options?.profileId ?? 'sqlite/default@1',
+      target: 'sqlite',
+      capabilities: defaultCapabilities,
+      codecs: () => this.codecRegistry,
+      readMarkerStatement: () => ({
+        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract_marker where id = ?',
+        params: [1],
+      }),
+    });
+  }
+
+  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {
+    return [];
+  }
+
+  lower(ast: AnyQueryAst, context: LowererContext<SqliteContract>) {
+    const collectedParamRefs = ast.collectParamRefs();
+    const params: unknown[] = [];
+    for (const ref of collectedParamRefs) {
+      params.push(ref.value);
+    }
+
+    let sql: string;
+
+    const node = ast;
+    switch (node.kind) {
+      case 'select':
+        sql = renderSelect(node, context.contract);
+        break;
+      case 'insert':
+        sql = renderInsert(node);
+        break;
+      case 'update':
+        sql = renderUpdate(node, context.contract);
+        break;
+      case 'delete':
+        sql = renderDelete(node);
+        break;
+      default:
+        throw new Error(`Unsupported AST node kind: ${(node as { kind: string }).kind}`);
+    }
+
+    return Object.freeze({
+      profileId: this.profile.id,
+      body: Object.freeze({ sql, params }),
+    });
+  }
+}
+
+function renderSelect(ast: SelectAst, contract?: SqliteContract): string {
+  const distinctPrefix = ast.distinct ? 'DISTINCT ' : '';
+  const selectClause = `SELECT ${distinctPrefix}${renderProjection(ast.projection, contract)}`;
+  const fromClause = `FROM ${renderSource(ast.from, contract)}`;
+
+  const joinsClause = ast.joins?.length
+    ? ast.joins.map((join) => renderJoin(join, contract)).join(' ')
+    : '';
+
+  const whereClause = ast.where ? `WHERE ${renderExpr(ast.where, contract)}` : '';
+  const groupByClause = ast.groupBy?.length
+    ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract)).join(', ')}`
+    : '';
+  const havingClause = ast.having ? `HAVING ${renderExpr(ast.having, contract)}` : '';
+  const orderClause = ast.orderBy?.length
+    ? `ORDER BY ${ast.orderBy
+        .map((order) => `${renderExpr(order.expr, contract)} ${order.dir.toUpperCase()}`)
+        .join(', ')}`
+    : '';
+  const limitClause = typeof ast.limit === 'number' ? `LIMIT ${ast.limit}` : '';
+  const offsetClause = typeof ast.offset === 'number' ? `OFFSET ${ast.offset}` : '';
+
+  return [
+    selectClause,
+    fromClause,
+    joinsClause,
+    whereClause,
+    groupByClause,
+    havingClause,
+    orderClause,
+    limitClause,
+    offsetClause,
+  ]
+    .filter((part) => part.length > 0)
+    .join(' ')
+    .trim();
+}
+
+function renderProjection(
+  projection: ReadonlyArray<ProjectionItem>,
+  contract?: SqliteContract,
+): string {
+  return projection
+    .map((item) => {
+      const alias = quoteIdentifier(item.alias);
+      if (item.expr.kind === 'literal') {
+        return `${renderLiteral(item.expr)} AS ${alias}`;
+      }
+      return `${renderExpr(item.expr, contract)} AS ${alias}`;
+    })
+    .join(', ');
+}
+
+function renderSource(source: AnyFromSource, contract?: SqliteContract): string {
+  const node = source;
+  switch (node.kind) {
+    case 'table-source': {
+      const table = quoteIdentifier(node.name);
+      if (!node.alias) {
+        return table;
+      }
+      return `${table} AS ${quoteIdentifier(node.alias)}`;
+    }
+    case 'derived-table-source':
+      return `(${renderSelect(node.query, contract)}) AS ${quoteIdentifier(node.alias)}`;
+    default:
+      throw new Error(`Unsupported source node kind: ${(node as { kind: string }).kind}`);
+  }
+}
+
+function renderExpr(expr: AnyExpression, contract?: SqliteContract): string {
+  const node = expr;
+  switch (node.kind) {
+    case 'column-ref':
+      return renderColumn(node);
+    case 'identifier-ref':
+      return quoteIdentifier(node.name);
+    case 'operation':
+      return renderOperation(node, contract);
+    case 'subquery':
+      return renderSubqueryExpr(node, contract);
+    case 'aggregate':
+      return renderAggregateExpr(node, contract);
+    case 'json-object':
+      return renderJsonObjectExpr(node, contract);
+    case 'json-array-agg':
+      return renderJsonArrayAggExpr(node, contract);
+    case 'binary':
+      return renderBinary(node, contract);
+    case 'and':
+      if (node.exprs.length === 0) {
+        return 'TRUE';
+      }
+      return `(${node.exprs.map((part) => renderExpr(part, contract)).join(' AND ')})`;
+    case 'or':
+      if (node.exprs.length === 0) {
+        return 'FALSE';
+      }
+      return `(${node.exprs.map((part) => renderExpr(part, contract)).join(' OR ')})`;
+    case 'exists': {
+      const notKeyword = node.notExists ? 'NOT ' : '';
+      const subquery = renderSelect(node.subquery, contract);
+      return `${notKeyword}EXISTS (${subquery})`;
+    }
+    case 'null-check':
+      return renderNullCheck(node, contract);
+    case 'not':
+      return `NOT (${renderExpr(node.expr, contract)})`;
+    case 'param-ref':
+      return '?';
+    case 'literal':
+      return renderLiteral(node);
+    case 'list':
+      return renderListLiteral(node);
+    default:
+      throw new Error(`Unsupported expression node kind: ${(node as { kind: string }).kind}`);
+  }
+}
+
+// `excluded` is a pseudo-table in ON CONFLICT DO UPDATE that references the
+// row proposed for insertion. It is not quoted because it's a keyword.
+function renderColumn(ref: ColumnRef): string {
+  if (ref.table === 'excluded') {
+    return `excluded.${quoteIdentifier(ref.column)}`;
+  }
+  return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
+}
+
+function renderLiteral(expr: LiteralExpr): string {
+  if (typeof expr.value === 'string') {
+    return `'${escapeLiteral(expr.value)}'`;
+  }
+  if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {
+    return String(expr.value);
+  }
+  if (typeof expr.value === 'bigint') {
+    return String(expr.value);
+  }
+  if (expr.value === null || expr.value === undefined) {
+    return 'NULL';
+  }
+  if (expr.value instanceof Date) {
+    return `'${escapeLiteral(expr.value.toISOString())}'`;
+  }
+  const json = JSON.stringify(expr.value);
+  if (json === undefined) {
+    return 'NULL';
+  }
+  return `'${escapeLiteral(json)}'`;
+}
+
+function renderOperation(expr: OperationExpr, contract?: SqliteContract): string {
+  const self = renderExpr(expr.self, contract);
+  const args = expr.args.map((arg) => renderExpr(arg, contract));
+
+  let result = expr.lowering.template;
+  result = result.replace(/\{\{self\}\}/g, self);
+  for (let i = 0; i < args.length; i++) {
+    result = result.replace(new RegExp(`\\{\\{arg${i}\\}\\}`, 'g'), args[i] ?? '');
+  }
+
+  return result;
+}
+
+function renderSubqueryExpr(expr: SubqueryExpr, contract?: SqliteContract): string {
+  if (expr.query.projection.length !== 1) {
+    throw new Error('Subquery expressions must project exactly one column');
+  }
+  return `(${renderSelect(expr.query, contract)})`;
+}
+
+function renderNullCheck(expr: NullCheckExpr, contract?: SqliteContract): string {
+  const rendered = renderExpr(expr.expr, contract);
+  const renderedExpr =
+    expr.expr.kind === 'operation' || expr.expr.kind === 'subquery' ? `(${rendered})` : rendered;
+  return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+
+function renderBinary(expr: BinaryExpr, contract?: SqliteContract): string {
+  if (expr.right.kind === 'list' && expr.right.values.length === 0) {
+    if (expr.op === 'in') {
+      return 'FALSE';
+    }
+    if (expr.op === 'notIn') {
+      return 'TRUE';
+    }
+  }
+
+  const leftExpr = expr.left;
+  const left = renderExpr(leftExpr, contract);
+  const leftRendered =
+    leftExpr.kind === 'operation' || leftExpr.kind === 'subquery' ? `(${left})` : left;
+
+  const rightNode = expr.right;
+  let right: string;
+  switch (rightNode.kind) {
+    case 'list':
+      right = renderListLiteral(rightNode);
+      break;
+    case 'literal':
+      right = renderLiteral(rightNode);
+      break;
+    case 'column-ref':
+      right = renderColumn(rightNode);
+      break;
+    case 'param-ref':
+      right = '?';
+      break;
+    default:
+      right = renderExpr(rightNode, contract);
+      break;
+  }
+
+  // ilike is not supported by SQLite — waiting for prisma/prisma-next#277
+  // to move ilike into an extension so it can be properly capability-gated.
+  if (expr.op === 'ilike') {
+    throw new Error('SQLite does not support ILIKE. Use LIKE for case-sensitive matching.');
+  }
+
+  const operatorMap: Record<BinaryExpr['op'], string> = {
+    eq: '=',
+    neq: '!=',
+    gt: '>',
+    lt: '<',
+    gte: '>=',
+    lte: '<=',
+    like: 'LIKE',
+    ilike: 'LIKE', // unreachable — guarded above; kept to satisfy Record<op, string>
+    in: 'IN',
+    notIn: 'NOT IN',
+  };
+
+  return `${leftRendered} ${operatorMap[expr.op]} ${right}`;
+}
+
+function renderListLiteral(expr: ListExpression): string {
+  if (expr.values.length === 0) {
+    return '(NULL)';
+  }
+  const values = expr.values
+    .map((v) => {
+      if (v.kind === 'param-ref') return '?';
+      if (v.kind === 'literal') return renderLiteral(v);
+      return renderExpr(v);
+    })
+    .join(', ');
+  return `(${values})`;
+}
+
+function renderAggregateExpr(expr: AggregateExpr, contract?: SqliteContract): string {
+  const fn = expr.fn.toUpperCase();
+  if (!expr.expr) {
+    return `${fn}(*)`;
+  }
+  return `${fn}(${renderExpr(expr.expr, contract)})`;
+}
+
+function renderJsonObjectExpr(expr: JsonObjectExpr, contract?: SqliteContract): string {
+  const args = expr.entries
+    .flatMap((entry): [string, string] => {
+      const key = `'${escapeLiteral(entry.key)}'`;
+      if (entry.value.kind === 'literal') {
+        return [key, renderLiteral(entry.value)];
+      }
+      return [key, renderExpr(entry.value, contract)];
+    })
+    .join(', ');
+  return `json_object(${args})`;
+}
+
+function renderOrderByItems(items: ReadonlyArray<OrderByItem>, contract?: SqliteContract): string {
+  return items
+    .map((item) => `${renderExpr(item.expr, contract)} ${item.dir.toUpperCase()}`)
+    .join(', ');
+}
+
+function renderJsonArrayAggExpr(expr: JsonArrayAggExpr, contract?: SqliteContract): string {
+  const aggregateOrderBy =
+    expr.orderBy && expr.orderBy.length > 0
+      ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract)}`
+      : '';
+  const aggregated = `json_group_array(${renderExpr(expr.expr, contract)}${aggregateOrderBy})`;
+  if (expr.onEmpty === 'emptyArray') {
+    return `coalesce(${aggregated}, '[]')`;
+  }
+  return aggregated;
+}
+
+function renderJoin(join: JoinAst, contract?: SqliteContract): string {
+  const joinType = join.joinType.toUpperCase();
+  const source = renderSource(join.source, contract);
+  const onClause = renderJoinOn(join.on, contract);
+  return `${joinType} JOIN ${source} ON ${onClause}`;
+}
+
+function renderJoinOn(on: JoinOnExpr, contract?: SqliteContract): string {
+  if (on.kind === 'eq-col-join-on') {
+    return `${renderColumn(on.left)} = ${renderColumn(on.right)}`;
+  }
+  return renderExpr(on, contract);
+}
+
+function renderInsertValue(value: InsertValue): string {
+  switch (value.kind) {
+    case 'param-ref':
+      return '?';
+    case 'column-ref':
+      return renderColumn(value);
+    case 'default-value':
+      throw new Error('SQLite does not support DEFAULT as a value in INSERT ... VALUES');
+    default:
+      throw new Error(`Unsupported value node in INSERT: ${(value as { kind: string }).kind}`);
+  }
+}
+
+function renderInsert(ast: InsertAst): string {
+  const table = quoteIdentifier(ast.table.name);
+  const rows = ast.rows;
+  if (rows.length === 0) {
+    throw new Error('INSERT requires at least one row');
+  }
+
+  const firstRow = rows[0] as Readonly<Record<string, InsertValue>>;
+  const columnOrder = Object.keys(firstRow);
+
+  let insertClause: string;
+  if (columnOrder.length === 0) {
+    insertClause = `INSERT INTO ${table} DEFAULT VALUES`;
+  } else {
+    const columns = columnOrder.map((column) => quoteIdentifier(column));
+    const values = rows
+      .map((row) => {
+        const renderedRow = columnOrder.map((column) => {
+          const value = row[column];
+          if (value === undefined) {
+            throw new Error(`Missing value for column "${column}" in INSERT row`);
+          }
+          return renderInsertValue(value);
+        });
+        return `(${renderedRow.join(', ')})`;
+      })
+      .join(', ');
+    insertClause = `INSERT INTO ${table} (${columns.join(', ')}) VALUES ${values}`;
+  }
+
+  let onConflictClause = '';
+  if (ast.onConflict) {
+    const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
+    if (conflictColumns.length === 0) {
+      throw new Error('INSERT onConflict requires at least one conflict column');
+    }
+
+    const action = ast.onConflict.action;
+    switch (action.kind) {
+      case 'do-nothing':
+        onConflictClause = ` ON CONFLICT (${conflictColumns.join(', ')}) DO NOTHING`;
+        break;
+      case 'do-update-set': {
+        const updates = Object.entries(action.set).map(([colName, value]) => {
+          const target = quoteIdentifier(colName);
+          if (value.kind === 'param-ref') {
+            return `${target} = ?`;
+          }
+          return `${target} = ${renderColumn(value)}`;
+        });
+        onConflictClause = ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${updates.join(', ')}`;
+        break;
+      }
+      default:
+        throw new Error(`Unsupported onConflict action: ${(action as { kind: string }).kind}`);
+    }
+  }
+
+  const returningClause = renderReturning(ast.returning);
+
+  return `${insertClause}${onConflictClause}${returningClause}`;
+}
+
+function renderUpdate(ast: UpdateAst, contract: SqliteContract): string {
+  const table = quoteIdentifier(ast.table.name);
+  const setClauses = Object.entries(ast.set).map(([col, val]) => {
+    const column = quoteIdentifier(col);
+    let value: string;
+    switch (val.kind) {
+      case 'param-ref':
+        value = '?';
+        break;
+      case 'column-ref':
+        value = renderColumn(val);
+        break;
+      default:
+        throw new Error(`Unsupported value node in UPDATE: ${(val as { kind: string }).kind}`);
+    }
+    return `${column} = ${value}`;
+  });
+
+  const whereClause = ast.where ? ` WHERE ${renderExpr(ast.where, contract)}` : '';
+  const returningClause = renderReturning(ast.returning);
+
+  return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;
+}
+
+function renderDelete(ast: DeleteAst): string {
+  const table = quoteIdentifier(ast.table.name);
+  const whereClause = ast.where ? ` WHERE ${renderExpr(ast.where)}` : '';
+  const returningClause = renderReturning(ast.returning);
+
+  return `DELETE FROM ${table}${whereClause}${returningClause}`;
+}
+
+function renderReturning(returning: ReadonlyArray<ColumnRef> | undefined): string {
+  if (!returning?.length) {
+    return '';
+  }
+  return ` RETURNING ${returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`;
+}
+
+export function createSqliteAdapter(options?: SqliteAdapterOptions) {
+  return Object.freeze(new SqliteAdapterImpl(options));
+}

package/src/core/codec-ids.ts

@@ -0,0 +1,14 @@
+export {
+  SQL_CHAR_CODEC_ID,
+  SQL_FLOAT_CODEC_ID,
+  SQL_INT_CODEC_ID,
+  SQL_VARCHAR_CODEC_ID,
+} from '@prisma-next/sql-relational-core/ast';
+export const SQLITE_TEXT_CODEC_ID = 'sqlite/text@1' as const;
+export const SQLITE_INTEGER_CODEC_ID = 'sqlite/integer@1' as const;
+export const SQLITE_REAL_CODEC_ID = 'sqlite/real@1' as const;
+export const SQLITE_BLOB_CODEC_ID = 'sqlite/blob@1' as const;
+export const SQLITE_BOOLEAN_CODEC_ID = 'sqlite/boolean@1' as const;
+export const SQLITE_DATETIME_CODEC_ID = 'sqlite/datetime@1' as const;
+export const SQLITE_JSON_CODEC_ID = 'sqlite/json@1' as const;
+export const SQLITE_BIGINT_CODEC_ID = 'sqlite/bigint@1' as const;

package/src/core/codecs.ts

@@ -0,0 +1,108 @@
+import { codec, defineCodecs, sqlCodecDefinitions } from '@prisma-next/sql-relational-core/ast';
+import {
+  SQLITE_BIGINT_CODEC_ID,
+  SQLITE_BLOB_CODEC_ID,
+  SQLITE_BOOLEAN_CODEC_ID,
+  SQLITE_DATETIME_CODEC_ID,
+  SQLITE_INTEGER_CODEC_ID,
+  SQLITE_JSON_CODEC_ID,
+  SQLITE_REAL_CODEC_ID,
+  SQLITE_TEXT_CODEC_ID,
+} from './codec-ids';
+
+const sqlCharCodec = sqlCodecDefinitions.char.codec;
+const sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;
+const sqlIntCodec = sqlCodecDefinitions.int.codec;
+const sqlFloatCodec = sqlCodecDefinitions.float.codec;
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { readonly [key: string]: JsonValue }
+  | readonly JsonValue[];
+
+const sqliteTextCodec = codec({
+  typeId: SQLITE_TEXT_CODEC_ID,
+  targetTypes: ['text'],
+  traits: ['equality', 'order', 'textual'],
+  encode: (value: string): string => value,
+  decode: (wire: string): string => wire,
+});
+
+const sqliteIntegerCodec = codec({
+  typeId: SQLITE_INTEGER_CODEC_ID,
+  targetTypes: ['integer'],
+  traits: ['equality', 'order', 'numeric'],
+  encode: (value: number): number => value,
+  decode: (wire: number): number => wire,
+});
+
+const sqliteRealCodec = codec({
+  typeId: SQLITE_REAL_CODEC_ID,
+  targetTypes: ['real'],
+  traits: ['equality', 'order', 'numeric'],
+  encode: (value: number): number => value,
+  decode: (wire: number): number => wire,
+});
+
+const sqliteBlobCodec = codec({
+  typeId: SQLITE_BLOB_CODEC_ID,
+  targetTypes: ['blob'],
+  traits: ['equality'],
+  encode: (value: Uint8Array): Uint8Array => value,
+  decode: (wire: Uint8Array): Uint8Array => wire,
+});
+
+const sqliteBooleanCodec = codec({
+  typeId: SQLITE_BOOLEAN_CODEC_ID,
+  targetTypes: ['integer'],
+  traits: ['equality', 'boolean'],
+  encode: (value: boolean): number => (value ? 1 : 0),
+  decode: (wire: number): boolean => wire !== 0,
+});
+
+const sqliteDatetimeCodec = codec({
+  typeId: SQLITE_DATETIME_CODEC_ID,
+  targetTypes: ['text'],
+  traits: ['equality', 'order'],
+  encode: (value: Date): string => value.toISOString(),
+  decode: (wire: string): Date => new Date(wire),
+});
+
+const sqliteJsonCodec = codec({
+  typeId: SQLITE_JSON_CODEC_ID,
+  targetTypes: ['text'],
+  traits: ['equality'],
+  encode: (value: JsonValue): string => JSON.stringify(value),
+  decode: (wire: string | JsonValue): JsonValue =>
+    typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire,
+});
+
+const sqliteBigintCodec = codec({
+  typeId: SQLITE_BIGINT_CODEC_ID,
+  targetTypes: ['integer'],
+  traits: ['equality', 'order', 'numeric'],
+  encode: (value: bigint): number | bigint => value,
+  decode: (wire: number | bigint): bigint => BigInt(wire),
+});
+
+const codecs = defineCodecs()
+  .add('char', sqlCharCodec)
+  .add('varchar', sqlVarcharCodec)
+  .add('int', sqlIntCodec)
+  .add('float', sqlFloatCodec)
+  .add('text', sqliteTextCodec)
+  .add('integer', sqliteIntegerCodec)
+  .add('real', sqliteRealCodec)
+  .add('blob', sqliteBlobCodec)
+  .add('boolean', sqliteBooleanCodec)
+  .add('datetime', sqliteDatetimeCodec)
+  .add('json', sqliteJsonCodec)
+  .add('bigint', sqliteBigintCodec);
+
+export const codecDefinitions = codecs.codecDefinitions;
+export const dataTypes = codecs.dataTypes;
+
+export type CodecTypes = typeof codecs.CodecTypes;

package/src/core/column-types.ts

@@ -0,0 +1,50 @@
+import {
+  SQLITE_BIGINT_CODEC_ID,
+  SQLITE_BLOB_CODEC_ID,
+  SQLITE_BOOLEAN_CODEC_ID,
+  SQLITE_DATETIME_CODEC_ID,
+  SQLITE_INTEGER_CODEC_ID,
+  SQLITE_JSON_CODEC_ID,
+  SQLITE_REAL_CODEC_ID,
+  SQLITE_TEXT_CODEC_ID,
+} from './codec-ids';
+
+export const textColumn = {
+  codecId: SQLITE_TEXT_CODEC_ID,
+  nativeType: 'text',
+} as const;
+
+export const integerColumn = {
+  codecId: SQLITE_INTEGER_CODEC_ID,
+  nativeType: 'integer',
+} as const;
+
+export const realColumn = {
+  codecId: SQLITE_REAL_CODEC_ID,
+  nativeType: 'real',
+} as const;
+
+export const blobColumn = {
+  codecId: SQLITE_BLOB_CODEC_ID,
+  nativeType: 'blob',
+} as const;
+
+export const booleanColumn = {
+  codecId: SQLITE_BOOLEAN_CODEC_ID,
+  nativeType: 'integer',
+} as const;
+
+export const datetimeColumn = {
+  codecId: SQLITE_DATETIME_CODEC_ID,
+  nativeType: 'text',
+} as const;
+
+export const jsonColumn = {
+  codecId: SQLITE_JSON_CODEC_ID,
+  nativeType: 'text',
+} as const;
+
+export const bigintColumn = {
+  codecId: SQLITE_BIGINT_CODEC_ID,
+  nativeType: 'integer',
+} as const;

package/src/core/control-adapter.ts

@@ -0,0 +1,18 @@
+import type {
+  ControlAdapterDescriptor,
+  ControlAdapterInstance,
+} from '@prisma-next/framework-components/control';
+import { sqliteAdapterDescriptorMeta } from './descriptor-meta';
+
+const sqliteControlAdapterDescriptor: ControlAdapterDescriptor<
+  'sql',
+  'sqlite',
+  ControlAdapterInstance<'sql', 'sqlite'>
+> = {
+  ...sqliteAdapterDescriptorMeta,
+  create(): ControlAdapterInstance<'sql', 'sqlite'> {
+    return { familyId: 'sql', targetId: 'sqlite' };
+  },
+};
+
+export default sqliteControlAdapterDescriptor;

package/src/core/descriptor-meta.ts

@@ -0,0 +1,26 @@
+export const sqliteAdapterDescriptorMeta = {
+  kind: 'adapter',
+  familyId: 'sql',
+  targetId: 'sqlite',
+  id: 'sqlite',
+  version: '0.0.1',
+  capabilities: {
+    sql: {
+      orderBy: true,
+      limit: true,
+      lateral: false,
+      jsonAgg: true,
+      returning: true,
+      enums: false,
+    },
+  },
+  types: {
+    codecTypes: {
+      import: {
+        package: '@prisma-next/adapter-sqlite/codec-types',
+        named: 'CodecTypes',
+        alias: 'SqliteTypes',
+      },
+    },
+  },
+} as const;

package/src/core/runtime-adapter.ts

@@ -0,0 +1,33 @@
+import type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';
+import type { CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import type { SqlRuntimeAdapterDescriptor } from '@prisma-next/sql-runtime';
+import { createSqliteAdapter } from './adapter';
+import { codecDefinitions } from './codecs';
+import { sqliteAdapterDescriptorMeta } from './descriptor-meta';
+
+export type SqliteRuntimeAdapterInstance = RuntimeAdapterInstance<'sql', 'sqlite'> &
+  ReturnType<typeof createSqliteAdapter>;
+
+function createSqliteCodecRegistry(): CodecRegistry {
+  const registry = createCodecRegistry();
+  for (const definition of Object.values(codecDefinitions)) {
+    registry.register(definition.codec);
+  }
+  return registry;
+}
+
+const sqliteRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<
+  'sqlite',
+  SqliteRuntimeAdapterInstance
+> = {
+  ...sqliteAdapterDescriptorMeta,
+  codecs: createSqliteCodecRegistry,
+  parameterizedCodecs: () => [],
+  mutationDefaultGenerators: () => [],
+  create(): SqliteRuntimeAdapterInstance {
+    return createSqliteAdapter();
+  },
+};
+
+export default sqliteRuntimeAdapterDescriptor;

package/src/core/sql-utils.ts

@@ -0,0 +1,35 @@
+export class SqlEscapeError extends Error {
+  constructor(
+    message: string,
+    public readonly value: string,
+    public readonly kind: 'identifier' | 'literal',
+  ) {
+    super(message);
+    this.name = 'SqlEscapeError';
+  }
+}
+
+export function quoteIdentifier(identifier: string): string {
+  if (identifier.length === 0) {
+    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');
+  }
+  if (identifier.includes('\0')) {
+    throw new SqlEscapeError(
+      'Identifier cannot contain null bytes',
+      identifier.replace(/\0/g, '\\0'),
+      'identifier',
+    );
+  }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+export function escapeLiteral(value: string): string {
+  if (value.includes('\0')) {
+    throw new SqlEscapeError(
+      'Literal value cannot contain null bytes',
+      value.replace(/\0/g, '\\0'),
+      'literal',
+    );
+  }
+  return value.replace(/'/g, "''");
+}

package/src/core/types.ts

@@ -0,0 +1,11 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
+
+export interface SqliteAdapterOptions {
+  readonly profileId?: string;
+}
+
+export type SqliteContract = Contract<SqlStorage> & { readonly target: 'sqlite' };
+
+export type SqliteLoweredStatement = LoweredStatement;

package/src/exports/adapter.ts

@@ -0,0 +1 @@
+export { createSqliteAdapter } from '../core/adapter';

package/src/exports/codec-types.ts

@@ -0,0 +1,6 @@
+import type { CodecTypes as CoreCodecTypes, JsonValue } from '../core/codecs';
+
+export type CodecTypes = CoreCodecTypes;
+
+export type { JsonValue };
+export { dataTypes } from '../core/codecs';

package/src/exports/column-types.ts

@@ -0,0 +1,10 @@
+export {
+  bigintColumn,
+  blobColumn,
+  booleanColumn,
+  datetimeColumn,
+  integerColumn,
+  jsonColumn,
+  realColumn,
+  textColumn,
+} from '../core/column-types';

package/src/exports/control.ts

@@ -0,0 +1 @@
+export { default } from '../core/control-adapter';

package/src/exports/runtime.ts

@@ -0,0 +1,2 @@
+export type { SqliteRuntimeAdapterInstance } from '../core/runtime-adapter';
+export { default } from '../core/runtime-adapter';

package/src/exports/types.ts

@@ -0,0 +1 @@
+export type { SqliteContract, SqliteLoweredStatement } from '../core/types';