From 61a504f3679d89807d9d2f3c90889e8a9c19b1c3 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 17 Apr 2026 11:39:53 +0800
Subject: [PATCH 01/24] feat: implement SQLite Adapter

---
 src/adapters/sqlite.test.ts | 310 ++++++++++++++++++
 src/adapters/sqlite.ts      | 636 ++++++++++++++++++++++++++++++++++++
 src/core.ts                 |  24 +-
 3 files changed, 961 insertions(+), 9 deletions(-)
 create mode 100644 src/adapters/sqlite.test.ts
 create mode 100644 src/adapters/sqlite.ts

diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
new file mode 100644
index 0000000..f121997
--- /dev/null
+++ b/src/adapters/sqlite.test.ts
@@ -0,0 +1,310 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, it, beforeEach } from "bun:test";
+
+import type { Schema, InferModel } from "../core";
+import { SqliteAdapter } from "./sqlite";
+
+describe("SqliteAdapter", () => {
+  const schema = {
+    users: {
+      fields: {
+        id: { type: { type: "string" } },
+        name: { type: { type: "string" } },
+        age: { type: { type: "number" } },
+        is_active: { type: { type: "boolean" } },
+        metadata: { type: { type: "json" }, nullable: true },
+      },
+      primaryKey: { fields: ["id"] },
+      indexes: [{ fields: [{ field: "name" }] }],
+    },
+  } as const satisfies Schema;
+
+  type User = InferModel<typeof schema.users>;
+
+  let adapter: SqliteAdapter;
+  let db: Database;
+
+  beforeEach(async () => {
+    db = new Database(":memory:");
+    adapter = new SqliteAdapter(schema, db);
+    await adapter.migrate();
+  });
+
+  it("should create and find a record", async () => {
+    const userData: User = {
+      id: "u1",
+      name: "Alice",
+      age: 25,
+      is_active: true,
+      metadata: { theme: "dark" },
+    };
+
+    await adapter.create({ model: "users", data: userData });
+
+    const found = await adapter.find<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(found).toEqual(userData);
+  });
+
+  it("should find multiple records with filters", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
+    });
+
+    const actives = await adapter.findMany<User>({
+      model: "users",
+      where: { field: "is_active", op: "eq", value: true },
+      sortBy: [{ field: "age", direction: "asc" }],
+    });
+
+    expect(actives).toHaveLength(2);
+    expect(actives[0]?.name).toBe("Alice");
+    expect(actives[1]?.name).toBe("Charlie");
+  });
+
+  it("should handle complex AND / OR where clauses", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 20, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 40, is_active: false, metadata: null },
+    });
+
+    const found = await adapter.findMany<User>({
+      model: "users",
+      where: {
+        or: [
+          {
+            and: [
+              { field: "age", op: "gte", value: 30 },
+              { field: "is_active", op: "eq", value: true },
+            ],
+          },
+          { field: "name", op: "eq", value: "Charlie" },
+        ],
+      },
+    });
+
+    expect(found).toHaveLength(2);
+    expect(found.map((f) => f.name)).toContain("Bob");
+    expect(found.map((f) => f.name)).toContain("Charlie");
+  });
+
+  it("should update a record", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    await adapter.update<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+      data: { age: 26 },
+    });
+
+    const updated = await adapter.find<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(updated?.age).toBe(26);
+  });
+
+  it("should delete a record", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    await adapter.delete({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    const found = await adapter.find<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(found).toBeNull();
+  });
+
+  it("should upsert a record", async () => {
+    const data = { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null };
+
+    // Insert
+    await adapter.upsert({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+      create: data,
+      update: { age: 26 },
+    });
+
+    let found = await adapter.find<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+    expect(found?.age).toBe(25);
+
+    // Update
+    await adapter.upsert({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+      create: data,
+      update: { age: 26 },
+    });
+
+    found = await adapter.find<User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+    expect(found?.age).toBe(26);
+  });
+
+  describe("Transactions", () => {
+    it("should successfully commit multiple operations in a transaction", async () => {
+      await adapter.transaction(async (tx) => {
+        await tx.create({
+          model: "users",
+          data: { id: "t1", name: "TxUser1", age: 20, is_active: true, metadata: null },
+        });
+        await tx.create({
+          model: "users",
+          data: { id: "t2", name: "TxUser2", age: 25, is_active: true, metadata: null },
+        });
+        await tx.update<User>({
+          model: "users",
+          where: { field: "id", op: "eq", value: "t1" },
+          data: { age: 21 },
+        });
+      });
+
+      const found1 = await adapter.find<User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "t1" },
+      });
+      const found2 = await adapter.find<User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "t2" },
+      });
+
+      expect(found1?.age).toBe(21);
+      expect(found2?.name).toBe("TxUser2");
+    });
+
+    it("should rollback all operations in a failed transaction", async () => {
+      // Pre-existing record
+      await adapter.create({
+        model: "users",
+        data: { id: "t3", name: "Existing", age: 30, is_active: true, metadata: null },
+      });
+
+      try {
+        await adapter.transaction(async (tx) => {
+          // Operation 1: Create new
+          await tx.create({
+            model: "users",
+            data: { id: "t4", name: "NewUser", age: 20, is_active: true, metadata: null },
+          });
+          // Operation 2: Update existing
+          await tx.update<User>({
+            model: "users",
+            where: { field: "id", op: "eq", value: "t3" },
+            data: { age: 31 },
+          });
+          throw new Error("Force rollback");
+        });
+      } catch (e) {
+        if (e instanceof Error) {
+          expect(e.message).toBe("Force rollback");
+        }
+      }
+
+      // Verify new record was NOT created
+      const foundNew = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "t4" },
+      });
+      expect(foundNew).toBeNull();
+
+      // Verify existing record was NOT updated
+      const foundExisting = await adapter.find<User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "t3" },
+      });
+      expect(foundExisting?.age).toBe(30); // Still 30, not 31
+    });
+
+    it("should handle multiple operations in nested transactions via savepoints", async () => {
+      await adapter.transaction(async (tx1) => {
+        // Outer operations
+        await tx1.create({
+          model: "users",
+          data: { id: "n1", name: "Outer1", age: 20, is_active: true, metadata: null },
+        });
+        await tx1.create({
+          model: "users",
+          data: { id: "n2", name: "Outer2", age: 20, is_active: true, metadata: null },
+        });
+
+        try {
+          if (tx1.transaction) {
+            await tx1.transaction(async (tx2) => {
+              // Inner operations
+              await tx2.create({
+                model: "users",
+                data: { id: "n3", name: "Inner1", age: 20, is_active: true, metadata: null },
+              });
+              await tx2.update<User>({
+                model: "users",
+                where: { field: "id", op: "eq", value: "n1" }, // Modifying outer record
+                data: { name: "Outer1_Modified" },
+              });
+              throw new Error("Inner rollback");
+            });
+          }
+        } catch {
+          // Expected inner rollback
+        }
+      });
+
+      // Outer operations should commit (n1 and n2 exist, but n1 is NOT modified by inner)
+      const outer1 = await adapter.find<User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "n1" },
+      });
+      const outer2 = await adapter.find<User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "n2" },
+      });
+
+      expect(outer1?.name).toBe("Outer1"); // Reverted the update from inner tx
+      expect(outer2).not.toBeNull();
+
+      // Inner operations should rollback (n3 does not exist)
+      const inner = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "n3" },
+      });
+      expect(inner).toBeNull();
+    });
+  });
+});
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
new file mode 100644
index 0000000..37a952a
--- /dev/null
+++ b/src/adapters/sqlite.ts
@@ -0,0 +1,636 @@
+import type { Adapter, Cursor, FieldName, Schema, Select, SortBy, Where } from "../core";
+
+export type SqliteValue = string | number | bigint | Uint8Array | null;
+
+/**
+ * Standard type guards for safe runtime-to-static bridging.
+ */
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function isValidField<T>(field: unknown): field is FieldName<T> {
+  return typeof field === "string" && field !== "";
+}
+
+function isStringKey(key: unknown): key is string {
+  return typeof key === "string" && key !== "";
+}
+
+function isModelType<T>(obj: unknown): obj is T {
+  return typeof obj === "object" && obj !== null;
+}
+
+/**
+ * The standard connection interface the Adapter expects.
+ */
+export interface SqliteDatabase {
+  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
+  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
+  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
+}
+
+/**
+ * Represents a raw native SQLite driver (like Bun or better-sqlite3).
+ */
+export interface NativeSqliteStatement {
+  run(...params: SqliteValue[]): unknown;
+  get(...params: SqliteValue[]): unknown;
+  all(...params: SqliteValue[]): unknown;
+}
+
+export interface NativeSqliteDriver {
+  prepare(sql: string): NativeSqliteStatement;
+}
+
+export class SqliteAdapter implements Adapter {
+  private db: SqliteDatabase;
+
+  constructor(
+    private schema: Schema,
+    database: SqliteDatabase | NativeSqliteDriver,
+  ) {
+    if ("prepare" in database) {
+      this.db = this.wrapNativeDriver(database);
+    } else {
+      this.db = database;
+    }
+  }
+
+  private wrapNativeDriver(native: NativeSqliteDriver): SqliteDatabase {
+    return {
+      run: (sql, params) => {
+        const stmt = native.prepare(sql);
+        const result = stmt.run(...params);
+        const changes =
+          isRecord(result) && typeof result["changes"] === "number" ? result["changes"] : 0;
+        return Promise.resolve({ changes });
+      },
+      get: (sql, params) => {
+        const stmt = native.prepare(sql);
+        const row = stmt.get(...params);
+        return Promise.resolve(isRecord(row) ? row : null);
+      },
+      all: (sql, params) => {
+        const stmt = native.prepare(sql);
+        const rows = stmt.all(...params);
+        return Promise.resolve(Array.isArray(rows) ? rows.filter((item) => isRecord(item)) : []);
+      },
+    };
+  }
+
+  async migrate(): Promise<void> {
+    for (const [name, model] of Object.entries(this.schema)) {
+      const columns = Object.entries(model.fields).map(([fieldName, field]) => {
+        const type = this.mapType(field.type.type);
+        const nullable = field.nullable === true ? "" : " NOT NULL";
+        return `${this.quote(fieldName)} ${type}${nullable}`;
+      });
+
+      const pk = `PRIMARY KEY (${model.primaryKey.fields.map((f) => this.quote(f)).join(", ")})`;
+
+      // Execute migrations sequentially
+      // eslint-disable-next-line no-await-in-loop
+      await this.db.run(
+        `CREATE TABLE IF NOT EXISTS ${this.quote(name)} (${columns.join(", ")}, ${pk})`,
+        [],
+      );
+
+      if (model.indexes !== undefined) {
+        for (let i = 0; i < model.indexes.length; i++) {
+          const index = model.indexes[i];
+          if (index === undefined) continue;
+          const fields = index.fields
+            .map((f) => `${this.quote(f.field)}${f.order ? ` ${f.order.toUpperCase()}` : ""}`)
+            .join(", ");
+          const indexName = `idx_${name}_${i}`;
+          // eslint-disable-next-line no-await-in-loop
+          await this.db.run(
+            `CREATE INDEX IF NOT EXISTS ${this.quote(indexName)} ON ${this.quote(name)} (${fields})`,
+            [],
+          );
+        }
+      }
+    }
+  }
+
+  async create<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    data: T;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, data, select } = args;
+    const mappedData = this.mapInput(model, data);
+    const fields = Object.keys(mappedData);
+
+    // Avoid mapping strings over and over, pre-allocate placeholders
+    const placeholders = Array.from({ length: fields.length }).fill("?").join(", ");
+    const columns = fields.map((f) => this.quote(f)).join(", ");
+
+    // Avoid spreads
+    const params: SqliteValue[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+      if (isStringKey(field)) params.push(mappedData[field] ?? null);
+    }
+
+    await this.db.run(
+      `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders})`,
+      params,
+    );
+
+    if (select !== undefined) {
+      const modelSpec = this.schema[model];
+      if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
+
+      const pkFields = modelSpec.primaryKey.fields;
+      const where: Where<T>[] = [];
+
+      for (let i = 0; i < pkFields.length; i++) {
+        const f = pkFields[i];
+        if (isValidField<T>(f)) {
+          where.push({
+            field: f,
+            op: "eq",
+            value: data[f],
+          });
+        }
+      }
+
+      const result = await this.find<T>({
+        model,
+        where: where.length === 1 && where[0] ? where[0] : { and: where },
+        select,
+      });
+
+      if (result === null) throw new Error("Failed to refetch created record");
+      return result;
+    }
+
+    return data;
+  }
+
+  async find<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where: Where<T>;
+    select?: Select<T>;
+  }): Promise<T | null> {
+    const { model, where, select } = args;
+    const query = this.buildSelect(model, select);
+    const { sql, params } = this.buildWhere(where);
+
+    const fullSql = `${query} WHERE ${sql} LIMIT 1`;
+    const row = await this.db.get(fullSql, params);
+
+    return row ? this.mapRow<T>(model, row) : null;
+  }
+
+  async findMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }): Promise<T[]> {
+    const { model, where, select, sortBy, limit, offset, cursor } = args;
+    const query = this.buildSelect(model, select);
+    const args_sql: SqliteValue[] = [];
+    const sql_parts: string[] = [query];
+
+    if (where !== undefined || cursor !== undefined) {
+      const { sql, params } = this.buildWhere(where, cursor);
+      sql_parts.push(`WHERE ${sql}`);
+      for (let i = 0; i < params.length; i++) {
+        const param = params[i];
+        if (param !== undefined) args_sql.push(param);
+      }
+    }
+
+    if (sortBy !== undefined) {
+      const order = sortBy
+        .map((s) => `${this.quote(s.field)} ${s.direction?.toUpperCase() ?? "ASC"}`)
+        .join(", ");
+      sql_parts.push(`ORDER BY ${order}`);
+    }
+
+    if (limit !== undefined) {
+      sql_parts.push(`LIMIT ?`);
+      args_sql.push(limit);
+    }
+
+    if (offset !== undefined) {
+      sql_parts.push(`OFFSET ?`);
+      args_sql.push(offset);
+    }
+
+    const rows = await this.db.all(sql_parts.join(" "), args_sql);
+    return rows.map((row) => this.mapRow<T>(model, row));
+  }
+
+  async update<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where: Where<T>;
+    data: Partial<T>;
+  }): Promise<T | null> {
+    const { model, where, data } = args;
+    const mappedData = this.mapInput(model, data);
+    const fields = Object.keys(mappedData);
+    const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
+
+    const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+
+    // Avoid spreads
+    const params: SqliteValue[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+      if (isStringKey(field)) params.push(mappedData[field] ?? null);
+    }
+    for (let i = 0; i < whereParams.length; i++) {
+      const param = whereParams[i];
+      if (param !== undefined) params.push(param);
+    }
+
+    await this.db.run(`UPDATE ${this.quote(model)} SET ${setClause} WHERE ${whereSql}`, params);
+
+    return this.find({ model, where });
+  }
+
+  async updateMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where?: Where<T>;
+    data: Partial<T>;
+  }): Promise<number> {
+    const { model, where, data } = args;
+    const mappedData = this.mapInput(model, data);
+    const fields = Object.keys(mappedData);
+    const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
+
+    // Avoid spreads
+    const args_sql: SqliteValue[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+      if (isStringKey(field)) args_sql.push(mappedData[field] ?? null);
+    }
+
+    let sql = `UPDATE ${this.quote(model)} SET ${setClause}`;
+    if (where !== undefined) {
+      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      sql += ` WHERE ${whereSql}`;
+      for (let i = 0; i < whereParams.length; i++) {
+        const param = whereParams[i];
+        if (param !== undefined) args_sql.push(param);
+      }
+    }
+
+    const result = await this.db.run(sql, args_sql);
+    return result.changes;
+  }
+
+  async delete<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where: Where<T>;
+  }): Promise<void> {
+    const { model, where } = args;
+    const { sql, params } = this.buildWhere(where);
+    await this.db.run(`DELETE FROM ${this.quote(model)} WHERE ${sql}`, params);
+  }
+
+  async deleteMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where?: Where<T>;
+  }): Promise<number> {
+    const { model, where } = args;
+    let sql = `DELETE FROM ${this.quote(model)}`;
+    const params: SqliteValue[] = [];
+
+    if (where !== undefined) {
+      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      sql += ` WHERE ${whereSql}`;
+      for (let i = 0; i < whereParams.length; i++) {
+        const param = whereParams[i];
+        if (param !== undefined) params.push(param);
+      }
+    }
+
+    const result = await this.db.run(sql, params);
+    return result.changes;
+  }
+
+  async count<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where?: Where<T>;
+  }): Promise<number> {
+    const { model, where } = args;
+    let sql = `SELECT COUNT(*) as count FROM ${this.quote(model)}`;
+    const params: SqliteValue[] = [];
+
+    if (where !== undefined) {
+      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      sql += ` WHERE ${whereSql}`;
+      for (let i = 0; i < whereParams.length; i++) {
+        const param = whereParams[i];
+        if (param !== undefined) params.push(param);
+      }
+    }
+
+    const result = await this.db.get(sql, params);
+    const countVal = result?.["count"];
+    return typeof countVal === "number" ? countVal : 0;
+  }
+
+  async upsert<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where: Where<T>;
+    create: T;
+    update: Partial<T>;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, create, update, select } = args;
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
+
+    const mappedCreate = this.mapInput(model, create);
+    const fields = Object.keys(mappedCreate);
+    const columns = fields.map((f) => this.quote(f)).join(", ");
+    const placeholders = fields.map(() => "?").join(", ");
+
+    const mappedUpdate = this.mapInput(model, update);
+    const updateFields = Object.keys(mappedUpdate);
+    const updateClause = updateFields.map((f) => `${this.quote(f)} = ?`).join(", ");
+
+    const pkFields = modelSpec.primaryKey.fields.map((f) => this.quote(f)).join(", ");
+
+    const sql = `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${pkFields}) DO UPDATE SET ${updateClause}`;
+
+    const params: SqliteValue[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+      if (isStringKey(field)) params.push(mappedCreate[field] ?? null);
+    }
+    for (let i = 0; i < updateFields.length; i++) {
+      const field = updateFields[i];
+      if (isStringKey(field)) params.push(mappedUpdate[field] ?? null);
+    }
+
+    await this.db.run(sql, params);
+
+    const pkValuesWhere: Where<T>[] = [];
+    for (let i = 0; i < modelSpec.primaryKey.fields.length; i++) {
+      const f = modelSpec.primaryKey.fields[i];
+      if (isValidField<T>(f)) {
+        pkValuesWhere.push({
+          field: f,
+          op: "eq",
+          value: create[f],
+        });
+      }
+    }
+
+    const result = await this.find<T>({
+      model,
+      where:
+        pkValuesWhere.length === 1 && pkValuesWhere[0] ? pkValuesWhere[0] : { and: pkValuesWhere },
+      select,
+    });
+
+    if (result === null) throw new Error("Failed to refetch upserted record");
+    return result;
+  }
+
+  async transaction<T>(fn: (tx: Adapter) => Promise<T>): Promise<T> {
+    // Generate a unique savepoint identifier for nested transactions
+    const sp = `sp_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+
+    await this.db.run(`SAVEPOINT ${sp}`, []);
+    try {
+      // By passing `this`, all sub-queries inherently participate in the active connection's savepoint
+      const result = await fn(this);
+      await this.db.run(`RELEASE SAVEPOINT ${sp}`, []);
+      return result;
+    } catch (error) {
+      await this.db.run(`ROLLBACK TO SAVEPOINT ${sp}`, []);
+      throw error;
+    }
+  }
+
+  // --- Helpers ---
+
+  private quote(name: string): string {
+    return `"${name}"`;
+  }
+
+  private mapType(type: string): string {
+    switch (type) {
+      case "string":
+        return "TEXT";
+      case "number":
+        return "REAL";
+      case "boolean":
+        return "INTEGER"; // SQLite stores booleans as 0 or 1
+      case "timestamp":
+        return "INTEGER"; // BIGINT/INTEGER for ms since epoch
+      case "json":
+        return "TEXT"; // Stored as string
+      default:
+        return "TEXT";
+    }
+  }
+
+  private buildSelect<T>(model: string, select?: Select<T>): string {
+    if (select !== undefined) {
+      return `SELECT ${select.map((f) => this.quote(f)).join(", ")} FROM ${this.quote(model)}`;
+    }
+    return `SELECT * FROM ${this.quote(model)}`;
+  }
+
+  private buildWhere<T>(
+    where?: Where<T>,
+    cursor?: Cursor<T>,
+  ): { sql: string; params: SqliteValue[] } {
+    const params: SqliteValue[] = [];
+    const parts: string[] = [];
+
+    if (where !== undefined) {
+      const result = this.buildWhereRecursive(where);
+      parts.push(result.sql);
+      for (let i = 0; i < result.params.length; i++) {
+        const param = result.params[i];
+        if (param !== undefined) params.push(param);
+      }
+    }
+
+    if (cursor !== undefined) {
+      const entries = Object.entries(cursor.after);
+      if (entries.length > 0) {
+        const cursorParts: string[] = [];
+        for (const [field, value] of entries) {
+          cursorParts.push(`${this.quote(field)} > ?`);
+          params.push(this.mapWhereValue(value));
+        }
+        parts.push(`(${cursorParts.join(" AND ")})`);
+      }
+    }
+
+    const sql = parts.length > 1 ? parts.map((p) => `(${p})`).join(" AND ") : (parts[0] ?? "1=1");
+
+    return {
+      sql,
+      params,
+    };
+  }
+
+  private appendParams(target: SqliteValue[], source: SqliteValue[]): void {
+    for (let j = 0; j < source.length; j++) {
+      const param = source[j];
+      if (param !== undefined) target.push(param);
+    }
+  }
+
+  private buildWhereRecursive<T>(where: Where<T>): { sql: string; params: SqliteValue[] } {
+    if ("and" in where) {
+      const parts = where.and.map((w) => this.buildWhereRecursive(w));
+      const sql = `(${parts.map((p) => p.sql).join(" AND ")})`;
+      const params: SqliteValue[] = [];
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) this.appendParams(params, part.params);
+      }
+      return { sql, params };
+    }
+
+    if ("or" in where) {
+      const parts = where.or.map((w) => this.buildWhereRecursive(w));
+      const sql = `(${parts.map((p) => p.sql).join(" OR ")})`;
+      const params: SqliteValue[] = [];
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) this.appendParams(params, part.params);
+      }
+      return { sql, params };
+    }
+
+    const leaf = where as { field: string; op: string; value: unknown };
+    const { field, op, value } = leaf;
+    const quotedField = this.quote(field);
+
+    switch (op) {
+      case "eq":
+        return { sql: `${quotedField} = ?`, params: [this.mapWhereValue(value)] };
+      case "ne":
+        return { sql: `${quotedField} != ?`, params: [this.mapWhereValue(value)] };
+      case "gt":
+        return { sql: `${quotedField} > ?`, params: [this.mapWhereValue(value)] };
+      case "gte":
+        return { sql: `${quotedField} >= ?`, params: [this.mapWhereValue(value)] };
+      case "lt":
+        return { sql: `${quotedField} < ?`, params: [this.mapWhereValue(value)] };
+      case "lte":
+        return { sql: `${quotedField} <= ?`, params: [this.mapWhereValue(value)] };
+      case "in": {
+        const list = Array.isArray(value) ? value : [value];
+        const params: SqliteValue[] = [];
+        for (let i = 0; i < list.length; i++) {
+          params.push(this.mapWhereValue(list[i]));
+        }
+        return {
+          sql: `${quotedField} IN (${list.map(() => "?").join(", ")})`,
+          params,
+        };
+      }
+      case "not_in": {
+        const list = Array.isArray(value) ? value : [value];
+        const params: SqliteValue[] = [];
+        for (let i = 0; i < list.length; i++) {
+          params.push(this.mapWhereValue(list[i]));
+        }
+        return {
+          sql: `${quotedField} NOT IN (${list.map(() => "?").join(", ")})`,
+          params,
+        };
+      }
+      default:
+        throw new Error(`Unsupported operator: ${op}`);
+    }
+  }
+
+  private mapWhereValue(value: unknown): SqliteValue {
+    if (value === null) return null;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (typeof value === "object" && !(value instanceof Uint8Array)) return JSON.stringify(value);
+    if (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "bigint" ||
+      value instanceof Uint8Array
+    ) {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+
+  private mapInput(
+    modelName: string,
+    data: Record<string, unknown> | Partial<Record<string, unknown>>,
+  ): Record<string, SqliteValue> {
+    const model = this.schema[modelName];
+    if (model === undefined) {
+      if (isModelType<Record<string, SqliteValue>>(data)) return data;
+      throw new Error("Invalid model payload");
+    }
+
+    const result: Record<string, SqliteValue> = {};
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      const val = data[fieldName];
+      if (val === undefined) continue;
+      if (val === null) {
+        result[fieldName] = null;
+        continue;
+      }
+
+      if (field.type.type === "json") {
+        result[fieldName] = JSON.stringify(val);
+      } else if (field.type.type === "boolean") {
+        result[fieldName] = val === true ? 1 : 0;
+      } else if (
+        typeof val === "string" ||
+        typeof val === "number" ||
+        typeof val === "bigint" ||
+        val instanceof Uint8Array
+      ) {
+        result[fieldName] = val;
+      } else {
+        result[fieldName] = JSON.stringify(val);
+      }
+    }
+    return result;
+  }
+
+  private mapRow<T>(modelName: string, row: Record<string, unknown>): T {
+    const model = this.schema[modelName];
+    if (model === undefined) {
+      if (isModelType<T>(row)) return row;
+      throw new Error("Invalid row data");
+    }
+
+    // Mutate the raw row dictionary in-place rather than spreading `{ ...row }`
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      const val = row[fieldName];
+      if (val === undefined || val === null) continue;
+
+      if (field.type.type === "json" && typeof val === "string") {
+        try {
+          row[fieldName] = JSON.parse(val);
+        } catch {
+          // Keep as string if parsing fails
+        }
+      } else if (field.type.type === "boolean") {
+        row[fieldName] = val === 1 || val === true;
+      }
+    }
+
+    if (isModelType<T>(row)) return row;
+    throw new Error("Row does not conform to model bounds");
+  }
+}
diff --git a/src/core.ts b/src/core.ts
index 814d2d9..7c6863a 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -62,25 +62,25 @@ export interface Adapter {
 
   transaction?<T>(fn: (tx: Adapter) => Promise<T>): Promise<T>;
 
-  create<T = Record<string, unknown>>(args: {
+  create<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     data: T;
     select?: Select<T>;
   }): Promise<T>;
 
-  update<T = Record<string, unknown>>(args: {
+  update<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where: Where<T>;
     data: Partial<T>;
   }): Promise<T | null>;
 
-  updateMany<T = Record<string, unknown>>(args: {
+  updateMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where?: Where<T>;
     data: Partial<T>;
   }): Promise<number>;
 
-  upsert?<T = Record<string, unknown>>(args: {
+  upsert?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where: Where<T>;
     create: T;
@@ -88,20 +88,23 @@ export interface Adapter {
     select?: Select<T>;
   }): Promise<T>;
 
-  delete<T = Record<string, unknown>>(args: { model: string; where: Where<T> }): Promise<void>;
+  delete<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where: Where<T>;
+  }): Promise<void>;
 
-  deleteMany?<T = Record<string, unknown>>(args: {
+  deleteMany?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where?: Where<T>;
   }): Promise<number>;
 
-  find<T = Record<string, unknown>>(args: {
+  find<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where: Where<T>;
     select?: Select<T>;
   }): Promise<T | null>;
 
-  findMany<T = Record<string, unknown>>(args: {
+  findMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
     model: string;
     where?: Where<T>;
     select?: Select<T>;
@@ -111,7 +114,10 @@ export interface Adapter {
     cursor?: Cursor<T>;
   }): Promise<T[]>;
 
-  count?<T = Record<string, unknown>>(args: { model: string; where?: Where<T> }): Promise<number>;
+  count?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
+    model: string;
+    where?: Where<T>;
+  }): Promise<number>;
 }
 
 export type FieldName<T> = Extract<keyof T, string>;

From 9dfd993afcaf7ba8783d3c305ed5d591cad7182b Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 17 Apr 2026 14:02:15 +0800
Subject: [PATCH 02/24] feat: support nested-path filtering for json fields

---
 src/adapters/sqlite.test.ts | 60 +++++++++++++++++++++++++++++++++++++
 src/adapters/sqlite.ts      | 13 +++++++-
 src/core.ts                 |  2 +-
 3 files changed, 73 insertions(+), 2 deletions(-)

diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index f121997..f6a240f 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -108,6 +108,66 @@ describe("SqliteAdapter", () => {
     expect(found.map((f) => f.name)).toContain("Charlie");
   });
 
+  it("should handle nested JSON path filtering with `->>` syntax", async () => {
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "j1",
+        name: "User1",
+        age: 20,
+        is_active: true,
+        metadata: { theme: "dark", window: { width: 800 } },
+      },
+    });
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "j2",
+        name: "User2",
+        age: 20,
+        is_active: true,
+        metadata: { theme: "light", window: { width: 1024 } },
+      },
+    });
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "j3",
+        name: "User3",
+        age: 20,
+        is_active: true,
+        metadata: { theme: "dark", window: { width: 1920 } },
+      },
+    });
+
+    // 1. Exact match on nested string (theme = 'dark')
+    const darkUsers = await adapter.findMany<User>({
+      model: "users",
+      where: { field: "metadata->>theme", op: "eq", value: "dark" },
+    });
+    expect(darkUsers).toHaveLength(2);
+    expect(darkUsers.map((u) => u.name)).toContain("User1");
+    expect(darkUsers.map((u) => u.name)).toContain("User3");
+
+    // 2. Numeric operator on deeply nested number (window.width > 900)
+    const wideUsers = await adapter.findMany<User>({
+      model: "users",
+      where: { field: "metadata->>window->>width", op: "gt", value: 900 },
+    });
+    expect(wideUsers).toHaveLength(2);
+    expect(wideUsers.map((u) => u.name)).toContain("User2");
+    expect(wideUsers.map((u) => u.name)).toContain("User3");
+
+    // 3. IN operator on nested string
+    const specificUsers = await adapter.findMany<User>({
+      model: "users",
+      where: { field: "metadata->>window->>width", op: "in", value: [800, 1024] },
+    });
+    expect(specificUsers).toHaveLength(2);
+    expect(specificUsers.map((u) => u.name)).toContain("User1");
+    expect(specificUsers.map((u) => u.name)).toContain("User2");
+  });
+
   it("should update a record", async () => {
     await adapter.create({
       model: "users",
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 37a952a..5b43572 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -513,7 +513,18 @@ export class SqliteAdapter implements Adapter {
 
     const leaf = where as { field: string; op: string; value: unknown };
     const { field, op, value } = leaf;
-    const quotedField = this.quote(field);
+
+    let quotedField: string;
+    if (field.includes("->>")) {
+      const parts = field.split("->>");
+      const topLevelColumn = parts[0];
+      if (topLevelColumn === undefined) throw new Error("Invalid JSON path");
+
+      const jsonPath = `$.${parts.slice(1).join(".")}`;
+      quotedField = `json_extract(${this.quote(topLevelColumn)}, '${jsonPath}')`;
+    } else {
+      quotedField = this.quote(field);
+    }
 
     switch (op) {
       case "eq":
diff --git a/src/core.ts b/src/core.ts
index 7c6863a..7cf83d9 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -120,7 +120,7 @@ export interface Adapter {
   }): Promise<number>;
 }
 
-export type FieldName<T> = Extract<keyof T, string>;
+export type FieldName<T> = Extract<keyof T, string> | `${Extract<keyof T, string>}->>${string}`;
 
 export type Select<T> = ReadonlyArray<FieldName<T>>;
 

From 7c63bc8e3cf391e35d10445d4579d2ff035dc975 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 17 Apr 2026 14:42:15 +0800
Subject: [PATCH 03/24] fix: some cleanup and bug fixes

---
 README.md                   | 10 ++++--
 src/adapters/sqlite.test.ts | 64 +++++++++++++++++++++++++++++++++++++
 src/adapters/sqlite.ts      | 55 +++++++++++++++----------------
 3 files changed, 98 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 8a81c2a..d181fbe 100644
--- a/README.md
+++ b/README.md
@@ -58,10 +58,16 @@ export type Conversation = InferModel<typeof schema.conversations>;
 import { Adapter } from "@8monkey/no-orm";
 // Import a concrete adapter (e.g., @8monkey/no-orm-sqlite)
 
-const adapter: Adapter = new SqliteAdapter({ schema, db });
+const adapter: Adapter = new SqliteAdapter(schema, db);
 
 // Minimal Schema Bootstrap
-await adapter.migrate({ schema });
+await adapter.migrate();
+
+// You can seamlessly query nested JSON!
+const darkUsers = await adapter.findMany({
+  model: "conversations",
+  where: { field: "metadata->>theme", op: "eq", value: "dark" },
+});
 
 // Create a record
 const conv = await adapter.create({
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index f6a240f..2f1a82f 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -367,4 +367,68 @@ describe("SqliteAdapter", () => {
       expect(inner).toBeNull();
     });
   });
+
+  describe("Pagination", () => {
+    beforeEach(async () => {
+      // Seed data for pagination
+      const creations = [];
+      for (let i = 1; i <= 5; i++) {
+        creations.push(
+          adapter.create({
+            model: "users",
+            data: { id: `p${i}`, name: `User ${i}`, age: 20 + i, is_active: true, metadata: null },
+          }),
+        );
+      }
+      await Promise.all(creations);
+    });
+
+    it("should respect limit and offset", async () => {
+      const page1 = await adapter.findMany<User>({
+        model: "users",
+        sortBy: [{ field: "age", direction: "asc" }],
+        limit: 2,
+        offset: 0,
+      });
+      expect(page1).toHaveLength(2);
+      expect(page1[0]?.name).toBe("User 1");
+      expect(page1[1]?.name).toBe("User 2");
+
+      const page2 = await adapter.findMany<User>({
+        model: "users",
+        sortBy: [{ field: "age", direction: "asc" }],
+        limit: 2,
+        offset: 2,
+      });
+      expect(page2).toHaveLength(2);
+      expect(page2[0]?.name).toBe("User 3");
+      expect(page2[1]?.name).toBe("User 4");
+    });
+
+    it("should handle cursor pagination ascending", async () => {
+      const result = await adapter.findMany<User>({
+        model: "users",
+        sortBy: [{ field: "age", direction: "asc" }],
+        cursor: { after: { age: 22 } },
+        limit: 2,
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]?.name).toBe("User 3"); // age 23 > 22
+      expect(result[1]?.name).toBe("User 4"); // age 24 > 22
+    });
+
+    it("should handle cursor pagination descending", async () => {
+      const result = await adapter.findMany<User>({
+        model: "users",
+        sortBy: [{ field: "age", direction: "desc" }],
+        cursor: { after: { age: 24 } },
+        limit: 2,
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]?.name).toBe("User 3"); // age 23 < 24
+      expect(result[1]?.name).toBe("User 2"); // age 22 < 24
+    });
+  });
 });
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 5b43572..084ed72 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -2,25 +2,6 @@ import type { Adapter, Cursor, FieldName, Schema, Select, SortBy, Where } from "
 
 export type SqliteValue = string | number | bigint | Uint8Array | null;
 
-/**
- * Standard type guards for safe runtime-to-static bridging.
- */
-export function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-function isValidField<T>(field: unknown): field is FieldName<T> {
-  return typeof field === "string" && field !== "";
-}
-
-function isStringKey(key: unknown): key is string {
-  return typeof key === "string" && key !== "";
-}
-
-function isModelType<T>(obj: unknown): obj is T {
-  return typeof obj === "object" && obj !== null;
-}
-
 /**
  * The standard connection interface the Adapter expects.
  */
@@ -89,7 +70,8 @@ export class SqliteAdapter implements Adapter {
 
       const pk = `PRIMARY KEY (${model.primaryKey.fields.map((f) => this.quote(f)).join(", ")})`;
 
-      // Execute migrations sequentially
+      // Migrations (CREATE TABLE / CREATE INDEX) must be executed sequentially
+      // to prevent database locking errors and ensure dependent objects exist.
       // eslint-disable-next-line no-await-in-loop
       await this.db.run(
         `CREATE TABLE IF NOT EXISTS ${this.quote(name)} (${columns.join(", ")}, ${pk})`,
@@ -104,6 +86,8 @@ export class SqliteAdapter implements Adapter {
             .map((f) => `${this.quote(f.field)}${f.order ? ` ${f.order.toUpperCase()}` : ""}`)
             .join(", ");
           const indexName = `idx_${name}_${i}`;
+          // Migrations (CREATE TABLE / CREATE INDEX) must be executed sequentially
+          // to prevent database locking errors and ensure dependent objects exist.
           // eslint-disable-next-line no-await-in-loop
           await this.db.run(
             `CREATE INDEX IF NOT EXISTS ${this.quote(indexName)} ON ${this.quote(name)} (${fields})`,
@@ -123,11 +107,9 @@ export class SqliteAdapter implements Adapter {
     const mappedData = this.mapInput(model, data);
     const fields = Object.keys(mappedData);
 
-    // Avoid mapping strings over and over, pre-allocate placeholders
     const placeholders = Array.from({ length: fields.length }).fill("?").join(", ");
     const columns = fields.map((f) => this.quote(f)).join(", ");
 
-    // Avoid spreads
     const params: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
@@ -200,7 +182,9 @@ export class SqliteAdapter implements Adapter {
     const sql_parts: string[] = [query];
 
     if (where !== undefined || cursor !== undefined) {
-      const { sql, params } = this.buildWhere(where, cursor);
+      // Determine cursor direction based on the first sort field, defaulting to asc
+      const isAsc = !sortBy || !sortBy[0] || sortBy[0].direction !== "desc";
+      const { sql, params } = this.buildWhere(where, cursor, isAsc ? "asc" : "desc");
       sql_parts.push(`WHERE ${sql}`);
       for (let i = 0; i < params.length; i++) {
         const param = params[i];
@@ -241,7 +225,6 @@ export class SqliteAdapter implements Adapter {
 
     const { sql: whereSql, params: whereParams } = this.buildWhere(where);
 
-    // Avoid spreads
     const params: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
@@ -267,7 +250,6 @@ export class SqliteAdapter implements Adapter {
     const fields = Object.keys(mappedData);
     const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
 
-    // Avoid spreads
     const args_sql: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
@@ -400,12 +382,10 @@ export class SqliteAdapter implements Adapter {
   }
 
   async transaction<T>(fn: (tx: Adapter) => Promise<T>): Promise<T> {
-    // Generate a unique savepoint identifier for nested transactions
     const sp = `sp_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
 
     await this.db.run(`SAVEPOINT ${sp}`, []);
     try {
-      // By passing `this`, all sub-queries inherently participate in the active connection's savepoint
       const result = await fn(this);
       await this.db.run(`RELEASE SAVEPOINT ${sp}`, []);
       return result;
@@ -448,6 +428,7 @@ export class SqliteAdapter implements Adapter {
   private buildWhere<T>(
     where?: Where<T>,
     cursor?: Cursor<T>,
+    cursorDirection: "asc" | "desc" = "asc",
   ): { sql: string; params: SqliteValue[] } {
     const params: SqliteValue[] = [];
     const parts: string[] = [];
@@ -465,8 +446,9 @@ export class SqliteAdapter implements Adapter {
       const entries = Object.entries(cursor.after);
       if (entries.length > 0) {
         const cursorParts: string[] = [];
+        const operator = cursorDirection === "asc" ? ">" : "<";
         for (const [field, value] of entries) {
-          cursorParts.push(`${this.quote(field)} > ?`);
+          cursorParts.push(`${this.quote(field)} ${operator} ?`);
           params.push(this.mapWhereValue(value));
         }
         parts.push(`(${cursorParts.join(" AND ")})`);
@@ -625,7 +607,6 @@ export class SqliteAdapter implements Adapter {
       throw new Error("Invalid row data");
     }
 
-    // Mutate the raw row dictionary in-place rather than spreading `{ ...row }`
     for (const [fieldName, field] of Object.entries(model.fields)) {
       const val = row[fieldName];
       if (val === undefined || val === null) continue;
@@ -645,3 +626,19 @@ export class SqliteAdapter implements Adapter {
     throw new Error("Row does not conform to model bounds");
   }
 }
+
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function isValidField<T>(field: unknown): field is FieldName<T> {
+  return typeof field === "string" && field !== "";
+}
+
+function isStringKey(key: unknown): key is string {
+  return typeof key === "string" && key !== "";
+}
+
+function isModelType<T>(obj: unknown): obj is T {
+  return typeof obj === "object" && obj !== null;
+}

From 680af86f14bedbd28c7503f9202b3276a261adfd Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 17 Apr 2026 15:05:39 +0800
Subject: [PATCH 04/24] fix: add path to interface for nested-path filtering

---
 README.md                   |  2 +-
 src/adapters/sqlite.test.ts |  6 ++---
 src/adapters/sqlite.ts      | 45 ++++++++++++++++++++-----------------
 src/core.ts                 |  5 ++++-
 4 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/README.md b/README.md
index d181fbe..fd9232d 100644
--- a/README.md
+++ b/README.md
@@ -66,7 +66,7 @@ await adapter.migrate();
 // You can seamlessly query nested JSON!
 const darkUsers = await adapter.findMany({
   model: "conversations",
-  where: { field: "metadata->>theme", op: "eq", value: "dark" },
+  where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
 });
 
 // Create a record
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 2f1a82f..ccb84b8 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -143,7 +143,7 @@ describe("SqliteAdapter", () => {
     // 1. Exact match on nested string (theme = 'dark')
     const darkUsers = await adapter.findMany<User>({
       model: "users",
-      where: { field: "metadata->>theme", op: "eq", value: "dark" },
+      where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
     });
     expect(darkUsers).toHaveLength(2);
     expect(darkUsers.map((u) => u.name)).toContain("User1");
@@ -152,7 +152,7 @@ describe("SqliteAdapter", () => {
     // 2. Numeric operator on deeply nested number (window.width > 900)
     const wideUsers = await adapter.findMany<User>({
       model: "users",
-      where: { field: "metadata->>window->>width", op: "gt", value: 900 },
+      where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 }
     });
     expect(wideUsers).toHaveLength(2);
     expect(wideUsers.map((u) => u.name)).toContain("User2");
@@ -161,7 +161,7 @@ describe("SqliteAdapter", () => {
     // 3. IN operator on nested string
     const specificUsers = await adapter.findMany<User>({
       model: "users",
-      where: { field: "metadata->>window->>width", op: "in", value: [800, 1024] },
+      where: { field: "metadata", path: ["window", "width"], op: "in", value: [800, 1024] }
     });
     expect(specificUsers).toHaveLength(2);
     expect(specificUsers.map((u) => u.name)).toContain("User1");
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 084ed72..3d15d50 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -159,7 +159,7 @@ export class SqliteAdapter implements Adapter {
   }): Promise<T | null> {
     const { model, where, select } = args;
     const query = this.buildSelect(model, select);
-    const { sql, params } = this.buildWhere(where);
+    const { sql, params } = this.buildWhere(model, where);
 
     const fullSql = `${query} WHERE ${sql} LIMIT 1`;
     const row = await this.db.get(fullSql, params);
@@ -184,7 +184,7 @@ export class SqliteAdapter implements Adapter {
     if (where !== undefined || cursor !== undefined) {
       // Determine cursor direction based on the first sort field, defaulting to asc
       const isAsc = !sortBy || !sortBy[0] || sortBy[0].direction !== "desc";
-      const { sql, params } = this.buildWhere(where, cursor, isAsc ? "asc" : "desc");
+      const { sql, params } = this.buildWhere(model, where, cursor, isAsc ? "asc" : "desc");
       sql_parts.push(`WHERE ${sql}`);
       for (let i = 0; i < params.length; i++) {
         const param = params[i];
@@ -223,7 +223,7 @@ export class SqliteAdapter implements Adapter {
     const fields = Object.keys(mappedData);
     const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
 
-    const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+    const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
 
     const params: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
@@ -258,7 +258,7 @@ export class SqliteAdapter implements Adapter {
 
     let sql = `UPDATE ${this.quote(model)} SET ${setClause}`;
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
       sql += ` WHERE ${whereSql}`;
       for (let i = 0; i < whereParams.length; i++) {
         const param = whereParams[i];
@@ -275,7 +275,7 @@ export class SqliteAdapter implements Adapter {
     where: Where<T>;
   }): Promise<void> {
     const { model, where } = args;
-    const { sql, params } = this.buildWhere(where);
+    const { sql, params } = this.buildWhere(model, where);
     await this.db.run(`DELETE FROM ${this.quote(model)} WHERE ${sql}`, params);
   }
 
@@ -288,7 +288,7 @@ export class SqliteAdapter implements Adapter {
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
       sql += ` WHERE ${whereSql}`;
       for (let i = 0; i < whereParams.length; i++) {
         const param = whereParams[i];
@@ -309,7 +309,7 @@ export class SqliteAdapter implements Adapter {
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(where);
+      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
       sql += ` WHERE ${whereSql}`;
       for (let i = 0; i < whereParams.length; i++) {
         const param = whereParams[i];
@@ -426,15 +426,16 @@ export class SqliteAdapter implements Adapter {
   }
 
   private buildWhere<T>(
+    modelName: string,
     where?: Where<T>,
     cursor?: Cursor<T>,
-    cursorDirection: "asc" | "desc" = "asc",
+    cursorDirection: "asc" | "desc" = "asc"
   ): { sql: string; params: SqliteValue[] } {
     const params: SqliteValue[] = [];
     const parts: string[] = [];
 
     if (where !== undefined) {
-      const result = this.buildWhereRecursive(where);
+      const result = this.buildWhereRecursive(modelName, where);
       parts.push(result.sql);
       for (let i = 0; i < result.params.length; i++) {
         const param = result.params[i];
@@ -470,9 +471,9 @@ export class SqliteAdapter implements Adapter {
     }
   }
 
-  private buildWhereRecursive<T>(where: Where<T>): { sql: string; params: SqliteValue[] } {
+  private buildWhereRecursive<T>(modelName: string, where: Where<T>): { sql: string; params: SqliteValue[] } {
     if ("and" in where) {
-      const parts = where.and.map((w) => this.buildWhereRecursive(w));
+      const parts = where.and.map((w) => this.buildWhereRecursive(modelName, w));
       const sql = `(${parts.map((p) => p.sql).join(" AND ")})`;
       const params: SqliteValue[] = [];
       for (let i = 0; i < parts.length; i++) {
@@ -483,7 +484,7 @@ export class SqliteAdapter implements Adapter {
     }
 
     if ("or" in where) {
-      const parts = where.or.map((w) => this.buildWhereRecursive(w));
+      const parts = where.or.map((w) => this.buildWhereRecursive(modelName, w));
       const sql = `(${parts.map((p) => p.sql).join(" OR ")})`;
       const params: SqliteValue[] = [];
       for (let i = 0; i < parts.length; i++) {
@@ -493,21 +494,23 @@ export class SqliteAdapter implements Adapter {
       return { sql, params };
     }
 
-    const leaf = where as { field: string; op: string; value: unknown };
-    const { field, op, value } = leaf;
+    const leaf = where as { field: string; path?: string[]; op: string; value: unknown };
+    const { field, path, op, value } = leaf;
 
     let quotedField: string;
-    if (field.includes("->>")) {
-      const parts = field.split("->>");
-      const topLevelColumn = parts[0];
-      if (topLevelColumn === undefined) throw new Error("Invalid JSON path");
+    if (path !== undefined && path.length > 0) {
+      const modelSpec = this.schema[modelName];
+      const fieldSpec = modelSpec?.fields[field];
+      if (fieldSpec?.type.type !== "json") {
+        throw new Error(`Cannot use 'path' filter on non-JSON field: ${field}`);
+      }
 
-      const jsonPath = `$.${parts.slice(1).join(".")}`;
-      quotedField = `json_extract(${this.quote(topLevelColumn)}, '${jsonPath}')`;
+      const jsonPath = `$.${path.join(".")}`;
+      const escapedPath = jsonPath.replaceAll("'", "''");
+      quotedField = `json_extract(${this.quote(field)}, '${escapedPath}')`;
     } else {
       quotedField = this.quote(field);
     }
-
     switch (op) {
       case "eq":
         return { sql: `${quotedField} = ?`, params: [this.mapWhereValue(value)] };
diff --git a/src/core.ts b/src/core.ts
index 7cf83d9..e92865f 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -120,23 +120,26 @@ export interface Adapter {
   }): Promise<number>;
 }
 
-export type FieldName<T> = Extract<keyof T, string> | `${Extract<keyof T, string>}->>${string}`;
+export type FieldName<T> = Extract<keyof T, string>;
 
 export type Select<T> = ReadonlyArray<FieldName<T>>;
 
 export type Where<T = Record<string, unknown>> =
   | {
       field: FieldName<T>;
+      path?: string[];
       op: "eq" | "ne";
       value: unknown;
     }
   | {
       field: FieldName<T>;
+      path?: string[];
       op: "gt" | "gte" | "lt" | "lte";
       value: unknown;
     }
   | {
       field: FieldName<T>;
+      path?: string[];
       op: "in" | "not_in";
       value: unknown[];
     }

From b323bacc8e47b86ed7f98c2f2d53b63b505f86a0 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 17 Apr 2026 16:44:42 +0800
Subject: [PATCH 05/24] fix: address CodeRabbit comments and document
 limitations

---
 README.md                   |   6 ++
 src/adapters/sqlite.test.ts |  54 +++++++++++-
 src/adapters/sqlite.ts      | 159 ++++++++++++++++++++++++++----------
 src/core.ts                 |   1 +
 4 files changed, 175 insertions(+), 45 deletions(-)

diff --git a/README.md b/README.md
index fd9232d..792a7a0 100644
--- a/README.md
+++ b/README.md
@@ -94,3 +94,9 @@ const results = await adapter.findMany({
 ## License
 
 MIT
+
+### Limitations
+
+- **Upserts on JSON paths:** Upsert operations require the conflict target to be explicitly identifiable by the database engine (like a `UNIQUE` index or `PRIMARY KEY`). Because `no-orm` focuses on minimal schema bootstrapping and doesn't enforce `UNIQUE` expression indexes natively in v1, upsert operations containing `path` arguments in the `where` clause will throw an error to prevent silent data corruption.
+
+- **Concurrent Transactions:** `no-orm` does not manage connection pools or implement JavaScript mutexes. If you share a single database connection globally (e.g., a single `bun:sqlite` instance) across concurrent web requests, their `adapter.transaction()` calls will interleave on the same connection, causing unpredictable rollbacks. For concurrent transactions, you must instantiate a new `Adapter` per request using a dedicated connection from a pool.
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index ccb84b8..257d688 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -152,7 +152,7 @@ describe("SqliteAdapter", () => {
     // 2. Numeric operator on deeply nested number (window.width > 900)
     const wideUsers = await adapter.findMany<User>({
       model: "users",
-      where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 }
+      where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 },
     });
     expect(wideUsers).toHaveLength(2);
     expect(wideUsers.map((u) => u.name)).toContain("User2");
@@ -161,7 +161,7 @@ describe("SqliteAdapter", () => {
     // 3. IN operator on nested string
     const specificUsers = await adapter.findMany<User>({
       model: "users",
-      where: { field: "metadata", path: ["window", "width"], op: "in", value: [800, 1024] }
+      where: { field: "metadata", path: ["window", "width"], op: "in", value: [800, 1024] },
     });
     expect(specificUsers).toHaveLength(2);
     expect(specificUsers.map((u) => u.name)).toContain("User1");
@@ -356,7 +356,7 @@ describe("SqliteAdapter", () => {
         where: { field: "id", op: "eq", value: "n2" },
       });
 
-      expect(outer1?.name).toBe("Outer1"); // Reverted the update from inner tx
+      expect(outer1?.name).toBe("Outer1"); // Inner tx rolled back; update to n1 was never applied
       expect(outer2).not.toBeNull();
 
       // Inner operations should rollback (n3 does not exist)
@@ -369,6 +369,54 @@ describe("SqliteAdapter", () => {
   });
 
   describe("Pagination", () => {
+    it("should handle multi-field keyset pagination correctly", async () => {
+      // Seed data specifically for multi-field sort
+      await adapter.create({
+        model: "users",
+        data: { id: "m1", name: "A", age: 30, is_active: true, metadata: null },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "m2", name: "B", age: 30, is_active: true, metadata: null },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "m3", name: "C", age: 30, is_active: true, metadata: null },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "m4", name: "A", age: 31, is_active: true, metadata: null },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "m5", name: "B", age: 31, is_active: true, metadata: null },
+      });
+
+      const result = await adapter.findMany<User>({
+        model: "users",
+        sortBy: [
+          { field: "age", direction: "asc" },
+          { field: "name", direction: "desc" },
+        ],
+        cursor: {
+          after: { age: 30, name: "B" }, // Cursor points to m2
+        },
+        limit: 3,
+      });
+
+      // Sorted order:
+      // 1. age: 30, name: "C" (m3) -> skipped (before cursor)
+      // 2. age: 30, name: "B" (m2) -> cursor
+      // 3. age: 30, name: "A" (m1) -> match 1
+      // 4. age: 31, name: "B" (m5) -> match 2
+      // 5. age: 31, name: "A" (m4) -> match 3
+
+      expect(result).toHaveLength(3);
+      expect(result[0]?.id).toBe("m1"); // age 30, name A (asc 30 == 30, desc A < B)
+      expect(result[1]?.id).toBe("m5"); // age 31, name B (asc 31 > 30)
+      expect(result[2]?.id).toBe("m4"); // age 31, name A
+    });
+
     beforeEach(async () => {
       // Seed data for pagination
       const creations = [];
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 3d15d50..fd6b856 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -182,9 +182,7 @@ export class SqliteAdapter implements Adapter {
     const sql_parts: string[] = [query];
 
     if (where !== undefined || cursor !== undefined) {
-      // Determine cursor direction based on the first sort field, defaulting to asc
-      const isAsc = !sortBy || !sortBy[0] || sortBy[0].direction !== "desc";
-      const { sql, params } = this.buildWhere(model, where, cursor, isAsc ? "asc" : "desc");
+      const { sql, params } = this.buildWhere(model, where, cursor, sortBy);
       sql_parts.push(`WHERE ${sql}`);
       for (let i = 0; i < params.length; i++) {
         const param = params[i];
@@ -194,7 +192,10 @@ export class SqliteAdapter implements Adapter {
 
     if (sortBy !== undefined) {
       const order = sortBy
-        .map((s) => `${this.quote(s.field)} ${s.direction?.toUpperCase() ?? "ASC"}`)
+        .map((s) => {
+          const col = this.buildColumnExpr(model, s.field as string, s.path);
+          return `${col} ${s.direction?.toUpperCase() ?? "ASC"}`;
+        })
         .join(", ");
       sql_parts.push(`ORDER BY ${order}`);
     }
@@ -329,10 +330,35 @@ export class SqliteAdapter implements Adapter {
     update: Partial<T>;
     select?: Select<T>;
   }): Promise<T> {
-    const { model, create, update, select } = args;
+    const { model, where, create, update, select } = args;
     const modelSpec = this.schema[model];
     if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
 
+    const extractConflictTargets = (w: Where<T>): string[] => {
+      if ("and" in w) {
+        const parts: string[] = [];
+        for (const sub of w.and) {
+          parts.push(...extractConflictTargets(sub));
+        }
+        return parts;
+      }
+      if ("or" in w) throw new Error("Upsert 'where' clause does not support 'or' operator.");
+
+      const leaf = w as { field: string; path?: string[]; op: string };
+      if (leaf.op !== "eq") throw new Error("Upsert 'where' clause only supports 'eq' operator.");
+
+      if (leaf.path && leaf.path.length > 0) {
+        throw new Error("Upsert operations by JSON path are currently unsupported.");
+      }
+
+      return [this.quote(leaf.field)];
+    };
+
+    const conflictTargets = extractConflictTargets(where);
+    if (conflictTargets.length === 0)
+      throw new Error("Upsert requires at least one conflict column in the 'where' clause.");
+    const conflictTargetSql = conflictTargets.join(", ");
+
     const mappedCreate = this.mapInput(model, create);
     const fields = Object.keys(mappedCreate);
     const columns = fields.map((f) => this.quote(f)).join(", ");
@@ -342,9 +368,7 @@ export class SqliteAdapter implements Adapter {
     const updateFields = Object.keys(mappedUpdate);
     const updateClause = updateFields.map((f) => `${this.quote(f)} = ?`).join(", ");
 
-    const pkFields = modelSpec.primaryKey.fields.map((f) => this.quote(f)).join(", ");
-
-    const sql = `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${pkFields}) DO UPDATE SET ${updateClause}`;
+    const sql = `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${conflictTargetSql}) DO UPDATE SET ${updateClause}`;
 
     const params: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
@@ -382,7 +406,7 @@ export class SqliteAdapter implements Adapter {
   }
 
   async transaction<T>(fn: (tx: Adapter) => Promise<T>): Promise<T> {
-    const sp = `sp_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+    const sp = this.quote(`sp_${Date.now()}_${Math.floor(Math.random() * 100000)}`);
 
     await this.db.run(`SAVEPOINT ${sp}`, []);
     try {
@@ -394,7 +418,6 @@ export class SqliteAdapter implements Adapter {
       throw error;
     }
   }
-
   // --- Helpers ---
 
   private quote(name: string): string {
@@ -425,11 +448,83 @@ export class SqliteAdapter implements Adapter {
     return `SELECT * FROM ${this.quote(model)}`;
   }
 
+  private buildColumnExpr(modelName: string, field: string, path?: string[]): string {
+    if (path !== undefined && path.length > 0) {
+      const modelSpec = this.schema[modelName];
+      const fieldSpec = modelSpec?.fields[field];
+      if (fieldSpec?.type.type !== "json") {
+        throw new Error(`Cannot use 'path' filter on non-JSON field: ${field}`);
+      }
+
+      const jsonPath = `$.${path.join(".")}`;
+      const escapedPath = jsonPath.replaceAll("'", "''");
+      return `json_extract(${this.quote(field)}, '${escapedPath}')`;
+    }
+    return this.quote(field);
+  }
+
+  private buildCursor<T>(
+    modelName: string,
+    cursor: Cursor<T>,
+    sortBy?: SortBy<T>[],
+  ): { sql: string; params: SqliteValue[] } {
+    const entries = Object.entries(cursor.after);
+    if (entries.length === 0) return { sql: "", params: [] };
+
+    const sortCriteria: SortBy<T>[] =
+      sortBy && sortBy.length > 0
+        ? sortBy
+        : entries.map(([field]) => {
+            if (!isValidField<T>(field)) throw new Error("Invalid cursor field");
+            return { field, direction: "asc" };
+          });
+
+    const validSorts = sortCriteria.filter((s) => {
+      return cursor.after[s.field] !== undefined;
+    });
+
+    const orParts: string[] = [];
+    const cursorParams: SqliteValue[] = [];
+
+    for (let i = 0; i < validSorts.length; i++) {
+      const currentSort = validSorts[i];
+      if (!currentSort) continue;
+
+      const andParts: string[] = [];
+
+      for (let j = 0; j < i; j++) {
+        const prevSort = validSorts[j];
+        if (!prevSort) continue;
+        const colExpr = this.buildColumnExpr(modelName, prevSort.field as string, prevSort.path);
+        andParts.push(`${colExpr} = ?`);
+        cursorParams.push(this.mapWhereValue(cursor.after[prevSort.field]));
+      }
+
+      const op = currentSort.direction === "desc" ? "<" : ">";
+      const colExpr = this.buildColumnExpr(
+        modelName,
+        currentSort.field as string,
+        currentSort.path,
+      );
+      andParts.push(`${colExpr} ${op} ?`);
+      cursorParams.push(this.mapWhereValue(cursor.after[currentSort.field]));
+
+      orParts.push(`(${andParts.join(" AND ")})`);
+    }
+
+    if (orParts.length === 0) return { sql: "", params: [] };
+
+    return {
+      sql: `(${orParts.join(" OR ")})`,
+      params: cursorParams,
+    };
+  }
+
   private buildWhere<T>(
     modelName: string,
     where?: Where<T>,
     cursor?: Cursor<T>,
-    cursorDirection: "asc" | "desc" = "asc"
+    sortBy?: SortBy<T>[],
   ): { sql: string; params: SqliteValue[] } {
     const params: SqliteValue[] = [];
     const parts: string[] = [];
@@ -437,31 +532,20 @@ export class SqliteAdapter implements Adapter {
     if (where !== undefined) {
       const result = this.buildWhereRecursive(modelName, where);
       parts.push(result.sql);
-      for (let i = 0; i < result.params.length; i++) {
-        const param = result.params[i];
-        if (param !== undefined) params.push(param);
-      }
+      this.appendParams(params, result.params);
     }
 
     if (cursor !== undefined) {
-      const entries = Object.entries(cursor.after);
-      if (entries.length > 0) {
-        const cursorParts: string[] = [];
-        const operator = cursorDirection === "asc" ? ">" : "<";
-        for (const [field, value] of entries) {
-          cursorParts.push(`${this.quote(field)} ${operator} ?`);
-          params.push(this.mapWhereValue(value));
-        }
-        parts.push(`(${cursorParts.join(" AND ")})`);
+      const cursorResult = this.buildCursor(modelName, cursor, sortBy);
+      if (cursorResult.sql !== "") {
+        parts.push(cursorResult.sql);
+        this.appendParams(params, cursorResult.params);
       }
     }
 
     const sql = parts.length > 1 ? parts.map((p) => `(${p})`).join(" AND ") : (parts[0] ?? "1=1");
 
-    return {
-      sql,
-      params,
-    };
+    return { sql, params };
   }
 
   private appendParams(target: SqliteValue[], source: SqliteValue[]): void {
@@ -471,7 +555,10 @@ export class SqliteAdapter implements Adapter {
     }
   }
 
-  private buildWhereRecursive<T>(modelName: string, where: Where<T>): { sql: string; params: SqliteValue[] } {
+  private buildWhereRecursive<T>(
+    modelName: string,
+    where: Where<T>,
+  ): { sql: string; params: SqliteValue[] } {
     if ("and" in where) {
       const parts = where.and.map((w) => this.buildWhereRecursive(modelName, w));
       const sql = `(${parts.map((p) => p.sql).join(" AND ")})`;
@@ -497,20 +584,8 @@ export class SqliteAdapter implements Adapter {
     const leaf = where as { field: string; path?: string[]; op: string; value: unknown };
     const { field, path, op, value } = leaf;
 
-    let quotedField: string;
-    if (path !== undefined && path.length > 0) {
-      const modelSpec = this.schema[modelName];
-      const fieldSpec = modelSpec?.fields[field];
-      if (fieldSpec?.type.type !== "json") {
-        throw new Error(`Cannot use 'path' filter on non-JSON field: ${field}`);
-      }
+    const quotedField = this.buildColumnExpr(modelName, field, path);
 
-      const jsonPath = `$.${path.join(".")}`;
-      const escapedPath = jsonPath.replaceAll("'", "''");
-      quotedField = `json_extract(${this.quote(field)}, '${escapedPath}')`;
-    } else {
-      quotedField = this.quote(field);
-    }
     switch (op) {
       case "eq":
         return { sql: `${quotedField} = ?`, params: [this.mapWhereValue(value)] };
diff --git a/src/core.ts b/src/core.ts
index e92865f..a30e24c 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -152,6 +152,7 @@ export type Where<T = Record<string, unknown>> =
 
 export interface SortBy<T = Record<string, unknown>> {
   field: FieldName<T>;
+  path?: string[];
   direction?: "asc" | "desc";
 }
 

From be054ee39d6caf09951034beb9a9656992a221c6 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Mon, 20 Apr 2026 04:58:44 +0800
Subject: [PATCH 06/24] fix: address H comments

---
 README.md                           | 112 +++--
 src/adapters/sqlite.test.ts         | 646 ++++++++++++----------------
 src/adapters/sqlite.ts              | 419 ++++++++----------
 src/adapters/sqlite.types.ts        |  23 +
 src/index.ts                        |   2 +-
 src/{core.test.ts => types.test.ts} |   2 +-
 src/{core.ts => types.ts}           |  84 ++--
 src/utils/is.ts                     |  17 +
 src/utils/sql.ts                    |   7 +
 9 files changed, 614 insertions(+), 698 deletions(-)
 create mode 100644 src/adapters/sqlite.types.ts
 rename src/{core.test.ts => types.test.ts} (97%)
 rename src/{core.ts => types.ts} (59%)
 create mode 100644 src/utils/is.ts
 create mode 100644 src/utils/sql.ts

diff --git a/README.md b/README.md
index 792a7a0..cf5d2cc 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,14 @@
-# no-orm
+# @8monkey/no-orm
 
-A tiny, database-independent persistence core for TypeScript libraries. No heavy abstractions, just the primitives.
+A tiny, composable ORM core for TypeScript libraries. No heavy abstractions, just the primitives to build cross-database tools with full type safety.
 
 ## Features
 
-- **Canonical Schema**: One portable schema representation for any database.
-- **Type Inference**: Derive TypeScript types directly from your schema.
-- **Adapter-Based**: Small, generic execution contract for multiple backends.
+- **Tiny Core**: Minimal overhead, focuses on schema definition and basic CRUD.
+- **Full Type Safety**: Inferred models from your schema definition.
+- **Adapter-Based**: Switch between SQLite, PostgreSQL (coming soon), and more.
+- **Nested JSON Support**: Query and filter nested JSON fields seamlessly.
+- **Transactions**: Built-in support for stacked transactions with automatic rollbacks.
 
 ## Installation
 
@@ -14,7 +16,7 @@ A tiny, database-independent persistence core for TypeScript libraries. No heavy
 bun add @8monkey/no-orm
 ```
 
-## Usage
+## Quick Start
 
 ### 1. Define your Schema
 
@@ -22,81 +24,71 @@ bun add @8monkey/no-orm
 import { Schema } from "@8monkey/no-orm";
 
 export const schema = {
-  conversations: {
+  users: {
     fields: {
-      id: { type: { type: "string", max: 255 } },
-      created_at: { type: { type: "timestamp" } },
-      metadata: { type: { type: "json" }, nullable: true },
-    },
-    primaryKey: {
-      fields: ["id"],
+      id: { type: "string" },
+      name: { type: "string" },
+      age: { type: "number" },
+      metadata: { type: "json", nullable: true },
+      tags: { type: "json[]" },
     },
+    primaryKey: "id",
     indexes: [
-      {
-        fields: [
-          { field: "created_at", order: "desc" },
-          { field: "id", order: "desc" },
-        ],
-      },
+      { field: "age" },
+      { field: ["name", "age"], order: "desc" },
     ],
   },
 } as const satisfies Schema;
 ```
 
-### 2. Infer Types
-
-```typescript
-import { InferModel } from "@8monkey/no-orm";
-
-export type Conversation = InferModel<typeof schema.conversations>;
-// Result: { id: string; created_at: number; metadata: Record<string, unknown> | null; }
-```
-
-### 3. Use an Adapter
+### 2. Initialize the Adapter
 
 ```typescript
-import { Adapter } from "@8monkey/no-orm";
-// Import a concrete adapter (e.g., @8monkey/no-orm-sqlite)
+import { SqliteAdapter } from "@8monkey/no-orm/adapters/sqlite";
+import { Database } from "bun:sqlite";
 
-const adapter: Adapter = new SqliteAdapter(schema, db);
+const db = new Database(":memory:");
+const adapter = new SqliteAdapter(schema, db);
 
-// Minimal Schema Bootstrap
 await adapter.migrate();
 
 // You can seamlessly query nested JSON!
-const darkUsers = await adapter.findMany({
-  model: "conversations",
-  where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
-});
-
-// Create a record
-const conv = await adapter.create({
-  model: "conversations",
-  data: {
-    id: "conv_123",
-    created_at: Date.now(),
-    metadata: { theme: "dark" },
-  },
-});
-
-// Find many with filters
-const results = await adapter.findMany({
-  model: "conversations",
+const users = await adapter.findMany({
+  model: "users",
   where: {
-    field: "created_at",
-    op: "gt",
-    value: Date.now() - 86400000,
+    field: "metadata",
+    path: ["settings", "theme"],
+    op: "eq",
+    value: "dark",
   },
-  limit: 10,
 });
 ```
 
-## License
+### 3. Transactions
 
-MIT
+```typescript
+await adapter.transaction(async (tx) => {
+  await tx.create({
+    model: "users",
+    data: { id: "1", name: "Alice", age: 30, tags: ["admin"] },
+  });
+  
+  // Nested transactions use SAVEPOINTs automatically
+  await tx.transaction(async (inner) => {
+    await inner.update({
+      model: "users",
+      where: { field: "id", op: "eq", value: "1" },
+      data: { age: 31 },
+    });
+  });
+});
+```
+
+## Limitations
 
-### Limitations
+- **Concurrent Transactions**: If you share a single database connection globally (e.g., a single `bun:sqlite` instance) across concurrent web requests, their `adapter.transaction()` calls will interleave on the same connection. `no-orm` uses `AsyncLocalStorage` to ensure that operations within a transaction block use the correct savepoint state, but for true isolation in highly concurrent environments, consider a connection pool.
+- **Upserts on JSON paths**: Upsert operations require the conflict target to be explicitly identifiable (like a `PRIMARY KEY`). `no-orm` does not support using `path` arguments in the `where` clause for `upsert` to prevent ambiguity.
 
-- **Upserts on JSON paths:** Upsert operations require the conflict target to be explicitly identifiable by the database engine (like a `UNIQUE` index or `PRIMARY KEY`). Because `no-orm` focuses on minimal schema bootstrapping and doesn't enforce `UNIQUE` expression indexes natively in v1, upsert operations containing `path` arguments in the `where` clause will throw an error to prevent silent data corruption.
+## License
 
-- **Concurrent Transactions:** `no-orm` does not manage connection pools or implement JavaScript mutexes. If you share a single database connection globally (e.g., a single `bun:sqlite` instance) across concurrent web requests, their `adapter.transaction()` calls will interleave on the same connection, causing unpredictable rollbacks. For concurrent transactions, you must instantiate a new `Adapter` per request using a dedicated connection from a pool.
+MIT
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 257d688..593c91f 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -1,28 +1,35 @@
-import { Database } from "bun:sqlite";
 import { describe, expect, it, beforeEach } from "bun:test";
-
-import type { Schema, InferModel } from "../core";
+import { Database } from "bun:sqlite";
 import { SqliteAdapter } from "./sqlite";
-
-describe("SqliteAdapter", () => {
-  const schema = {
-    users: {
-      fields: {
-        id: { type: { type: "string" } },
-        name: { type: { type: "string" } },
-        age: { type: { type: "number" } },
-        is_active: { type: { type: "boolean" } },
-        metadata: { type: { type: "json" }, nullable: true },
-      },
-      primaryKey: { fields: ["id"] },
-      indexes: [{ fields: [{ field: "name" }] }],
+import type { Schema } from "../types";
+
+const schema = {
+  users: {
+    fields: {
+      id: { type: "string" },
+      name: { type: "string" },
+      age: { type: "number" },
+      is_active: { type: "boolean" },
+      metadata: { type: "json", nullable: true },
+      tags: { type: "json[]", nullable: true },
     },
-  } as const satisfies Schema;
+    primaryKey: "id",
+    indexes: [{ field: "name" }, { field: "age" }],
+  },
+} as const satisfies Schema;
+
+type User = {
+  id: string;
+  name: string;
+  age: number;
+  is_active: boolean;
+  metadata?: { theme: string; window?: { width: number } } | null;
+  tags?: string[] | null;
+};
 
-  type User = InferModel<typeof schema.users>;
-
-  let adapter: SqliteAdapter;
+describe("SqliteAdapter", () => {
   let db: Database;
+  let adapter: SqliteAdapter<typeof schema>;
 
   beforeEach(async () => {
     db = new Database(":memory:");
@@ -30,453 +37,368 @@ describe("SqliteAdapter", () => {
     await adapter.migrate();
   });
 
-  it("should create and find a record", async () => {
-    const userData: User = {
-      id: "u1",
-      name: "Alice",
-      age: 25,
-      is_active: true,
-      metadata: { theme: "dark" },
-    };
-
-    await adapter.create({ model: "users", data: userData });
-
-    const found = await adapter.find<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
-    });
-
-    expect(found).toEqual(userData);
-  });
-
-  it("should find multiple records with filters", async () => {
-    await adapter.create({
-      model: "users",
-      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
-    });
-    await adapter.create({
-      model: "users",
-      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
-    });
-    await adapter.create({
-      model: "users",
-      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
-    });
-
-    const actives = await adapter.findMany<User>({
-      model: "users",
-      where: { field: "is_active", op: "eq", value: true },
-      sortBy: [{ field: "age", direction: "asc" }],
-    });
-
-    expect(actives).toHaveLength(2);
-    expect(actives[0]?.name).toBe("Alice");
-    expect(actives[1]?.name).toBe("Charlie");
-  });
-
-  it("should handle complex AND / OR where clauses", async () => {
-    await adapter.create({
-      model: "users",
-      data: { id: "u1", name: "Alice", age: 20, is_active: true, metadata: null },
-    });
-    await adapter.create({
-      model: "users",
-      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
-    });
-    await adapter.create({
-      model: "users",
-      data: { id: "u3", name: "Charlie", age: 40, is_active: false, metadata: null },
-    });
+  describe("Basic CRUD", () => {
+    it("should create and find a record", async () => {
+      const user: User = {
+        id: "u1",
+        name: "Alice",
+        age: 30,
+        is_active: true,
+        metadata: { theme: "dark" },
+        tags: ["admin"],
+      };
+      await adapter.create({ model: "users", data: user });
 
-    const found = await adapter.findMany<User>({
-      model: "users",
-      where: {
-        or: [
-          {
-            and: [
-              { field: "age", op: "gte", value: 30 },
-              { field: "is_active", op: "eq", value: true },
-            ],
-          },
-          { field: "name", op: "eq", value: "Charlie" },
-        ],
-      },
+      const found = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found).toEqual(expect.objectContaining(user));
     });
 
-    expect(found).toHaveLength(2);
-    expect(found.map((f) => f.name)).toContain("Bob");
-    expect(found.map((f) => f.name)).toContain("Charlie");
-  });
-
-  it("should handle nested JSON path filtering with `->>` syntax", async () => {
-    await adapter.create({
-      model: "users",
-      data: {
-        id: "j1",
-        name: "User1",
-        age: 20,
-        is_active: true,
-        metadata: { theme: "dark", window: { width: 800 } },
-      },
-    });
-    await adapter.create({
-      model: "users",
-      data: {
-        id: "j2",
-        name: "User2",
-        age: 20,
-        is_active: true,
-        metadata: { theme: "light", window: { width: 1024 } },
-      },
-    });
-    await adapter.create({
-      model: "users",
-      data: {
-        id: "j3",
-        name: "User3",
-        age: 20,
-        is_active: true,
-        metadata: { theme: "dark", window: { width: 1920 } },
-      },
+    it("should update a record and refetch correctly", async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "u1", name: "Alice", age: 30, is_active: true },
+      });
+      const updated = await adapter.update({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+        data: { age: 31 },
+      });
+      expect(updated?.age).toBe(31);
     });
 
-    // 1. Exact match on nested string (theme = 'dark')
-    const darkUsers = await adapter.findMany<User>({
-      model: "users",
-      where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
-    });
-    expect(darkUsers).toHaveLength(2);
-    expect(darkUsers.map((u) => u.name)).toContain("User1");
-    expect(darkUsers.map((u) => u.name)).toContain("User3");
-
-    // 2. Numeric operator on deeply nested number (window.width > 900)
-    const wideUsers = await adapter.findMany<User>({
-      model: "users",
-      where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 },
-    });
-    expect(wideUsers).toHaveLength(2);
-    expect(wideUsers.map((u) => u.name)).toContain("User2");
-    expect(wideUsers.map((u) => u.name)).toContain("User3");
-
-    // 3. IN operator on nested string
-    const specificUsers = await adapter.findMany<User>({
-      model: "users",
-      where: { field: "metadata", path: ["window", "width"], op: "in", value: [800, 1024] },
+    it("should delete a record", async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "u1", name: "Alice", age: 30, is_active: true },
+      });
+      await adapter.delete({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      const found = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found).toBeNull();
     });
-    expect(specificUsers).toHaveLength(2);
-    expect(specificUsers.map((u) => u.name)).toContain("User1");
-    expect(specificUsers.map((u) => u.name)).toContain("User2");
   });
 
-  it("should update a record", async () => {
-    await adapter.create({
-      model: "users",
-      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+  describe("Filtering and Sorting", () => {
+    beforeEach(async () => {
+      await Promise.all([
+        adapter.create({
+          model: "users",
+          data: { id: "u1", name: "Alice", age: 25, is_active: true },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "u2", name: "Bob", age: 30, is_active: false },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "u3", name: "Charlie", age: 35, is_active: true },
+        }),
+      ]);
     });
 
-    await adapter.update<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
-      data: { age: 26 },
+    it("should filter with 'in' operator", async () => {
+      const users = await adapter.findMany({
+        model: "users",
+        where: { field: "age", op: "in", value: [25, 35] },
+      });
+      expect(users).toHaveLength(2);
     });
 
-    const updated = await adapter.find<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
+    it("should handle empty 'in' list gracefully", async () => {
+      const users = await adapter.findMany({
+        model: "users",
+        where: { field: "age", op: "in", value: [] },
+      });
+      expect(users).toHaveLength(0);
     });
 
-    expect(updated?.age).toBe(26);
-  });
-
-  it("should delete a record", async () => {
-    await adapter.create({
-      model: "users",
-      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
-    });
+    it("should handle complex AND / OR where clauses", async () => {
+      const found = await adapter.findMany({
+        model: "users",
+        where: {
+          or: [
+            {
+              and: [
+                { field: "age", op: "gte", value: 30 },
+                { field: "is_active", op: "eq", value: true },
+              ],
+            },
+            { field: "name", op: "eq", value: "Bob" },
+          ],
+        },
+      });
 
-    await adapter.delete({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
+      expect(found).toHaveLength(2);
+      expect(found.map((f) => f.name)).toContain("Bob");
+      expect(found.map((f) => f.name)).toContain("Charlie");
     });
 
-    const found = await adapter.find<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
+    it("should sort records", async () => {
+      const users = await adapter.findMany({
+        model: "users",
+        sortBy: [{ field: "age", direction: "desc" }],
+      });
+      expect(users[0]?.id).toBe("u3");
     });
-
-    expect(found).toBeNull();
   });
 
-  it("should upsert a record", async () => {
-    const data = { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null };
-
-    // Insert
-    await adapter.upsert({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
-      create: data,
-      update: { age: 26 },
-    });
+  describe("JSON Path Filtering", () => {
+    it("should handle nested JSON path filtering", async () => {
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "j1",
+          name: "User1",
+          age: 20,
+          is_active: true,
+          metadata: { theme: "dark", window: { width: 800 } },
+        },
+      });
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "j2",
+          name: "User2",
+          age: 20,
+          is_active: true,
+          metadata: { theme: "light", window: { width: 1024 } },
+        },
+      });
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "j3",
+          name: "User3",
+          age: 20,
+          is_active: true,
+          metadata: { theme: "dark", window: { width: 1920 } },
+        },
+      });
 
-    let found = await adapter.find<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
-    });
-    expect(found?.age).toBe(25);
-
-    // Update
-    await adapter.upsert({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
-      create: data,
-      update: { age: 26 },
-    });
+      // 1. Exact match on nested string (theme = 'dark')
+      const darkUsers = await adapter.findMany({
+        model: "users",
+        where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
+      });
+      expect(darkUsers).toHaveLength(2);
 
-    found = await adapter.find<User>({
-      model: "users",
-      where: { field: "id", op: "eq", value: "u1" },
+      // 2. Numeric operator on deeply nested number (window.width > 900)
+      const wideUsers = await adapter.findMany({
+        model: "users",
+        where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 },
+      });
+      expect(wideUsers).toHaveLength(2);
     });
-    expect(found?.age).toBe(26);
   });
 
   describe("Transactions", () => {
-    it("should successfully commit multiple operations in a transaction", async () => {
+    it("should commit successful transactions", async () => {
       await adapter.transaction(async (tx) => {
         await tx.create({
           model: "users",
-          data: { id: "t1", name: "TxUser1", age: 20, is_active: true, metadata: null },
-        });
-        await tx.create({
-          model: "users",
-          data: { id: "t2", name: "TxUser2", age: 25, is_active: true, metadata: null },
-        });
-        await tx.update<User>({
-          model: "users",
-          where: { field: "id", op: "eq", value: "t1" },
-          data: { age: 21 },
+          data: { id: "t1", name: "TxUser1", age: 20, is_active: true },
         });
       });
-
-      const found1 = await adapter.find<User>({
+      const found = await adapter.find({
         model: "users",
         where: { field: "id", op: "eq", value: "t1" },
       });
-      const found2 = await adapter.find<User>({
-        model: "users",
-        where: { field: "id", op: "eq", value: "t2" },
-      });
-
-      expect(found1?.age).toBe(21);
-      expect(found2?.name).toBe("TxUser2");
+      expect(found).not.toBeNull();
     });
 
-    it("should rollback all operations in a failed transaction", async () => {
-      // Pre-existing record
-      await adapter.create({
-        model: "users",
-        data: { id: "t3", name: "Existing", age: 30, is_active: true, metadata: null },
-      });
-
+    it("should rollback failed transactions", async () => {
       try {
         await adapter.transaction(async (tx) => {
-          // Operation 1: Create new
           await tx.create({
             model: "users",
-            data: { id: "t4", name: "NewUser", age: 20, is_active: true, metadata: null },
-          });
-          // Operation 2: Update existing
-          await tx.update<User>({
-            model: "users",
-            where: { field: "id", op: "eq", value: "t3" },
-            data: { age: 31 },
+            data: { id: "t1", name: "TxUser1", age: 20, is_active: true },
           });
-          throw new Error("Force rollback");
+          throw new Error("Failure");
         });
-      } catch (e) {
-        if (e instanceof Error) {
-          expect(e.message).toBe("Force rollback");
-        }
+      } catch {
+        // expected
       }
-
-      // Verify new record was NOT created
-      const foundNew = await adapter.find({
-        model: "users",
-        where: { field: "id", op: "eq", value: "t4" },
-      });
-      expect(foundNew).toBeNull();
-
-      // Verify existing record was NOT updated
-      const foundExisting = await adapter.find<User>({
+      const found = await adapter.find({
         model: "users",
-        where: { field: "id", op: "eq", value: "t3" },
+        where: { field: "id", op: "eq", value: "t1" },
       });
-      expect(foundExisting?.age).toBe(30); // Still 30, not 31
+      expect(found).toBeNull();
     });
 
-    it("should handle multiple operations in nested transactions via savepoints", async () => {
-      await adapter.transaction(async (tx1) => {
-        // Outer operations
-        await tx1.create({
-          model: "users",
-          data: { id: "n1", name: "Outer1", age: 20, is_active: true, metadata: null },
-        });
-        await tx1.create({
+    it("should handle nested transactions with savepoints", async () => {
+      await adapter.transaction(async (outer) => {
+        await outer.create({
           model: "users",
-          data: { id: "n2", name: "Outer2", age: 20, is_active: true, metadata: null },
+          data: { id: "n1", name: "Outer1", age: 20, is_active: true },
         });
 
         try {
-          if (tx1.transaction) {
-            await tx1.transaction(async (tx2) => {
-              // Inner operations
-              await tx2.create({
-                model: "users",
-                data: { id: "n3", name: "Inner1", age: 20, is_active: true, metadata: null },
-              });
-              await tx2.update<User>({
-                model: "users",
-                where: { field: "id", op: "eq", value: "n1" }, // Modifying outer record
-                data: { name: "Outer1_Modified" },
-              });
-              throw new Error("Inner rollback");
+          await outer.transaction(async (inner) => {
+            await inner.update({
+              model: "users",
+              where: { field: "id", op: "eq", value: "n1" },
+              data: { age: 40 },
             });
-          }
+            throw new Error("Inner fail");
+          });
         } catch {
-          // Expected inner rollback
+          // expected
         }
       });
 
-      // Outer operations should commit (n1 and n2 exist, but n1 is NOT modified by inner)
-      const outer1 = await adapter.find<User>({
+      const found = await adapter.find({
         model: "users",
         where: { field: "id", op: "eq", value: "n1" },
       });
-      const outer2 = await adapter.find<User>({
-        model: "users",
-        where: { field: "id", op: "eq", value: "n2" },
-      });
-
-      expect(outer1?.name).toBe("Outer1"); // Inner tx rolled back; update to n1 was never applied
-      expect(outer2).not.toBeNull();
-
-      // Inner operations should rollback (n3 does not exist)
-      const inner = await adapter.find({
-        model: "users",
-        where: { field: "id", op: "eq", value: "n3" },
-      });
-      expect(inner).toBeNull();
+      expect(found?.age).toBe(20);
     });
   });
 
   describe("Pagination", () => {
     it("should handle multi-field keyset pagination correctly", async () => {
-      // Seed data specifically for multi-field sort
       await adapter.create({
         model: "users",
-        data: { id: "m1", name: "A", age: 30, is_active: true, metadata: null },
+        data: { id: "m1", name: "A", age: 30, is_active: true },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m2", name: "B", age: 30, is_active: true, metadata: null },
+        data: { id: "m2", name: "B", age: 30, is_active: true },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m3", name: "C", age: 30, is_active: true, metadata: null },
+        data: { id: "m3", name: "C", age: 30, is_active: true },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m4", name: "A", age: 31, is_active: true, metadata: null },
+        data: { id: "m4", name: "A", age: 31, is_active: true },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m5", name: "B", age: 31, is_active: true, metadata: null },
+        data: { id: "m5", name: "B", age: 31, is_active: true },
       });
 
-      const result = await adapter.findMany<User>({
+      const result = await adapter.findMany({
         model: "users",
         sortBy: [
           { field: "age", direction: "asc" },
           { field: "name", direction: "desc" },
         ],
         cursor: {
-          after: { age: 30, name: "B" }, // Cursor points to m2
+          after: { age: 30, name: "B" },
         },
         limit: 3,
       });
 
-      // Sorted order:
-      // 1. age: 30, name: "C" (m3) -> skipped (before cursor)
-      // 2. age: 30, name: "B" (m2) -> cursor
-      // 3. age: 30, name: "A" (m1) -> match 1
-      // 4. age: 31, name: "B" (m5) -> match 2
-      // 5. age: 31, name: "A" (m4) -> match 3
-
       expect(result).toHaveLength(3);
-      expect(result[0]?.id).toBe("m1"); // age 30, name A (asc 30 == 30, desc A < B)
-      expect(result[1]?.id).toBe("m5"); // age 31, name B (asc 31 > 30)
-      expect(result[2]?.id).toBe("m4"); // age 31, name A
-    });
+      expect(result[0]?.id).toBe("m1");
+      expect(result[1]?.id).toBe("m5");
+      expect(result[2]?.id).toBe("m4");
+    });
+
+    describe("Seeded Pagination", () => {
+      beforeEach(async () => {
+        const creations = [];
+        for (let i = 1; i <= 5; i++) {
+          creations.push(
+            adapter.create({
+              model: "users",
+              data: {
+                id: `p${i}`,
+                name: `User ${i}`,
+                age: 20 + i,
+                is_active: true,
+              },
+            }),
+          );
+        }
+        await Promise.all(creations);
+      });
 
-    beforeEach(async () => {
-      // Seed data for pagination
-      const creations = [];
-      for (let i = 1; i <= 5; i++) {
-        creations.push(
-          adapter.create({
-            model: "users",
-            data: { id: `p${i}`, name: `User ${i}`, age: 20 + i, is_active: true, metadata: null },
-          }),
-        );
-      }
-      await Promise.all(creations);
-    });
+      it("should respect limit and offset", async () => {
+        const page1 = await adapter.findMany({
+          model: "users",
+          sortBy: [{ field: "age", direction: "asc" }],
+          limit: 2,
+          offset: 0,
+        });
+        expect(page1).toHaveLength(2);
+        expect(page1[0]?.id).toBe("p1");
 
-    it("should respect limit and offset", async () => {
-      const page1 = await adapter.findMany<User>({
-        model: "users",
-        sortBy: [{ field: "age", direction: "asc" }],
-        limit: 2,
-        offset: 0,
+        const page2 = await adapter.findMany({
+          model: "users",
+          sortBy: [{ field: "age", direction: "asc" }],
+          limit: 2,
+          offset: 2,
+        });
+        expect(page2).toHaveLength(2);
+        expect(page2[0]?.id).toBe("p3");
       });
-      expect(page1).toHaveLength(2);
-      expect(page1[0]?.name).toBe("User 1");
-      expect(page1[1]?.name).toBe("User 2");
 
-      const page2 = await adapter.findMany<User>({
-        model: "users",
-        sortBy: [{ field: "age", direction: "asc" }],
-        limit: 2,
-        offset: 2,
+      it("should handle cursor pagination ascending", async () => {
+        const result = await adapter.findMany({
+          model: "users",
+          sortBy: [{ field: "age", direction: "asc" }],
+          cursor: { after: { age: 22 } },
+          limit: 2,
+        });
+
+        expect(result).toHaveLength(2);
+        expect(result[0]?.id).toBe("p3");
+      });
+
+      it("should handle cursor pagination descending", async () => {
+        const result = await adapter.findMany({
+          model: "users",
+          sortBy: [{ field: "age", direction: "desc" }],
+          cursor: { after: { age: 24 } },
+          limit: 2,
+        });
+
+        expect(result).toHaveLength(2);
+        expect(result[0]?.id).toBe("p3");
       });
-      expect(page2).toHaveLength(2);
-      expect(page2[0]?.name).toBe("User 3");
-      expect(page2[1]?.name).toBe("User 4");
     });
+  });
+
+  describe("Upsert", () => {
+    it("should handle upsert correctly", async () => {
+      const data = { id: "u1", name: "Alice", age: 25, is_active: true };
 
-    it("should handle cursor pagination ascending", async () => {
-      const result = await adapter.findMany<User>({
+      // Insert
+      await adapter.upsert({
         model: "users",
-        sortBy: [{ field: "age", direction: "asc" }],
-        cursor: { after: { age: 22 } },
-        limit: 2,
+        where: { field: "id", op: "eq", value: "u1" },
+        create: data,
+        update: { age: 26 },
       });
 
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe("User 3"); // age 23 > 22
-      expect(result[1]?.name).toBe("User 4"); // age 24 > 22
-    });
+      let found = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(25);
 
-    it("should handle cursor pagination descending", async () => {
-      const result = await adapter.findMany<User>({
+      // Update
+      await adapter.upsert({
         model: "users",
-        sortBy: [{ field: "age", direction: "desc" }],
-        cursor: { after: { age: 24 } },
-        limit: 2,
+        where: { field: "id", op: "eq", value: "u1" },
+        create: data,
+        update: { age: 26 },
       });
 
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe("User 3"); // age 23 < 24
-      expect(result[1]?.name).toBe("User 2"); // age 22 < 24
+      found = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(26);
     });
   });
 });
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index fd6b856..a8e6424 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,34 +1,30 @@
-import type { Adapter, Cursor, FieldName, Schema, Select, SortBy, Where } from "../core";
-
-export type SqliteValue = string | number | bigint | Uint8Array | null;
-
-/**
- * The standard connection interface the Adapter expects.
- */
-export interface SqliteDatabase {
-  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
-  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
-  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
-}
-
-/**
- * Represents a raw native SQLite driver (like Bun or better-sqlite3).
- */
-export interface NativeSqliteStatement {
-  run(...params: SqliteValue[]): unknown;
-  get(...params: SqliteValue[]): unknown;
-  all(...params: SqliteValue[]): unknown;
-}
-
-export interface NativeSqliteDriver {
-  prepare(sql: string): NativeSqliteStatement;
-}
-
-export class SqliteAdapter implements Adapter {
+import { AsyncLocalStorage } from "node:async_hooks";
+import type {
+  Adapter,
+  Cursor,
+  FieldName,
+  Schema,
+  Select,
+  SortBy,
+  Where,
+  WhereWithoutPath,
+} from "../types";
+import { isModelType, isRecord, isStringKey, isValidField } from "../utils/is";
+import { escapeLiteral, quote } from "../utils/sql";
+import type {
+  NativeSqliteDriver,
+  SqliteDatabase,
+  SqliteValue,
+} from "./sqlite.types";
+
+const transactionStorage = new AsyncLocalStorage<SqliteDatabase>();
+
+export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   private db: SqliteDatabase;
+  private spCounter = 0;
 
   constructor(
-    private schema: Schema,
+    private schema: S,
     database: SqliteDatabase | NativeSqliteDriver,
   ) {
     if ("prepare" in database) {
@@ -38,6 +34,10 @@ export class SqliteAdapter implements Adapter {
     }
   }
 
+  private get activeDb(): SqliteDatabase {
+    return transactionStorage.getStore() ?? this.db;
+  }
+
   private wrapNativeDriver(native: NativeSqliteDriver): SqliteDatabase {
     return {
       run: (sql, params) => {
@@ -63,18 +63,20 @@ export class SqliteAdapter implements Adapter {
   async migrate(): Promise<void> {
     for (const [name, model] of Object.entries(this.schema)) {
       const columns = Object.entries(model.fields).map(([fieldName, field]) => {
-        const type = this.mapType(field.type.type);
+        const type = this.mapType(field.type);
         const nullable = field.nullable === true ? "" : " NOT NULL";
-        return `${this.quote(fieldName)} ${type}${nullable}`;
+        return `${quote(fieldName)} ${type}${nullable}`;
       });
 
-      const pk = `PRIMARY KEY (${model.primaryKey.fields.map((f) => this.quote(f)).join(", ")})`;
+      const pkFields = Array.isArray(model.primaryKey)
+        ? model.primaryKey
+        : [model.primaryKey];
+      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
 
       // Migrations (CREATE TABLE / CREATE INDEX) must be executed sequentially
       // to prevent database locking errors and ensure dependent objects exist.
-      // eslint-disable-next-line no-await-in-loop
-      await this.db.run(
-        `CREATE TABLE IF NOT EXISTS ${this.quote(name)} (${columns.join(", ")}, ${pk})`,
+      await this.activeDb.run(
+        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
         [],
       );
 
@@ -82,15 +84,13 @@ export class SqliteAdapter implements Adapter {
         for (let i = 0; i < model.indexes.length; i++) {
           const index = model.indexes[i];
           if (index === undefined) continue;
-          const fields = index.fields
-            .map((f) => `${this.quote(f.field)}${f.order ? ` ${f.order.toUpperCase()}` : ""}`)
+          const fields = Array.isArray(index.field) ? index.field : [index.field];
+          const fieldList = fields
+            .map((f) => `${quote(f)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
             .join(", ");
           const indexName = `idx_${name}_${i}`;
-          // Migrations (CREATE TABLE / CREATE INDEX) must be executed sequentially
-          // to prevent database locking errors and ensure dependent objects exist.
-          // eslint-disable-next-line no-await-in-loop
-          await this.db.run(
-            `CREATE INDEX IF NOT EXISTS ${this.quote(indexName)} ON ${this.quote(name)} (${fields})`,
+          await this.activeDb.run(
+            `CREATE INDEX IF NOT EXISTS ${quote(indexName)} ON ${quote(name)} (${fieldList})`,
             [],
           );
         }
@@ -98,8 +98,8 @@ export class SqliteAdapter implements Adapter {
     }
   }
 
-  async create<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async create<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     data: T;
     select?: Select<T>;
   }): Promise<T> {
@@ -108,7 +108,7 @@ export class SqliteAdapter implements Adapter {
     const fields = Object.keys(mappedData);
 
     const placeholders = Array.from({ length: fields.length }).fill("?").join(", ");
-    const columns = fields.map((f) => this.quote(f)).join(", ");
+    const columns = fields.map((f) => quote(f)).join(", ");
 
     const params: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
@@ -116,44 +116,42 @@ export class SqliteAdapter implements Adapter {
       if (isStringKey(field)) params.push(mappedData[field] ?? null);
     }
 
-    await this.db.run(
-      `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders})`,
+    await this.activeDb.run(
+      `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`,
       params,
     );
 
-    if (select !== undefined) {
-      const modelSpec = this.schema[model];
-      if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
-
-      const pkFields = modelSpec.primaryKey.fields;
-      const where: Where<T>[] = [];
-
-      for (let i = 0; i < pkFields.length; i++) {
-        const f = pkFields[i];
-        if (isValidField<T>(f)) {
-          where.push({
-            field: f,
-            op: "eq",
-            value: data[f],
-          });
-        }
-      }
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
 
-      const result = await this.find<T>({
-        model,
-        where: where.length === 1 && where[0] ? where[0] : { and: where },
-        select,
-      });
+    const pkFields = Array.isArray(modelSpec.primaryKey)
+      ? modelSpec.primaryKey
+      : [modelSpec.primaryKey];
 
-      if (result === null) throw new Error("Failed to refetch created record");
-      return result;
+    const where: Where<T>[] = [];
+    for (let i = 0; i < pkFields.length; i++) {
+      const f = pkFields[i];
+      if (isValidField<T>(f)) {
+        where.push({
+          field: f,
+          op: "eq",
+          value: (data as any)[f],
+        });
+      }
     }
 
-    return data;
+    const result = await this.find<K, T>({
+      model,
+      where: where.length === 1 && where[0] ? where[0] : { and: where },
+      select,
+    });
+
+    if (result === null) throw new Error("Failed to refetch created record");
+    return result;
   }
 
-  async find<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async find<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
     select?: Select<T>;
   }): Promise<T | null> {
@@ -162,13 +160,13 @@ export class SqliteAdapter implements Adapter {
     const { sql, params } = this.buildWhere(model, where);
 
     const fullSql = `${query} WHERE ${sql} LIMIT 1`;
-    const row = await this.db.get(fullSql, params);
+    const row = await this.activeDb.get(fullSql, params);
 
     return row ? this.mapRow<T>(model, row) : null;
   }
 
-  async findMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async findMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
     select?: Select<T>;
     sortBy?: SortBy<T>[];
@@ -210,20 +208,21 @@ export class SqliteAdapter implements Adapter {
       args_sql.push(offset);
     }
 
-    const rows = await this.db.all(sql_parts.join(" "), args_sql);
+    const rows = await this.activeDb.all(sql_parts.join(" "), args_sql);
     return rows.map((row) => this.mapRow<T>(model, row));
   }
 
-  async update<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async update<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
     data: Partial<T>;
   }): Promise<T | null> {
     const { model, where, data } = args;
     const mappedData = this.mapInput(model, data);
     const fields = Object.keys(mappedData);
-    const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
+    if (fields.length === 0) return this.find({ model, where });
 
+    const setClause = fields.map((f) => `${quote(f)} = ?`).join(", ");
     const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
 
     const params: SqliteValue[] = [];
@@ -236,28 +235,49 @@ export class SqliteAdapter implements Adapter {
       if (param !== undefined) params.push(param);
     }
 
-    await this.db.run(`UPDATE ${this.quote(model)} SET ${setClause} WHERE ${whereSql}`, params);
+    await this.activeDb.run(`UPDATE ${quote(model)} SET ${setClause} WHERE ${whereSql}`, params);
+
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
+
+    const pkFields = Array.isArray(modelSpec.primaryKey)
+      ? modelSpec.primaryKey
+      : [modelSpec.primaryKey];
+
+    const preRead = await this.find<K, T>({ model, where });
+    if (!preRead) return null;
+
+    const pkWhere: Where<T>[] = [];
+    for (const f of pkFields) {
+      if (isValidField<T>(f)) {
+        pkWhere.push({ field: f, op: "eq", value: (preRead as any)[f] });
+      }
+    }
 
-    return this.find({ model, where });
+    return this.find<K, T>({
+      model,
+      where: pkWhere.length === 1 && pkWhere[0] ? pkWhere[0] : { and: pkWhere },
+    });
   }
 
-  async updateMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async updateMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
     data: Partial<T>;
   }): Promise<number> {
     const { model, where, data } = args;
     const mappedData = this.mapInput(model, data);
     const fields = Object.keys(mappedData);
-    const setClause = fields.map((f) => `${this.quote(f)} = ?`).join(", ");
+    if (fields.length === 0) return 0;
 
+    const setClause = fields.map((f) => `${quote(f)} = ?`).join(", ");
     const args_sql: SqliteValue[] = [];
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
       if (isStringKey(field)) args_sql.push(mappedData[field] ?? null);
     }
 
-    let sql = `UPDATE ${this.quote(model)} SET ${setClause}`;
+    let sql = `UPDATE ${quote(model)} SET ${setClause}`;
     if (where !== undefined) {
       const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
       sql += ` WHERE ${whereSql}`;
@@ -267,25 +287,25 @@ export class SqliteAdapter implements Adapter {
       }
     }
 
-    const result = await this.db.run(sql, args_sql);
+    const result = await this.activeDb.run(sql, args_sql);
     return result.changes;
   }
 
-  async delete<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async delete<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
   }): Promise<void> {
     const { model, where } = args;
     const { sql, params } = this.buildWhere(model, where);
-    await this.db.run(`DELETE FROM ${this.quote(model)} WHERE ${sql}`, params);
+    await this.activeDb.run(`DELETE FROM ${quote(model)} WHERE ${sql}`, params);
   }
 
-  async deleteMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async deleteMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
   }): Promise<number> {
     const { model, where } = args;
-    let sql = `DELETE FROM ${this.quote(model)}`;
+    let sql = `DELETE FROM ${quote(model)}`;
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
@@ -297,16 +317,16 @@ export class SqliteAdapter implements Adapter {
       }
     }
 
-    const result = await this.db.run(sql, params);
+    const result = await this.activeDb.run(sql, params);
     return result.changes;
   }
 
-  async count<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  async count<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
   }): Promise<number> {
     const { model, where } = args;
-    let sql = `SELECT COUNT(*) as count FROM ${this.quote(model)}`;
+    let sql = `SELECT COUNT(*) as count FROM ${quote(model)}`;
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
@@ -318,14 +338,14 @@ export class SqliteAdapter implements Adapter {
       }
     }
 
-    const result = await this.db.get(sql, params);
+    const result = await this.activeDb.get(sql, params);
     const countVal = result?.["count"];
     return typeof countVal === "number" ? countVal : 0;
   }
 
-  async upsert<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
-    where: Where<T>;
+  async upsert<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
+    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
     select?: Select<T>;
@@ -336,22 +356,13 @@ export class SqliteAdapter implements Adapter {
 
     const extractConflictTargets = (w: Where<T>): string[] => {
       if ("and" in w) {
-        const parts: string[] = [];
-        for (const sub of w.and) {
-          parts.push(...extractConflictTargets(sub));
-        }
-        return parts;
+        return w.and.flatMap((sub) => extractConflictTargets(sub));
       }
       if ("or" in w) throw new Error("Upsert 'where' clause does not support 'or' operator.");
 
-      const leaf = w as { field: string; path?: string[]; op: string };
+      const leaf = w as { field: string; op: string };
       if (leaf.op !== "eq") throw new Error("Upsert 'where' clause only supports 'eq' operator.");
-
-      if (leaf.path && leaf.path.length > 0) {
-        throw new Error("Upsert operations by JSON path are currently unsupported.");
-      }
-
-      return [this.quote(leaf.field)];
+      return [quote(leaf.field)];
     };
 
     const conflictTargets = extractConflictTargets(where);
@@ -361,43 +372,35 @@ export class SqliteAdapter implements Adapter {
 
     const mappedCreate = this.mapInput(model, create);
     const fields = Object.keys(mappedCreate);
-    const columns = fields.map((f) => this.quote(f)).join(", ");
+    const columns = fields.map((f) => quote(f)).join(", ");
     const placeholders = fields.map(() => "?").join(", ");
 
     const mappedUpdate = this.mapInput(model, update);
     const updateFields = Object.keys(mappedUpdate);
-    const updateClause = updateFields.map((f) => `${this.quote(f)} = ?`).join(", ");
+    const updateClause = updateFields.map((f) => `${quote(f)} = ?`).join(", ");
 
-    const sql = `INSERT INTO ${this.quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${conflictTargetSql}) DO UPDATE SET ${updateClause}`;
+    const sql = `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${conflictTargetSql}) DO UPDATE SET ${updateClause}`;
 
     const params: SqliteValue[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (isStringKey(field)) params.push(mappedCreate[field] ?? null);
-    }
-    for (let i = 0; i < updateFields.length; i++) {
-      const field = updateFields[i];
-      if (isStringKey(field)) params.push(mappedUpdate[field] ?? null);
-    }
+    for (const f of fields) params.push(mappedCreate[f] ?? null);
+    for (const f of updateFields) params.push(mappedUpdate[f] ?? null);
+
+    await this.activeDb.run(sql, params);
 
-    await this.db.run(sql, params);
+    const pkFields = Array.isArray(modelSpec.primaryKey)
+      ? modelSpec.primaryKey
+      : [modelSpec.primaryKey];
 
-    const pkValuesWhere: Where<T>[] = [];
-    for (let i = 0; i < modelSpec.primaryKey.fields.length; i++) {
-      const f = modelSpec.primaryKey.fields[i];
+    const pkWhere: Where<T>[] = [];
+    for (const f of pkFields) {
       if (isValidField<T>(f)) {
-        pkValuesWhere.push({
-          field: f,
-          op: "eq",
-          value: create[f],
-        });
+        pkWhere.push({ field: f, op: "eq", value: (create as any)[f] });
       }
     }
 
-    const result = await this.find<T>({
+    const result = await this.find<K, T>({
       model,
-      where:
-        pkValuesWhere.length === 1 && pkValuesWhere[0] ? pkValuesWhere[0] : { and: pkValuesWhere },
+      where: pkWhere.length === 1 && pkWhere[0] ? pkWhere[0] : { and: pkWhere },
       select,
     });
 
@@ -405,24 +408,19 @@ export class SqliteAdapter implements Adapter {
     return result;
   }
 
-  async transaction<T>(fn: (tx: Adapter) => Promise<T>): Promise<T> {
-    const sp = this.quote(`sp_${Date.now()}_${Math.floor(Math.random() * 100000)}`);
+  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    const sp = quote(`sp_${this.spCounter++}`);
 
-    await this.db.run(`SAVEPOINT ${sp}`, []);
+    await this.activeDb.run(`SAVEPOINT ${sp}`, []);
     try {
-      const result = await fn(this);
-      await this.db.run(`RELEASE SAVEPOINT ${sp}`, []);
+      const result = await transactionStorage.run(this.activeDb, () => fn(this));
+      await this.activeDb.run(`RELEASE SAVEPOINT ${sp}`, []);
       return result;
     } catch (error) {
-      await this.db.run(`ROLLBACK TO SAVEPOINT ${sp}`, []);
+      await this.activeDb.run(`ROLLBACK TO SAVEPOINT ${sp}`, []);
       throw error;
     }
   }
-  // --- Helpers ---
-
-  private quote(name: string): string {
-    return `"${name}"`;
-  }
 
   private mapType(type: string): string {
     switch (type) {
@@ -431,11 +429,11 @@ export class SqliteAdapter implements Adapter {
       case "number":
         return "REAL";
       case "boolean":
-        return "INTEGER"; // SQLite stores booleans as 0 or 1
       case "timestamp":
-        return "INTEGER"; // BIGINT/INTEGER for ms since epoch
+        return "INTEGER";
       case "json":
-        return "TEXT"; // Stored as string
+      case "json[]":
+        return "TEXT";
       default:
         return "TEXT";
     }
@@ -443,24 +441,23 @@ export class SqliteAdapter implements Adapter {
 
   private buildSelect<T>(model: string, select?: Select<T>): string {
     if (select !== undefined) {
-      return `SELECT ${select.map((f) => this.quote(f)).join(", ")} FROM ${this.quote(model)}`;
+      return `SELECT ${select.map((f) => quote(f as string)).join(", ")} FROM ${quote(model)}`;
     }
-    return `SELECT * FROM ${this.quote(model)}`;
+    return `SELECT * FROM ${quote(model)}`;
   }
 
   private buildColumnExpr(modelName: string, field: string, path?: string[]): string {
     if (path !== undefined && path.length > 0) {
-      const modelSpec = this.schema[modelName];
+      const modelSpec = (this.schema as any)[modelName];
       const fieldSpec = modelSpec?.fields[field];
-      if (fieldSpec?.type.type !== "json") {
+      if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
         throw new Error(`Cannot use 'path' filter on non-JSON field: ${field}`);
       }
 
       const jsonPath = `$.${path.join(".")}`;
-      const escapedPath = jsonPath.replaceAll("'", "''");
-      return `json_extract(${this.quote(field)}, '${escapedPath}')`;
+      return `json_extract(${quote(field)}, '${escapeLiteral(jsonPath)}')`;
     }
-    return this.quote(field);
+    return quote(field);
   }
 
   private buildCursor<T>(
@@ -479,22 +476,16 @@ export class SqliteAdapter implements Adapter {
             return { field, direction: "asc" };
           });
 
-    const validSorts = sortCriteria.filter((s) => {
-      return cursor.after[s.field] !== undefined;
-    });
-
+    const validSorts = sortCriteria.filter((s) => cursor.after[s.field] !== undefined);
     const orParts: string[] = [];
     const cursorParams: SqliteValue[] = [];
 
     for (let i = 0; i < validSorts.length; i++) {
-      const currentSort = validSorts[i];
-      if (!currentSort) continue;
-
+      const currentSort = validSorts[i]!;
       const andParts: string[] = [];
 
       for (let j = 0; j < i; j++) {
-        const prevSort = validSorts[j];
-        if (!prevSort) continue;
+        const prevSort = validSorts[j]!;
         const colExpr = this.buildColumnExpr(modelName, prevSort.field as string, prevSort.path);
         andParts.push(`${colExpr} = ?`);
         cursorParams.push(this.mapWhereValue(cursor.after[prevSort.field]));
@@ -512,10 +503,8 @@ export class SqliteAdapter implements Adapter {
       orParts.push(`(${andParts.join(" AND ")})`);
     }
 
-    if (orParts.length === 0) return { sql: "", params: [] };
-
     return {
-      sql: `(${orParts.join(" OR ")})`,
+      sql: orParts.length > 0 ? `(${orParts.join(" OR ")})` : "",
       params: cursorParams,
     };
   }
@@ -532,58 +521,43 @@ export class SqliteAdapter implements Adapter {
     if (where !== undefined) {
       const result = this.buildWhereRecursive(modelName, where);
       parts.push(result.sql);
-      this.appendParams(params, result.params);
+      params.push(...result.params);
     }
 
     if (cursor !== undefined) {
       const cursorResult = this.buildCursor(modelName, cursor, sortBy);
       if (cursorResult.sql !== "") {
         parts.push(cursorResult.sql);
-        this.appendParams(params, cursorResult.params);
+        params.push(...cursorResult.params);
       }
     }
 
     const sql = parts.length > 1 ? parts.map((p) => `(${p})`).join(" AND ") : (parts[0] ?? "1=1");
-
     return { sql, params };
   }
 
-  private appendParams(target: SqliteValue[], source: SqliteValue[]): void {
-    for (let j = 0; j < source.length; j++) {
-      const param = source[j];
-      if (param !== undefined) target.push(param);
-    }
-  }
-
   private buildWhereRecursive<T>(
     modelName: string,
     where: Where<T>,
   ): { sql: string; params: SqliteValue[] } {
     if ("and" in where) {
       const parts = where.and.map((w) => this.buildWhereRecursive(modelName, w));
-      const sql = `(${parts.map((p) => p.sql).join(" AND ")})`;
-      const params: SqliteValue[] = [];
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (part) this.appendParams(params, part.params);
-      }
-      return { sql, params };
+      return {
+        sql: `(${parts.map((p) => p.sql).join(" AND ")})`,
+        params: parts.flatMap((p) => p.params),
+      };
     }
 
     if ("or" in where) {
       const parts = where.or.map((w) => this.buildWhereRecursive(modelName, w));
-      const sql = `(${parts.map((p) => p.sql).join(" OR ")})`;
-      const params: SqliteValue[] = [];
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (part) this.appendParams(params, part.params);
-      }
-      return { sql, params };
+      return {
+        sql: `(${parts.map((p) => p.sql).join(" OR ")})`,
+        params: parts.flatMap((p) => p.params),
+      };
     }
 
     const leaf = where as { field: string; path?: string[]; op: string; value: unknown };
     const { field, path, op, value } = leaf;
-
     const quotedField = this.buildColumnExpr(modelName, field, path);
 
     switch (op) {
@@ -601,24 +575,18 @@ export class SqliteAdapter implements Adapter {
         return { sql: `${quotedField} <= ?`, params: [this.mapWhereValue(value)] };
       case "in": {
         const list = Array.isArray(value) ? value : [value];
-        const params: SqliteValue[] = [];
-        for (let i = 0; i < list.length; i++) {
-          params.push(this.mapWhereValue(list[i]));
-        }
+        if (list.length === 0) return { sql: "1=0", params: [] };
         return {
           sql: `${quotedField} IN (${list.map(() => "?").join(", ")})`,
-          params,
+          params: list.map((v) => this.mapWhereValue(v)),
         };
       }
       case "not_in": {
         const list = Array.isArray(value) ? value : [value];
-        const params: SqliteValue[] = [];
-        for (let i = 0; i < list.length; i++) {
-          params.push(this.mapWhereValue(list[i]));
-        }
+        if (list.length === 0) return { sql: "1=1", params: [] };
         return {
           sql: `${quotedField} NOT IN (${list.map(() => "?").join(", ")})`,
-          params,
+          params: list.map((v) => this.mapWhereValue(v)),
         };
       }
       default:
@@ -660,9 +628,9 @@ export class SqliteAdapter implements Adapter {
         continue;
       }
 
-      if (field.type.type === "json") {
+      if (field.type === "json" || field.type === "json[]") {
         result[fieldName] = JSON.stringify(val);
-      } else if (field.type.type === "boolean") {
+      } else if (field.type === "boolean") {
         result[fieldName] = val === true ? 1 : 0;
       } else if (
         typeof val === "string" ||
@@ -679,44 +647,29 @@ export class SqliteAdapter implements Adapter {
   }
 
   private mapRow<T>(modelName: string, row: Record<string, unknown>): T {
-    const model = this.schema[modelName];
-    if (model === undefined) {
-      if (isModelType<T>(row)) return row;
-      throw new Error("Invalid row data");
-    }
+    const model = (this.schema as any)[modelName];
+    if (model === undefined) return row as T;
 
-    for (const [fieldName, field] of Object.entries(model.fields)) {
+    for (const [fieldName, field] of Object.entries(model.fields as Record<string, any>)) {
       const val = row[fieldName];
       if (val === undefined || val === null) continue;
 
-      if (field.type.type === "json" && typeof val === "string") {
+      if ((field.type === "json" || field.type === "json[]") && typeof val === "string") {
         try {
           row[fieldName] = JSON.parse(val);
         } catch {
           // Keep as string if parsing fails
         }
-      } else if (field.type.type === "boolean") {
+      } else if (field.type === "boolean") {
         row[fieldName] = val === 1 || val === true;
+      } else if (field.type === "number" || field.type === "timestamp") {
+        if (typeof val === "string") {
+          row[fieldName] = Number(val);
+        } else if (typeof val === "bigint") {
+          row[fieldName] = Number(val);
+        }
       }
     }
-
-    if (isModelType<T>(row)) return row;
-    throw new Error("Row does not conform to model bounds");
+    return row as T;
   }
 }
-
-export function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-function isValidField<T>(field: unknown): field is FieldName<T> {
-  return typeof field === "string" && field !== "";
-}
-
-function isStringKey(key: unknown): key is string {
-  return typeof key === "string" && key !== "";
-}
-
-function isModelType<T>(obj: unknown): obj is T {
-  return typeof obj === "object" && obj !== null;
-}
diff --git a/src/adapters/sqlite.types.ts b/src/adapters/sqlite.types.ts
new file mode 100644
index 0000000..0f94257
--- /dev/null
+++ b/src/adapters/sqlite.types.ts
@@ -0,0 +1,23 @@
+export type SqliteValue = string | number | bigint | Uint8Array | null;
+
+/**
+ * The standard connection interface the Adapter expects.
+ */
+export interface SqliteDatabase {
+  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
+  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
+  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
+}
+
+/**
+ * Represents a raw native SQLite driver (like Bun or better-sqlite3).
+ */
+export interface NativeSqliteStatement {
+  run(...params: SqliteValue[]): unknown;
+  get(...params: SqliteValue[]): unknown;
+  all(...params: SqliteValue[]): unknown;
+}
+
+export interface NativeSqliteDriver {
+  prepare(sql: string): NativeSqliteStatement;
+}
diff --git a/src/index.ts b/src/index.ts
index 8d119de..eea524d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1 +1 @@
-export * from "./core";
+export * from "./types";
diff --git a/src/core.test.ts b/src/types.test.ts
similarity index 97%
rename from src/core.test.ts
rename to src/types.test.ts
index 0444fd8..b77ffb7 100644
--- a/src/core.test.ts
+++ b/src/types.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import type { InferModel, Schema } from "./core";
+import type { InferModel, Schema } from "./types";
 
 describe("no-orm core", () => {
   it("should infer correct types for a schema", () => {
diff --git a/src/core.ts b/src/types.ts
similarity index 59%
rename from src/core.ts
rename to src/types.ts
index a30e24c..b991d1b 100644
--- a/src/core.ts
+++ b/src/types.ts
@@ -8,30 +8,26 @@ export type Schema = Record<string, Model>;
 
 export interface Model {
   fields: Record<string, Field>;
-  primaryKey: {
-    fields: [string, ...string[]];
-  };
+  primaryKey: string | string[];
   indexes?: Index[];
 }
 
 export interface Field {
   type: FieldType;
   nullable?: boolean;
+  max?: number; // Only for string
 }
 
 export type FieldType =
-  | { type: "string"; max?: number }
-  | { type: "number" }
-  | { type: "boolean" }
-  | { type: "timestamp" }
-  | { type: "json" };
+  | "string"
+  | "number"
+  | "boolean"
+  | "timestamp"
+  | "json"
+  | "json[]";
 
 export interface Index {
-  fields: [IndexField, ...IndexField[]];
-}
-
-export interface IndexField {
-  field: string;
+  field: string | string[];
   order?: "asc" | "desc";
 }
 
@@ -43,69 +39,71 @@ export type InferModel<M extends Model> = {
     : ResolveTSValue<M["fields"][K]["type"]>;
 };
 
-type ResolveTSValue<T extends FieldType> = T["type"] extends "string"
+type ResolveTSValue<T extends FieldType> = T extends "string"
   ? string
-  : T["type"] extends "number"
+  : T extends "number"
     ? number
-    : T["type"] extends "boolean"
+    : T extends "boolean"
       ? boolean
-      : T["type"] extends "timestamp"
+      : T extends "timestamp"
         ? number
-        : T["type"] extends "json"
+        : T extends "json"
           ? Record<string, unknown> // Note: Defaults to object record, may need casting for JSON arrays
-          : never;
+          : T extends "json[]"
+            ? unknown[]
+            : never;
 
 // --- ADAPTER SPEC V1 (#3) ---
 
-export interface Adapter {
-  migrate?(args: { schema: Schema }): Promise<void>;
+export interface Adapter<S extends Schema = Schema> {
+  migrate?(args: { schema: S }): Promise<void>;
 
-  transaction?<T>(fn: (tx: Adapter) => Promise<T>): Promise<T>;
+  transaction?<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
 
-  create<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  create<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     data: T;
     select?: Select<T>;
   }): Promise<T>;
 
-  update<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  update<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
     data: Partial<T>;
   }): Promise<T | null>;
 
-  updateMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  updateMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
     data: Partial<T>;
   }): Promise<number>;
 
-  upsert?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
-    where: Where<T>;
+  upsert?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
+    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
     select?: Select<T>;
   }): Promise<T>;
 
-  delete<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  delete<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
   }): Promise<void>;
 
-  deleteMany?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  deleteMany?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
   }): Promise<number>;
 
-  find<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  find<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where: Where<T>;
     select?: Select<T>;
   }): Promise<T | null>;
 
-  findMany<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  findMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
     select?: Select<T>;
     sortBy?: SortBy<T>[];
@@ -114,8 +112,8 @@ export interface Adapter {
     cursor?: Cursor<T>;
   }): Promise<T[]>;
 
-  count?<T extends Record<string, unknown> = Record<string, unknown>>(args: {
-    model: string;
+  count?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+    model: K;
     where?: Where<T>;
   }): Promise<number>;
 }
@@ -150,6 +148,10 @@ export type Where<T = Record<string, unknown>> =
       or: Where<T>[];
     };
 
+export type WhereWithoutPath<T = Record<string, unknown>> = Omit<Where<T>, "path"> & {
+  path?: never;
+};
+
 export interface SortBy<T = Record<string, unknown>> {
   field: FieldName<T>;
   path?: string[];
diff --git a/src/utils/is.ts b/src/utils/is.ts
new file mode 100644
index 0000000..cc2ce84
--- /dev/null
+++ b/src/utils/is.ts
@@ -0,0 +1,17 @@
+import type { FieldName } from "../types";
+
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+export function isValidField<T>(field: unknown): field is FieldName<T> {
+  return typeof field === "string" && field !== "";
+}
+
+export function isStringKey(key: unknown): key is string {
+  return typeof key === "string" && key !== "";
+}
+
+export function isModelType<T>(obj: unknown): obj is T {
+  return typeof obj === "object" && obj !== null;
+}
diff --git a/src/utils/sql.ts b/src/utils/sql.ts
new file mode 100644
index 0000000..411bc27
--- /dev/null
+++ b/src/utils/sql.ts
@@ -0,0 +1,7 @@
+export function quote(name: string): string {
+  return `"${name}"`;
+}
+
+export function escapeLiteral(val: string): string {
+  return val.replaceAll("'", "''");
+}

From 7601d4131efbe6837ff818c41af1bd5b0c3f04fe Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Mon, 20 Apr 2026 18:29:41 +0800
Subject: [PATCH 07/24] feat: implement postgres adapter and some refactoring

---
 README.md                    | 145 ++++--
 package.json                 |  12 +
 src/adapters/common.ts       | 151 +++++++
 src/adapters/memory.test.ts  | 199 ++++++++
 src/adapters/memory.ts       | 395 ++++++++++++++++
 src/adapters/postgres.ts     | 651 ++++++++++++++++++++++++++
 src/adapters/sqlite.test.ts  | 143 ++++--
 src/adapters/sqlite.ts       | 855 ++++++++++++++++++-----------------
 src/adapters/sqlite.types.ts |  23 -
 src/types.test.ts            |  28 +-
 src/types.ts                 |  65 +--
 src/utils/is.ts              |  17 -
 src/utils/sql.ts             |   7 -
 13 files changed, 2101 insertions(+), 590 deletions(-)
 create mode 100644 src/adapters/common.ts
 create mode 100644 src/adapters/memory.test.ts
 create mode 100644 src/adapters/memory.ts
 create mode 100644 src/adapters/postgres.ts
 delete mode 100644 src/adapters/sqlite.types.ts
 delete mode 100644 src/utils/is.ts
 delete mode 100644 src/utils/sql.ts

diff --git a/README.md b/README.md
index cf5d2cc..d436049 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,15 @@
 # @8monkey/no-orm
 
-A tiny, composable ORM core for TypeScript libraries. No heavy abstractions, just the primitives to build cross-database tools with full type safety.
+A tiny, schema-first persistence core for TypeScript libraries.
 
-## Features
+`no-orm` is intentionally small:
 
-- **Tiny Core**: Minimal overhead, focuses on schema definition and basic CRUD.
-- **Full Type Safety**: Inferred models from your schema definition.
-- **Adapter-Based**: Switch between SQLite, PostgreSQL (coming soon), and more.
-- **Nested JSON Support**: Query and filter nested JSON fields seamlessly.
-- **Transactions**: Built-in support for stacked transactions with automatic rollbacks.
+- one canonical schema shape
+- inferred TypeScript model types
+- adapter-based persistence
+- minimal CRUD, filtering, ordering, pagination, and transactions
+
+It is not a query builder, migration framework, or full ORM runtime.
 
 ## Installation
 
@@ -16,78 +17,146 @@ A tiny, composable ORM core for TypeScript libraries. No heavy abstractions, jus
 bun add @8monkey/no-orm
 ```
 
-## Quick Start
-
-### 1. Define your Schema
+## Define a Schema
 
-```typescript
-import { Schema } from "@8monkey/no-orm";
+```ts
+import type { InferModel, Schema } from "@8monkey/no-orm";
 
 export const schema = {
   users: {
     fields: {
       id: { type: "string" },
-      name: { type: "string" },
+      name: { type: "string", max: 255 },
       age: { type: "number" },
+      is_active: { type: "boolean" },
       metadata: { type: "json", nullable: true },
-      tags: { type: "json[]" },
+      tags: { type: "json[]", nullable: true },
+      created_at: { type: "timestamp" },
     },
     primaryKey: "id",
-    indexes: [
-      { field: "age" },
-      { field: ["name", "age"], order: "desc" },
-    ],
+    indexes: [{ field: "created_at", order: "desc" }],
   },
 } as const satisfies Schema;
+
+type User = InferModel<typeof schema.users>;
 ```
 
-### 2. Initialize the Adapter
+## Choose an Adapter
 
-```typescript
-import { SqliteAdapter } from "@8monkey/no-orm/adapters/sqlite";
+### SQLite
+
+```ts
 import { Database } from "bun:sqlite";
+import { SqliteAdapter } from "@8monkey/no-orm/adapters/sqlite";
 
 const db = new Database(":memory:");
 const adapter = new SqliteAdapter(schema, db);
 
 await adapter.migrate();
+```
+
+### Postgres
+
+```ts
+import { SQL } from "bun";
+import { PostgresAdapter } from "@8monkey/no-orm/adapters/postgres";
+
+const sql = new SQL(process.env.POSTGRES_URL!);
+const adapter = new PostgresAdapter(schema, sql);
+
+await adapter.migrate();
+```
+
+### Memory
+
+```ts
+import { MemoryAdapter } from "@8monkey/no-orm/adapters/memory";
+
+const adapter = new MemoryAdapter(schema);
+await adapter.migrate({ schema });
+```
+
+## Basic Operations
 
-// You can seamlessly query nested JSON!
-const users = await adapter.findMany({
+```ts
+const created = await adapter.create<"users", User>({
+  model: "users",
+  data: {
+    id: "u1",
+    name: "Alice",
+    age: 30,
+    is_active: true,
+    metadata: { theme: "dark" },
+    tags: ["admin"],
+    created_at: Date.now(),
+  },
+});
+
+const found = await adapter.find<"users", User>({
+  model: "users",
+  where: { field: "id", op: "eq", value: "u1" },
+});
+
+const recentUsers = await adapter.findMany<"users", User>({
+  model: "users",
+  where: { field: "is_active", op: "eq", value: true },
+  sortBy: [{ field: "created_at", direction: "desc" }],
+  limit: 20,
+});
+```
+
+## JSON Path Filters
+
+Nested JSON filters use the base field plus a `path` array:
+
+```ts
+const darkUsers = await adapter.findMany<"users", User>({
   model: "users",
   where: {
     field: "metadata",
-    path: ["settings", "theme"],
+    path: ["preferences", "theme"],
     op: "eq",
     value: "dark",
   },
 });
 ```
 
-### 3. Transactions
+Path segments are intentionally restricted to simple identifiers so adapters can
+compile them safely for each backend.
+
+## Transactions
 
-```typescript
+```ts
 await adapter.transaction(async (tx) => {
   await tx.create({
     model: "users",
-    data: { id: "1", name: "Alice", age: 30, tags: ["admin"] },
+    data: {
+      id: "u2",
+      name: "Bob",
+      age: 28,
+      is_active: true,
+      metadata: null,
+      tags: null,
+      created_at: Date.now(),
+    },
   });
-  
-  // Nested transactions use SAVEPOINTs automatically
-  await tx.transaction(async (inner) => {
-    await inner.update({
-      model: "users",
-      where: { field: "id", op: "eq", value: "1" },
-      data: { age: 31 },
-    });
+
+  await tx.update({
+    model: "users",
+    where: { field: "id", op: "eq", value: "u2" },
+    data: { age: 29 },
   });
 });
 ```
 
-## Limitations
+SQLite and Postgres both support nested transactions through savepoints.
+
+## Notes
 
-- **Concurrent Transactions**: If you share a single database connection globally (e.g., a single `bun:sqlite` instance) across concurrent web requests, their `adapter.transaction()` calls will interleave on the same connection. `no-orm` uses `AsyncLocalStorage` to ensure that operations within a transaction block use the correct savepoint state, but for true isolation in highly concurrent environments, consider a connection pool.
-- **Upserts on JSON paths**: Upsert operations require the conflict target to be explicitly identifiable (like a `PRIMARY KEY`). `no-orm` does not support using `path` arguments in the `where` clause for `upsert` to prevent ambiguity.
+- `upsert` is intentionally conservative in v1: the `where` clause must be equality conditions for every primary-key field.
+- Primary-key updates are rejected to keep adapter behavior simple and consistent across backends.
+- SQLite stores JSON as text; Postgres stores JSON as `jsonb`.
+- **Numeric Precision**: `number` and `timestamp` fields use standard JavaScript `Number`. `bigint` is intentionally not supported in v1 to keep the core and adapters tiny.
 
 ## License
 
diff --git a/package.json b/package.json
index d82aec9..b595d50 100644
--- a/package.json
+++ b/package.json
@@ -33,6 +33,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./adapters/memory": {
+      "types": "./dist/adapters/memory.d.ts",
+      "import": "./dist/adapters/memory.js"
+    },
+    "./adapters/sqlite": {
+      "types": "./dist/adapters/sqlite.d.ts",
+      "import": "./dist/adapters/sqlite.js"
+    },
+    "./adapters/postgres": {
+      "types": "./dist/adapters/postgres.d.ts",
+      "import": "./dist/adapters/postgres.js"
     }
   },
   "scripts": {
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
new file mode 100644
index 0000000..811bb19
--- /dev/null
+++ b/src/adapters/common.ts
@@ -0,0 +1,151 @@
+import type { FieldName, Model, Where, WhereWithoutPath } from "../types";
+
+// --- Type Guards ---
+
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+export function isValidField<T>(field: unknown): field is FieldName<T> {
+  return typeof field === "string" && field !== "";
+}
+
+export function isStringKey(key: unknown): key is string {
+  return typeof key === "string" && key !== "";
+}
+
+export function isModelType<T>(obj: unknown): obj is T {
+  return typeof obj === "object" && obj !== null;
+}
+
+// --- SQL Helpers ---
+
+export function quote(name: string): string {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+export function escapeLiteral(val: string): string {
+  return val.replaceAll("'", "''");
+}
+
+// --- Schema & Logic Helpers ---
+
+const JSON_PATH_SEGMENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+export function getPrimaryKeyFields(model: Model): string[] {
+  return Array.isArray(model.primaryKey) ? model.primaryKey : [model.primaryKey];
+}
+
+export function validateJsonPath(path: string[]): string[] {
+  for (const segment of path) {
+    if (!JSON_PATH_SEGMENT.test(segment)) {
+      throw new Error(`Invalid JSON path segment: ${segment}`);
+    }
+  }
+  return path;
+}
+
+export function extractEqualityWhere<T>(where: WhereWithoutPath<T>): Map<string, unknown> {
+  const values = new Map<string, unknown>();
+
+  const visit = (clause: WhereWithoutPath<T>): void => {
+    if ("and" in clause) {
+      for (const child of clause.and) {
+        visit(child);
+      }
+      return;
+    }
+
+    if ("or" in clause) {
+      // Upsert needs one deterministic conflict key. Allowing OR conditions would
+      // make the conflict target ambiguous across all adapters, not just SQL ones.
+      throw new Error("Upsert 'where' clause does not support 'or' conditions.");
+    }
+
+    if (clause.path !== undefined) {
+      // Path-based filters are query semantics, not stable identity semantics.
+      // Keeping them out of upsert avoids backend-specific conflict behavior.
+      throw new Error("Upsert 'where' clause does not support JSON paths.");
+    }
+
+    if (clause.op !== "eq") {
+      // v1 upsert is intentionally conservative: equality on identity fields only.
+      throw new Error("Upsert 'where' clause only supports 'eq' conditions.");
+    }
+
+    const existing = values.get(clause.field);
+    if (existing !== undefined && existing !== clause.value) {
+      throw new Error(`Conflicting upsert values for field ${clause.field}.`);
+    }
+    values.set(clause.field, clause.value);
+  };
+
+  visit(where);
+  return values;
+}
+
+export function getPrimaryKeyWhereValues<T>(
+  model: Model,
+  where: WhereWithoutPath<T>,
+): Record<string, unknown> {
+  const equalityWhere = extractEqualityWhere(where);
+  const pkFields = getPrimaryKeyFields(model);
+  const values: Record<string, unknown> = {};
+
+  if (equalityWhere.size !== pkFields.length) {
+    // We currently support primary-key based upserts only. This keeps the same
+    // rule across memory, SQLite, and Postgres instead of inventing per-backend
+    // uniqueness semantics in v1.
+    throw new Error("Upsert requires equality filters for every primary key field.");
+  }
+
+  for (const field of pkFields) {
+    if (!equalityWhere.has(field)) {
+      throw new Error("Upsert requires equality filters for every primary key field.");
+    }
+    values[field] = equalityWhere.get(field);
+  }
+
+  return values;
+}
+
+export function buildPrimaryKeyWhere<T extends Record<string, unknown>>(
+  model: Model,
+  source: Record<string, unknown>,
+): Where<T> {
+  const pkFields = getPrimaryKeyFields(model);
+  const clauses = pkFields.map((field) => ({
+    // The schema is the source of truth for valid field names here.
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    field: field as FieldName<T>,
+    op: "eq" as const,
+    value: source[field],
+  }));
+
+  if (clauses.length === 1) {
+    return clauses[0]!;
+  }
+
+  return { and: clauses };
+}
+
+export function assertNoPrimaryKeyUpdates(
+  model: Model,
+  data: Partial<Record<string, unknown>>,
+): void {
+  for (const field of getPrimaryKeyFields(model)) {
+    if (data[field] !== undefined) {
+      // Primary-key rewrites are intentionally out of scope for v1 because they
+      // complicate refetch, conflict handling, and adapter parity.
+      throw new Error("Primary key updates are not supported.");
+    }
+  }
+}
+
+/**
+ * Maps database numeric values to JS numbers.
+ * Note: bigint is intentionally not supported in v1 to keep the core tiny.
+ */
+export function mapNumeric(value: unknown): number | null {
+  return value === null || value === undefined ? null : Number(value);
+}
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
new file mode 100644
index 0000000..d6b108b
--- /dev/null
+++ b/src/adapters/memory.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect, it, beforeEach } from "bun:test";
+
+import type { Schema, InferModel } from "../types";
+import { MemoryAdapter } from "./memory";
+
+describe("MemoryAdapter", () => {
+  const schema = {
+    users: {
+      fields: {
+        id: { type: "string" },
+        name: { type: "string" },
+        age: { type: "number" },
+        is_active: { type: "boolean" },
+        metadata: { type: "json", nullable: true },
+      },
+      primaryKey: "id",
+    },
+  } as const satisfies Schema;
+
+  type User = InferModel<typeof schema.users>;
+
+  let adapter: MemoryAdapter<typeof schema>;
+
+  beforeEach(async () => {
+    adapter = new MemoryAdapter(schema);
+    await adapter.migrate({ schema });
+  });
+
+  it("should create and find a record", async () => {
+    const userData: User = {
+      id: "u1",
+      name: "Alice",
+      age: 25,
+      is_active: true,
+      metadata: { theme: "dark" },
+    };
+
+    await adapter.create({ model: "users", data: userData });
+
+    const found = await adapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(found).toEqual(userData);
+  });
+
+  it("should find multiple records with filters", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
+    });
+
+    const actives = await adapter.findMany<"users", User>({
+      model: "users",
+      where: { field: "is_active", op: "eq", value: true },
+      sortBy: [{ field: "age", direction: "asc" }],
+    });
+
+    expect(actives).toHaveLength(2);
+    expect(actives[0]?.name).toBe("Alice");
+    expect(actives[1]?.name).toBe("Charlie");
+  });
+
+  it("should support nested JSON path filters", async () => {
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "u1",
+        name: "Alice",
+        age: 25,
+        is_active: true,
+        metadata: { settings: { theme: "dark" } },
+      },
+    });
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "u2",
+        name: "Bob",
+        age: 30,
+        is_active: true,
+        metadata: { settings: { theme: "light" } },
+      },
+    });
+
+    const darkThemeUsers = await adapter.findMany<"users", User>({
+      model: "users",
+      where: { field: "metadata", path: ["settings", "theme"], op: "eq", value: "dark" },
+    });
+
+    expect(darkThemeUsers).toHaveLength(1);
+    expect(darkThemeUsers[0]?.name).toBe("Alice");
+  });
+
+  it("should update a record", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    await adapter.update<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+      data: { age: 26 },
+    });
+
+    const updated = await adapter.find<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(updated?.age).toBe(26);
+  });
+
+  it("should reject primary key updates", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    expect(() =>
+      adapter.update<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+        data: { id: "u2" },
+      }),
+    ).toThrow("Primary key updates are not supported.");
+  });
+
+  it("should delete a record", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    await adapter.delete({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    const found = await adapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+
+    expect(found).toBeNull();
+  });
+
+  it("should support complex logical operators", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
+    });
+
+    const results = await adapter.findMany({
+      model: "users",
+      where: {
+        or: [
+          { field: "age", op: "gt", value: 28 },
+          { field: "name", op: "eq", value: "Alice" },
+        ],
+      },
+    });
+
+    expect(results).toHaveLength(2);
+  });
+
+  it("should require primary-key equality in upsert filters", () => {
+    const userData: User = {
+      id: "u1",
+      name: "Alice",
+      age: 25,
+      is_active: true,
+      metadata: null,
+    };
+
+    expect(() =>
+      adapter.upsert<"users", User>({
+        model: "users",
+        where: { field: "name", op: "eq", value: "Alice" },
+        create: userData,
+        update: { age: 26 },
+      }),
+    ).toThrow("Upsert requires equality filters for every primary key field.");
+  });
+});
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
new file mode 100644
index 0000000..5dd2dbe
--- /dev/null
+++ b/src/adapters/memory.ts
@@ -0,0 +1,395 @@
+import type {
+  Adapter,
+  Cursor,
+  InferModel,
+  Schema,
+  Select,
+  SortBy,
+  Where,
+  WhereWithoutPath,
+} from "../types";
+import {
+  assertNoPrimaryKeyUpdates,
+  getPrimaryKeyFields,
+  getPrimaryKeyWhereValues,
+  isRecord,
+} from "./common";
+
+type Comparable = string | number;
+type RowData = Record<string, unknown>;
+
+/**
+ * A zero-dependency, in-memory implementation of the no-orm Adapter interface.
+ * Useful for testing, development, and small-scale caching.
+ */
+export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private storage = new Map<string, Map<string, InferModel<S[keyof S]>>>();
+
+  constructor(private schema: S) {}
+
+  migrate(_args: { schema: S }): Promise<void> {
+    for (const name of Object.keys(this.schema)) {
+      if (!this.storage.has(name)) {
+        this.storage.set(name, new Map());
+      }
+    }
+    return Promise.resolve();
+  }
+
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    // Basic execution for V1. In-memory snapshots for true isolation
+    // are deferred to future versions.
+    return fn(this);
+  }
+
+  create<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    data: T;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, data, select } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+    const pkValue = this.getPrimaryKeyString(model, data);
+
+    if (modelStorage.has(pkValue)) {
+      throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
+    }
+
+    const record: T = { ...data };
+    modelStorage.set(pkValue, record);
+
+    return Promise.resolve(this.applySelect(record, select));
+  }
+
+  find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    select?: Select<T>;
+  }): Promise<T | null> {
+    const { model, where, select } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+
+    for (const record of modelStorage.values()) {
+      if (this.evaluateWhere(where, record)) {
+        return Promise.resolve(this.applySelect(record, select));
+      }
+    }
+
+    return Promise.resolve(null);
+  }
+
+  findMany<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }): Promise<T[]> {
+    const { model, where, select, sortBy, limit, offset, cursor } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+
+    let results = Array.from(modelStorage.values());
+
+    if (where) {
+      results = results.filter((record) => this.evaluateWhere(where, record));
+    }
+
+    if (cursor) {
+      const cursorValues = cursor.after as Record<string, unknown>;
+      const sortCriteria =
+        sortBy !== undefined && sortBy.length > 0
+          ? sortBy
+              .filter((sort) => cursorValues[sort.field] !== undefined)
+              .map((sort) => ({
+                field: sort.field as string,
+                direction: sort.direction ?? "asc",
+                path: sort.path,
+              }))
+          : Object.keys(cursor.after).map((field) => ({
+              field,
+              direction: "asc" as const,
+              path: undefined,
+            }));
+
+      if (sortCriteria.length > 0) {
+        results = results.filter((record) => {
+          // Lexicographic keyset pagination:
+          // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
+          for (let i = 0; i < sortCriteria.length; i++) {
+            let allPreviousEqual = true;
+            for (let j = 0; j < i; j++) {
+              const prev = sortCriteria[j]!;
+              const recordVal = this.getValue(record, prev.field, prev.path);
+              const cursorVal = cursorValues[prev.field];
+              if (this.compareValues(recordVal, cursorVal) !== 0) {
+                allPreviousEqual = false;
+                break;
+              }
+            }
+
+            if (!allPreviousEqual) continue;
+
+            const current = sortCriteria[i]!;
+            const recordVal = this.getValue(record, current.field, current.path);
+            const cursorVal = cursorValues[current.field];
+            const comp = this.compareValues(recordVal, cursorVal);
+
+            if (current.direction === "desc") {
+              if (comp < 0) return true;
+            } else if (comp > 0) {
+              return true;
+            }
+
+            // If this was the last criteria and it's equal, it doesn't satisfy "after"
+          }
+          return false;
+        });
+      }
+    }
+
+    if (sortBy) {
+      results.sort((a, b) => {
+        for (const { field, direction, path } of sortBy) {
+          const valA = this.getValue(a, field as string, path);
+          const valB = this.getValue(b, field as string, path);
+          if (valA === valB) continue;
+          const factor = direction === "desc" ? -1 : 1;
+          if (valA === undefined || valB === undefined) return 0;
+          const comparison = this.compareValues(valA, valB);
+          if (comparison === 0) continue;
+          return comparison * factor;
+        }
+        return 0;
+      });
+    }
+
+    const start = offset ?? 0;
+    const end = limit === undefined ? undefined : start + limit;
+    results = results.slice(start, end);
+
+    return Promise.resolve(results.map((record) => this.applySelect(record, select)));
+  }
+
+  update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    data: Partial<T>;
+  }): Promise<T | null> {
+    const { model, where, data } = args;
+    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const modelStorage = this.getModelStorage<K, T>(model);
+
+    for (const [pk, record] of modelStorage.entries()) {
+      if (this.evaluateWhere(where, record)) {
+        const updated: T = { ...record, ...data };
+        modelStorage.set(pk, updated);
+        return Promise.resolve(updated);
+      }
+    }
+
+    return Promise.resolve(null);
+  }
+
+  updateMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    const { model, where, data } = args;
+    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const modelStorage = this.getModelStorage<K, T>(model);
+    let count = 0;
+
+    for (const [pk, record] of modelStorage.entries()) {
+      if (where === undefined || this.evaluateWhere(where, record)) {
+        const updated: T = { ...record, ...data };
+        modelStorage.set(pk, updated);
+        count++;
+      }
+    }
+
+    return Promise.resolve(count);
+  }
+
+  async upsert<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: WhereWithoutPath<T>;
+    create: T;
+    update: Partial<T>;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, where, create, update, select } = args;
+    getPrimaryKeyWhereValues(this.getModel(model), where);
+    assertNoPrimaryKeyUpdates(this.getModel(model), update);
+    const existing = await this.find({ model, where, select });
+
+    if (existing) {
+      const updated = await this.update({ model, where, data: update });
+      if (updated === null) {
+        throw new Error("Failed to refetch updated record during upsert");
+      }
+      return this.applySelect(updated, select);
+    }
+
+    return this.create({ model, data: create, select });
+  }
+
+  delete<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+  }): Promise<void> {
+    const { model, where } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+
+    for (const [pk, record] of modelStorage.entries()) {
+      if (this.evaluateWhere(where, record)) {
+        modelStorage.delete(pk);
+        return Promise.resolve();
+      }
+    }
+    return Promise.resolve();
+  }
+
+  deleteMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model, where } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+    let count = 0;
+
+    for (const [pk, record] of modelStorage.entries()) {
+      if (where === undefined || this.evaluateWhere(where, record)) {
+        modelStorage.delete(pk);
+        count++;
+      }
+    }
+
+    return Promise.resolve(count);
+  }
+
+  count<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where?: Where<T>;
+  }): Promise<number> {
+    const { model, where } = args;
+    const modelStorage = this.getModelStorage<K, T>(model);
+
+    if (!where) return Promise.resolve(modelStorage.size);
+
+    let count = 0;
+    for (const record of modelStorage.values()) {
+      if (this.evaluateWhere(where, record)) {
+        count++;
+      }
+    }
+    return Promise.resolve(count);
+  }
+
+  // --- Helpers ---
+
+  private getModelStorage<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(model: K): Map<string, T> {
+    const storage = this.storage.get(model);
+    if (!storage) {
+      throw new Error(`Model ${model} not initialized. Call migrate() first.`);
+    }
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return storage as Map<string, T>;
+  }
+
+  private getModel<K extends keyof S & string>(model: K): S[K] {
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) {
+      throw new Error(`Model ${model} not found in schema`);
+    }
+    return modelSpec;
+  }
+
+  private getPrimaryKeyString(modelName: string, data: Record<string, unknown>): string {
+    const model = this.schema[modelName];
+    if (!model) throw new Error(`Model ${modelName} not found in schema`);
+
+    return getPrimaryKeyFields(model)
+      .map((field) => String(data[field]))
+      .join("|");
+  }
+
+  private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
+    if (select === undefined) return record;
+
+    const result: Partial<T> = {};
+    for (const field of select) {
+      result[field] = record[field];
+    }
+
+    // The public adapter contract returns `T` even when `select` narrows fields.
+    // Preserve that contract while keeping the internal representation typed.
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return result as T;
+  }
+
+  private getValue(record: RowData, field: string, path?: string[]): unknown {
+    let value = record[field];
+    if (path && path.length > 0) {
+      for (const segment of path) {
+        if (!isRecord(value)) {
+          return undefined;
+        }
+        value = value[segment];
+      }
+    }
+    return value;
+  }
+
+  private evaluateWhere<T extends RowData>(where: Where<T>, record: T): boolean {
+    if ("and" in where) {
+      return where.and.every((w) => this.evaluateWhere(w, record));
+    }
+    if ("or" in where) {
+      return where.or.some((w) => this.evaluateWhere(w, record));
+    }
+
+    const leaf = where as { field: string; op: string; value: unknown; path?: string[] };
+    const { field, op, value, path } = leaf;
+    const recordValue = this.getValue(record, field, path);
+
+    switch (op) {
+      case "eq":
+        return recordValue === value;
+      case "ne":
+        return recordValue !== value;
+      case "gt":
+        return this.compareValues(recordValue, value) > 0;
+      case "gte":
+        return this.compareValues(recordValue, value) >= 0;
+      case "lt":
+        return this.compareValues(recordValue, value) < 0;
+      case "lte":
+        return this.compareValues(recordValue, value) <= 0;
+      case "in":
+        return Array.isArray(value) && value.includes(recordValue);
+      case "not_in":
+        return Array.isArray(value) && !value.includes(recordValue);
+      default:
+        return false;
+    }
+  }
+
+  private compareValues(left: unknown, right: unknown): number {
+    if (left === right) return 0;
+    if (!this.isComparable(left) || !this.isComparable(right)) return 0;
+    if (typeof left !== typeof right) return 0;
+    return left < right ? -1 : 1;
+  }
+
+  private isComparable(value: unknown): value is Comparable {
+    return typeof value === "string" || typeof value === "number";
+  }
+}
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
new file mode 100644
index 0000000..70c34f6
--- /dev/null
+++ b/src/adapters/postgres.ts
@@ -0,0 +1,651 @@
+import type { SQL, TransactionSQL } from "bun";
+
+import type {
+  Adapter,
+  Cursor,
+  Field,
+  InferModel,
+  Schema,
+  Select,
+  SortBy,
+  Where,
+  WhereWithoutPath,
+} from "../types";
+import {
+  assertNoPrimaryKeyUpdates,
+  buildPrimaryKeyWhere,
+  escapeLiteral,
+  getPrimaryKeyFields,
+  getPrimaryKeyWhereValues,
+  isRecord,
+  mapNumeric,
+  quote,
+  validateJsonPath,
+} from "./common";
+
+function supportsSavepoints(sql: SQL): sql is TransactionSQL {
+  return "savepoint" in sql;
+}
+
+export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
+  constructor(
+    private schema: S,
+    private sql: SQL,
+  ) {}
+
+  async migrate(): Promise<void> {
+    for (const [name, model] of Object.entries(this.schema)) {
+      const columns = Object.entries(model.fields).map(([fieldName, field]) => {
+        const nullable = field.nullable === true ? "" : " NOT NULL";
+        return `${quote(fieldName)} ${this.mapFieldType(field)}${nullable}`;
+      });
+
+      const pk = `PRIMARY KEY (${getPrimaryKeyFields(model)
+        .map((field) => quote(field))
+        .join(", ")})`;
+
+      // Postgres can run these one by one without much ceremony, which keeps the
+      // bootstrap logic easy to read and debug.
+      // oxlint-disable-next-line eslint/no-await-in-loop
+      await this.sql.unsafe(
+        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
+      );
+
+      if (model.indexes === undefined) continue;
+
+      for (let i = 0; i < model.indexes.length; i++) {
+        const index = model.indexes[i];
+        if (index === undefined) continue;
+
+        const fields = (Array.isArray(index.field) ? index.field : [index.field])
+          .map((field) => `${quote(field)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
+          .join(", ");
+
+        // oxlint-disable-next-line eslint/no-await-in-loop
+        await this.sql.unsafe(
+          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
+        );
+      }
+    }
+  }
+
+  async create<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+    const { model, data, select } = args;
+    const modelSpec = this.getModel(model);
+    const insertData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(insertData);
+    const values = fields.map((field) => insertData[field]);
+    const placeholders = fields.map((_, index) => `$${index + 1}`).join(", ");
+    const sql = `INSERT INTO ${quote(model)} (${fields.map((field) => quote(field)).join(", ")}) VALUES (${placeholders}) RETURNING ${this.buildSelect(select)}`;
+
+    const rows = await this.query(sql, values);
+    const row = rows[0];
+    if (row === undefined) {
+      throw new Error("Failed to create record.");
+    }
+    return this.mapRow(model, row, select);
+  }
+
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model, where, select } = args;
+    const builtWhere = this.buildWhere(model, where);
+    const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
+    const rows = await this.query(sql, builtWhere.params);
+    const row = rows[0];
+    return row === undefined ? null : this.mapRow(model, row, select);
+  }
+
+  async findMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }): Promise<T[]> {
+    const { model, where, select, sortBy, limit, offset, cursor } = args;
+    const parts: string[] = [`SELECT ${this.buildSelect(select)} FROM ${quote(model)}`];
+    const params: unknown[] = [];
+
+    if (where !== undefined || cursor !== undefined) {
+      const builtWhere = this.buildWhere(model, where, cursor, sortBy);
+      parts.push(`WHERE ${builtWhere.sql}`);
+      params.push(...builtWhere.params);
+    }
+
+    if (sortBy !== undefined && sortBy.length > 0) {
+      parts.push(
+        `ORDER BY ${sortBy
+          .map(
+            (sort) =>
+              `${this.buildSortExpr(model, sort.field as string, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
+          )
+          .join(", ")}`,
+      );
+    }
+
+    if (limit !== undefined) {
+      parts.push(`LIMIT $${params.length + 1}`);
+      params.push(limit);
+    }
+
+    if (offset !== undefined) {
+      parts.push(`OFFSET $${params.length + 1}`);
+      params.push(offset);
+    }
+
+    const rows = await this.query(parts.join(" "), params);
+    return rows.map((row) => this.mapRow(model, row, select));
+  }
+
+  async update<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+    const { model, where, data } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
+
+    const updateData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(updateData);
+    if (fields.length === 0) {
+      return this.find({ model, where });
+    }
+
+    const assignments = fields.map((field, index) => `${quote(field)} = $${index + 1}`).join(", ");
+    const builtWhere = this.buildWhere(model, where, undefined, undefined, fields.length + 1);
+    const sql = `UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql} RETURNING *`;
+    const values = [...fields.map((field) => updateData[field]), ...builtWhere.params];
+    const rows = await this.query(sql, values);
+    const row = rows[0];
+    return row === undefined ? null : this.mapRow(model, row);
+  }
+
+  async updateMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    const { model, where, data } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
+
+    const updateData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(updateData);
+    if (fields.length === 0) {
+      return 0;
+    }
+
+    const assignments = fields.map((field, index) => `${quote(field)} = $${index + 1}`).join(", ");
+    const params = fields.map((field) => updateData[field]);
+    let sql = `UPDATE ${quote(model)} SET ${assignments}`;
+
+    if (where !== undefined) {
+      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length + 1);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
+    }
+
+    const rows = await this.query(`${sql} RETURNING 1 as touched`, params);
+    return rows.length;
+  }
+
+  async upsert<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: WhereWithoutPath<T>;
+    create: T;
+    update: Partial<T>;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, where, create, update, select } = args;
+    const modelSpec = this.getModel(model);
+    const pkValues = getPrimaryKeyWhereValues(modelSpec, where);
+    assertNoPrimaryKeyUpdates(modelSpec, update);
+
+    const createData = this.mapInput(modelSpec.fields, create);
+    const createFields = Object.keys(createData);
+    const updateData = this.mapInput(modelSpec.fields, update);
+    const updateFields = Object.keys(updateData);
+    const pkFields = getPrimaryKeyFields(modelSpec);
+
+    const insertValues = createFields.map((field) => createData[field]);
+    const insertPlaceholders = createFields.map((_, index) => `$${index + 1}`).join(", ");
+    const conflictTarget = pkFields.map((field) => quote(field)).join(", ");
+
+    const updateClause =
+      updateFields.length > 0
+        ? updateFields
+            .map(
+              (field) =>
+                `${quote(field)} = $${insertValues.length + updateFields.indexOf(field) + 1}`,
+            )
+            .join(", ")
+        : `${quote(pkFields[0]!)} = EXCLUDED.${quote(pkFields[0]!)}`;
+
+    const params =
+      updateFields.length > 0
+        ? [...insertValues, ...updateFields.map((field) => updateData[field])]
+        : insertValues;
+
+    const sql = `INSERT INTO ${quote(model)} (${createFields.map((field) => quote(field)).join(", ")}) VALUES (${insertPlaceholders}) ON CONFLICT (${conflictTarget}) DO UPDATE SET ${updateClause} RETURNING ${this.buildSelect(select)}`;
+    const rows = await this.query(sql, params);
+    const row = rows[0];
+
+    if (row !== undefined) {
+      return this.mapRow(model, row, select);
+    }
+
+    const existing = await this.find<K, T>({
+      model,
+      where: buildPrimaryKeyWhere(modelSpec, pkValues),
+      select,
+    });
+    if (existing === null) {
+      throw new Error("Failed to refetch upserted record.");
+    }
+    return existing;
+  }
+
+  async delete<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T> }): Promise<void> {
+    const existing = await this.find<K, T>({ model: args.model, where: args.where });
+    if (existing === null) {
+      return;
+    }
+
+    const builtWhere = this.buildWhere(
+      args.model,
+      buildPrimaryKeyWhere(this.getModel(args.model), existing),
+    );
+    await this.query(`DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`, builtWhere.params);
+  }
+
+  async deleteMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model, where } = args;
+    let sql = `DELETE FROM ${quote(model)}`;
+    const params: unknown[] = [];
+
+    if (where !== undefined) {
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
+    }
+
+    const rows = await this.query(`${sql} RETURNING 1 as touched`, params);
+    return rows.length;
+  }
+
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model, where } = args;
+    let sql = `SELECT COUNT(*) as count FROM ${quote(model)}`;
+    const params: unknown[] = [];
+
+    if (where !== undefined) {
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
+    }
+
+    const rows = await this.query(sql, params);
+    const row = rows[0];
+    return isRecord(row) && typeof row["count"] === "number"
+      ? row["count"]
+      : Number(row?.["count"] ?? 0);
+  }
+
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (supportsSavepoints(this.sql)) {
+      // Nested Postgres transactions become savepoints on the already-reserved
+      // transaction connection.
+      return this.sql.savepoint((savepointSql) => {
+        const txAdapter = new PostgresAdapter(this.schema, savepointSql);
+        return fn(txAdapter);
+      });
+    }
+
+    // Bun SQL already reserves a dedicated connection for the transaction callback,
+    // so unlike SQLite we do not need an extra top-level transaction queue here.
+    return this.sql.transaction((tx) => {
+      const txAdapter = new PostgresAdapter(this.schema, tx);
+      return fn(txAdapter);
+    });
+  }
+
+  private getModel<K extends keyof S & string>(model: K): S[K] {
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) {
+      throw new Error(`Model ${model} not found in schema.`);
+    }
+    return modelSpec;
+  }
+
+  private query<T extends Record<string, unknown> = Record<string, unknown>>(
+    sql: string,
+    params: unknown[] = [],
+  ): Promise<T[]> {
+    return this.sql.unsafe<T[]>(sql, params);
+  }
+
+  private mapFieldType(field: Field): string {
+    switch (field.type) {
+      case "string":
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+      case "number":
+        return "DOUBLE PRECISION";
+      case "boolean":
+        return "BOOLEAN";
+      case "timestamp":
+        return "BIGINT";
+      case "json":
+      case "json[]":
+        // Both logical JSON shapes can live in jsonb; the TS type distinguishes them.
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+
+  private buildSelect<T>(select?: Select<T>): string {
+    return select === undefined ? "*" : select.map((field) => quote(field as string)).join(", ");
+  }
+
+  private buildSortExpr(modelName: string, field: string, path?: string[]): string {
+    if (path === undefined || path.length === 0) {
+      return quote(field);
+    }
+
+    // For v1, JSON-path sorting is kept simple and text-based. Filtering paths can
+    // still cast based on the comparison value, but sort semantics stay predictable.
+    return this.buildColumnExpr(modelName, field, path);
+  }
+
+  private buildColumnExpr(
+    modelName: string,
+    field: string,
+    path?: string[],
+    value?: unknown,
+  ): string {
+    if (path === undefined || path.length === 0) {
+      return quote(field);
+    }
+
+    const model = this.schema[modelName as keyof S];
+    const fieldSpec = model?.fields[field];
+    if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
+      throw new Error(`Cannot use JSON path on non-JSON field: ${field}`);
+    }
+
+    const segments = validateJsonPath(path)
+      .map((segment) => `'${escapeLiteral(segment)}'`)
+      .join(", ");
+    const baseExpr = `jsonb_extract_path_text(${quote(field)}, ${segments})`;
+
+    if (typeof value === "number") {
+      return `(${baseExpr})::double precision`;
+    }
+    if (typeof value === "boolean") {
+      return `(${baseExpr})::boolean`;
+    }
+    return baseExpr;
+  }
+
+  private buildCursor<T>(
+    modelName: string,
+    cursor: Cursor<T>,
+    sortBy?: SortBy<T>[],
+    startIndex = 1,
+  ): { sql: string; params: unknown[]; nextIndex: number } {
+    type CursorSort = {
+      field: Extract<keyof T, string>;
+      direction: "asc" | "desc";
+      path?: string[];
+    };
+    const cursorValues = cursor.after as Partial<Record<string, unknown>>;
+    const sortCriteria: CursorSort[] =
+      sortBy !== undefined && sortBy.length > 0
+        ? sortBy
+            .filter((sort) => cursorValues[sort.field] !== undefined)
+            .map((sort) => ({
+              field: sort.field,
+              direction: sort.direction ?? "asc",
+              path: sort.path,
+            }))
+        : Object.keys(cursor.after).map((field) => ({
+            // Cursor keys come from the typed `Cursor<T>` surface.
+            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+            field: field as Extract<keyof T, string>,
+            direction: "asc" as const,
+            path: undefined,
+          }));
+
+    if (sortCriteria.length === 0) {
+      return { sql: "", params: [], nextIndex: startIndex };
+    }
+
+    const orClauses: string[] = [];
+    const params: unknown[] = [];
+    let nextIndex = startIndex;
+
+    for (let i = 0; i < sortCriteria.length; i++) {
+      const andClauses: string[] = [];
+
+      for (let j = 0; j < i; j++) {
+        const previous = sortCriteria[j]!;
+        andClauses.push(
+          `${this.buildColumnExpr(modelName, previous.field, previous.path, cursorValues[previous.field])} = $${nextIndex}`,
+        );
+        params.push(cursorValues[previous.field]);
+        nextIndex++;
+      }
+
+      const current = sortCriteria[i]!;
+      andClauses.push(
+        `${this.buildColumnExpr(modelName, current.field, current.path, cursorValues[current.field])} ${current.direction === "desc" ? "<" : ">"} $${nextIndex}`,
+      );
+      params.push(cursorValues[current.field]);
+      nextIndex++;
+      orClauses.push(`(${andClauses.join(" AND ")})`);
+    }
+
+    return {
+      sql: `(${orClauses.join(" OR ")})`,
+      params,
+      nextIndex,
+    };
+  }
+
+  private buildWhere<T>(
+    modelName: string,
+    where?: Where<T>,
+    cursor?: Cursor<T>,
+    sortBy?: SortBy<T>[],
+    startIndex = 1,
+  ): { sql: string; params: unknown[]; nextIndex: number } {
+    const parts: string[] = [];
+    const params: unknown[] = [];
+    let nextIndex = startIndex;
+
+    if (where !== undefined) {
+      const builtWhere = this.buildWhereRecursive(modelName, where, nextIndex);
+      parts.push(builtWhere.sql);
+      params.push(...builtWhere.params);
+      nextIndex = builtWhere.nextIndex;
+    }
+
+    if (cursor !== undefined) {
+      const builtCursor = this.buildCursor(modelName, cursor, sortBy, nextIndex);
+      if (builtCursor.sql !== "") {
+        parts.push(builtCursor.sql);
+        params.push(...builtCursor.params);
+        nextIndex = builtCursor.nextIndex;
+      }
+    }
+
+    return {
+      sql: parts.length > 0 ? parts.map((part) => `(${part})`).join(" AND ") : "1=1",
+      params,
+      nextIndex,
+    };
+  }
+
+  private buildWhereRecursive<T>(
+    modelName: string,
+    where: Where<T>,
+    startIndex: number,
+  ): { sql: string; params: unknown[]; nextIndex: number } {
+    if ("and" in where) {
+      const parts: string[] = [];
+      const params: unknown[] = [];
+      let nextIndex = startIndex;
+
+      for (const clause of where.and) {
+        const built = this.buildWhereRecursive(modelName, clause, nextIndex);
+        parts.push(`(${built.sql})`);
+        params.push(...built.params);
+        nextIndex = built.nextIndex;
+      }
+
+      return { sql: parts.join(" AND "), params, nextIndex };
+    }
+
+    if ("or" in where) {
+      const parts: string[] = [];
+      const params: unknown[] = [];
+      let nextIndex = startIndex;
+
+      for (const clause of where.or) {
+        const built = this.buildWhereRecursive(modelName, clause, nextIndex);
+        parts.push(`(${built.sql})`);
+        params.push(...built.params);
+        nextIndex = built.nextIndex;
+      }
+
+      return { sql: parts.join(" OR "), params, nextIndex };
+    }
+
+    const expr = this.buildColumnExpr(modelName, where.field as string, where.path, where.value);
+    switch (where.op) {
+      case "eq":
+        return {
+          sql: `${expr} = $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "ne":
+        return {
+          sql: `${expr} != $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "gt":
+        return {
+          sql: `${expr} > $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "gte":
+        return {
+          sql: `${expr} >= $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "lt":
+        return {
+          sql: `${expr} < $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "lte":
+        return {
+          sql: `${expr} <= $${startIndex}`,
+          params: [where.value],
+          nextIndex: startIndex + 1,
+        };
+      case "in":
+        if (where.value.length === 0) {
+          return { sql: "1=0", params: [], nextIndex: startIndex };
+        }
+        return {
+          sql: `${expr} IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
+          params: where.value,
+          nextIndex: startIndex + where.value.length,
+        };
+      case "not_in":
+        if (where.value.length === 0) {
+          return { sql: "1=1", params: [], nextIndex: startIndex };
+        }
+        return {
+          sql: `${expr} NOT IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
+          params: where.value,
+          nextIndex: startIndex + where.value.length,
+        };
+      default:
+        throw new Error(`Unsupported operator: ${(where as { op: string }).op}`);
+    }
+  }
+
+  private mapInput(
+    fields: Record<string, Field>,
+    data: Record<string, unknown> | Partial<Record<string, unknown>>,
+  ): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+
+    for (const [fieldName] of Object.entries(fields)) {
+      const value = data[fieldName];
+      if (value === undefined) continue;
+      result[fieldName] = value;
+    }
+
+    return result;
+  }
+
+  private mapRow<K extends keyof S & string, T extends Record<string, unknown>>(
+    model: K,
+    row: Record<string, unknown>,
+    select?: Select<T>,
+  ): T {
+    const fieldSpecs = this.getModel(model).fields;
+    const output: Record<string, unknown> = {};
+    const selectedFields =
+      select === undefined ? Object.keys(row) : select.map((field) => field as string);
+
+    for (const fieldName of selectedFields) {
+      const fieldSpec = fieldSpecs[fieldName];
+      const value = row[fieldName];
+
+      if (fieldSpec === undefined || value === undefined || value === null) {
+        output[fieldName] = value;
+        continue;
+      }
+
+      if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
+        output[fieldName] = mapNumeric(value);
+      } else {
+        output[fieldName] = value;
+      }
+    }
+
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return output as T;
+  }
+}
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 593c91f..156550e 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -1,7 +1,8 @@
-import { describe, expect, it, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
+import { describe, expect, it, beforeEach } from "bun:test";
+
+import type { Schema, InferModel } from "../types";
 import { SqliteAdapter } from "./sqlite";
-import type { Schema } from "../types";
 
 const schema = {
   users: {
@@ -18,14 +19,7 @@ const schema = {
   },
 } as const satisfies Schema;
 
-type User = {
-  id: string;
-  name: string;
-  age: number;
-  is_active: boolean;
-  metadata?: { theme: string; window?: { width: number } } | null;
-  tags?: string[] | null;
-};
+type User = InferModel<typeof schema.users>;
 
 describe("SqliteAdapter", () => {
   let db: Database;
@@ -49,19 +43,19 @@ describe("SqliteAdapter", () => {
       };
       await adapter.create({ model: "users", data: user });
 
-      const found = await adapter.find({
+      const found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
       });
-      expect(found).toEqual(expect.objectContaining(user));
+      expect(found).toEqual(user);
     });
 
     it("should update a record and refetch correctly", async () => {
       await adapter.create({
         model: "users",
-        data: { id: "u1", name: "Alice", age: 30, is_active: true },
+        data: { id: "u1", name: "Alice", age: 30, is_active: true, metadata: null, tags: null },
       });
-      const updated = await adapter.update({
+      const updated = await adapter.update<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
         data: { age: 31 },
@@ -69,16 +63,31 @@ describe("SqliteAdapter", () => {
       expect(updated?.age).toBe(31);
     });
 
+    it("should reject primary key updates", async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "u1", name: "Alice", age: 30, is_active: true, metadata: null, tags: null },
+      });
+
+      expect(() =>
+        adapter.update<"users", User>({
+          model: "users",
+          where: { field: "id", op: "eq", value: "u1" },
+          data: { id: "u2" },
+        }),
+      ).toThrow("Primary key updates are not supported.");
+    });
+
     it("should delete a record", async () => {
       await adapter.create({
         model: "users",
-        data: { id: "u1", name: "Alice", age: 30, is_active: true },
+        data: { id: "u1", name: "Alice", age: 30, is_active: true, metadata: null, tags: null },
       });
       await adapter.delete({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
       });
-      const found = await adapter.find({
+      const found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
       });
@@ -91,21 +100,21 @@ describe("SqliteAdapter", () => {
       await Promise.all([
         adapter.create({
           model: "users",
-          data: { id: "u1", name: "Alice", age: 25, is_active: true },
+          data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null, tags: null },
         }),
         adapter.create({
           model: "users",
-          data: { id: "u2", name: "Bob", age: 30, is_active: false },
+          data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null, tags: null },
         }),
         adapter.create({
           model: "users",
-          data: { id: "u3", name: "Charlie", age: 35, is_active: true },
+          data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null, tags: null },
         }),
       ]);
     });
 
     it("should filter with 'in' operator", async () => {
-      const users = await adapter.findMany({
+      const users = await adapter.findMany<"users", User>({
         model: "users",
         where: { field: "age", op: "in", value: [25, 35] },
       });
@@ -113,7 +122,7 @@ describe("SqliteAdapter", () => {
     });
 
     it("should handle empty 'in' list gracefully", async () => {
-      const users = await adapter.findMany({
+      const users = await adapter.findMany<"users", User>({
         model: "users",
         where: { field: "age", op: "in", value: [] },
       });
@@ -121,7 +130,7 @@ describe("SqliteAdapter", () => {
     });
 
     it("should handle complex AND / OR where clauses", async () => {
-      const found = await adapter.findMany({
+      const found = await adapter.findMany<"users", User>({
         model: "users",
         where: {
           or: [
@@ -142,7 +151,7 @@ describe("SqliteAdapter", () => {
     });
 
     it("should sort records", async () => {
-      const users = await adapter.findMany({
+      const users = await adapter.findMany<"users", User>({
         model: "users",
         sortBy: [{ field: "age", direction: "desc" }],
       });
@@ -160,6 +169,7 @@ describe("SqliteAdapter", () => {
           age: 20,
           is_active: true,
           metadata: { theme: "dark", window: { width: 800 } },
+          tags: null,
         },
       });
       await adapter.create({
@@ -170,6 +180,7 @@ describe("SqliteAdapter", () => {
           age: 20,
           is_active: true,
           metadata: { theme: "light", window: { width: 1024 } },
+          tags: null,
         },
       });
       await adapter.create({
@@ -180,18 +191,19 @@ describe("SqliteAdapter", () => {
           age: 20,
           is_active: true,
           metadata: { theme: "dark", window: { width: 1920 } },
+          tags: null,
         },
       });
 
       // 1. Exact match on nested string (theme = 'dark')
-      const darkUsers = await adapter.findMany({
+      const darkUsers = await adapter.findMany<"users", User>({
         model: "users",
         where: { field: "metadata", path: ["theme"], op: "eq", value: "dark" },
       });
       expect(darkUsers).toHaveLength(2);
 
       // 2. Numeric operator on deeply nested number (window.width > 900)
-      const wideUsers = await adapter.findMany({
+      const wideUsers = await adapter.findMany<"users", User>({
         model: "users",
         where: { field: "metadata", path: ["window", "width"], op: "gt", value: 900 },
       });
@@ -204,10 +216,10 @@ describe("SqliteAdapter", () => {
       await adapter.transaction(async (tx) => {
         await tx.create({
           model: "users",
-          data: { id: "t1", name: "TxUser1", age: 20, is_active: true },
+          data: { id: "t1", name: "TxUser1", age: 20, is_active: true, metadata: null, tags: null },
         });
       });
-      const found = await adapter.find({
+      const found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "t1" },
       });
@@ -219,14 +231,21 @@ describe("SqliteAdapter", () => {
         await adapter.transaction(async (tx) => {
           await tx.create({
             model: "users",
-            data: { id: "t1", name: "TxUser1", age: 20, is_active: true },
+            data: {
+              id: "t1",
+              name: "TxUser1",
+              age: 20,
+              is_active: true,
+              metadata: null,
+              tags: null,
+            },
           });
           throw new Error("Failure");
         });
       } catch {
         // expected
       }
-      const found = await adapter.find({
+      const found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "t1" },
       });
@@ -235,14 +254,15 @@ describe("SqliteAdapter", () => {
 
     it("should handle nested transactions with savepoints", async () => {
       await adapter.transaction(async (outer) => {
+        if (!outer.transaction) throw new Error("Transactions not supported");
         await outer.create({
           model: "users",
-          data: { id: "n1", name: "Outer1", age: 20, is_active: true },
+          data: { id: "n1", name: "Outer1", age: 20, is_active: true, metadata: null, tags: null },
         });
 
         try {
           await outer.transaction(async (inner) => {
-            await inner.update({
+            await inner.update<"users", User>({
               model: "users",
               where: { field: "id", op: "eq", value: "n1" },
               data: { age: 40 },
@@ -254,7 +274,7 @@ describe("SqliteAdapter", () => {
         }
       });
 
-      const found = await adapter.find({
+      const found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "n1" },
       });
@@ -266,26 +286,26 @@ describe("SqliteAdapter", () => {
     it("should handle multi-field keyset pagination correctly", async () => {
       await adapter.create({
         model: "users",
-        data: { id: "m1", name: "A", age: 30, is_active: true },
+        data: { id: "m1", name: "A", age: 30, is_active: true, metadata: null, tags: null },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m2", name: "B", age: 30, is_active: true },
+        data: { id: "m2", name: "B", age: 30, is_active: true, metadata: null, tags: null },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m3", name: "C", age: 30, is_active: true },
+        data: { id: "m3", name: "C", age: 30, is_active: true, metadata: null, tags: null },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m4", name: "A", age: 31, is_active: true },
+        data: { id: "m4", name: "A", age: 31, is_active: true, metadata: null, tags: null },
       });
       await adapter.create({
         model: "users",
-        data: { id: "m5", name: "B", age: 31, is_active: true },
+        data: { id: "m5", name: "B", age: 31, is_active: true, metadata: null, tags: null },
       });
 
-      const result = await adapter.findMany({
+      const result = await adapter.findMany<"users", User>({
         model: "users",
         sortBy: [
           { field: "age", direction: "asc" },
@@ -315,6 +335,8 @@ describe("SqliteAdapter", () => {
                 name: `User ${i}`,
                 age: 20 + i,
                 is_active: true,
+                metadata: null,
+                tags: null,
               },
             }),
           );
@@ -323,7 +345,7 @@ describe("SqliteAdapter", () => {
       });
 
       it("should respect limit and offset", async () => {
-        const page1 = await adapter.findMany({
+        const page1 = await adapter.findMany<"users", User>({
           model: "users",
           sortBy: [{ field: "age", direction: "asc" }],
           limit: 2,
@@ -332,7 +354,7 @@ describe("SqliteAdapter", () => {
         expect(page1).toHaveLength(2);
         expect(page1[0]?.id).toBe("p1");
 
-        const page2 = await adapter.findMany({
+        const page2 = await adapter.findMany<"users", User>({
           model: "users",
           sortBy: [{ field: "age", direction: "asc" }],
           limit: 2,
@@ -343,7 +365,7 @@ describe("SqliteAdapter", () => {
       });
 
       it("should handle cursor pagination ascending", async () => {
-        const result = await adapter.findMany({
+        const result = await adapter.findMany<"users", User>({
           model: "users",
           sortBy: [{ field: "age", direction: "asc" }],
           cursor: { after: { age: 22 } },
@@ -355,7 +377,7 @@ describe("SqliteAdapter", () => {
       });
 
       it("should handle cursor pagination descending", async () => {
-        const result = await adapter.findMany({
+        const result = await adapter.findMany<"users", User>({
           model: "users",
           sortBy: [{ field: "age", direction: "desc" }],
           cursor: { after: { age: 24 } },
@@ -370,35 +392,62 @@ describe("SqliteAdapter", () => {
 
   describe("Upsert", () => {
     it("should handle upsert correctly", async () => {
-      const data = { id: "u1", name: "Alice", age: 25, is_active: true };
+      const data: User = {
+        id: "u1",
+        name: "Alice",
+        age: 25,
+        is_active: true,
+        metadata: null,
+        tags: null,
+      };
 
       // Insert
-      await adapter.upsert({
+      await adapter.upsert<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
         create: data,
         update: { age: 26 },
       });
 
-      let found = await adapter.find({
+      let found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
       });
       expect(found?.age).toBe(25);
 
       // Update
-      await adapter.upsert({
+      await adapter.upsert<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
         create: data,
         update: { age: 26 },
       });
 
-      found = await adapter.find({
+      found = await adapter.find<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
       });
       expect(found?.age).toBe(26);
     });
+
+    it("should require primary-key equality in upsert filters", () => {
+      const data: User = {
+        id: "u1",
+        name: "Alice",
+        age: 25,
+        is_active: true,
+        metadata: null,
+        tags: null,
+      };
+
+      expect(() =>
+        adapter.upsert<"users", User>({
+          model: "users",
+          where: { field: "name", op: "eq", value: "Alice" },
+          create: data,
+          update: { age: 26 },
+        }),
+      ).toThrow("Upsert requires equality filters for every primary key field.");
+    });
   });
 });
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index a8e6424..1bf0ab2 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,44 +1,69 @@
-import { AsyncLocalStorage } from "node:async_hooks";
 import type {
   Adapter,
   Cursor,
-  FieldName,
+  Field,
+  InferModel,
   Schema,
   Select,
   SortBy,
   Where,
   WhereWithoutPath,
 } from "../types";
-import { isModelType, isRecord, isStringKey, isValidField } from "../utils/is";
-import { escapeLiteral, quote } from "../utils/sql";
-import type {
-  NativeSqliteDriver,
-  SqliteDatabase,
-  SqliteValue,
-} from "./sqlite.types";
+import {
+  assertNoPrimaryKeyUpdates,
+  buildPrimaryKeyWhere,
+  escapeLiteral,
+  getPrimaryKeyFields,
+  getPrimaryKeyWhereValues,
+  isRecord,
+  mapNumeric,
+  quote,
+  validateJsonPath,
+} from "./common";
+
+export type SqliteValue = string | number | Uint8Array | null;
+
+/**
+ * The standard connection interface the adapter expects.
+ * Keeping this narrow lets the adapter work with Bun's sqlite driver
+ * and any small compatibility wrapper without adding another abstraction layer.
+ */
+export interface SqliteDatabase {
+  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
+  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
+  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
+}
+
+export interface NativeSqliteStatement {
+  run(...params: SqliteValue[]): unknown;
+  get(...params: SqliteValue[]): unknown;
+  all(...params: SqliteValue[]): unknown;
+}
 
-const transactionStorage = new AsyncLocalStorage<SqliteDatabase>();
+export interface NativeSqliteDriver {
+  // This is a tiny compatibility surface, not a promise to support one specific
+  // external driver package. The adapter only needs `prepare/run/get/all`.
+  prepare(sql: string): NativeSqliteStatement;
+}
 
 export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   private db: SqliteDatabase;
-  private spCounter = 0;
+  private savepointCounter = 0;
+  private transactionQueue = Promise.resolve();
+  private isTransaction = false;
 
   constructor(
     private schema: S,
     database: SqliteDatabase | NativeSqliteDriver,
+    _isTransaction = false,
   ) {
-    if ("prepare" in database) {
-      this.db = this.wrapNativeDriver(database);
-    } else {
-      this.db = database;
-    }
-  }
-
-  private get activeDb(): SqliteDatabase {
-    return transactionStorage.getStore() ?? this.db;
+    this.db = "prepare" in database ? this.wrapNativeDriver(database) : database;
+    this.isTransaction = _isTransaction;
   }
 
   private wrapNativeDriver(native: NativeSqliteDriver): SqliteDatabase {
+    // Normalize Bun's synchronous sqlite driver into the tiny async contract used
+    // by the adapter so the rest of the implementation can stay consistent.
     return {
       run: (sql, params) => {
         const stmt = native.prepare(sql);
@@ -63,109 +88,82 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   async migrate(): Promise<void> {
     for (const [name, model] of Object.entries(this.schema)) {
       const columns = Object.entries(model.fields).map(([fieldName, field]) => {
-        const type = this.mapType(field.type);
         const nullable = field.nullable === true ? "" : " NOT NULL";
-        return `${quote(fieldName)} ${type}${nullable}`;
+        return `${quote(fieldName)} ${this.mapFieldType(field)}${nullable}`;
       });
 
-      const pkFields = Array.isArray(model.primaryKey)
-        ? model.primaryKey
-        : [model.primaryKey];
-      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
+      const pk = `PRIMARY KEY (${getPrimaryKeyFields(model)
+        .map((field) => quote(field))
+        .join(", ")})`;
 
-      // Migrations (CREATE TABLE / CREATE INDEX) must be executed sequentially
-      // to prevent database locking errors and ensure dependent objects exist.
-      await this.activeDb.run(
+      // SQLite schema bootstrap is intentionally sequential.
+      // CREATE INDEX depends on CREATE TABLE and shared connections can lock.
+      // oxlint-disable-next-line eslint/no-await-in-loop
+      await this.db.run(
         `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
         [],
       );
 
-      if (model.indexes !== undefined) {
-        for (let i = 0; i < model.indexes.length; i++) {
-          const index = model.indexes[i];
-          if (index === undefined) continue;
-          const fields = Array.isArray(index.field) ? index.field : [index.field];
-          const fieldList = fields
-            .map((f) => `${quote(f)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
-            .join(", ");
-          const indexName = `idx_${name}_${i}`;
-          await this.activeDb.run(
-            `CREATE INDEX IF NOT EXISTS ${quote(indexName)} ON ${quote(name)} (${fieldList})`,
-            [],
-          );
-        }
+      if (model.indexes === undefined) continue;
+
+      for (let i = 0; i < model.indexes.length; i++) {
+        const index = model.indexes[i];
+        if (index === undefined) continue;
+
+        const fields = (Array.isArray(index.field) ? index.field : [index.field])
+          .map((field) => `${quote(field)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
+          .join(", ");
+
+        // oxlint-disable-next-line eslint/no-await-in-loop
+        await this.db.run(
+          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
+          [],
+        );
       }
     }
   }
 
-  async create<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    data: T;
-    select?: Select<T>;
-  }): Promise<T> {
+  async create<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
     const { model, data, select } = args;
-    const mappedData = this.mapInput(model, data);
+    const modelSpec = this.getModel(model);
+    const mappedData = this.mapInput(modelSpec.fields, data);
     const fields = Object.keys(mappedData);
+    const placeholders = fields.map(() => "?").join(", ");
+    const columns = fields.map((field) => quote(field)).join(", ");
+    const params = fields.map((field) => mappedData[field] ?? null);
 
-    const placeholders = Array.from({ length: fields.length }).fill("?").join(", ");
-    const columns = fields.map((f) => quote(f)).join(", ");
-
-    const params: SqliteValue[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (isStringKey(field)) params.push(mappedData[field] ?? null);
-    }
-
-    await this.activeDb.run(
-      `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`,
-      params,
-    );
-
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
-
-    const pkFields = Array.isArray(modelSpec.primaryKey)
-      ? modelSpec.primaryKey
-      : [modelSpec.primaryKey];
-
-    const where: Where<T>[] = [];
-    for (let i = 0; i < pkFields.length; i++) {
-      const f = pkFields[i];
-      if (isValidField<T>(f)) {
-        where.push({
-          field: f,
-          op: "eq",
-          value: (data as any)[f],
-        });
-      }
-    }
+    await this.db.run(`INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`, params);
 
     const result = await this.find<K, T>({
       model,
-      where: where.length === 1 && where[0] ? where[0] : { and: where },
+      where: buildPrimaryKeyWhere(modelSpec, data),
       select,
     });
 
-    if (result === null) throw new Error("Failed to refetch created record");
+    if (result === null) {
+      throw new Error("Failed to refetch created record.");
+    }
     return result;
   }
 
-  async find<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    select?: Select<T>;
-  }): Promise<T | null> {
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
     const { model, where, select } = args;
-    const query = this.buildSelect(model, select);
-    const { sql, params } = this.buildWhere(model, where);
-
-    const fullSql = `${query} WHERE ${sql} LIMIT 1`;
-    const row = await this.activeDb.get(fullSql, params);
-
-    return row ? this.mapRow<T>(model, row) : null;
+    const builtWhere = this.buildWhere(model, where);
+    const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
+    const row = await this.db.get(sql, builtWhere.params);
+    return row === null ? null : this.mapRow(model, row, select);
   }
 
-  async findMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  async findMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
     where?: Where<T>;
     select?: Select<T>;
@@ -175,257 +173,268 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor?: Cursor<T>;
   }): Promise<T[]> {
     const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const query = this.buildSelect(model, select);
-    const args_sql: SqliteValue[] = [];
-    const sql_parts: string[] = [query];
+    const parts: string[] = [`SELECT ${this.buildSelect(select)} FROM ${quote(model)}`];
+    const params: SqliteValue[] = [];
 
     if (where !== undefined || cursor !== undefined) {
-      const { sql, params } = this.buildWhere(model, where, cursor, sortBy);
-      sql_parts.push(`WHERE ${sql}`);
-      for (let i = 0; i < params.length; i++) {
-        const param = params[i];
-        if (param !== undefined) args_sql.push(param);
-      }
+      const builtWhere = this.buildWhere(model, where, cursor, sortBy);
+      parts.push(`WHERE ${builtWhere.sql}`);
+      params.push(...builtWhere.params);
     }
 
-    if (sortBy !== undefined) {
+    if (sortBy !== undefined && sortBy.length > 0) {
       const order = sortBy
-        .map((s) => {
-          const col = this.buildColumnExpr(model, s.field as string, s.path);
-          return `${col} ${s.direction?.toUpperCase() ?? "ASC"}`;
+        .map((sort) => {
+          const expr = this.buildColumnExpr(model, sort.field as string, sort.path);
+          return `${expr} ${(sort.direction ?? "asc").toUpperCase()}`;
         })
         .join(", ");
-      sql_parts.push(`ORDER BY ${order}`);
+      parts.push(`ORDER BY ${order}`);
     }
 
     if (limit !== undefined) {
-      sql_parts.push(`LIMIT ?`);
-      args_sql.push(limit);
+      parts.push("LIMIT ?");
+      params.push(limit);
     }
 
     if (offset !== undefined) {
-      sql_parts.push(`OFFSET ?`);
-      args_sql.push(offset);
+      parts.push("OFFSET ?");
+      params.push(offset);
     }
 
-    const rows = await this.activeDb.all(sql_parts.join(" "), args_sql);
-    return rows.map((row) => this.mapRow<T>(model, row));
+    const rows = await this.db.all(parts.join(" "), params);
+    return rows.map((row) => this.mapRow(model, row, select));
   }
 
-  async update<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    data: Partial<T>;
-  }): Promise<T | null> {
+  async update<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
     const { model, where, data } = args;
-    const mappedData = this.mapInput(model, data);
-    const fields = Object.keys(mappedData);
-    if (fields.length === 0) return this.find({ model, where });
-
-    const setClause = fields.map((f) => `${quote(f)} = ?`).join(", ");
-    const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
 
-    const params: SqliteValue[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (isStringKey(field)) params.push(mappedData[field] ?? null);
+    const existing = await this.find<K, T>({ model, where });
+    if (existing === null) {
+      return null;
     }
-    for (let i = 0; i < whereParams.length; i++) {
-      const param = whereParams[i];
-      if (param !== undefined) params.push(param);
-    }
-
-    await this.activeDb.run(`UPDATE ${quote(model)} SET ${setClause} WHERE ${whereSql}`, params);
 
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
-
-    const pkFields = Array.isArray(modelSpec.primaryKey)
-      ? modelSpec.primaryKey
-      : [modelSpec.primaryKey];
+    const mappedData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(mappedData);
+    if (fields.length === 0) {
+      return existing;
+    }
 
-    const preRead = await this.find<K, T>({ model, where });
-    if (!preRead) return null;
+    const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
+    const params = fields.map((field) => mappedData[field] ?? null);
+    const primaryKeyWhere: Where<T> = buildPrimaryKeyWhere(modelSpec, existing);
+    const builtWhere = this.buildWhere(model, primaryKeyWhere);
 
-    const pkWhere: Where<T>[] = [];
-    for (const f of pkFields) {
-      if (isValidField<T>(f)) {
-        pkWhere.push({ field: f, op: "eq", value: (preRead as any)[f] });
-      }
-    }
+    await this.db.run(`UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql}`, [
+      ...params,
+      ...builtWhere.params,
+    ]);
 
-    return this.find<K, T>({
-      model,
-      where: pkWhere.length === 1 && pkWhere[0] ? pkWhere[0] : { and: pkWhere },
-    });
+    return this.find<K, T>({ model, where: primaryKeyWhere });
   }
 
-  async updateMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-    data: Partial<T>;
-  }): Promise<number> {
+  async updateMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
     const { model, where, data } = args;
-    const mappedData = this.mapInput(model, data);
-    const fields = Object.keys(mappedData);
-    if (fields.length === 0) return 0;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
 
-    const setClause = fields.map((f) => `${quote(f)} = ?`).join(", ");
-    const args_sql: SqliteValue[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (isStringKey(field)) args_sql.push(mappedData[field] ?? null);
+    const mappedData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(mappedData);
+    if (fields.length === 0) {
+      return 0;
     }
 
-    let sql = `UPDATE ${quote(model)} SET ${setClause}`;
+    const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
+    const params = fields.map((field) => mappedData[field] ?? null);
+    let sql = `UPDATE ${quote(model)} SET ${assignments}`;
+
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
-      sql += ` WHERE ${whereSql}`;
-      for (let i = 0; i < whereParams.length; i++) {
-        const param = whereParams[i];
-        if (param !== undefined) args_sql.push(param);
-      }
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
     }
 
-    const result = await this.activeDb.run(sql, args_sql);
+    const result = await this.db.run(sql, params);
     return result.changes;
   }
 
-  async delete<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  async upsert<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
-    where: Where<T>;
-  }): Promise<void> {
-    const { model, where } = args;
-    const { sql, params } = this.buildWhere(model, where);
-    await this.activeDb.run(`DELETE FROM ${quote(model)} WHERE ${sql}`, params);
+    where: WhereWithoutPath<T>;
+    create: T;
+    update: Partial<T>;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, where, create, update, select } = args;
+    const modelSpec = this.getModel(model);
+    const primaryKeyValues = getPrimaryKeyWhereValues(modelSpec, where);
+    assertNoPrimaryKeyUpdates(modelSpec, update);
+
+    const mappedCreate = this.mapInput(modelSpec.fields, create);
+    const createFields = Object.keys(mappedCreate);
+    const mappedUpdate = this.mapInput(modelSpec.fields, update);
+    const updateFields = Object.keys(mappedUpdate);
+    const primaryKeyFields = getPrimaryKeyFields(modelSpec);
+
+    const conflictColumns = primaryKeyFields.map((field) => quote(field)).join(", ");
+    const insertColumns = createFields.map((field) => quote(field)).join(", ");
+    const insertPlaceholders = createFields.map(() => "?").join(", ");
+    const updateClause =
+      updateFields.length > 0
+        ? // SQLite has no generic "merge this object" primitive, so we spell out
+          // the UPDATE clause and bind update values explicitly.
+          updateFields.map((field) => `${quote(field)} = ?`).join(", ")
+        : `${quote(primaryKeyFields[0]!)} = excluded.${quote(primaryKeyFields[0]!)}`;
+
+    const params =
+      updateFields.length > 0
+        ? [
+            ...createFields.map((field) => mappedCreate[field] ?? null),
+            ...updateFields.map((field) => mappedUpdate[field] ?? null),
+          ]
+        : createFields.map((field) => mappedCreate[field] ?? null);
+
+    await this.db.run(
+      `INSERT INTO ${quote(model)} (${insertColumns}) VALUES (${insertPlaceholders}) ON CONFLICT(${conflictColumns}) DO UPDATE SET ${updateClause}`,
+      params,
+    );
+
+    const result = await this.find<K, T>({
+      model,
+      where: buildPrimaryKeyWhere(modelSpec, primaryKeyValues),
+      select,
+    });
+
+    if (result === null) {
+      throw new Error("Failed to refetch upserted record.");
+    }
+    return result;
   }
 
-  async deleteMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-  }): Promise<number> {
+  async delete<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T> }): Promise<void> {
+    const existing = await this.find<K, T>({ model: args.model, where: args.where });
+    if (existing === null) {
+      return;
+    }
+
+    const builtWhere = this.buildWhere(
+      args.model,
+      buildPrimaryKeyWhere(this.getModel(args.model), existing),
+    );
+    await this.db.run(
+      `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
+      builtWhere.params,
+    );
+  }
+
+  async deleteMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model, where } = args;
     let sql = `DELETE FROM ${quote(model)}`;
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
-      sql += ` WHERE ${whereSql}`;
-      for (let i = 0; i < whereParams.length; i++) {
-        const param = whereParams[i];
-        if (param !== undefined) params.push(param);
-      }
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
     }
 
-    const result = await this.activeDb.run(sql, params);
+    const result = await this.db.run(sql, params);
     return result.changes;
   }
 
-  async count<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-  }): Promise<number> {
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model, where } = args;
     let sql = `SELECT COUNT(*) as count FROM ${quote(model)}`;
     const params: SqliteValue[] = [];
 
     if (where !== undefined) {
-      const { sql: whereSql, params: whereParams } = this.buildWhere(model, where);
-      sql += ` WHERE ${whereSql}`;
-      for (let i = 0; i < whereParams.length; i++) {
-        const param = whereParams[i];
-        if (param !== undefined) params.push(param);
-      }
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
     }
 
-    const result = await this.activeDb.get(sql, params);
-    const countVal = result?.["count"];
-    return typeof countVal === "number" ? countVal : 0;
+    const result = await this.db.get(sql, params);
+    return isRecord(result) && typeof result["count"] === "number" ? result["count"] : 0;
   }
 
-  async upsert<K extends keyof S & string, T = InferModel<S[K]>>(args: {
-    model: K;
-    where: WhereWithoutPath<T>;
-    create: T;
-    update: Partial<T>;
-    select?: Select<T>;
-  }): Promise<T> {
-    const { model, where, create, update, select } = args;
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) throw new Error(`Model ${model} not found in schema`);
-
-    const extractConflictTargets = (w: Where<T>): string[] => {
-      if ("and" in w) {
-        return w.and.flatMap((sub) => extractConflictTargets(sub));
-      }
-      if ("or" in w) throw new Error("Upsert 'where' clause does not support 'or' operator.");
-
-      const leaf = w as { field: string; op: string };
-      if (leaf.op !== "eq") throw new Error("Upsert 'where' clause only supports 'eq' operator.");
-      return [quote(leaf.field)];
-    };
-
-    const conflictTargets = extractConflictTargets(where);
-    if (conflictTargets.length === 0)
-      throw new Error("Upsert requires at least one conflict column in the 'where' clause.");
-    const conflictTargetSql = conflictTargets.join(", ");
-
-    const mappedCreate = this.mapInput(model, create);
-    const fields = Object.keys(mappedCreate);
-    const columns = fields.map((f) => quote(f)).join(", ");
-    const placeholders = fields.map(() => "?").join(", ");
-
-    const mappedUpdate = this.mapInput(model, update);
-    const updateFields = Object.keys(mappedUpdate);
-    const updateClause = updateFields.map((f) => `${quote(f)} = ?`).join(", ");
-
-    const sql = `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders}) ON CONFLICT(${conflictTargetSql}) DO UPDATE SET ${updateClause}`;
-
-    const params: SqliteValue[] = [];
-    for (const f of fields) params.push(mappedCreate[f] ?? null);
-    for (const f of updateFields) params.push(mappedUpdate[f] ?? null);
-
-    await this.activeDb.run(sql, params);
-
-    const pkFields = Array.isArray(modelSpec.primaryKey)
-      ? modelSpec.primaryKey
-      : [modelSpec.primaryKey];
-
-    const pkWhere: Where<T>[] = [];
-    for (const f of pkFields) {
-      if (isValidField<T>(f)) {
-        pkWhere.push({ field: f, op: "eq", value: (create as any)[f] });
-      }
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (this.isTransaction) {
+      // Nested transactions stay on the current connection and use savepoints.
+      return this.runSavepoint(this.db, fn);
     }
 
-    const result = await this.find<K, T>({
-      model,
-      where: pkWhere.length === 1 && pkWhere[0] ? pkWhere[0] : { and: pkWhere },
-      select,
-    });
-
-    if (result === null) throw new Error("Failed to refetch upserted record");
-    return result;
+    // Top-level SQLite transactions on one shared connection must be serialized.
+    return this.withTransactionLock(() => this.runSavepoint(this.db, fn));
   }
 
-  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    const sp = quote(`sp_${this.spCounter++}`);
+  private async runSavepoint<T>(
+    db: SqliteDatabase,
+    fn: (tx: Adapter<S>) => Promise<T>,
+  ): Promise<T> {
+    const savepoint = quote(`sp_${this.savepointCounter++}`);
+    const txAdapter = new SqliteAdapter(this.schema, db, true);
 
-    await this.activeDb.run(`SAVEPOINT ${sp}`, []);
+    await db.run(`SAVEPOINT ${savepoint}`, []);
     try {
-      const result = await transactionStorage.run(this.activeDb, () => fn(this));
-      await this.activeDb.run(`RELEASE SAVEPOINT ${sp}`, []);
+      const result = await fn(txAdapter);
+      await db.run(`RELEASE SAVEPOINT ${savepoint}`, []);
       return result;
     } catch (error) {
-      await this.activeDb.run(`ROLLBACK TO SAVEPOINT ${sp}`, []);
+      await db.run(`ROLLBACK TO SAVEPOINT ${savepoint}`, []);
       throw error;
     }
   }
 
-  private mapType(type: string): string {
-    switch (type) {
+  private async withTransactionLock<T>(fn: () => Promise<T>): Promise<T> {
+    let release!: () => void;
+    const current = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const previous = this.transactionQueue;
+    this.transactionQueue = previous.then(() => current);
+
+    // SQLite uses one connection here, so top-level transactions are serialized.
+    // Nested transactions still work via savepoints on that same connection.
+    await previous;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+
+  private getModel<K extends keyof S & string>(model: K): S[K] {
+    const modelSpec = this.schema[model];
+    if (modelSpec === undefined) {
+      throw new Error(`Model ${model} not found in schema.`);
+    }
+    return modelSpec;
+  }
+
+  private mapFieldType(field: Field): string {
+    switch (field.type) {
       case "string":
-        return "TEXT";
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
       case "number":
         return "REAL";
       case "boolean":
@@ -433,31 +442,30 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
         return "INTEGER";
       case "json":
       case "json[]":
+        // SQLite has no dedicated JSON column type, so JSON is stored as TEXT.
         return "TEXT";
       default:
         return "TEXT";
     }
   }
 
-  private buildSelect<T>(model: string, select?: Select<T>): string {
-    if (select !== undefined) {
-      return `SELECT ${select.map((f) => quote(f as string)).join(", ")} FROM ${quote(model)}`;
-    }
-    return `SELECT * FROM ${quote(model)}`;
+  private buildSelect<T>(select?: Select<T>): string {
+    return select === undefined ? "*" : select.map((field) => quote(field as string)).join(", ");
   }
 
   private buildColumnExpr(modelName: string, field: string, path?: string[]): string {
-    if (path !== undefined && path.length > 0) {
-      const modelSpec = (this.schema as any)[modelName];
-      const fieldSpec = modelSpec?.fields[field];
-      if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
-        throw new Error(`Cannot use 'path' filter on non-JSON field: ${field}`);
-      }
+    if (path === undefined || path.length === 0) {
+      return quote(field);
+    }
 
-      const jsonPath = `$.${path.join(".")}`;
-      return `json_extract(${quote(field)}, '${escapeLiteral(jsonPath)}')`;
+    const model = this.schema[modelName as keyof S];
+    const fieldSpec = model?.fields[field];
+    if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
+      throw new Error(`Cannot use JSON path on non-JSON field: ${field}`);
     }
-    return quote(field);
+
+    const jsonPath = `$.${validateJsonPath(path).join(".")}`;
+    return `json_extract(${quote(field)}, '${escapeLiteral(jsonPath)}')`;
   }
 
   private buildCursor<T>(
@@ -465,47 +473,58 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor: Cursor<T>,
     sortBy?: SortBy<T>[],
   ): { sql: string; params: SqliteValue[] } {
-    const entries = Object.entries(cursor.after);
-    if (entries.length === 0) return { sql: "", params: [] };
-
-    const sortCriteria: SortBy<T>[] =
-      sortBy && sortBy.length > 0
+    type CursorSort = {
+      field: Extract<keyof T, string>;
+      direction: "asc" | "desc";
+      path?: string[];
+    };
+    const cursorValues = cursor.after as Partial<Record<string, unknown>>;
+    const sortCriteria: CursorSort[] =
+      sortBy !== undefined && sortBy.length > 0
         ? sortBy
-        : entries.map(([field]) => {
-            if (!isValidField<T>(field)) throw new Error("Invalid cursor field");
-            return { field, direction: "asc" };
-          });
+            .filter((sort) => cursorValues[sort.field] !== undefined)
+            .map((sort) => ({
+              field: sort.field,
+              direction: sort.direction ?? "asc",
+              path: sort.path,
+            }))
+        : Object.keys(cursor.after).map((field) => ({
+            // Cursor keys come from the typed `Cursor<T>` surface.
+            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+            field: field as Extract<keyof T, string>,
+            direction: "asc" as const,
+            path: undefined,
+          }));
+
+    if (sortCriteria.length === 0) {
+      return { sql: "", params: [] };
+    }
 
-    const validSorts = sortCriteria.filter((s) => cursor.after[s.field] !== undefined);
-    const orParts: string[] = [];
-    const cursorParams: SqliteValue[] = [];
+    const orClauses: string[] = [];
+    const params: SqliteValue[] = [];
 
-    for (let i = 0; i < validSorts.length; i++) {
-      const currentSort = validSorts[i]!;
-      const andParts: string[] = [];
+    for (let i = 0; i < sortCriteria.length; i++) {
+      const andClauses: string[] = [];
 
       for (let j = 0; j < i; j++) {
-        const prevSort = validSorts[j]!;
-        const colExpr = this.buildColumnExpr(modelName, prevSort.field as string, prevSort.path);
-        andParts.push(`${colExpr} = ?`);
-        cursorParams.push(this.mapWhereValue(cursor.after[prevSort.field]));
+        const previous = sortCriteria[j]!;
+        // Lexicographic keyset pagination:
+        // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
+        andClauses.push(`${this.buildColumnExpr(modelName, previous.field, previous.path)} = ?`);
+        params.push(this.mapWhereValue(cursorValues[previous.field]));
       }
 
-      const op = currentSort.direction === "desc" ? "<" : ">";
-      const colExpr = this.buildColumnExpr(
-        modelName,
-        currentSort.field as string,
-        currentSort.path,
+      const current = sortCriteria[i]!;
+      andClauses.push(
+        `${this.buildColumnExpr(modelName, current.field, current.path)} ${current.direction === "desc" ? "<" : ">"} ?`,
       );
-      andParts.push(`${colExpr} ${op} ?`);
-      cursorParams.push(this.mapWhereValue(cursor.after[currentSort.field]));
-
-      orParts.push(`(${andParts.join(" AND ")})`);
+      params.push(this.mapWhereValue(cursorValues[current.field]));
+      orClauses.push(`(${andClauses.join(" AND ")})`);
     }
 
     return {
-      sql: orParts.length > 0 ? `(${orParts.join(" OR ")})` : "",
-      params: cursorParams,
+      sql: `(${orClauses.join(" OR ")})`,
+      params,
     };
   }
 
@@ -515,25 +534,27 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor?: Cursor<T>,
     sortBy?: SortBy<T>[],
   ): { sql: string; params: SqliteValue[] } {
-    const params: SqliteValue[] = [];
     const parts: string[] = [];
+    const params: SqliteValue[] = [];
 
     if (where !== undefined) {
-      const result = this.buildWhereRecursive(modelName, where);
-      parts.push(result.sql);
-      params.push(...result.params);
+      const builtWhere = this.buildWhereRecursive(modelName, where);
+      parts.push(builtWhere.sql);
+      params.push(...builtWhere.params);
     }
 
     if (cursor !== undefined) {
-      const cursorResult = this.buildCursor(modelName, cursor, sortBy);
-      if (cursorResult.sql !== "") {
-        parts.push(cursorResult.sql);
-        params.push(...cursorResult.params);
+      const builtCursor = this.buildCursor(modelName, cursor, sortBy);
+      if (builtCursor.sql !== "") {
+        parts.push(builtCursor.sql);
+        params.push(...builtCursor.params);
       }
     }
 
-    const sql = parts.length > 1 ? parts.map((p) => `(${p})`).join(" AND ") : (parts[0] ?? "1=1");
-    return { sql, params };
+    return {
+      sql: parts.length > 0 ? parts.map((part) => `(${part})`).join(" AND ") : "1=1",
+      params,
+    };
   }
 
   private buildWhereRecursive<T>(
@@ -541,135 +562,135 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     where: Where<T>,
   ): { sql: string; params: SqliteValue[] } {
     if ("and" in where) {
-      const parts = where.and.map((w) => this.buildWhereRecursive(modelName, w));
+      const parts = where.and.map((clause) => this.buildWhereRecursive(modelName, clause));
       return {
-        sql: `(${parts.map((p) => p.sql).join(" AND ")})`,
-        params: parts.flatMap((p) => p.params),
+        sql: parts.map((part) => `(${part.sql})`).join(" AND "),
+        params: parts.flatMap((part) => part.params),
       };
     }
 
     if ("or" in where) {
-      const parts = where.or.map((w) => this.buildWhereRecursive(modelName, w));
+      const parts = where.or.map((clause) => this.buildWhereRecursive(modelName, clause));
       return {
-        sql: `(${parts.map((p) => p.sql).join(" OR ")})`,
-        params: parts.flatMap((p) => p.params),
+        sql: parts.map((part) => `(${part.sql})`).join(" OR "),
+        params: parts.flatMap((part) => part.params),
       };
     }
 
-    const leaf = where as { field: string; path?: string[]; op: string; value: unknown };
-    const { field, path, op, value } = leaf;
-    const quotedField = this.buildColumnExpr(modelName, field, path);
+    const expr = this.buildColumnExpr(modelName, where.field as string, where.path);
 
-    switch (op) {
+    switch (where.op) {
       case "eq":
-        return { sql: `${quotedField} = ?`, params: [this.mapWhereValue(value)] };
+        return { sql: `${expr} = ?`, params: [this.mapWhereValue(where.value)] };
       case "ne":
-        return { sql: `${quotedField} != ?`, params: [this.mapWhereValue(value)] };
+        return { sql: `${expr} != ?`, params: [this.mapWhereValue(where.value)] };
       case "gt":
-        return { sql: `${quotedField} > ?`, params: [this.mapWhereValue(value)] };
+        return { sql: `${expr} > ?`, params: [this.mapWhereValue(where.value)] };
       case "gte":
-        return { sql: `${quotedField} >= ?`, params: [this.mapWhereValue(value)] };
+        return { sql: `${expr} >= ?`, params: [this.mapWhereValue(where.value)] };
       case "lt":
-        return { sql: `${quotedField} < ?`, params: [this.mapWhereValue(value)] };
+        return { sql: `${expr} < ?`, params: [this.mapWhereValue(where.value)] };
       case "lte":
-        return { sql: `${quotedField} <= ?`, params: [this.mapWhereValue(value)] };
-      case "in": {
-        const list = Array.isArray(value) ? value : [value];
-        if (list.length === 0) return { sql: "1=0", params: [] };
+        return { sql: `${expr} <= ?`, params: [this.mapWhereValue(where.value)] };
+      case "in":
+        if (where.value.length === 0) {
+          return { sql: "1=0", params: [] };
+        }
         return {
-          sql: `${quotedField} IN (${list.map(() => "?").join(", ")})`,
-          params: list.map((v) => this.mapWhereValue(v)),
+          sql: `${expr} IN (${where.value.map(() => "?").join(", ")})`,
+          params: where.value.map((value) => this.mapWhereValue(value)),
         };
-      }
-      case "not_in": {
-        const list = Array.isArray(value) ? value : [value];
-        if (list.length === 0) return { sql: "1=1", params: [] };
+      case "not_in":
+        if (where.value.length === 0) {
+          return { sql: "1=1", params: [] };
+        }
         return {
-          sql: `${quotedField} NOT IN (${list.map(() => "?").join(", ")})`,
-          params: list.map((v) => this.mapWhereValue(v)),
+          sql: `${expr} NOT IN (${where.value.map(() => "?").join(", ")})`,
+          params: where.value.map((value) => this.mapWhereValue(value)),
         };
-      }
       default:
-        throw new Error(`Unsupported operator: ${op}`);
-    }
-  }
-
-  private mapWhereValue(value: unknown): SqliteValue {
-    if (value === null) return null;
-    if (typeof value === "boolean") return value ? 1 : 0;
-    if (typeof value === "object" && !(value instanceof Uint8Array)) return JSON.stringify(value);
-    if (
-      typeof value === "string" ||
-      typeof value === "number" ||
-      typeof value === "bigint" ||
-      value instanceof Uint8Array
-    ) {
-      return value;
+        throw new Error(`Unsupported operator: ${(where as { op: string }).op}`);
     }
-    return JSON.stringify(value);
   }
 
   private mapInput(
-    modelName: string,
+    fields: Record<string, Field>,
     data: Record<string, unknown> | Partial<Record<string, unknown>>,
   ): Record<string, SqliteValue> {
-    const model = this.schema[modelName];
-    if (model === undefined) {
-      if (isModelType<Record<string, SqliteValue>>(data)) return data;
-      throw new Error("Invalid model payload");
-    }
-
     const result: Record<string, SqliteValue> = {};
-    for (const [fieldName, field] of Object.entries(model.fields)) {
-      const val = data[fieldName];
-      if (val === undefined) continue;
-      if (val === null) {
+
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const value = data[fieldName];
+      if (value === undefined) continue;
+      if (value === null) {
         result[fieldName] = null;
         continue;
       }
 
       if (field.type === "json" || field.type === "json[]") {
-        result[fieldName] = JSON.stringify(val);
+        result[fieldName] = JSON.stringify(value);
       } else if (field.type === "boolean") {
-        result[fieldName] = val === true ? 1 : 0;
-      } else if (
-        typeof val === "string" ||
-        typeof val === "number" ||
-        typeof val === "bigint" ||
-        val instanceof Uint8Array
-      ) {
-        result[fieldName] = val;
+        result[fieldName] = value === true ? 1 : 0;
       } else {
-        result[fieldName] = JSON.stringify(val);
+        result[fieldName] = this.toSqliteValue(value);
       }
     }
+
     return result;
   }
 
-  private mapRow<T>(modelName: string, row: Record<string, unknown>): T {
-    const model = (this.schema as any)[modelName];
-    if (model === undefined) return row as T;
-
-    for (const [fieldName, field] of Object.entries(model.fields as Record<string, any>)) {
-      const val = row[fieldName];
-      if (val === undefined || val === null) continue;
+  private mapRow<K extends keyof S & string, T extends Record<string, unknown>>(
+    model: K,
+    row: Record<string, unknown>,
+    select?: Select<T>,
+  ): T {
+    const fieldSpecs = this.getModel(model).fields;
+    const output: Record<string, unknown> = {};
+    const selectedFields =
+      select === undefined ? Object.keys(row) : select.map((field) => field as string);
+
+    for (const fieldName of selectedFields) {
+      const fieldSpec = fieldSpecs[fieldName];
+      const value = row[fieldName];
+
+      if (fieldSpec === undefined || value === undefined || value === null) {
+        output[fieldName] = value;
+        continue;
+      }
 
-      if ((field.type === "json" || field.type === "json[]") && typeof val === "string") {
-        try {
-          row[fieldName] = JSON.parse(val);
-        } catch {
-          // Keep as string if parsing fails
-        }
-      } else if (field.type === "boolean") {
-        row[fieldName] = val === 1 || val === true;
-      } else if (field.type === "number" || field.type === "timestamp") {
-        if (typeof val === "string") {
-          row[fieldName] = Number(val);
-        } else if (typeof val === "bigint") {
-          row[fieldName] = Number(val);
-        }
+      if ((fieldSpec.type === "json" || fieldSpec.type === "json[]") && typeof value === "string") {
+        output[fieldName] = JSON.parse(value);
+      } else if (fieldSpec.type === "boolean") {
+        output[fieldName] = value === 1 || value === true;
+      } else if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
+        output[fieldName] = mapNumeric(value);
+      } else {
+        output[fieldName] = value;
       }
     }
-    return row as T;
+
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return output as T;
+  }
+
+  private mapWhereValue(value: unknown): SqliteValue {
+    if (value === null) return null;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (typeof value === "object" && !(value instanceof Uint8Array)) {
+      return JSON.stringify(value);
+    }
+    return this.toSqliteValue(value);
+  }
+
+  private toSqliteValue(value: unknown): SqliteValue {
+    if (typeof value === "string" || typeof value === "number" || value instanceof Uint8Array) {
+      return value;
+    }
+
+    if (typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
+
+    return JSON.stringify(value);
   }
 }
diff --git a/src/adapters/sqlite.types.ts b/src/adapters/sqlite.types.ts
deleted file mode 100644
index 0f94257..0000000
--- a/src/adapters/sqlite.types.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-export type SqliteValue = string | number | bigint | Uint8Array | null;
-
-/**
- * The standard connection interface the Adapter expects.
- */
-export interface SqliteDatabase {
-  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
-  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
-  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
-}
-
-/**
- * Represents a raw native SQLite driver (like Bun or better-sqlite3).
- */
-export interface NativeSqliteStatement {
-  run(...params: SqliteValue[]): unknown;
-  get(...params: SqliteValue[]): unknown;
-  all(...params: SqliteValue[]): unknown;
-}
-
-export interface NativeSqliteDriver {
-  prepare(sql: string): NativeSqliteStatement;
-}
diff --git a/src/types.test.ts b/src/types.test.ts
index b77ffb7..07657af 100644
--- a/src/types.test.ts
+++ b/src/types.test.ts
@@ -7,15 +7,13 @@ describe("no-orm core", () => {
     const schema = {
       users: {
         fields: {
-          id: { type: { type: "string" } },
-          age: { type: { type: "number" } },
-          is_active: { type: { type: "boolean" } },
-          created_at: { type: { type: "timestamp" } },
-          metadata: { type: { type: "json" }, nullable: true },
-        },
-        primaryKey: {
-          fields: ["id"],
+          id: { type: "string" },
+          age: { type: "number" },
+          is_active: { type: "boolean" },
+          created_at: { type: "timestamp" },
+          metadata: { type: "json", nullable: true },
         },
+        primaryKey: "id",
       },
     } as const satisfies Schema;
 
@@ -51,18 +49,18 @@ describe("no-orm core", () => {
     const schema = {
       conversations: {
         fields: {
-          id: { type: { type: "string", max: 255 } },
-          created_at: { type: { type: "timestamp" } },
+          id: { type: "string", max: 255 },
+          created_at: { type: "timestamp" },
         },
-        primaryKey: { fields: ["id"] },
+        primaryKey: "id",
       },
       messages: {
         fields: {
-          id: { type: { type: "string", max: 255 } },
-          conversation_id: { type: { type: "string", max: 255 } },
-          content: { type: { type: "string" } },
+          id: { type: "string", max: 255 },
+          conversation_id: { type: "string", max: 255 },
+          content: { type: "string" },
         },
-        primaryKey: { fields: ["id"] },
+        primaryKey: "id",
       },
     } as const satisfies Schema;
 
diff --git a/src/types.ts b/src/types.ts
index b991d1b..55ad99f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -18,13 +18,8 @@ export interface Field {
   max?: number; // Only for string
 }
 
-export type FieldType =
-  | "string"
-  | "number"
-  | "boolean"
-  | "timestamp"
-  | "json"
-  | "json[]";
+export type FieldType = "string" | "number" | "boolean" | "timestamp" | "json" | "json[]";
+// Note: "number" and "timestamp" intentionally exclude bigint support in v1 to keep the core tiny.
 
 export interface Index {
   field: string | string[];
@@ -37,7 +32,7 @@ export type InferModel<M extends Model> = {
   [K in keyof M["fields"]]: M["fields"][K]["nullable"] extends true
     ? ResolveTSValue<M["fields"][K]["type"]> | null
     : ResolveTSValue<M["fields"][K]["type"]>;
-};
+} & Record<string, unknown>;
 
 type ResolveTSValue<T extends FieldType> = T extends "string"
   ? string
@@ -60,25 +55,28 @@ export interface Adapter<S extends Schema = Schema> {
 
   transaction?<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
 
-  create<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  create<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     data: T;
     select?: Select<T>;
   }): Promise<T>;
 
-  update<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
     data: Partial<T>;
   }): Promise<T | null>;
 
-  updateMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  updateMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
     where?: Where<T>;
     data: Partial<T>;
   }): Promise<number>;
 
-  upsert?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  upsert?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: WhereWithoutPath<T>;
     create: T;
@@ -86,23 +84,26 @@ export interface Adapter<S extends Schema = Schema> {
     select?: Select<T>;
   }): Promise<T>;
 
-  delete<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  delete<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
   }): Promise<void>;
 
-  deleteMany?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  deleteMany?<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
     where?: Where<T>;
   }): Promise<number>;
 
-  find<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
     select?: Select<T>;
   }): Promise<T | null>;
 
-  findMany<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  findMany<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;
     select?: Select<T>;
@@ -112,7 +113,7 @@ export interface Adapter<S extends Schema = Schema> {
     cursor?: Cursor<T>;
   }): Promise<T[]>;
 
-  count?<K extends keyof S & string, T = InferModel<S[K]>>(args: {
+  count?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;
   }): Promise<number>;
@@ -126,32 +127,44 @@ export type Where<T = Record<string, unknown>> =
   | {
       field: FieldName<T>;
       path?: string[];
-      op: "eq" | "ne";
+      op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
       value: unknown;
     }
   | {
       field: FieldName<T>;
       path?: string[];
-      op: "gt" | "gte" | "lt" | "lte";
+      op: "in" | "not_in";
+      value: unknown[];
+    }
+  | {
+      and: Where<T>[];
+    }
+  | {
+      or: Where<T>[];
+    };
+
+export type WhereWithoutPath<T = Record<string, unknown>> =
+  | {
+      field: FieldName<T>;
+      op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
       value: unknown;
+      path?: never;
     }
   | {
       field: FieldName<T>;
-      path?: string[];
       op: "in" | "not_in";
       value: unknown[];
+      path?: never;
     }
   | {
-      and: Where<T>[];
+      and: WhereWithoutPath<T>[];
+      path?: never;
     }
   | {
-      or: Where<T>[];
+      or: WhereWithoutPath<T>[];
+      path?: never;
     };
 
-export type WhereWithoutPath<T = Record<string, unknown>> = Omit<Where<T>, "path"> & {
-  path?: never;
-};
-
 export interface SortBy<T = Record<string, unknown>> {
   field: FieldName<T>;
   path?: string[];
diff --git a/src/utils/is.ts b/src/utils/is.ts
deleted file mode 100644
index cc2ce84..0000000
--- a/src/utils/is.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import type { FieldName } from "../types";
-
-export function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-export function isValidField<T>(field: unknown): field is FieldName<T> {
-  return typeof field === "string" && field !== "";
-}
-
-export function isStringKey(key: unknown): key is string {
-  return typeof key === "string" && key !== "";
-}
-
-export function isModelType<T>(obj: unknown): obj is T {
-  return typeof obj === "object" && obj !== null;
-}
diff --git a/src/utils/sql.ts b/src/utils/sql.ts
deleted file mode 100644
index 411bc27..0000000
--- a/src/utils/sql.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export function quote(name: string): string {
-  return `"${name}"`;
-}
-
-export function escapeLiteral(val: string): string {
-  return val.replaceAll("'", "''");
-}

From 5ba6c3a8b7826151c70af9674997e3c4fcc6cb4c Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Tue, 21 Apr 2026 13:30:46 +0800
Subject: [PATCH 08/24] fix: address upsert concerns and simplify
 implementation

---
 README.md                   |   3 +-
 src/adapters/common.ts      | 100 ++++++++---------------------------
 src/adapters/memory.test.ts | 102 +++++++++++++++++++++++++++++++-----
 src/adapters/memory.ts      | 102 ++++++++++++++++++++----------------
 src/adapters/postgres.ts    |  23 ++++----
 src/adapters/sqlite.test.ts |  41 +++++++++++----
 src/adapters/sqlite.ts      |  32 ++++++-----
 src/types.ts                |  24 +--------
 8 files changed, 232 insertions(+), 195 deletions(-)

diff --git a/README.md b/README.md
index d436049..15ae14b 100644
--- a/README.md
+++ b/README.md
@@ -153,7 +153,8 @@ SQLite and Postgres both support nested transactions through savepoints.
 
 ## Notes
 
-- `upsert` is intentionally conservative in v1: the `where` clause must be equality conditions for every primary-key field.
+- `upsert` in v1 always conflicts on the **Primary Key**. Identity is inferred automatically from the `create` data.
+- The optional `where` clause in `upsert` acts as a **predicate** for the update: the record is only updated if the condition is met.
 - Primary-key updates are rejected to keep adapter behavior simple and consistent across backends.
 - SQLite stores JSON as text; Postgres stores JSON as `jsonb`.
 - **Numeric Precision**: `number` and `timestamp` fields use standard JavaScript `Number`. `bigint` is intentionally not supported in v1 to keep the core and adapters tiny.
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 811bb19..94a9727 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -1,4 +1,4 @@
-import type { FieldName, Model, Where, WhereWithoutPath } from "../types";
+import type { FieldName, Model, Where } from "../types";
 
 // --- Type Guards ---
 
@@ -6,16 +6,8 @@ export function isRecord(v: unknown): v is Record<string, unknown> {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
-export function isValidField<T>(field: unknown): field is FieldName<T> {
-  return typeof field === "string" && field !== "";
-}
-
-export function isStringKey(key: unknown): key is string {
-  return typeof key === "string" && key !== "";
-}
-
-export function isModelType<T>(obj: unknown): obj is T {
-  return typeof obj === "object" && obj !== null;
+export function isNonEmptyString(v: unknown): v is string {
+  return typeof v === "string" && v !== "";
 }
 
 // --- SQL Helpers ---
@@ -36,86 +28,40 @@ export function getPrimaryKeyFields(model: Model): string[] {
   return Array.isArray(model.primaryKey) ? model.primaryKey : [model.primaryKey];
 }
 
-export function validateJsonPath(path: string[]): string[] {
-  for (const segment of path) {
-    if (!JSON_PATH_SEGMENT.test(segment)) {
-      throw new Error(`Invalid JSON path segment: ${segment}`);
+/**
+ * Extracts primary key values from a data object based on the model schema.
+ */
+export function getIdentityValues(model: Model, data: Record<string, unknown>): Record<string, unknown> {
+  const pkFields = getPrimaryKeyFields(model);
+  const values: Record<string, unknown> = {};
+  for (const field of pkFields) {
+    const val = data[field];
+    if (val === undefined) {
+      throw new Error(`Missing primary key field: ${field}`);
     }
+    values[field] = val;
   }
-  return path;
-}
-
-export function extractEqualityWhere<T>(where: WhereWithoutPath<T>): Map<string, unknown> {
-  const values = new Map<string, unknown>();
-
-  const visit = (clause: WhereWithoutPath<T>): void => {
-    if ("and" in clause) {
-      for (const child of clause.and) {
-        visit(child);
-      }
-      return;
-    }
-
-    if ("or" in clause) {
-      // Upsert needs one deterministic conflict key. Allowing OR conditions would
-      // make the conflict target ambiguous across all adapters, not just SQL ones.
-      throw new Error("Upsert 'where' clause does not support 'or' conditions.");
-    }
-
-    if (clause.path !== undefined) {
-      // Path-based filters are query semantics, not stable identity semantics.
-      // Keeping them out of upsert avoids backend-specific conflict behavior.
-      throw new Error("Upsert 'where' clause does not support JSON paths.");
-    }
-
-    if (clause.op !== "eq") {
-      // v1 upsert is intentionally conservative: equality on identity fields only.
-      throw new Error("Upsert 'where' clause only supports 'eq' conditions.");
-    }
-
-    const existing = values.get(clause.field);
-    if (existing !== undefined && existing !== clause.value) {
-      throw new Error(`Conflicting upsert values for field ${clause.field}.`);
-    }
-    values.set(clause.field, clause.value);
-  };
-
-  visit(where);
   return values;
 }
 
-export function getPrimaryKeyWhereValues<T>(
-  model: Model,
-  where: WhereWithoutPath<T>,
-): Record<string, unknown> {
-  const equalityWhere = extractEqualityWhere(where);
-  const pkFields = getPrimaryKeyFields(model);
-  const values: Record<string, unknown> = {};
-
-  if (equalityWhere.size !== pkFields.length) {
-    // We currently support primary-key based upserts only. This keeps the same
-    // rule across memory, SQLite, and Postgres instead of inventing per-backend
-    // uniqueness semantics in v1.
-    throw new Error("Upsert requires equality filters for every primary key field.");
-  }
-
-  for (const field of pkFields) {
-    if (!equalityWhere.has(field)) {
-      throw new Error("Upsert requires equality filters for every primary key field.");
+export function validateJsonPath(path: string[]): string[] {
+  for (const segment of path) {
+    if (!JSON_PATH_SEGMENT.test(segment)) {
+      throw new Error(`Invalid JSON path segment: ${segment}`);
     }
-    values[field] = equalityWhere.get(field);
   }
-
-  return values;
+  return path;
 }
 
-export function buildPrimaryKeyWhere<T extends Record<string, unknown>>(
+/**
+ * Builds a 'Where' filter targeting the primary key of a specific record.
+ */
+export function buildIdentityFilter<T extends Record<string, unknown>>(
   model: Model,
   source: Record<string, unknown>,
 ): Where<T> {
   const pkFields = getPrimaryKeyFields(model);
   const clauses = pkFields.map((field) => ({
-    // The schema is the source of truth for valid field names here.
     // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
     field: field as FieldName<T>,
     op: "eq" as const,
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index d6b108b..4b87a37 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -178,22 +178,96 @@ describe("MemoryAdapter", () => {
     expect(results).toHaveLength(2);
   });
 
-  it("should require primary-key equality in upsert filters", () => {
-    const userData: User = {
-      id: "u1",
-      name: "Alice",
-      age: 25,
-      is_active: true,
-      metadata: null,
-    };
+  describe("Upsert", () => {
+    it("should handle upsert correctly (insert and update)", async () => {
+      const userData: User = {
+        id: "u1",
+        name: "Alice",
+        age: 25,
+        is_active: true,
+        metadata: null,
+      };
 
-    expect(() =>
-      adapter.upsert<"users", User>({
+      // 1. Insert because it doesn't exist
+      await adapter.upsert<"users", User>({
         model: "users",
-        where: { field: "name", op: "eq", value: "Alice" },
         create: userData,
-        update: { age: 26 },
-      }),
-    ).toThrow("Upsert requires equality filters for every primary key field.");
+        update: { age: 30 },
+      });
+
+      let found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(25); // Should have used 'create' data
+
+      // 2. Update because it exists
+      await adapter.upsert<"users", User>({
+        model: "users",
+        create: userData,
+        update: { age: 31 },
+      });
+
+      found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(31); // Should have used 'update' data
+    });
+
+    it("should support predicated upsert", async () => {
+      const userData: User = {
+        id: "u1",
+        name: "Alice",
+        age: 25,
+        is_active: true,
+        metadata: null,
+      };
+
+      await adapter.create({ model: "users", data: userData });
+
+      // Condition fails, no update
+      await adapter.upsert<"users", User>({
+        model: "users",
+        create: userData,
+        update: { age: 30 },
+        where: { field: "age", op: "gt", value: 40 },
+      });
+
+      let found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(25);
+
+      // Condition passes, update happens
+      await adapter.upsert<"users", User>({
+        model: "users",
+        create: userData,
+        update: { age: 30 },
+        where: { field: "age", op: "lt", value: 40 },
+      });
+
+      found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(30);
+    });
+
+    it("should throw error if primary key is missing in 'create' data", async () => {
+      const invalidData = {
+        name: "Missing ID",
+        age: 20,
+      } as any;
+
+      expect(() =>
+        adapter.upsert({
+          model: "users",
+          create: invalidData,
+          update: { age: 21 },
+        }),
+      ).toThrow("Missing primary key field: id");
+    });
   });
 });
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 5dd2dbe..583187f 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -6,12 +6,11 @@ import type {
   Select,
   SortBy,
   Where,
-  WhereWithoutPath,
 } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
+  getIdentityValues,
   getPrimaryKeyFields,
-  getPrimaryKeyWhereValues,
   isRecord,
 } from "./common";
 
@@ -23,7 +22,7 @@ type RowData = Record<string, unknown>;
  * Useful for testing, development, and small-scale caching.
  */
 export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<string, Map<string, InferModel<S[keyof S]>>>();
+  private storage = new Map<string, Map<string, Record<string, unknown>>>();
 
   constructor(private schema: S) {}
 
@@ -55,7 +54,8 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
-    const record: T = { ...data };
+    // Optimization: Avoid object spread in hot path
+    const record = Object.assign({}, data) as T;
     modelStorage.set(pkValue, record);
 
     return Promise.resolve(this.applySelect(record, select));
@@ -70,8 +70,8 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const modelStorage = this.getModelStorage<K, T>(model);
 
     for (const record of modelStorage.values()) {
-      if (this.evaluateWhere(where, record)) {
-        return Promise.resolve(this.applySelect(record, select));
+      if (this.evaluateWhere(where, record as T)) {
+        return Promise.resolve(this.applySelect(record as T, select));
       }
     }
 
@@ -90,7 +90,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, select, sortBy, limit, offset, cursor } = args;
     const modelStorage = this.getModelStorage<K, T>(model);
 
-    let results = Array.from(modelStorage.values());
+    let results = Array.from(modelStorage.values()) as T[];
 
     if (where) {
       results = results.filter((record) => this.evaluateWhere(where, record));
@@ -121,7 +121,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
             let allPreviousEqual = true;
             for (let j = 0; j < i; j++) {
               const prev = sortCriteria[j]!;
-              const recordVal = this.getValue(record, prev.field, prev.path);
+              const recordVal = this.getValue(record as RowData, prev.field, prev.path);
               const cursorVal = cursorValues[prev.field];
               if (this.compareValues(recordVal, cursorVal) !== 0) {
                 allPreviousEqual = false;
@@ -132,7 +132,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
             if (!allPreviousEqual) continue;
 
             const current = sortCriteria[i]!;
-            const recordVal = this.getValue(record, current.field, current.path);
+            const recordVal = this.getValue(record as RowData, current.field, current.path);
             const cursorVal = cursorValues[current.field];
             const comp = this.compareValues(recordVal, cursorVal);
 
@@ -152,8 +152,8 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (sortBy) {
       results.sort((a, b) => {
         for (const { field, direction, path } of sortBy) {
-          const valA = this.getValue(a, field as string, path);
-          const valB = this.getValue(b, field as string, path);
+          const valA = this.getValue(a as RowData, field as string, path);
+          const valB = this.getValue(b as RowData, field as string, path);
           if (valA === valB) continue;
           const factor = direction === "desc" ? -1 : 1;
           if (valA === undefined || valB === undefined) return 0;
@@ -178,14 +178,16 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     data: Partial<T>;
   }): Promise<T | null> {
     const { model, where, data } = args;
-    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
     const modelStorage = this.getModelStorage<K, T>(model);
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (this.evaluateWhere(where, record)) {
-        const updated: T = { ...record, ...data };
+      if (this.evaluateWhere(where, record as T)) {
+        // Optimization: Create a new object to avoid mutating internal storage reference
+        const updated = Object.assign({}, record, data) as T;
         modelStorage.set(pk, updated);
-        return Promise.resolve(updated);
+        return Promise.resolve(this.applySelect(updated, undefined));
       }
     }
 
@@ -197,13 +199,15 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
     const { model, where, data } = args;
-    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
     const modelStorage = this.getModelStorage<K, T>(model);
     let count = 0;
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (where === undefined || this.evaluateWhere(where, record)) {
-        const updated: T = { ...record, ...data };
+      if (where === undefined || this.evaluateWhere(where, record as T)) {
+        // Optimization: Create a new object to avoid mutating internal storage reference
+        const updated = Object.assign({}, record, data) as T;
         modelStorage.set(pk, updated);
         count++;
       }
@@ -212,27 +216,32 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(count);
   }
 
-  async upsert<
+  upsert<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
     model: K;
-    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
+    where?: Where<T>;
     select?: Select<T>;
   }): Promise<T> {
-    const { model, where, create, update, select } = args;
-    getPrimaryKeyWhereValues(this.getModel(model), where);
-    assertNoPrimaryKeyUpdates(this.getModel(model), update);
-    const existing = await this.find({ model, where, select });
+    const { model, create, update, where, select } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, update);
+
+    const pkValue = this.getPrimaryKeyString(model, create);
+    const modelStorage = this.getModelStorage<K, T>(model);
+    const existing = modelStorage.get(pkValue);
 
     if (existing) {
-      const updated = await this.update({ model, where, data: update });
-      if (updated === null) {
-        throw new Error("Failed to refetch updated record during upsert");
+      // Use optional where predicate
+      if (where === undefined || this.evaluateWhere(where, existing as T)) {
+        const updated = Object.assign({}, existing, update) as T;
+        modelStorage.set(pkValue, updated);
+        return Promise.resolve(this.applySelect(updated, select));
       }
-      return this.applySelect(updated, select);
+      return Promise.resolve(this.applySelect(existing as T, select));
     }
 
     return this.create({ model, data: create, select });
@@ -246,7 +255,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const modelStorage = this.getModelStorage<K, T>(model);
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (this.evaluateWhere(where, record)) {
+      if (this.evaluateWhere(where, record as T)) {
         modelStorage.delete(pk);
         return Promise.resolve();
       }
@@ -263,7 +272,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     let count = 0;
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (where === undefined || this.evaluateWhere(where, record)) {
+      if (where === undefined || this.evaluateWhere(where, record as T)) {
         modelStorage.delete(pk);
         count++;
       }
@@ -283,7 +292,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     let count = 0;
     for (const record of modelStorage.values()) {
-      if (this.evaluateWhere(where, record)) {
+      if (this.evaluateWhere(where, record as T)) {
         count++;
       }
     }
@@ -295,13 +304,12 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   private getModelStorage<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(model: K): Map<string, T> {
+  >(model: K): Map<string, Record<string, unknown>> {
     const storage = this.storage.get(model);
     if (!storage) {
       throw new Error(`Model ${model} not initialized. Call migrate() first.`);
     }
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    return storage as Map<string, T>;
+    return storage;
   }
 
   private getModel<K extends keyof S & string>(model: K): S[K] {
@@ -313,25 +321,27 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   }
 
   private getPrimaryKeyString(modelName: string, data: Record<string, unknown>): string {
-    const model = this.schema[modelName];
-    if (!model) throw new Error(`Model ${modelName} not found in schema`);
-
+    const model = this.getModel(modelName as keyof S & string);
+    const pkValues = getIdentityValues(model, data);
     return getPrimaryKeyFields(model)
-      .map((field) => String(data[field]))
+      .map((field) => String(pkValues[field]))
       .join("|");
   }
 
   private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
-    if (select === undefined) return record;
-
     const result: Partial<T> = {};
+
+    if (select === undefined) {
+      // Always return a shallow clone to match DB snapshot behavior
+      return Object.assign(result, record) as T;
+    }
+
     for (const field of select) {
-      result[field] = record[field];
+      const val = record[field];
+      // Normalize undefined to null to match SQL behavior
+      result[field] = val === undefined ? (null as any) : val;
     }
 
-    // The public adapter contract returns `T` even when `select` narrows fields.
-    // Preserve that contract while keeping the internal representation typed.
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
     return result as T;
   }
 
@@ -342,7 +352,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
         if (!isRecord(value)) {
           return undefined;
         }
-        value = value[segment];
+        value = (value as Record<string, unknown>)[segment];
       }
     }
     return value;
@@ -386,7 +396,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (left === right) return 0;
     if (!this.isComparable(left) || !this.isComparable(right)) return 0;
     if (typeof left !== typeof right) return 0;
-    return left < right ? -1 : 1;
+    return (left as any) < (right as any) ? -1 : 1;
   }
 
   private isComparable(value: unknown): value is Comparable {
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 70c34f6..08c594f 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -9,14 +9,13 @@ import type {
   Select,
   SortBy,
   Where,
-  WhereWithoutPath,
 } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
-  buildPrimaryKeyWhere,
+  buildIdentityFilter,
   escapeLiteral,
+  getIdentityValues,
   getPrimaryKeyFields,
-  getPrimaryKeyWhereValues,
   isRecord,
   mapNumeric,
   quote,
@@ -204,14 +203,14 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
     model: K;
-    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
+    where?: Where<T>;
     select?: Select<T>;
   }): Promise<T> {
-    const { model, where, create, update, select } = args;
+    const { model, create, update, where, select } = args;
     const modelSpec = this.getModel(model);
-    const pkValues = getPrimaryKeyWhereValues(modelSpec, where);
+    const identityValues = getIdentityValues(modelSpec, create);
     assertNoPrimaryKeyUpdates(modelSpec, update);
 
     const createData = this.mapInput(modelSpec.fields, create);
@@ -224,7 +223,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const insertPlaceholders = createFields.map((_, index) => `$${index + 1}`).join(", ");
     const conflictTarget = pkFields.map((field) => quote(field)).join(", ");
 
-    const updateClause =
+    let updateClause =
       updateFields.length > 0
         ? updateFields
             .map(
@@ -239,6 +238,12 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         ? [...insertValues, ...updateFields.map((field) => updateData[field])]
         : insertValues;
 
+    if (where !== undefined) {
+      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length + 1);
+      updateClause += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
+    }
+
     const sql = `INSERT INTO ${quote(model)} (${createFields.map((field) => quote(field)).join(", ")}) VALUES (${insertPlaceholders}) ON CONFLICT (${conflictTarget}) DO UPDATE SET ${updateClause} RETURNING ${this.buildSelect(select)}`;
     const rows = await this.query(sql, params);
     const row = rows[0];
@@ -249,7 +254,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const existing = await this.find<K, T>({
       model,
-      where: buildPrimaryKeyWhere(modelSpec, pkValues),
+      where: buildIdentityFilter(modelSpec, identityValues),
       select,
     });
     if (existing === null) {
@@ -269,7 +274,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const builtWhere = this.buildWhere(
       args.model,
-      buildPrimaryKeyWhere(this.getModel(args.model), existing),
+      buildIdentityFilter(this.getModel(args.model), existing),
     );
     await this.query(`DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`, builtWhere.params);
   }
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 156550e..a835f34 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -404,7 +404,6 @@ describe("SqliteAdapter", () => {
       // Insert
       await adapter.upsert<"users", User>({
         model: "users",
-        where: { field: "id", op: "eq", value: "u1" },
         create: data,
         update: { age: 26 },
       });
@@ -418,7 +417,6 @@ describe("SqliteAdapter", () => {
       // Update
       await adapter.upsert<"users", User>({
         model: "users",
-        where: { field: "id", op: "eq", value: "u1" },
         create: data,
         update: { age: 26 },
       });
@@ -430,7 +428,7 @@ describe("SqliteAdapter", () => {
       expect(found?.age).toBe(26);
     });
 
-    it("should require primary-key equality in upsert filters", () => {
+    it("should handle predicated upsert", async () => {
       const data: User = {
         id: "u1",
         name: "Alice",
@@ -440,14 +438,35 @@ describe("SqliteAdapter", () => {
         tags: null,
       };
 
-      expect(() =>
-        adapter.upsert<"users", User>({
-          model: "users",
-          where: { field: "name", op: "eq", value: "Alice" },
-          create: data,
-          update: { age: 26 },
-        }),
-      ).toThrow("Upsert requires equality filters for every primary key field.");
+      await adapter.create({ model: "users", data });
+
+      // Update should NOT happen if where condition is false
+      await adapter.upsert<"users", User>({
+        model: "users",
+        create: data,
+        update: { age: 30 },
+        where: { field: "age", op: "gt", value: 50 },
+      });
+
+      let found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(25);
+
+      // Update SHOULD happen if where condition is true
+      await adapter.upsert<"users", User>({
+        model: "users",
+        create: data,
+        update: { age: 30 },
+        where: { field: "age", op: "lt", value: 50 },
+      });
+
+      found = await adapter.find<"users", User>({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+      });
+      expect(found?.age).toBe(30);
     });
   });
 });
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 1bf0ab2..c6e6778 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -7,14 +7,13 @@ import type {
   Select,
   SortBy,
   Where,
-  WhereWithoutPath,
 } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
-  buildPrimaryKeyWhere,
+  buildIdentityFilter,
   escapeLiteral,
+  getIdentityValues,
   getPrimaryKeyFields,
-  getPrimaryKeyWhereValues,
   isRecord,
   mapNumeric,
   quote,
@@ -139,7 +138,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const result = await this.find<K, T>({
       model,
-      where: buildPrimaryKeyWhere(modelSpec, data),
+      where: buildIdentityFilter(modelSpec, data),
       select,
     });
 
@@ -227,7 +226,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
     const params = fields.map((field) => mappedData[field] ?? null);
-    const primaryKeyWhere: Where<T> = buildPrimaryKeyWhere(modelSpec, existing);
+    const primaryKeyWhere: Where<T> = buildIdentityFilter(modelSpec, existing);
     const builtWhere = this.buildWhere(model, primaryKeyWhere);
 
     await this.db.run(`UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql}`, [
@@ -271,14 +270,14 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
     model: K;
-    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
+    where?: Where<T>;
     select?: Select<T>;
   }): Promise<T> {
-    const { model, where, create, update, select } = args;
+    const { model, create, update, where, select } = args;
     const modelSpec = this.getModel(model);
-    const primaryKeyValues = getPrimaryKeyWhereValues(modelSpec, where);
+    const identityValues = getIdentityValues(modelSpec, create);
     assertNoPrimaryKeyUpdates(modelSpec, update);
 
     const mappedCreate = this.mapInput(modelSpec.fields, create);
@@ -290,11 +289,10 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const conflictColumns = primaryKeyFields.map((field) => quote(field)).join(", ");
     const insertColumns = createFields.map((field) => quote(field)).join(", ");
     const insertPlaceholders = createFields.map(() => "?").join(", ");
-    const updateClause =
+
+    let updateClause =
       updateFields.length > 0
-        ? // SQLite has no generic "merge this object" primitive, so we spell out
-          // the UPDATE clause and bind update values explicitly.
-          updateFields.map((field) => `${quote(field)} = ?`).join(", ")
+        ? updateFields.map((field) => `${quote(field)} = ?`).join(", ")
         : `${quote(primaryKeyFields[0]!)} = excluded.${quote(primaryKeyFields[0]!)}`;
 
     const params =
@@ -305,6 +303,12 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
           ]
         : createFields.map((field) => mappedCreate[field] ?? null);
 
+    if (where !== undefined) {
+      const builtWhere = this.buildWhere(model, where);
+      updateClause += ` WHERE ${builtWhere.sql}`;
+      params.push(...builtWhere.params);
+    }
+
     await this.db.run(
       `INSERT INTO ${quote(model)} (${insertColumns}) VALUES (${insertPlaceholders}) ON CONFLICT(${conflictColumns}) DO UPDATE SET ${updateClause}`,
       params,
@@ -312,7 +316,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const result = await this.find<K, T>({
       model,
-      where: buildPrimaryKeyWhere(modelSpec, primaryKeyValues),
+      where: buildIdentityFilter(modelSpec, identityValues),
       select,
     });
 
@@ -333,7 +337,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const builtWhere = this.buildWhere(
       args.model,
-      buildPrimaryKeyWhere(this.getModel(args.model), existing),
+      buildIdentityFilter(this.getModel(args.model), existing),
     );
     await this.db.run(
       `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
diff --git a/src/types.ts b/src/types.ts
index 55ad99f..441a538 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -78,9 +78,9 @@ export interface Adapter<S extends Schema = Schema> {
 
   upsert?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
-    where: WhereWithoutPath<T>;
     create: T;
     update: Partial<T>;
+    where?: Where<T>;
     select?: Select<T>;
   }): Promise<T>;
 
@@ -143,28 +143,6 @@ export type Where<T = Record<string, unknown>> =
       or: Where<T>[];
     };
 
-export type WhereWithoutPath<T = Record<string, unknown>> =
-  | {
-      field: FieldName<T>;
-      op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
-      value: unknown;
-      path?: never;
-    }
-  | {
-      field: FieldName<T>;
-      op: "in" | "not_in";
-      value: unknown[];
-      path?: never;
-    }
-  | {
-      and: WhereWithoutPath<T>[];
-      path?: never;
-    }
-  | {
-      or: WhereWithoutPath<T>[];
-      path?: never;
-    };
-
 export interface SortBy<T = Record<string, unknown>> {
   field: FieldName<T>;
   path?: string[];

From 23df8f0432a564ab9b3b3563f9cfd9d4809f5e2b Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Tue, 21 Apr 2026 15:52:09 +0800
Subject: [PATCH 09/24] fix: bun typecheck

---
 src/adapters/common.ts      |  21 ++--
 src/adapters/memory.test.ts |  65 +++++++++++-
 src/adapters/memory.ts      | 200 ++++++++++++++++++------------------
 src/adapters/postgres.ts    |  11 +-
 src/adapters/sqlite.ts      |  11 +-
 5 files changed, 179 insertions(+), 129 deletions(-)

diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 94a9727..d548be2 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -31,7 +31,10 @@ export function getPrimaryKeyFields(model: Model): string[] {
 /**
  * Extracts primary key values from a data object based on the model schema.
  */
-export function getIdentityValues(model: Model, data: Record<string, unknown>): Record<string, unknown> {
+export function getIdentityValues(
+  model: Model,
+  data: Record<string, unknown>,
+): Record<string, unknown> {
   const pkFields = getPrimaryKeyFields(model);
   const values: Record<string, unknown> = {};
   for (const field of pkFields) {
@@ -61,12 +64,16 @@ export function buildIdentityFilter<T extends Record<string, unknown>>(
   source: Record<string, unknown>,
 ): Where<T> {
   const pkFields = getPrimaryKeyFields(model);
-  const clauses = pkFields.map((field) => ({
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    field: field as FieldName<T>,
-    op: "eq" as const,
-    value: source[field],
-  }));
+  const clauses = pkFields.map((field) => {
+    // field is string from getPrimaryKeyFields, narrowing to FieldName<T> is safe
+    const fieldName = field as FieldName<T>; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    const leaf: Where<T> = {
+      field: fieldName,
+      op: "eq" as const,
+      value: source[field],
+    };
+    return leaf;
+  });
 
   if (clauses.length === 1) {
     return clauses[0]!;
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 4b87a37..2a63c8a 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -255,11 +255,12 @@ describe("MemoryAdapter", () => {
       expect(found?.age).toBe(30);
     });
 
-    it("should throw error if primary key is missing in 'create' data", async () => {
+    it("should throw error if primary key is missing in 'create' data", () => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
       const invalidData = {
         name: "Missing ID",
         age: 20,
-      } as any;
+      } as unknown as User;
 
       expect(() =>
         adapter.upsert({
@@ -270,4 +271,64 @@ describe("MemoryAdapter", () => {
       ).toThrow("Missing primary key field: id");
     });
   });
+
+  it("should sort records with null values", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: { theme: "dark" } },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
+    });
+
+    const results = await adapter.findMany({
+      model: "users",
+      sortBy: [{ field: "metadata", direction: "asc" }],
+    });
+
+    expect(results).toHaveLength(2);
+    expect(results[0]?.["id"]).toBe("u2"); // null should come first in asc
+    expect(results[1]?.["id"]).toBe("u1");
+  });
+
+  it("should support keyset pagination", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 20, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 20, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 30, is_active: true, metadata: null },
+    });
+
+    // Page 1
+    const p1 = await adapter.findMany({
+      model: "users",
+      sortBy: [
+        { field: "age", direction: "asc" },
+        { field: "id", direction: "asc" },
+      ],
+      limit: 2,
+    });
+    expect(p1).toHaveLength(2);
+    expect(p1[0]?.["id"]).toBe("u1");
+    expect(p1[1]?.["id"]).toBe("u2");
+
+    // Page 2
+    const p2 = await adapter.findMany({
+      model: "users",
+      sortBy: [
+        { field: "age", direction: "asc" },
+        { field: "id", direction: "asc" },
+      ],
+      cursor: { after: { age: 20, id: "u2" } },
+    });
+    expect(p2).toHaveLength(1);
+    expect(p2[0]?.["id"]).toBe("u3");
+  });
 });
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 583187f..da39895 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -1,6 +1,7 @@
 import type {
   Adapter,
   Cursor,
+  FieldName,
   InferModel,
   Schema,
   Select,
@@ -22,7 +23,7 @@ type RowData = Record<string, unknown>;
  * Useful for testing, development, and small-scale caching.
  */
 export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<string, Map<string, Record<string, unknown>>>();
+  private storage = new Map<string, Map<string, RowData>>();
 
   constructor(private schema: S) {}
 
@@ -47,7 +48,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T> {
     const { model, data, select } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
     const pkValue = this.getPrimaryKeyString(model, data);
 
     if (modelStorage.has(pkValue)) {
@@ -55,10 +56,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     // Optimization: Avoid object spread in hot path
-    const record = Object.assign({}, data) as T;
+    const record = Object.assign({}, data);
     modelStorage.set(pkValue, record);
 
-    return Promise.resolve(this.applySelect(record, select));
+    return Promise.resolve(this.applySelect(this.asModel(record), select));
   }
 
   find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
@@ -67,11 +68,12 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T | null> {
     const { model, where, select } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
 
     for (const record of modelStorage.values()) {
-      if (this.evaluateWhere(where, record as T)) {
-        return Promise.resolve(this.applySelect(record as T, select));
+      const modelRecord = this.asModel<T>(record);
+      if (this.evaluateWhere(where, modelRecord)) {
+        return Promise.resolve(this.applySelect(modelRecord, select));
       }
     }
 
@@ -88,26 +90,26 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor?: Cursor<T>;
   }): Promise<T[]> {
     const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
 
-    let results = Array.from(modelStorage.values()) as T[];
+    let results = Array.from(modelStorage.values()).map((r) => this.asModel<T>(r));
 
     if (where) {
       results = results.filter((record) => this.evaluateWhere(where, record));
     }
 
     if (cursor) {
-      const cursorValues = cursor.after as Record<string, unknown>;
+      const cursorValues = cursor.after;
       const sortCriteria =
         sortBy !== undefined && sortBy.length > 0
           ? sortBy
               .filter((sort) => cursorValues[sort.field] !== undefined)
               .map((sort) => ({
-                field: sort.field as string,
+                field: sort.field,
                 direction: sort.direction ?? "asc",
                 path: sort.path,
               }))
-          : Object.keys(cursor.after).map((field) => ({
+          : this.getFieldNames(cursor.after).map((field) => ({
               field,
               direction: "asc" as const,
               path: undefined,
@@ -117,32 +119,14 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
         results = results.filter((record) => {
           // Lexicographic keyset pagination:
           // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
-          for (let i = 0; i < sortCriteria.length; i++) {
-            let allPreviousEqual = true;
-            for (let j = 0; j < i; j++) {
-              const prev = sortCriteria[j]!;
-              const recordVal = this.getValue(record as RowData, prev.field, prev.path);
-              const cursorVal = cursorValues[prev.field];
-              if (this.compareValues(recordVal, cursorVal) !== 0) {
-                allPreviousEqual = false;
-                break;
-              }
-            }
-
-            if (!allPreviousEqual) continue;
-
-            const current = sortCriteria[i]!;
-            const recordVal = this.getValue(record as RowData, current.field, current.path);
+          for (const current of sortCriteria) {
+            const recordVal = this.getValue(record, current.field, current.path);
             const cursorVal = cursorValues[current.field];
             const comp = this.compareValues(recordVal, cursorVal);
 
-            if (current.direction === "desc") {
-              if (comp < 0) return true;
-            } else if (comp > 0) {
-              return true;
-            }
+            if (comp === 0) continue;
 
-            // If this was the last criteria and it's equal, it doesn't satisfy "after"
+            return current.direction === "desc" ? comp < 0 : comp > 0;
           }
           return false;
         });
@@ -152,8 +136,8 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (sortBy) {
       results.sort((a, b) => {
         for (const { field, direction, path } of sortBy) {
-          const valA = this.getValue(a as RowData, field as string, path);
-          const valB = this.getValue(b as RowData, field as string, path);
+          const valA = this.getValue(a, field, path);
+          const valB = this.getValue(b, field, path);
           if (valA === valB) continue;
           const factor = direction === "desc" ? -1 : 1;
           if (valA === undefined || valB === undefined) return 0;
@@ -180,14 +164,15 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, data } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, data);
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (this.evaluateWhere(where, record as T)) {
+      const modelRecord = this.asModel<T>(record);
+      if (this.evaluateWhere(where, modelRecord)) {
         // Optimization: Create a new object to avoid mutating internal storage reference
-        const updated = Object.assign({}, record, data) as T;
+        const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
-        return Promise.resolve(this.applySelect(updated, undefined));
+        return Promise.resolve(this.applySelect(this.asModel(updated)));
       }
     }
 
@@ -201,13 +186,14 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, data } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, data);
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
     let count = 0;
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (where === undefined || this.evaluateWhere(where, record as T)) {
+      const modelRecord = this.asModel<T>(record);
+      if (where === undefined || this.evaluateWhere(where, modelRecord)) {
         // Optimization: Create a new object to avoid mutating internal storage reference
-        const updated = Object.assign({}, record, data) as T;
+        const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
         count++;
       }
@@ -216,10 +202,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(count);
   }
 
-  upsert<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
+  upsert<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     create: T;
     update: Partial<T>;
@@ -231,17 +214,18 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     assertNoPrimaryKeyUpdates(modelSpec, update);
 
     const pkValue = this.getPrimaryKeyString(model, create);
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
     const existing = modelStorage.get(pkValue);
 
-    if (existing) {
+    if (existing !== undefined) {
+      const modelExisting = this.asModel<T>(existing);
       // Use optional where predicate
-      if (where === undefined || this.evaluateWhere(where, existing as T)) {
-        const updated = Object.assign({}, existing, update) as T;
+      if (where === undefined || this.evaluateWhere(where, modelExisting)) {
+        const updated = Object.assign({}, modelExisting, update);
         modelStorage.set(pkValue, updated);
-        return Promise.resolve(this.applySelect(updated, select));
+        return Promise.resolve(this.applySelect(this.asModel(updated), select));
       }
-      return Promise.resolve(this.applySelect(existing as T, select));
+      return Promise.resolve(this.applySelect(modelExisting, select));
     }
 
     return this.create({ model, data: create, select });
@@ -252,10 +236,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where: Where<T>;
   }): Promise<void> {
     const { model, where } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (this.evaluateWhere(where, record as T)) {
+      if (this.evaluateWhere(where, this.asModel<T>(record))) {
         modelStorage.delete(pk);
         return Promise.resolve();
       }
@@ -268,11 +252,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model, where } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
     let count = 0;
 
     for (const [pk, record] of modelStorage.entries()) {
-      if (where === undefined || this.evaluateWhere(where, record as T)) {
+      if (where === undefined || this.evaluateWhere(where, this.asModel<T>(record))) {
         modelStorage.delete(pk);
         count++;
       }
@@ -286,13 +270,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where?: Where<T>;
   }): Promise<number> {
     const { model, where } = args;
-    const modelStorage = this.getModelStorage<K, T>(model);
+    const modelStorage = this.getModelStorage(model);
 
-    if (!where) return Promise.resolve(modelStorage.size);
+    if (where === undefined) return Promise.resolve(modelStorage.size);
 
     let count = 0;
     for (const record of modelStorage.values()) {
-      if (this.evaluateWhere(where, record as T)) {
+      if (this.evaluateWhere(where, this.asModel<T>(record))) {
         count++;
       }
     }
@@ -301,10 +285,17 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
   // --- Helpers ---
 
-  private getModelStorage<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(model: K): Map<string, Record<string, unknown>> {
+  private getFieldNames<T>(obj: Partial<Record<FieldName<T>, unknown>>): FieldName<T>[] {
+    // Object.keys always returns string[], narrowing to FieldName<T> is safe - keys come from typed cursor
+    return Object.keys(obj) as FieldName<T>[]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  }
+
+  private asModel<T extends RowData>(record: RowData): T {
+    // Internal storage only contains RowData from previous operations; T is inferred from call site
+    return record as T; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  }
+
+  private getModelStorage(model: string): Map<string, RowData> {
     const storage = this.storage.get(model);
     if (!storage) {
       throw new Error(`Model ${model} not initialized. Call migrate() first.`);
@@ -329,30 +320,34 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   }
 
   private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
-    const result: Partial<T> = {};
-
     if (select === undefined) {
-      // Always return a shallow clone to match DB snapshot behavior
-      return Object.assign(result, record) as T;
+      return Object.assign({}, record);
     }
 
+    // Empty object to be populated with selected fields only
+    const result = {} as T; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
     for (const field of select) {
-      const val = record[field];
-      // Normalize undefined to null to match SQL behavior
-      result[field] = val === undefined ? (null as any) : val;
+      const fieldName = field as FieldName<T>;
+      const val = record[fieldName];
+      this.setField(result, fieldName, val ?? null);
     }
 
-    return result as T;
+    return result;
+  }
+
+  private setField<T extends RowData, K extends FieldName<T>>(obj: T, key: K, value: unknown): void {
+    // Value is either from the record or defaulted to null - both are valid for T[K]
+    obj[key] = value as T[K]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   }
 
-  private getValue(record: RowData, field: string, path?: string[]): unknown {
-    let value = record[field];
+  private getValue<T extends RowData>(record: T, field: FieldName<T>, path?: string[]): unknown {
+    let value: unknown = record[field];
     if (path && path.length > 0) {
       for (const segment of path) {
         if (!isRecord(value)) {
           return undefined;
         }
-        value = (value as Record<string, unknown>)[segment];
+        value = value[segment];
       }
     }
     return value;
@@ -366,37 +361,42 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       return where.or.some((w) => this.evaluateWhere(w, record));
     }
 
-    const leaf = where as { field: string; op: string; value: unknown; path?: string[] };
-    const { field, op, value, path } = leaf;
-    const recordValue = this.getValue(record, field, path);
-
-    switch (op) {
-      case "eq":
-        return recordValue === value;
-      case "ne":
-        return recordValue !== value;
-      case "gt":
-        return this.compareValues(recordValue, value) > 0;
-      case "gte":
-        return this.compareValues(recordValue, value) >= 0;
-      case "lt":
-        return this.compareValues(recordValue, value) < 0;
-      case "lte":
-        return this.compareValues(recordValue, value) <= 0;
-      case "in":
-        return Array.isArray(value) && value.includes(recordValue);
-      case "not_in":
-        return Array.isArray(value) && !value.includes(recordValue);
-      default:
-        return false;
+    if ("field" in where && "op" in where) {
+      const { field, op, value, path } = where;
+      const recordValue = this.getValue(record, field, path);
+
+      switch (op) {
+        case "eq":
+          return recordValue === value;
+        case "ne":
+          return recordValue !== value;
+        case "gt":
+          return this.compareValues(recordValue, value) > 0;
+        case "gte":
+          return this.compareValues(recordValue, value) >= 0;
+        case "lt":
+          return this.compareValues(recordValue, value) < 0;
+        case "lte":
+          return this.compareValues(recordValue, value) <= 0;
+        case "in":
+          return Array.isArray(value) && value.includes(recordValue);
+        case "not_in":
+          return Array.isArray(value) && !value.includes(recordValue);
+      }
     }
+    return false;
   }
 
   private compareValues(left: unknown, right: unknown): number {
     if (left === right) return 0;
-    if (!this.isComparable(left) || !this.isComparable(right)) return 0;
+    if (left === null || left === undefined) return -1;
+    if (right === null || right === undefined) return 1;
     if (typeof left !== typeof right) return 0;
-    return (left as any) < (right as any) ? -1 : 1;
+    if (this.isComparable(left) && this.isComparable(right)) {
+      if (left < right) return -1;
+      if (left > right) return 1;
+    }
+    return 0;
   }
 
   private isComparable(value: unknown): value is Comparable {
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 08c594f..f9b1b04 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,15 +1,6 @@
 import type { SQL, TransactionSQL } from "bun";
 
-import type {
-  Adapter,
-  Cursor,
-  Field,
-  InferModel,
-  Schema,
-  Select,
-  SortBy,
-  Where,
-} from "../types";
+import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
   buildIdentityFilter,
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index c6e6778..8896417 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,13 +1,4 @@
-import type {
-  Adapter,
-  Cursor,
-  Field,
-  InferModel,
-  Schema,
-  Select,
-  SortBy,
-  Where,
-} from "../types";
+import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
   buildIdentityFilter,

From 2ceaaa05e9aef6893c438b084ce4af7c9342fb7d Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Tue, 21 Apr 2026 22:40:50 +0800
Subject: [PATCH 10/24] refactor: update dependencies and use offical types

---
 bun.lock                    | 299 ++++++++++++++++++++++++++++++++++++
 package.json                |  25 ++-
 src/adapters/memory.test.ts |  40 ++++-
 src/adapters/memory.ts      |   9 +-
 src/adapters/postgres.ts    | 176 ++++++++++++++++-----
 src/adapters/sqlite.test.ts |  62 ++++++++
 src/adapters/sqlite.ts      | 194 ++++++++++++++---------
 src/types.ts                |  53 ++++++-
 8 files changed, 735 insertions(+), 123 deletions(-)

diff --git a/bun.lock b/bun.lock
index cd4ff65..e31e194 100644
--- a/bun.lock
+++ b/bun.lock
@@ -5,15 +5,36 @@
     "": {
       "name": "@8monkey/no-orm",
       "devDependencies": {
+        "@types/better-sqlite3": "^7.6.13",
         "@types/bun": "^1.3.12",
+        "@types/pg": "^8.11.11",
+        "@types/sqlite3": "^5.1.0",
         "oxfmt": "^0.44.0",
         "oxlint": "^1.59.0",
         "oxlint-tsgolint": "^0.20.0",
         "typescript": "^6.0.2",
       },
+      "peerDependencies": {
+        "better-sqlite3": "^11.0.0",
+        "pg": "^8.0.0",
+        "sqlite": "^5.0.0",
+        "sqlite3": "^5.0.0",
+      },
+      "optionalPeers": [
+        "better-sqlite3",
+        "pg",
+        "sqlite",
+        "sqlite3",
+      ],
     },
   },
   "packages": {
+    "@gar/promisify": ["@gar/promisify@1.1.3", "", {}, "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw=="],
+
+    "@npmcli/fs": ["@npmcli/fs@1.1.1", "", { "dependencies": { "@gar/promisify": "^1.0.1", "semver": "^7.3.5" } }, "sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ=="],
+
+    "@npmcli/move-file": ["@npmcli/move-file@1.1.2", "", { "dependencies": { "mkdirp": "^1.0.4", "rimraf": "^3.0.2" } }, "sha512-1SUf/Cg2GzGDyaf15aR9St9TWlb+XvbZXWpDx8YKs7MLzMH/BCeopv+y9vzrzgkfykCGuWOlSu3mZhj2+FQcrg=="],
+
     "@oxfmt/binding-android-arm-eabi": ["@oxfmt/binding-android-arm-eabi@0.44.0", "", { "os": "android", "cpu": "arm" }, "sha512-5UvghMd9SA/yvKTWCAxMAPXS1d2i054UeOf4iFjZjfayTwCINcC3oaSXjtbZfCaEpxgJod7XiOjTtby5yEv/BQ=="],
 
     "@oxfmt/binding-android-arm64": ["@oxfmt/binding-android-arm64@0.44.0", "", { "os": "android", "cpu": "arm64" }, "sha512-IVudM1BWfvrYO++Khtzr8q9n5Rxu7msUvoFMqzGJVdX7HfUXUDHwaH2zHZNB58svx2J56pmCUzophyaPFkcG/A=="],
@@ -102,22 +123,300 @@
 
     "@oxlint/binding-win32-x64-msvc": ["@oxlint/binding-win32-x64-msvc@1.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-xkE7puteDS/vUyRngLXW0t8WgdWoS/tfxXjhP/P7SMqPDx+hs44SpssO3h3qmTqECYEuXBUPzcAw5257Ka+ofA=="],
 
+    "@tootallnate/once": ["@tootallnate/once@1.1.2", "", {}, "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw=="],
+
+    "@types/better-sqlite3": ["@types/better-sqlite3@7.6.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA=="],
+
     "@types/bun": ["@types/bun@1.3.12", "", { "dependencies": { "bun-types": "1.3.12" } }, "sha512-DBv81elK+/VSwXHDlnH3Qduw+KxkTIWi7TXkAeh24zpi5l0B2kUg9Ga3tb4nJaPcOFswflgi/yAvMVBPrxMB+A=="],
 
     "@types/node": ["@types/node@25.6.0", "", { "dependencies": { "undici-types": "~7.19.0" } }, "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ=="],
 
+    "@types/pg": ["@types/pg@8.20.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow=="],
+
+    "@types/sqlite3": ["@types/sqlite3@5.1.0", "", { "dependencies": { "sqlite3": "*" } }, "sha512-w25Gd6OzcN0Sb6g/BO7cyee0ugkiLgonhgGYfG+H0W9Ub6PUsC2/4R+KXy2tc80faPIWO3Qytbvr8gP1fU4siA=="],
+
+    "abbrev": ["abbrev@1.1.1", "", {}, "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q=="],
+
+    "agent-base": ["agent-base@6.0.2", "", { "dependencies": { "debug": "4" } }, "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ=="],
+
+    "agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
+
+    "aggregate-error": ["aggregate-error@3.1.0", "", { "dependencies": { "clean-stack": "^2.0.0", "indent-string": "^4.0.0" } }, "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "aproba": ["aproba@2.1.0", "", {}, "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew=="],
+
+    "are-we-there-yet": ["are-we-there-yet@3.0.1", "", { "dependencies": { "delegates": "^1.0.0", "readable-stream": "^3.6.0" } }, "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
+
+    "bindings": ["bindings@1.5.0", "", { "dependencies": { "file-uri-to-path": "1.0.0" } }, "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ=="],
+
+    "bl": ["bl@4.1.0", "", { "dependencies": { "buffer": "^5.5.0", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w=="],
+
+    "brace-expansion": ["brace-expansion@1.1.14", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g=="],
+
+    "buffer": ["buffer@5.7.1", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" } }, "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ=="],
+
     "bun-types": ["bun-types@1.3.12", "", { "dependencies": { "@types/node": "*" } }, "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA=="],
 
+    "cacache": ["cacache@15.3.0", "", { "dependencies": { "@npmcli/fs": "^1.0.0", "@npmcli/move-file": "^1.0.1", "chownr": "^2.0.0", "fs-minipass": "^2.0.0", "glob": "^7.1.4", "infer-owner": "^1.0.4", "lru-cache": "^6.0.0", "minipass": "^3.1.1", "minipass-collect": "^1.0.2", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.2", "mkdirp": "^1.0.3", "p-map": "^4.0.0", "promise-inflight": "^1.0.1", "rimraf": "^3.0.2", "ssri": "^8.0.1", "tar": "^6.0.2", "unique-filename": "^1.1.1" } }, "sha512-VVdYzXEn+cnbXpFgWs5hTT7OScegHVmLhJIR8Ufqk3iFD6A6j5iSX1KuBTfNEv4tdJWE2PzA6IVFtcLC7fN9wQ=="],
+
+    "chownr": ["chownr@2.0.0", "", {}, "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ=="],
+
+    "clean-stack": ["clean-stack@2.2.0", "", {}, "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A=="],
+
+    "color-support": ["color-support@1.1.3", "", { "bin": { "color-support": "bin.js" } }, "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "console-control-strings": ["console-control-strings@1.1.0", "", {}, "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "decompress-response": ["decompress-response@6.0.0", "", { "dependencies": { "mimic-response": "^3.1.0" } }, "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ=="],
+
+    "deep-extend": ["deep-extend@0.6.0", "", {}, "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="],
+
+    "delegates": ["delegates@1.0.0", "", {}, "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "encoding": ["encoding@0.1.13", "", { "dependencies": { "iconv-lite": "^0.6.2" } }, "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A=="],
+
+    "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="],
+
+    "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="],
+
+    "err-code": ["err-code@2.0.3", "", {}, "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA=="],
+
+    "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="],
+
+    "file-uri-to-path": ["file-uri-to-path@1.0.0", "", {}, "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="],
+
+    "fs-constants": ["fs-constants@1.0.0", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="],
+
+    "fs-minipass": ["fs-minipass@2.1.0", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg=="],
+
+    "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="],
+
+    "gauge": ["gauge@4.0.4", "", { "dependencies": { "aproba": "^1.0.3 || ^2.0.0", "color-support": "^1.1.3", "console-control-strings": "^1.1.0", "has-unicode": "^2.0.1", "signal-exit": "^3.0.7", "string-width": "^4.2.3", "strip-ansi": "^6.0.1", "wide-align": "^1.1.5" } }, "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg=="],
+
+    "github-from-package": ["github-from-package@0.0.0", "", {}, "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="],
+
+    "glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "has-unicode": ["has-unicode@2.0.1", "", {}, "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ=="],
+
+    "http-cache-semantics": ["http-cache-semantics@4.2.0", "", {}, "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ=="],
+
+    "http-proxy-agent": ["http-proxy-agent@4.0.1", "", { "dependencies": { "@tootallnate/once": "1", "agent-base": "6", "debug": "4" } }, "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg=="],
+
+    "https-proxy-agent": ["https-proxy-agent@5.0.1", "", { "dependencies": { "agent-base": "6", "debug": "4" } }, "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA=="],
+
+    "humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
+
+    "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
+
+    "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
+
+    "indent-string": ["indent-string@4.0.0", "", {}, "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="],
+
+    "infer-owner": ["infer-owner@1.0.4", "", {}, "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A=="],
+
+    "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="],
+
+    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
+
+    "ini": ["ini@1.3.8", "", {}, "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="],
+
+    "ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="],
+
+    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+    "is-lambda": ["is-lambda@1.0.1", "", {}, "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ=="],
+
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
+    "lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+
+    "make-fetch-happen": ["make-fetch-happen@9.1.0", "", { "dependencies": { "agentkeepalive": "^4.1.3", "cacache": "^15.2.0", "http-cache-semantics": "^4.1.0", "http-proxy-agent": "^4.0.1", "https-proxy-agent": "^5.0.0", "is-lambda": "^1.0.1", "lru-cache": "^6.0.0", "minipass": "^3.1.3", "minipass-collect": "^1.0.2", "minipass-fetch": "^1.3.2", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "negotiator": "^0.6.2", "promise-retry": "^2.0.1", "socks-proxy-agent": "^6.0.0", "ssri": "^8.0.0" } }, "sha512-+zopwDy7DNknmwPQplem5lAZX/eCOzSvSNNcSKm5eVwTkOBzoktEfXsa9L23J/GIRhxRsaxzkPEhrJEpE2F4Gg=="],
+
+    "mimic-response": ["mimic-response@3.1.0", "", {}, "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="],
+
+    "minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "minipass": ["minipass@5.0.0", "", {}, "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ=="],
+
+    "minipass-collect": ["minipass-collect@1.0.2", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA=="],
+
+    "minipass-fetch": ["minipass-fetch@1.4.1", "", { "dependencies": { "minipass": "^3.1.0", "minipass-sized": "^1.0.3", "minizlib": "^2.0.0" }, "optionalDependencies": { "encoding": "^0.1.12" } }, "sha512-CGH1eblLq26Y15+Azk7ey4xh0J/XfJfrCox5LDJiKqI2Q2iwOLOKrlmIaODiSQS8d18jalF6y2K2ePUm0CmShw=="],
+
+    "minipass-flush": ["minipass-flush@1.0.7", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-TbqTz9cUwWyHS2Dy89P3ocAGUGxKjjLuR9z8w4WUTGAVgEj17/4nhgo2Du56i0Fm3Pm30g4iA8Lcqctc76jCzA=="],
+
+    "minipass-pipeline": ["minipass-pipeline@1.2.4", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A=="],
+
+    "minipass-sized": ["minipass-sized@1.0.3", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g=="],
+
+    "minizlib": ["minizlib@2.1.2", "", { "dependencies": { "minipass": "^3.0.0", "yallist": "^4.0.0" } }, "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg=="],
+
+    "mkdirp": ["mkdirp@1.0.4", "", { "bin": { "mkdirp": "bin/cmd.js" } }, "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="],
+
+    "mkdirp-classic": ["mkdirp-classic@0.5.3", "", {}, "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "napi-build-utils": ["napi-build-utils@2.0.0", "", {}, "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA=="],
+
+    "negotiator": ["negotiator@0.6.4", "", {}, "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w=="],
+
+    "node-abi": ["node-abi@3.89.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-6u9UwL0HlAl21+agMN3YAMXcKByMqwGx+pq+P76vii5f7hTPtKDp08/H9py6DY+cfDw7kQNTGEj/rly3IgbNQA=="],
+
+    "node-addon-api": ["node-addon-api@7.1.1", "", {}, "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ=="],
+
+    "node-gyp": ["node-gyp@8.4.1", "", { "dependencies": { "env-paths": "^2.2.0", "glob": "^7.1.4", "graceful-fs": "^4.2.6", "make-fetch-happen": "^9.1.0", "nopt": "^5.0.0", "npmlog": "^6.0.0", "rimraf": "^3.0.2", "semver": "^7.3.5", "tar": "^6.1.2", "which": "^2.0.2" }, "bin": { "node-gyp": "bin/node-gyp.js" } }, "sha512-olTJRgUtAb/hOXG0E93wZDs5YiJlgbXxTwQAFHyNlRsXQnYzUaF2aGgujZbw+hR8aF4ZG/rST57bWMWD16jr9w=="],
+
+    "nopt": ["nopt@5.0.0", "", { "dependencies": { "abbrev": "1" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ=="],
+
+    "npmlog": ["npmlog@6.0.2", "", { "dependencies": { "are-we-there-yet": "^3.0.0", "console-control-strings": "^1.1.0", "gauge": "^4.0.3", "set-blocking": "^2.0.0" } }, "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg=="],
+
+    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
+
     "oxfmt": ["oxfmt@0.44.0", "", { "dependencies": { "tinypool": "2.1.0" }, "optionalDependencies": { "@oxfmt/binding-android-arm-eabi": "0.44.0", "@oxfmt/binding-android-arm64": "0.44.0", "@oxfmt/binding-darwin-arm64": "0.44.0", "@oxfmt/binding-darwin-x64": "0.44.0", "@oxfmt/binding-freebsd-x64": "0.44.0", "@oxfmt/binding-linux-arm-gnueabihf": "0.44.0", "@oxfmt/binding-linux-arm-musleabihf": "0.44.0", "@oxfmt/binding-linux-arm64-gnu": "0.44.0", "@oxfmt/binding-linux-arm64-musl": "0.44.0", "@oxfmt/binding-linux-ppc64-gnu": "0.44.0", "@oxfmt/binding-linux-riscv64-gnu": "0.44.0", "@oxfmt/binding-linux-riscv64-musl": "0.44.0", "@oxfmt/binding-linux-s390x-gnu": "0.44.0", "@oxfmt/binding-linux-x64-gnu": "0.44.0", "@oxfmt/binding-linux-x64-musl": "0.44.0", "@oxfmt/binding-openharmony-arm64": "0.44.0", "@oxfmt/binding-win32-arm64-msvc": "0.44.0", "@oxfmt/binding-win32-ia32-msvc": "0.44.0", "@oxfmt/binding-win32-x64-msvc": "0.44.0" }, "bin": { "oxfmt": "bin/oxfmt" } }, "sha512-lnncqvHewyRvaqdrnntVIrZV2tEddz8lbvPsQzG/zlkfvgZkwy0HP1p/2u1aCDToeg1jb9zBpbJdfkV73Itw+w=="],
 
     "oxlint": ["oxlint@1.59.0", "", { "optionalDependencies": { "@oxlint/binding-android-arm-eabi": "1.59.0", "@oxlint/binding-android-arm64": "1.59.0", "@oxlint/binding-darwin-arm64": "1.59.0", "@oxlint/binding-darwin-x64": "1.59.0", "@oxlint/binding-freebsd-x64": "1.59.0", "@oxlint/binding-linux-arm-gnueabihf": "1.59.0", "@oxlint/binding-linux-arm-musleabihf": "1.59.0", "@oxlint/binding-linux-arm64-gnu": "1.59.0", "@oxlint/binding-linux-arm64-musl": "1.59.0", "@oxlint/binding-linux-ppc64-gnu": "1.59.0", "@oxlint/binding-linux-riscv64-gnu": "1.59.0", "@oxlint/binding-linux-riscv64-musl": "1.59.0", "@oxlint/binding-linux-s390x-gnu": "1.59.0", "@oxlint/binding-linux-x64-gnu": "1.59.0", "@oxlint/binding-linux-x64-musl": "1.59.0", "@oxlint/binding-openharmony-arm64": "1.59.0", "@oxlint/binding-win32-arm64-msvc": "1.59.0", "@oxlint/binding-win32-ia32-msvc": "1.59.0", "@oxlint/binding-win32-x64-msvc": "1.59.0" }, "peerDependencies": { "oxlint-tsgolint": ">=0.18.0" }, "optionalPeers": ["oxlint-tsgolint"], "bin": { "oxlint": "bin/oxlint" } }, "sha512-0xBLeGGjP4vD9pygRo8iuOkOzEU1MqOnfiOl7KYezL/QvWL8NUg6n03zXc7ZVqltiOpUxBk2zgHI3PnRIEdAvw=="],
 
     "oxlint-tsgolint": ["oxlint-tsgolint@0.20.0", "", { "optionalDependencies": { "@oxlint-tsgolint/darwin-arm64": "0.20.0", "@oxlint-tsgolint/darwin-x64": "0.20.0", "@oxlint-tsgolint/linux-arm64": "0.20.0", "@oxlint-tsgolint/linux-x64": "0.20.0", "@oxlint-tsgolint/win32-arm64": "0.20.0", "@oxlint-tsgolint/win32-x64": "0.20.0" }, "bin": { "tsgolint": "bin/tsgolint.js" } }, "sha512-/Uc9TQyN1l8w9QNvXtVHYtz+SzDJHKpb5X0UnHodl0BVzijUPk0LPlDOHAvogd1UI+iy9ZSF6gQxEqfzUxCULQ=="],
 
+    "p-map": ["p-map@4.0.0", "", { "dependencies": { "aggregate-error": "^3.0.0" } }, "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ=="],
+
+    "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="],
+
+    "pg-int8": ["pg-int8@1.0.1", "", {}, "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw=="],
+
+    "pg-protocol": ["pg-protocol@1.13.0", "", {}, "sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w=="],
+
+    "pg-types": ["pg-types@2.2.0", "", { "dependencies": { "pg-int8": "1.0.1", "postgres-array": "~2.0.0", "postgres-bytea": "~1.0.0", "postgres-date": "~1.0.4", "postgres-interval": "^1.1.0" } }, "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA=="],
+
+    "postgres-array": ["postgres-array@2.0.0", "", {}, "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA=="],
+
+    "postgres-bytea": ["postgres-bytea@1.0.1", "", {}, "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ=="],
+
+    "postgres-date": ["postgres-date@1.0.7", "", {}, "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q=="],
+
+    "postgres-interval": ["postgres-interval@1.2.0", "", { "dependencies": { "xtend": "^4.0.0" } }, "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ=="],
+
+    "prebuild-install": ["prebuild-install@7.1.3", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^2.0.0", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug=="],
+
+    "promise-inflight": ["promise-inflight@1.0.1", "", {}, "sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g=="],
+
+    "promise-retry": ["promise-retry@2.0.1", "", { "dependencies": { "err-code": "^2.0.2", "retry": "^0.12.0" } }, "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g=="],
+
+    "pump": ["pump@3.0.4", "", { "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA=="],
+
+    "rc": ["rc@1.2.8", "", { "dependencies": { "deep-extend": "^0.6.0", "ini": "~1.3.0", "minimist": "^1.2.0", "strip-json-comments": "~2.0.1" }, "bin": { "rc": "./cli.js" } }, "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw=="],
+
+    "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+    "retry": ["retry@0.12.0", "", {}, "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow=="],
+
+    "rimraf": ["rimraf@3.0.2", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "bin.js" } }, "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="],
+
+    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
+    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
+
+    "semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="],
+
+    "set-blocking": ["set-blocking@2.0.0", "", {}, "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="],
+
+    "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+    "simple-concat": ["simple-concat@1.0.1", "", {}, "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="],
+
+    "simple-get": ["simple-get@4.0.1", "", { "dependencies": { "decompress-response": "^6.0.0", "once": "^1.3.1", "simple-concat": "^1.0.0" } }, "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA=="],
+
+    "smart-buffer": ["smart-buffer@4.2.0", "", {}, "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="],
+
+    "socks": ["socks@2.8.7", "", { "dependencies": { "ip-address": "^10.0.1", "smart-buffer": "^4.2.0" } }, "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A=="],
+
+    "socks-proxy-agent": ["socks-proxy-agent@6.2.1", "", { "dependencies": { "agent-base": "^6.0.2", "debug": "^4.3.3", "socks": "^2.6.2" } }, "sha512-a6KW9G+6B3nWZ1yB8G7pJwL3ggLy1uTzKAgCb7ttblwqdz9fMGJUuTy3uFzEP48FAs9FLILlmzDlE2JJhVQaXQ=="],
+
+    "sqlite": ["sqlite@5.1.1", "", {}, "sha512-oBkezXa2hnkfuJwUo44Hl9hS3er+YFtueifoajrgidvqsJRQFpc5fKoAkAor1O5ZnLoa28GBScfHXs8j0K358Q=="],
+
+    "sqlite3": ["sqlite3@5.1.7", "", { "dependencies": { "bindings": "^1.5.0", "node-addon-api": "^7.0.0", "prebuild-install": "^7.1.1", "tar": "^6.1.11" }, "optionalDependencies": { "node-gyp": "8.x" } }, "sha512-GGIyOiFaG+TUra3JIfkI/zGP8yZYLPQ0pl1bH+ODjiX57sPhrLU5sQJn1y9bDKZUFYkX1crlrPfSYt0BKKdkog=="],
+
+    "ssri": ["ssri@8.0.1", "", { "dependencies": { "minipass": "^3.1.1" } }, "sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ=="],
+
+    "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "strip-json-comments": ["strip-json-comments@2.0.1", "", {}, "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ=="],
+
+    "tar": ["tar@6.2.1", "", { "dependencies": { "chownr": "^2.0.0", "fs-minipass": "^2.0.0", "minipass": "^5.0.0", "minizlib": "^2.1.1", "mkdirp": "^1.0.3", "yallist": "^4.0.0" } }, "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A=="],
+
+    "tar-fs": ["tar-fs@2.1.4", "", { "dependencies": { "chownr": "^1.1.1", "mkdirp-classic": "^0.5.2", "pump": "^3.0.0", "tar-stream": "^2.1.4" } }, "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ=="],
+
+    "tar-stream": ["tar-stream@2.2.0", "", { "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", "fs-constants": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^3.1.1" } }, "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ=="],
+
     "tinypool": ["tinypool@2.1.0", "", {}, "sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw=="],
 
+    "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="],
+
     "typescript": ["typescript@6.0.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ=="],
 
     "undici-types": ["undici-types@7.19.2", "", {}, "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="],
+
+    "unique-filename": ["unique-filename@1.1.1", "", { "dependencies": { "unique-slug": "^2.0.0" } }, "sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ=="],
+
+    "unique-slug": ["unique-slug@2.0.2", "", { "dependencies": { "imurmurhash": "^0.1.4" } }, "sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w=="],
+
+    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
+    "wide-align": ["wide-align@1.1.5", "", { "dependencies": { "string-width": "^1.0.2 || 2 || 3 || 4" } }, "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg=="],
+
+    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
+
+    "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="],
+
+    "yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
+
+    "cacache/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "fs-minipass/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "make-fetch-happen/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minipass-collect/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minipass-fetch/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minipass-flush/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minipass-pipeline/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minipass-sized/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "minizlib/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "ssri/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "tar-fs/chownr": ["chownr@1.1.4", "", {}, "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="],
   }
 }
diff --git a/package.json b/package.json
index b595d50..2752b7d 100644
--- a/package.json
+++ b/package.json
@@ -61,12 +61,33 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.12",
+    "@types/pg": "^8.11.11",
+    "@types/sqlite3": "^5.1.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
     "oxlint-tsgolint": "^0.20.0",
     "typescript": "^6.0.2"
   },
-  "peerDependencies": {},
-  "peerDependenciesMeta": {}
+  "peerDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "pg": "^8.0.0",
+    "sqlite": "^5.0.0",
+    "sqlite3": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "sqlite": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    }
+  }
 }
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 2a63c8a..f9ecc61 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -12,6 +12,7 @@ describe("MemoryAdapter", () => {
         age: { type: "number" },
         is_active: { type: "boolean" },
         metadata: { type: "json", nullable: true },
+        tags: { type: "json[]", nullable: true },
       },
       primaryKey: "id",
     },
@@ -178,13 +179,45 @@ describe("MemoryAdapter", () => {
     expect(results).toHaveLength(2);
   });
 
+  it("should filter by null equality (op: eq, value: null)", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u4", name: "NullUser", age: 40, is_active: true, metadata: null, tags: null },
+    });
+    const users = await adapter.findMany<"users", User>({
+      model: "users",
+      where: { field: "metadata", op: "eq", value: null },
+    });
+    expect(users.find((u) => u.id === "u4")).toBeDefined();
+  });
+
+  it("should filter by null inequality (op: ne, value: null)", async () => {
+    await adapter.create({
+      model: "users",
+      data: {
+        id: "u5",
+        name: "NotNullUser",
+        age: 40,
+        is_active: true,
+        metadata: { has_data: true },
+        tags: null,
+      },
+    });
+    const users = await adapter.findMany<"users", User>({
+      model: "users",
+      where: { field: "metadata", op: "ne", value: null },
+    });
+    expect(users.find((u) => u.id === "u5")).toBeDefined();
+    expect(users.find((u) => u.id === "u4")).toBeUndefined();
+  });
+
   describe("Upsert", () => {
     it("should handle upsert correctly (insert and update)", async () => {
       const userData: User = {
         id: "u1",
         name: "Alice",
         age: 25,
-        is_active: true,
+        is_active: true as boolean,
         metadata: null,
       };
 
@@ -220,7 +253,7 @@ describe("MemoryAdapter", () => {
         id: "u1",
         name: "Alice",
         age: 25,
-        is_active: true,
+        is_active: true as boolean,
         metadata: null,
       };
 
@@ -256,7 +289,8 @@ describe("MemoryAdapter", () => {
     });
 
     it("should throw error if primary key is missing in 'create' data", () => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      // Intentionally passing incomplete data to test validation
+      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
       const invalidData = {
         name: "Missing ID",
         age: 20,
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index da39895..5067bdd 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -55,7 +55,6 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
-    // Optimization: Avoid object spread in hot path
     const record = Object.assign({}, data);
     modelStorage.set(pkValue, record);
 
@@ -169,7 +168,6 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     for (const [pk, record] of modelStorage.entries()) {
       const modelRecord = this.asModel<T>(record);
       if (this.evaluateWhere(where, modelRecord)) {
-        // Optimization: Create a new object to avoid mutating internal storage reference
         const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
         return Promise.resolve(this.applySelect(this.asModel(updated)));
@@ -192,7 +190,6 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     for (const [pk, record] of modelStorage.entries()) {
       const modelRecord = this.asModel<T>(record);
       if (where === undefined || this.evaluateWhere(where, modelRecord)) {
-        // Optimization: Create a new object to avoid mutating internal storage reference
         const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
         count++;
@@ -335,7 +332,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return result;
   }
 
-  private setField<T extends RowData, K extends FieldName<T>>(obj: T, key: K, value: unknown): void {
+  private setField<T extends RowData, K extends FieldName<T>>(
+    obj: T,
+    key: K,
+    value: unknown,
+  ): void {
     // Value is either from the record or defaulted to null - both are valid for T[K]
     obj[key] = value as T[K]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index f9b1b04..572de3a 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,4 +1,5 @@
-import type { SQL, TransactionSQL } from "bun";
+import type { SQL } from "bun";
+import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
 
 import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
@@ -13,15 +14,116 @@ import {
   validateJsonPath,
 } from "./common";
 
-function supportsSavepoints(sql: SQL): sql is TransactionSQL {
-  return "savepoint" in sql;
+/**
+ * Internal interface to abstract away the differences between pg and Bun SQL.
+ */
+interface PostgresExecutor {
+  query(sql: string, params: unknown[]): Promise<Record<string, unknown>[]>;
+  transaction<T>(fn: (executor: PostgresExecutor) => Promise<T>): Promise<T>;
+}
+
+export type PostgresDriver = SQL | PgClient | PgPool | PgPoolClient;
+
+/**
+ * Internal interface for Bun SQL.
+ */
+interface BunSQL {
+  unsafe<T>(sql: string, params?: unknown[]): Promise<T>;
+  transaction<T>(fn: (tx: BunSQL) => Promise<T>): Promise<T>;
+}
+
+/**
+ * Standardized way to wrap various Postgres drivers.
+ * All driver-specific logic is localized here.
+ */
+function createExecutor(driver: PostgresDriver): PostgresExecutor {
+  // Bun SQL Sniffing
+  if ("unsafe" in driver && typeof driver.unsafe === "function") {
+    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    const sql = driver as BunSQL;
+    return {
+      query: async (querySql: string, params: unknown[]) => {
+        // Bun's unsafe returns Promise<unknown>, cast to any[] for executor compatibility
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return, typescript-eslint/no-unnecessary-type-assertion
+        return (await sql.unsafe(querySql, params)) as Record<string, unknown>[];
+      },
+      transaction: (fn) => {
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+        return sql.transaction((tx) => fn(createExecutor(tx as PostgresDriver)));
+      },
+    };
+  }
+
+  // pg Pool Sniffing
+  if ("connect" in driver && typeof driver.connect === "function") {
+    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    const pool = driver as PgPool;
+    return {
+      query: async (querySql: string, params: unknown[]) => {
+        const result = await pool.query(querySql, params);
+        // pg's result.rows is any[], cast to proper type
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return
+        return result.rows as Record<string, unknown>[];
+      },
+      transaction: async (fn) => {
+        const client = await pool.connect();
+        try {
+          await client.query("BEGIN");
+          // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+          const result = await fn(createExecutor(client as PostgresDriver));
+          await client.query("COMMIT");
+          return result;
+        } catch (e) {
+          await client.query("ROLLBACK");
+          throw e;
+        } finally {
+          client.release();
+        }
+      },
+    };
+  }
+
+  // pg Client / PoolClient Sniffing
+  if ("query" in driver && typeof driver.query === "function") {
+    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    const client = driver as PgClient | PgPoolClient;
+    return {
+      query: async (querySql: string, params: unknown[]) => {
+        const result = await client.query(querySql, params);
+        // pg's result.rows is any[], cast to proper type
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return
+        return result.rows as Record<string, unknown>[];
+      },
+      transaction: async (fn) => {
+        await client.query("BEGIN");
+        try {
+          // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+          const result = await fn(createExecutor(client as PostgresDriver));
+          await client.query("COMMIT");
+          return result;
+        } catch (e) {
+          await client.query("ROLLBACK");
+          throw e;
+        }
+      },
+    };
+  }
+
+  throw new Error("Unsupported Postgres driver.");
 }
 
 export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private executor: PostgresExecutor;
+
   constructor(
     private schema: S,
-    private sql: SQL,
-  ) {}
+    driver: PostgresDriver,
+  ) {
+    this.executor = createExecutor(driver);
+  }
 
   async migrate(): Promise<void> {
     for (const [name, model] of Object.entries(this.schema)) {
@@ -34,11 +136,10 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         .map((field) => quote(field))
         .join(", ")})`;
 
-      // Postgres can run these one by one without much ceremony, which keeps the
-      // bootstrap logic easy to read and debug.
       // oxlint-disable-next-line eslint/no-await-in-loop
-      await this.sql.unsafe(
+      await this.executor.query(
         `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
+        [],
       );
 
       if (model.indexes === undefined) continue;
@@ -52,8 +153,9 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
           .join(", ");
 
         // oxlint-disable-next-line eslint/no-await-in-loop
-        await this.sql.unsafe(
+        await this.executor.query(
           `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
+          [],
         );
       }
     }
@@ -71,7 +173,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const placeholders = fields.map((_, index) => `$${index + 1}`).join(", ");
     const sql = `INSERT INTO ${quote(model)} (${fields.map((field) => quote(field)).join(", ")}) VALUES (${placeholders}) RETURNING ${this.buildSelect(select)}`;
 
-    const rows = await this.query(sql, values);
+    const rows = await this.executor.query(sql, values);
     const row = rows[0];
     if (row === undefined) {
       throw new Error("Failed to create record.");
@@ -86,7 +188,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, select } = args;
     const builtWhere = this.buildWhere(model, where);
     const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const rows = await this.query(sql, builtWhere.params);
+    const rows = await this.executor.query(sql, builtWhere.params);
     const row = rows[0];
     return row === undefined ? null : this.mapRow(model, row, select);
   }
@@ -134,7 +236,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(offset);
     }
 
-    const rows = await this.query(parts.join(" "), params);
+    const rows = await this.executor.query(parts.join(" "), params);
     return rows.map((row) => this.mapRow(model, row, select));
   }
 
@@ -156,7 +258,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const builtWhere = this.buildWhere(model, where, undefined, undefined, fields.length + 1);
     const sql = `UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql} RETURNING *`;
     const values = [...fields.map((field) => updateData[field]), ...builtWhere.params];
-    const rows = await this.query(sql, values);
+    const rows = await this.executor.query(sql, values);
     const row = rows[0];
     return row === undefined ? null : this.mapRow(model, row);
   }
@@ -185,7 +287,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const rows = await this.query(`${sql} RETURNING 1 as touched`, params);
+    const rows = await this.executor.query(`${sql} RETURNING 1 as touched`, params);
     return rows.length;
   }
 
@@ -236,7 +338,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const sql = `INSERT INTO ${quote(model)} (${createFields.map((field) => quote(field)).join(", ")}) VALUES (${insertPlaceholders}) ON CONFLICT (${conflictTarget}) DO UPDATE SET ${updateClause} RETURNING ${this.buildSelect(select)}`;
-    const rows = await this.query(sql, params);
+    const rows = await this.executor.query(sql, params);
     const row = rows[0];
 
     if (row !== undefined) {
@@ -267,7 +369,10 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       args.model,
       buildIdentityFilter(this.getModel(args.model), existing),
     );
-    await this.query(`DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`, builtWhere.params);
+    await this.executor.query(
+      `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
+      builtWhere.params,
+    );
   }
 
   async deleteMany<
@@ -284,7 +389,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const rows = await this.query(`${sql} RETURNING 1 as touched`, params);
+    const rows = await this.executor.query(`${sql} RETURNING 1 as touched`, params);
     return rows.length;
   }
 
@@ -302,7 +407,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const rows = await this.query(sql, params);
+    const rows = await this.executor.query(sql, params);
     const row = rows[0];
     return isRecord(row) && typeof row["count"] === "number"
       ? row["count"]
@@ -310,19 +415,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    if (supportsSavepoints(this.sql)) {
-      // Nested Postgres transactions become savepoints on the already-reserved
-      // transaction connection.
-      return this.sql.savepoint((savepointSql) => {
-        const txAdapter = new PostgresAdapter(this.schema, savepointSql);
-        return fn(txAdapter);
-      });
-    }
-
-    // Bun SQL already reserves a dedicated connection for the transaction callback,
-    // so unlike SQLite we do not need an extra top-level transaction queue here.
-    return this.sql.transaction((tx) => {
-      const txAdapter = new PostgresAdapter(this.schema, tx);
+    return this.executor.transaction((innerExecutor) => {
+      // Driver is not used in transaction adapter, only executor is injected
+      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript/no-explicit-any
+      const txAdapter = new PostgresAdapter(this.schema, null as unknown as PostgresDriver);
+      txAdapter.executor = innerExecutor;
       return fn(txAdapter);
     });
   }
@@ -335,13 +432,6 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     return modelSpec;
   }
 
-  private query<T extends Record<string, unknown> = Record<string, unknown>>(
-    sql: string,
-    params: unknown[] = [],
-  ): Promise<T[]> {
-    return this.sql.unsafe<T[]>(sql, params);
-  }
-
   private mapFieldType(field: Field): string {
     switch (field.type) {
       case "string":
@@ -354,7 +444,6 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         return "BIGINT";
       case "json":
       case "json[]":
-        // Both logical JSON shapes can live in jsonb; the TS type distinguishes them.
         return "JSONB";
       default:
         return "TEXT";
@@ -369,9 +458,6 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (path === undefined || path.length === 0) {
       return quote(field);
     }
-
-    // For v1, JSON-path sorting is kept simple and text-based. Filtering paths can
-    // still cast based on the comparison value, but sort semantics stay predictable.
     return this.buildColumnExpr(modelName, field, path);
   }
 
@@ -542,12 +628,18 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const expr = this.buildColumnExpr(modelName, where.field as string, where.path, where.value);
     switch (where.op) {
       case "eq":
+        if (where.value === null) {
+          return { sql: `${expr} IS NULL`, params: [], nextIndex: startIndex };
+        }
         return {
           sql: `${expr} = $${startIndex}`,
           params: [where.value],
           nextIndex: startIndex + 1,
         };
       case "ne":
+        if (where.value === null) {
+          return { sql: `${expr} IS NOT NULL`, params: [], nextIndex: startIndex };
+        }
         return {
           sql: `${expr} != $${startIndex}`,
           params: [where.value],
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index a835f34..799f364 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -157,6 +157,68 @@ describe("SqliteAdapter", () => {
       });
       expect(users[0]?.id).toBe("u3");
     });
+
+    it("should filter by null equality (IS NULL)", async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "u4", name: "NullUser", age: 40, is_active: true, metadata: null, tags: null },
+      });
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "metadata", op: "eq", value: null },
+      });
+      // u1, u2, u3 in beforeEach also have metadata: null
+      expect(users.length).toBeGreaterThanOrEqual(1);
+      expect(users.find((u) => u.id === "u4")).toBeDefined();
+    });
+
+    it("should filter by null inequality (IS NOT NULL)", async () => {
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "u5",
+          name: "NotNullUser",
+          age: 40,
+          is_active: true,
+          metadata: { has_data: true },
+          tags: null,
+        },
+      });
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "metadata", op: "ne", value: null },
+      });
+      expect(users.find((u) => u.id === "u5")).toBeDefined();
+      expect(users.find((u) => u.id === "u1")).toBeUndefined();
+    });
+
+    it("should sort records with null values", async () => {
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "sn1",
+          name: "Alice",
+          age: 25,
+          is_active: true,
+          metadata: { theme: "dark" },
+          tags: null,
+        },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "sn2", name: "Bob", age: 30, is_active: true, metadata: null, tags: null },
+      });
+
+      const results = await adapter.findMany({
+        model: "users",
+        where: { field: "id", op: "in", value: ["sn1", "sn2"] },
+        sortBy: [{ field: "metadata", direction: "asc" }],
+      });
+
+      expect(results).toHaveLength(2);
+      expect(results[0]?.["id"]).toBe("sn2"); // null should come first in SQLite ASC
+      expect(results[1]?.["id"]).toBe("sn1");
+    });
   });
 
   describe("JSON Path Filtering", () => {
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 8896417..8fd74dd 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,3 +1,8 @@
+import type { Database as BunDatabase } from "bun:sqlite";
+
+import type { Database as BetterSqlite3Database } from "better-sqlite3";
+import type { Database as SqliteDatabase } from "sqlite";
+
 import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
@@ -14,67 +19,112 @@ import {
 export type SqliteValue = string | number | Uint8Array | null;
 
 /**
- * The standard connection interface the adapter expects.
- * Keeping this narrow lets the adapter work with Bun's sqlite driver
- * and any small compatibility wrapper without adding another abstraction layer.
+ * Clean interface for SQLite execution.
  */
-export interface SqliteDatabase {
+interface SqliteExecutor {
   run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
   get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
   all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
 }
 
-export interface NativeSqliteStatement {
-  run(...params: SqliteValue[]): unknown;
-  get(...params: SqliteValue[]): unknown;
-  all(...params: SqliteValue[]): unknown;
-}
+export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database | SqliteExecutor;
 
-export interface NativeSqliteDriver {
-  // This is a tiny compatibility surface, not a promise to support one specific
-  // external driver package. The adapter only needs `prepare/run/get/all`.
-  prepare(sql: string): NativeSqliteStatement;
+/**
+ * Internal interface for synchronous SQLite drivers.
+ * Both Bun and Better-Sqlite3 expose `prepare` which returns a statement with run/get/all.
+ */
+interface SyncStatement {
+  run(...params: unknown[]): unknown;
+  get(...params: unknown[]): unknown;
+  all(...params: unknown[]): unknown;
 }
 
-export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private db: SqliteDatabase;
-  private savepointCounter = 0;
-  private transactionQueue = Promise.resolve();
-  private isTransaction = false;
+interface SyncDriver {
+  prepare(sql: string): SyncStatement;
+}
 
-  constructor(
-    private schema: S,
-    database: SqliteDatabase | NativeSqliteDriver,
-    _isTransaction = false,
-  ) {
-    this.db = "prepare" in database ? this.wrapNativeDriver(database) : database;
-    this.isTransaction = _isTransaction;
+/**
+ * Helper to wrap synchronous statements and handle casting.
+ * All environment sniffing and "any" usage is localized here.
+ */
+function createExecutor(driver: SqliteDriver): SqliteExecutor {
+  // If it's already an executor, return it
+  if (objIsObject(driver) && "run" in driver && "get" in driver && "all" in driver) {
+    // Already implements SqliteExecutor interface
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return driver as SqliteExecutor;
   }
 
-  private wrapNativeDriver(native: NativeSqliteDriver): SqliteDatabase {
-    // Normalize Bun's synchronous sqlite driver into the tiny async contract used
-    // by the adapter so the rest of the implementation can stay consistent.
+  // Sniff for Sync Drivers (Bun or Better-Sqlite3)
+  const isSync = checkIsSyncDriver(driver);
+
+  if (isSync) {
+    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    const syncDb = driver as SyncDriver;
     return {
       run: (sql, params) => {
-        const stmt = native.prepare(sql);
+        const stmt = syncDb.prepare(sql);
         const result = stmt.run(...params);
-        const changes =
-          isRecord(result) && typeof result["changes"] === "number" ? result["changes"] : 0;
-        return Promise.resolve({ changes });
+        return Promise.resolve({
+          changes:
+            isRecord(result) && typeof result["changes"] === "number" ? result["changes"] : 0,
+        });
       },
       get: (sql, params) => {
-        const stmt = native.prepare(sql);
+        const stmt = syncDb.prepare(sql);
         const row = stmt.get(...params);
         return Promise.resolve(isRecord(row) ? row : null);
       },
       all: (sql, params) => {
-        const stmt = native.prepare(sql);
+        const stmt = syncDb.prepare(sql);
         const rows = stmt.all(...params);
-        return Promise.resolve(Array.isArray(rows) ? rows.filter((item) => isRecord(item)) : []);
+        return Promise.resolve(
+          Array.isArray(rows)
+            ? rows.filter((item): item is Record<string, unknown> => isRecord(item))
+            : [],
+        );
       },
     };
   }
 
+  // Otherwise assume it matches SqliteDatabase (async sqlite driver)
+  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+  return driver as SqliteExecutor;
+}
+
+function objIsObject(obj: unknown): obj is Record<string, unknown> {
+  return obj !== null && typeof obj === "object";
+}
+
+function checkIsSyncDriver(obj: unknown): boolean {
+  if (!objIsObject(obj)) return false;
+  if (!("prepare" in obj) || typeof obj["prepare"] !== "function") return false;
+  const hasAsyncGet = "get" in obj && typeof obj["get"] === "function";
+  if (hasAsyncGet) {
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    const getFn = obj["get"] as { constructor: { name: string } };
+    return getFn.constructor.name !== "AsyncFunction";
+  }
+  return true;
+}
+
+export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private executor: SqliteExecutor;
+  private savepointCounter = 0;
+  // Top-level SQLite transactions on one shared connection must be serialized.
+  private transactionQueue = Promise.resolve();
+  private isTransaction = false;
+
+  constructor(
+    private schema: S,
+    driver: SqliteDriver,
+    _isTransaction = false,
+  ) {
+    this.executor = createExecutor(driver);
+    this.isTransaction = _isTransaction;
+  }
+
   async migrate(): Promise<void> {
     for (const [name, model] of Object.entries(this.schema)) {
       const columns = Object.entries(model.fields).map(([fieldName, field]) => {
@@ -86,10 +136,8 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
         .map((field) => quote(field))
         .join(", ")})`;
 
-      // SQLite schema bootstrap is intentionally sequential.
-      // CREATE INDEX depends on CREATE TABLE and shared connections can lock.
       // oxlint-disable-next-line eslint/no-await-in-loop
-      await this.db.run(
+      await this.executor.run(
         `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
         [],
       );
@@ -105,7 +153,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
           .join(", ");
 
         // oxlint-disable-next-line eslint/no-await-in-loop
-        await this.db.run(
+        await this.executor.run(
           `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
           [],
         );
@@ -123,9 +171,12 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const fields = Object.keys(mappedData);
     const placeholders = fields.map(() => "?").join(", ");
     const columns = fields.map((field) => quote(field)).join(", ");
-    const params = fields.map((field) => mappedData[field] ?? null);
+    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
 
-    await this.db.run(`INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`, params);
+    await this.executor.run(
+      `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`,
+      params,
+    );
 
     const result = await this.find<K, T>({
       model,
@@ -146,7 +197,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, select } = args;
     const builtWhere = this.buildWhere(model, where);
     const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const row = await this.db.get(sql, builtWhere.params);
+    const row = await this.executor.get(sql, builtWhere.params);
     return row === null ? null : this.mapRow(model, row, select);
   }
 
@@ -192,7 +243,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(offset);
     }
 
-    const rows = await this.db.all(parts.join(" "), params);
+    const rows = await this.executor.all(parts.join(" "), params);
     return rows.map((row) => this.mapRow(model, row, select));
   }
 
@@ -216,11 +267,11 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
-    const params = fields.map((field) => mappedData[field] ?? null);
+    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
     const primaryKeyWhere: Where<T> = buildIdentityFilter(modelSpec, existing);
     const builtWhere = this.buildWhere(model, primaryKeyWhere);
 
-    await this.db.run(`UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql}`, [
+    await this.executor.run(`UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql}`, [
       ...params,
       ...builtWhere.params,
     ]);
@@ -243,7 +294,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
-    const params = fields.map((field) => mappedData[field] ?? null);
+    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
     let sql = `UPDATE ${quote(model)} SET ${assignments}`;
 
     if (where !== undefined) {
@@ -252,7 +303,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const result = await this.db.run(sql, params);
+    const result = await this.executor.run(sql, params);
     return result.changes;
   }
 
@@ -289,10 +340,10 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const params =
       updateFields.length > 0
         ? [
-            ...createFields.map((field) => mappedCreate[field] ?? null),
-            ...updateFields.map((field) => mappedUpdate[field] ?? null),
+            ...createFields.map((field) => this.toSqliteValue(mappedCreate[field])),
+            ...updateFields.map((field) => this.toSqliteValue(mappedUpdate[field])),
           ]
-        : createFields.map((field) => mappedCreate[field] ?? null);
+        : createFields.map((field) => this.toSqliteValue(mappedCreate[field]));
 
     if (where !== undefined) {
       const builtWhere = this.buildWhere(model, where);
@@ -300,7 +351,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    await this.db.run(
+    await this.executor.run(
       `INSERT INTO ${quote(model)} (${insertColumns}) VALUES (${insertPlaceholders}) ON CONFLICT(${conflictColumns}) DO UPDATE SET ${updateClause}`,
       params,
     );
@@ -330,7 +381,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       args.model,
       buildIdentityFilter(this.getModel(args.model), existing),
     );
-    await this.db.run(
+    await this.executor.run(
       `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
       builtWhere.params,
     );
@@ -350,7 +401,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const result = await this.db.run(sql, params);
+    const result = await this.executor.run(sql, params);
     return result.changes;
   }
 
@@ -368,24 +419,22 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       params.push(...builtWhere.params);
     }
 
-    const result = await this.db.get(sql, params);
+    const result = await this.executor.get(sql, params);
     return isRecord(result) && typeof result["count"] === "number" ? result["count"] : 0;
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
     if (this.isTransaction) {
-      // Nested transactions stay on the current connection and use savepoints.
-      return this.runSavepoint(this.db, fn);
+      return this.runSavepoint(this.executor, fn);
     }
-
-    // Top-level SQLite transactions on one shared connection must be serialized.
-    return this.withTransactionLock(() => this.runSavepoint(this.db, fn));
+    return this.withTransactionLock(() => this.runSavepoint(this.executor, fn));
   }
 
   private async runSavepoint<T>(
-    db: SqliteDatabase,
+    db: SqliteExecutor,
     fn: (tx: Adapter<S>) => Promise<T>,
   ): Promise<T> {
+    // Nested transactions stay on the current connection and use savepoints.
     const savepoint = quote(`sp_${this.savepointCounter++}`);
     const txAdapter = new SqliteAdapter(this.schema, db, true);
 
@@ -408,8 +457,6 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const previous = this.transactionQueue;
     this.transactionQueue = previous.then(() => current);
 
-    // SQLite uses one connection here, so top-level transactions are serialized.
-    // Nested transactions still work via savepoints on that same connection.
     await previous;
     try {
       return await fn();
@@ -503,8 +550,6 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
       for (let j = 0; j < i; j++) {
         const previous = sortCriteria[j]!;
-        // Lexicographic keyset pagination:
-        // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
         andClauses.push(`${this.buildColumnExpr(modelName, previous.field, previous.path)} = ?`);
         params.push(this.mapWhereValue(cursorValues[previous.field]));
       }
@@ -576,8 +621,14 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     switch (where.op) {
       case "eq":
+        if (where.value === null) {
+          return { sql: `${expr} IS NULL`, params: [] };
+        }
         return { sql: `${expr} = ?`, params: [this.mapWhereValue(where.value)] };
       case "ne":
+        if (where.value === null) {
+          return { sql: `${expr} IS NOT NULL`, params: [] };
+        }
         return { sql: `${expr} != ?`, params: [this.mapWhereValue(where.value)] };
       case "gt":
         return { sql: `${expr} > ?`, params: [this.mapWhereValue(where.value)] };
@@ -611,8 +662,8 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   private mapInput(
     fields: Record<string, Field>,
     data: Record<string, unknown> | Partial<Record<string, unknown>>,
-  ): Record<string, SqliteValue> {
-    const result: Record<string, SqliteValue> = {};
+  ): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
 
     for (const [fieldName, field] of Object.entries(fields)) {
       const value = data[fieldName];
@@ -627,7 +678,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       } else if (field.type === "boolean") {
         result[fieldName] = value === true ? 1 : 0;
       } else {
-        result[fieldName] = this.toSqliteValue(value);
+        result[fieldName] = value;
       }
     }
 
@@ -678,8 +729,13 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   }
 
   private toSqliteValue(value: unknown): SqliteValue {
-    if (typeof value === "string" || typeof value === "number" || value instanceof Uint8Array) {
-      return value;
+    if (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      value instanceof Uint8Array ||
+      value === null
+    ) {
+      return value as SqliteValue;
     }
 
     if (typeof value === "boolean") {
diff --git a/src/types.ts b/src/types.ts
index 441a538..756e30b 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -29,9 +29,13 @@ export interface Index {
 // --- TYPE INFERENCE V1 (#1) ---
 
 export type InferModel<M extends Model> = {
-  [K in keyof M["fields"]]: M["fields"][K]["nullable"] extends true
-    ? ResolveTSValue<M["fields"][K]["type"]> | null
-    : ResolveTSValue<M["fields"][K]["type"]>;
+  [K in keyof M["fields"] as M["fields"][K]["nullable"] extends true ? K : never]?: ResolveTSValue<
+    M["fields"][K]["type"]
+  > | null;
+} & {
+  [K in keyof M["fields"] as M["fields"][K]["nullable"] extends true ? never : K]: ResolveTSValue<
+    M["fields"][K]["type"]
+  >;
 } & Record<string, unknown>;
 
 type ResolveTSValue<T extends FieldType> = T extends "string"
@@ -51,22 +55,43 @@ type ResolveTSValue<T extends FieldType> = T extends "string"
 // --- ADAPTER SPEC V1 (#3) ---
 
 export interface Adapter<S extends Schema = Schema> {
+  /**
+   * Initializes the database schema. Should be idempotent.
+   */
   migrate?(args: { schema: S }): Promise<void>;
 
+  /**
+   * Executes a callback within a database transaction.
+   * Implementation may vary by adapter (e.g., in-memory vs SQL).
+   */
   transaction?<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
 
+  /**
+   * Inserts a new record.
+   * @throws Error if a record with the same primary key already exists.
+   */
   create<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     data: T;
     select?: Select<T>;
   }): Promise<T>;
 
+  /**
+   * Updates a single record matching the mandatory 'where' clause.
+   * Primary key fields in 'data' are forbidden or ignored to prevent identity swaps.
+   * @returns The updated record, or null if no record matched 'where'.
+   */
   update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
     data: Partial<T>;
   }): Promise<T | null>;
 
+  /**
+   * Updates multiple records matching the 'where' clause.
+   * Primary key fields in 'data' are forbidden or ignored.
+   * @returns The number of records updated.
+   */
   updateMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
@@ -76,6 +101,12 @@ export interface Adapter<S extends Schema = Schema> {
     data: Partial<T>;
   }): Promise<number>;
 
+  /**
+   * Atomic insert-or-update.
+   * Uses the primary key extracted from 'create' to check for existence.
+   * If the record exists, 'update' is applied only if it satisfies the optional 'where' predicate.
+   * If the record does not exist, 'create' is applied.
+   */
   upsert?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     create: T;
@@ -84,11 +115,18 @@ export interface Adapter<S extends Schema = Schema> {
     select?: Select<T>;
   }): Promise<T>;
 
+  /**
+   * Deletes a single record matching the 'where' clause.
+   */
   delete<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
   }): Promise<void>;
 
+  /**
+   * Deletes multiple records matching the 'where' clause.
+   * @returns The number of records deleted.
+   */
   deleteMany?<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
@@ -97,12 +135,18 @@ export interface Adapter<S extends Schema = Schema> {
     where?: Where<T>;
   }): Promise<number>;
 
+  /**
+   * Finds the first record matching the 'where' clause.
+   */
   find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where: Where<T>;
     select?: Select<T>;
   }): Promise<T | null>;
 
+  /**
+   * Finds all records matching the 'where' clause with sorting and pagination support.
+   */
   findMany<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;
@@ -113,6 +157,9 @@ export interface Adapter<S extends Schema = Schema> {
     cursor?: Cursor<T>;
   }): Promise<T[]>;
 
+  /**
+   * Returns the count of records matching the 'where' clause.
+   */
   count?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;

From 8029d8071b3c98cd6d89ca4e061b6fdcc0f5f4eb Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Wed, 22 Apr 2026 02:30:11 +0800
Subject: [PATCH 11/24] fix: boolean handling in postgres

---
 src/adapters/common.ts      |   3 +-
 src/adapters/postgres.ts    |  55 ++++--
 src/adapters/sqlite.test.ts | 338 ++++++++++++++++++++++++++++++++++++
 src/adapters/sqlite.ts      |  10 +-
 4 files changed, 389 insertions(+), 17 deletions(-)

diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index d548be2..f3eb9ab 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -23,6 +23,7 @@ export function escapeLiteral(val: string): string {
 // --- Schema & Logic Helpers ---
 
 const JSON_PATH_SEGMENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export const JSON_PATH_INDEX = /^[0-9]+$/;
 
 export function getPrimaryKeyFields(model: Model): string[] {
   return Array.isArray(model.primaryKey) ? model.primaryKey : [model.primaryKey];
@@ -49,7 +50,7 @@ export function getIdentityValues(
 
 export function validateJsonPath(path: string[]): string[] {
   for (const segment of path) {
-    if (!JSON_PATH_SEGMENT.test(segment)) {
+    if (!JSON_PATH_SEGMENT.test(segment) && !JSON_PATH_INDEX.test(segment)) {
       throw new Error(`Invalid JSON path segment: ${segment}`);
     }
   }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 572de3a..430a064 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -626,6 +626,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const expr = this.buildColumnExpr(modelName, where.field as string, where.path, where.value);
+    const mappedValue = this.mapWhereValue(where.value);
     switch (where.op) {
       case "eq":
         if (where.value === null) {
@@ -633,7 +634,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         }
         return {
           sql: `${expr} = $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
       case "ne":
@@ -642,51 +643,55 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         }
         return {
           sql: `${expr} != $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
       case "gt":
         return {
           sql: `${expr} > $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
       case "gte":
         return {
           sql: `${expr} >= $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
       case "lt":
         return {
           sql: `${expr} < $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
       case "lte":
         return {
           sql: `${expr} <= $${startIndex}`,
-          params: [where.value],
+          params: [mappedValue],
           nextIndex: startIndex + 1,
         };
-      case "in":
+      case "in": {
         if (where.value.length === 0) {
           return { sql: "1=0", params: [], nextIndex: startIndex };
         }
+        const inValues = where.value.map((v) => this.mapWhereValue(v));
         return {
           sql: `${expr} IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
-          params: where.value,
+          params: inValues,
           nextIndex: startIndex + where.value.length,
         };
-      case "not_in":
+      }
+      case "not_in": {
         if (where.value.length === 0) {
           return { sql: "1=1", params: [], nextIndex: startIndex };
         }
+        const notInValues = where.value.map((v) => this.mapWhereValue(v));
         return {
           sql: `${expr} NOT IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
-          params: where.value,
+          params: notInValues,
           nextIndex: startIndex + where.value.length,
         };
+      }
       default:
         throw new Error(`Unsupported operator: ${(where as { op: string }).op}`);
     }
@@ -698,15 +703,35 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   ): Record<string, unknown> {
     const result: Record<string, unknown> = {};
 
-    for (const [fieldName] of Object.entries(fields)) {
+    for (const [fieldName, field] of Object.entries(fields)) {
       const value = data[fieldName];
       if (value === undefined) continue;
-      result[fieldName] = value;
+      if (value === null) {
+        result[fieldName] = null;
+        continue;
+      }
+
+      if (field.type === "json" || field.type === "json[]") {
+        result[fieldName] = value;
+      } else if (field.type === "boolean") {
+        result[fieldName] = value === true;
+      } else {
+        result[fieldName] = value;
+      }
     }
 
     return result;
   }
 
+  private mapWhereValue(value: unknown): unknown {
+    if (value === null) return null;
+    if (typeof value === "boolean") return value;
+    if (typeof value === "object" && value !== null) {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+
   private mapRow<K extends keyof S & string, T extends Record<string, unknown>>(
     model: K,
     row: Record<string, unknown>,
@@ -726,7 +751,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         continue;
       }
 
-      if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
+      if (fieldSpec.type === "json" || fieldSpec.type === "json[]") {
+        output[fieldName] = typeof value === "string" ? JSON.parse(value) : value;
+      } else if (fieldSpec.type === "boolean") {
+        output[fieldName] = value === true || value === 1;
+      } else if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
         output[fieldName] = mapNumeric(value);
       } else {
         output[fieldName] = value;
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 799f364..463c396 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -452,6 +452,344 @@ describe("SqliteAdapter", () => {
     });
   });
 
+  describe("Boolean Filtering", () => {
+    beforeEach(async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "b1", name: "Active1", age: 20, is_active: true, metadata: null, tags: null },
+      });
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "b2",
+          name: "Inactive1",
+          age: 20,
+          is_active: false,
+          metadata: null,
+          tags: null,
+        },
+      });
+      await adapter.create({
+        model: "users",
+        data: { id: "b3", name: "Active2", age: 30, is_active: true, metadata: null, tags: null },
+      });
+    });
+
+    it("should filter by boolean eq true", async () => {
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "is_active", op: "eq", value: true },
+      });
+      expect(users).toHaveLength(2);
+      // oxlint-disable-next-line unicorn/no-array-sort
+      expect(users.map((u) => u["id"]).sort()).toEqual(["b1", "b3"]);
+    });
+
+    it("should filter by boolean eq false", async () => {
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "is_active", op: "eq", value: false },
+      });
+      expect(users).toHaveLength(1);
+      expect(users[0]?.["id"]).toBe("b2");
+    });
+
+    it("should filter by boolean in list", async () => {
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "is_active", op: "in", value: [true] },
+      });
+      expect(users).toHaveLength(2);
+    });
+  });
+
+  describe("Count", () => {
+    beforeEach(async () => {
+      await Promise.all([
+        adapter.create({
+          model: "users",
+          data: { id: "c1", name: "Alice", age: 25, is_active: true, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "c2", name: "Bob", age: 30, is_active: false, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "c3", name: "Charlie", age: 35, is_active: true, metadata: null, tags: null },
+        }),
+      ]);
+    });
+
+    it("should count all records", async () => {
+      const count = await adapter.count({ model: "users" });
+      expect(count).toBe(3);
+    });
+
+    it("should count with where clause", async () => {
+      const count = await adapter.count({
+        model: "users",
+        where: { field: "is_active", op: "eq", value: true },
+      });
+      expect(count).toBe(2);
+    });
+
+    it("should count with complex where clause", async () => {
+      const count = await adapter.count({
+        model: "users",
+        where: {
+          and: [
+            { field: "age", op: "gte", value: 30 },
+            { field: "is_active", op: "eq", value: true },
+          ],
+        },
+      });
+      expect(count).toBe(1);
+    });
+
+    it("should count with no matches", async () => {
+      const count = await adapter.count({
+        model: "users",
+        where: { field: "age", op: "gt", value: 100 },
+      });
+      expect(count).toBe(0);
+    });
+  });
+
+  describe("DeleteMany", () => {
+    beforeEach(async () => {
+      await Promise.all([
+        adapter.create({
+          model: "users",
+          data: { id: "d1", name: "Alice", age: 25, is_active: true, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "d2", name: "Bob", age: 30, is_active: false, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "d3", name: "Charlie", age: 35, is_active: true, metadata: null, tags: null },
+        }),
+      ]);
+    });
+
+    it("should delete all records with no where clause", async () => {
+      const deleted = await adapter.deleteMany({ model: "users" });
+      expect(deleted).toBe(3);
+      const count = await adapter.count({ model: "users" });
+      expect(count).toBe(0);
+    });
+
+    it("should delete matching records", async () => {
+      const deleted = await adapter.deleteMany({
+        model: "users",
+        where: { field: "is_active", op: "eq", value: true },
+      });
+      expect(deleted).toBe(2);
+      const remaining = await adapter.findMany({ model: "users" });
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0]?.id).toBe("d2");
+    });
+
+    it("should return 0 when no matches", async () => {
+      const deleted = await adapter.deleteMany({
+        model: "users",
+        where: { field: "age", op: "gt", value: 100 },
+      });
+      expect(deleted).toBe(0);
+    });
+  });
+
+  describe("UpdateMany", () => {
+    beforeEach(async () => {
+      await Promise.all([
+        adapter.create({
+          model: "users",
+          data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null, tags: null },
+        }),
+        adapter.create({
+          model: "users",
+          data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null, tags: null },
+        }),
+      ]);
+    });
+
+    it("should update all records with no where clause", async () => {
+      const updated = await adapter.updateMany({
+        model: "users",
+        data: { age: 99 },
+      });
+      expect(updated).toBe(3);
+      const users = await adapter.findMany({ model: "users" });
+      expect(users.every((u) => u.age === 99)).toBe(true);
+    });
+
+    it("should update matching records", async () => {
+      const updated = await adapter.updateMany<"users", User>({
+        model: "users",
+        where: { field: "is_active", op: "eq", value: true },
+        data: { age: 100 },
+      });
+      expect(updated).toBe(2);
+      const users = await adapter.findMany({ model: "users" });
+      const actives = users.filter((u) => u["is_active"]);
+      const inactive = users.find((u) => !u["is_active"]);
+      expect(actives.every((u) => u["age"] === 100)).toBe(true);
+      expect(inactive?.["age"]).toBe(30);
+    });
+
+    it("should return 0 when no matches", async () => {
+      const updated = await adapter.updateMany({
+        model: "users",
+        where: { field: "age", op: "gt", value: 100 },
+        data: { age: 0 },
+      });
+      expect(updated).toBe(0);
+    });
+
+    it("should do nothing with empty data", async () => {
+      const updated = await adapter.updateMany({
+        model: "users",
+        where: { field: "id", op: "eq", value: "u1" },
+        data: {},
+      });
+      expect(updated).toBe(0);
+    });
+  });
+
+  describe("Migration Idempotency", () => {
+    it("should be idempotent when running migrate twice", async () => {
+      await adapter.migrate();
+      await adapter.migrate();
+      const count = await adapter.count({ model: "users" });
+      expect(count).toBe(0);
+    });
+
+    it("should preserve data when running migrate twice", async () => {
+      await adapter.create({
+        model: "users",
+        data: { id: "m1", name: "Test", age: 20, is_active: true, metadata: null, tags: null },
+      });
+      await adapter.migrate();
+      await adapter.migrate();
+      const found = await adapter.find({
+        model: "users",
+        where: { field: "id", op: "eq", value: "m1" },
+      });
+      expect(found?.["name"]).toBe("Test");
+    });
+  });
+
+  describe("Composite Primary Key", () => {
+    const compositeSchema = {
+      order_items: {
+        fields: {
+          order_id: { type: "string" },
+          item_id: { type: "string" },
+          quantity: { type: "number" },
+          price: { type: "number" },
+        },
+        primaryKey: ["order_id", "item_id"],
+      },
+    } satisfies Schema;
+
+    type OrderItem = { order_id: string; item_id: string; quantity: number; price: number };
+
+    it("should handle composite primary key operations", async () => {
+      const compAdapter = new SqliteAdapter(compositeSchema, db);
+      await compAdapter.migrate();
+
+      await compAdapter.create<"order_items", OrderItem>({
+        model: "order_items",
+        data: { order_id: "o1", item_id: "i1", quantity: 2, price: 10 },
+      });
+
+      const found = await compAdapter.find<"order_items", OrderItem>({
+        model: "order_items",
+        where: { field: "order_id", op: "eq", value: "o1" },
+      });
+      expect(found?.["quantity"]).toBe(2);
+
+      await compAdapter.update<"order_items", OrderItem>({
+        model: "order_items",
+        where: { field: "order_id", op: "eq", value: "o1" },
+        data: { quantity: 5 },
+      });
+
+      const updated = await compAdapter.find<"order_items", OrderItem>({
+        model: "order_items",
+        where: { field: "order_id", op: "eq", value: "o1" },
+      });
+      expect(updated?.["quantity"]).toBe(5);
+    });
+  });
+
+  describe("JSON Array Filtering", () => {
+    it("should filter by json array field", async () => {
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "j1",
+          name: "User1",
+          age: 20,
+          is_active: true,
+          metadata: null,
+          tags: ["admin", "vip"],
+        },
+      });
+      await adapter.create({
+        model: "users",
+        data: {
+          id: "j2",
+          name: "User2",
+          age: 20,
+          is_active: true,
+          metadata: null,
+          tags: ["user"],
+        },
+      });
+
+      const users = await adapter.findMany<"users", User>({
+        model: "users",
+        where: { field: "tags", path: ["0"], op: "eq", value: "admin" },
+      });
+      expect(users).toHaveLength(1);
+      expect(users[0]?.["id"]).toBe("j1");
+    });
+  });
+
+  describe("Minimal Schema Model", () => {
+    const minimalSchema = {
+      minimal_table: {
+        fields: {
+          id: { type: "string" },
+        },
+        primaryKey: "id",
+      },
+    } satisfies Schema;
+
+    it("should handle minimal model with single field", async () => {
+      const minAdapter = new SqliteAdapter(minimalSchema, db);
+      await minAdapter.migrate();
+
+      await minAdapter.create({
+        model: "minimal_table",
+        data: { id: "e1" },
+      });
+
+      const found = await minAdapter.find({
+        model: "minimal_table",
+        where: { field: "id", op: "eq", value: "e1" },
+      });
+      expect(found?.["id"]).toBe("e1");
+    });
+  });
+
   describe("Upsert", () => {
     it("should handle upsert correctly", async () => {
       const data: User = {
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 8fd74dd..84e7a2a 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -7,10 +7,10 @@ import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where
 import {
   assertNoPrimaryKeyUpdates,
   buildIdentityFilter,
-  escapeLiteral,
   getIdentityValues,
   getPrimaryKeyFields,
   isRecord,
+  JSON_PATH_INDEX,
   mapNumeric,
   quote,
   validateJsonPath,
@@ -506,8 +506,12 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       throw new Error(`Cannot use JSON path on non-JSON field: ${field}`);
     }
 
-    const jsonPath = `$.${validateJsonPath(path).join(".")}`;
-    return `json_extract(${quote(field)}, '${escapeLiteral(jsonPath)}')`;
+    const jsonPath =
+      "$" +
+      validateJsonPath(path)
+        .map((segment) => (JSON_PATH_INDEX.test(segment) ? `[${segment}]` : `.${segment}`))
+        .join("");
+    return `json_extract(${quote(field)}, '${jsonPath}')`;
   }
 
   private buildCursor<T>(

From aad2a7436a5d6dc508bb912dadc1c82067ff1f11 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Wed, 22 Apr 2026 02:51:43 +0800
Subject: [PATCH 12/24] docs: update README.md

---
 README.md | 110 +++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 88 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 15ae14b..1797d45 100644
--- a/README.md
+++ b/README.md
@@ -76,9 +76,10 @@ const adapter = new MemoryAdapter(schema);
 await adapter.migrate({ schema });
 ```
 
-## Basic Operations
+## CRUD
 
 ```ts
+// Create
 const created = await adapter.create<"users", User>({
   model: "users",
   data: {
@@ -92,22 +93,76 @@ const created = await adapter.create<"users", User>({
   },
 });
 
+// Find one
 const found = await adapter.find<"users", User>({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
 });
 
-const recentUsers = await adapter.findMany<"users", User>({
+// Find many
+const users = await adapter.findMany<"users", User>({
   model: "users",
   where: { field: "is_active", op: "eq", value: true },
   sortBy: [{ field: "created_at", direction: "desc" }],
   limit: 20,
 });
+
+// Update
+const updated = await adapter.update<"users", User>({
+  model: "users",
+  where: { field: "id", op: "eq", value: "u1" },
+  data: { age: 31 },
+});
+
+// Delete
+await adapter.delete<"users", User>({
+  model: "users",
+  where: { field: "id", op: "eq", value: "u1" },
+});
+
+// Count
+const total = await adapter.count<"users", User>({
+  model: "users",
+  where: { field: "is_active", op: "eq", value: true },
+});
+
+// Upsert - insert or update by primary key
+const user = await adapter.upsert<"users", User>({
+  model: "users",
+  create: { id: "u1", name: "Alice", age: 30, is_active: true, created_at: Date.now() },
+  update: { age: 31 },
+  // Optional: only update if predicate is met
+  where: { field: "is_active", op: "eq", value: true },
+});
 ```
 
-## JSON Path Filters
+## Filtering
 
-Nested JSON filters use the base field plus a `path` array:
+All operations accept a `where` clause:
+
+```ts
+// Operators
+where: { field: "age", op: "eq", value: 30 }
+where: { field: "age", op: "ne", value: null }
+where: { field: "age", op: "gt", value: 18 }
+where: { field: "age", op: "gte", value: 18 }
+where: { field: "age", op: "lt", value: 65 }
+where: { field: "age", op: "lte", value: 65 }
+where: { field: "status", op: "in", value: ["active", "pending"] }
+where: { field: "status", op: "not_in", value: ["banned"] }
+
+// Combine with and/or
+where: {
+  and: [
+    { field: "age", op: "gte", value: 18 },
+    { field: "is_active", op: "eq", value: true },
+  ],
+}
+```
+
+## JSON Paths
+
+Filter nested JSON fields using `path`:
 
 ```ts
 const darkUsers = await adapter.findMany<"users", User>({
@@ -121,8 +176,27 @@ const darkUsers = await adapter.findMany<"users", User>({
 });
 ```
 
-Path segments are intentionally restricted to simple identifiers so adapters can
-compile them safely for each backend.
+## Pagination
+
+```ts
+// Offset pagination
+const page = await adapter.findMany<"users", User>({
+  model: "users",
+  sortBy: [{ field: "created_at", direction: "desc" }],
+  limit: 20,
+  offset: 40,
+});
+
+// Cursor pagination (keyset)
+const cursorPage = await adapter.findMany<"users", User>({
+  model: "users",
+  sortBy: [{ field: "created_at", direction: "desc" }],
+  limit: 20,
+  cursor: {
+    after: { created_at: 1699900000000, id: "u20" },
+  },
+});
+```
 
 ## Transactions
 
@@ -130,15 +204,7 @@ compile them safely for each backend.
 await adapter.transaction(async (tx) => {
   await tx.create({
     model: "users",
-    data: {
-      id: "u2",
-      name: "Bob",
-      age: 28,
-      is_active: true,
-      metadata: null,
-      tags: null,
-      created_at: Date.now(),
-    },
+    data: { id: "u2", name: "Bob", age: 28, is_active: true, created_at: Date.now() },
   });
 
   await tx.update({
@@ -149,16 +215,16 @@ await adapter.transaction(async (tx) => {
 });
 ```
 
-SQLite and Postgres both support nested transactions through savepoints.
+SQLite and Postgres support nested transactions via savepoints.
 
 ## Notes
 
-- `upsert` in v1 always conflicts on the **Primary Key**. Identity is inferred automatically from the `create` data.
-- The optional `where` clause in `upsert` acts as a **predicate** for the update: the record is only updated if the condition is met.
-- Primary-key updates are rejected to keep adapter behavior simple and consistent across backends.
-- SQLite stores JSON as text; Postgres stores JSON as `jsonb`.
-- **Numeric Precision**: `number` and `timestamp` fields use standard JavaScript `Number`. `bigint` is intentionally not supported in v1 to keep the core and adapters tiny.
+- `upsert` always conflicts on the Primary Key
+- Optional `where` in `upsert` acts as a predicate — record is only updated if condition is met
+- Primary-key updates are rejected to keep adapter behavior consistent
+- SQLite stores JSON as text; Postgres stores JSON as `jsonb`
+- `number` and `timestamp` use standard JavaScript `Number`. `bigint` is not supported in v1.
 
 ## License
 
-MIT
+MIT
\ No newline at end of file

From ca8e08f1c0d6af8eaf49cdc50d8cd6258a40b529 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Wed, 22 Apr 2026 03:14:20 +0800
Subject: [PATCH 13/24] refactor: clean up some disable comments

---
 README.md                |  2 +-
 src/adapters/postgres.ts | 49 ++++++++++++++++++++++++----------------
 src/adapters/sqlite.ts   | 34 +++++++++++++++-------------
 3 files changed, 48 insertions(+), 37 deletions(-)

diff --git a/README.md b/README.md
index 1797d45..53a017a 100644
--- a/README.md
+++ b/README.md
@@ -227,4 +227,4 @@ SQLite and Postgres support nested transactions via savepoints.
 
 ## License
 
-MIT
\ No newline at end of file
+MIT
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 430a064..fdc2bf7 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -32,46 +32,57 @@ interface BunSQL {
   transaction<T>(fn: (tx: BunSQL) => Promise<T>): Promise<T>;
 }
 
+function isBunSQL(obj: unknown): obj is BunSQL {
+  return objIsObject(obj) && "unsafe" in obj && typeof obj["unsafe"] === "function";
+}
+
+function isPgPool(obj: unknown): obj is PgPool {
+  return objIsObject(obj) && "connect" in obj && typeof obj["connect"] === "function";
+}
+
+function isPgClient(obj: unknown): obj is PgClient {
+  return (
+    objIsObject(obj) && "query" in obj && typeof obj["query"] === "function" && "release" in obj
+  );
+}
+
+function objIsObject(obj: unknown): obj is Record<string, unknown> {
+  return obj !== null && typeof obj === "object";
+}
+
 /**
  * Standardized way to wrap various Postgres drivers.
  * All driver-specific logic is localized here.
  */
 function createExecutor(driver: PostgresDriver): PostgresExecutor {
   // Bun SQL Sniffing
-  if ("unsafe" in driver && typeof driver.unsafe === "function") {
-    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    const sql = driver as BunSQL;
+  if (isBunSQL(driver)) {
+    const sql = driver;
     return {
-      query: async (querySql: string, params: unknown[]) => {
-        // Bun's unsafe returns Promise<unknown>, cast to any[] for executor compatibility
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return, typescript-eslint/no-unnecessary-type-assertion
-        return (await sql.unsafe(querySql, params)) as Record<string, unknown>[];
+      query: async (querySql, params) => {
+        const rows = await sql.unsafe<Record<string, unknown>[]>(querySql, params);
+        return rows;
       },
       transaction: (fn) => {
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
         return sql.transaction((tx) => fn(createExecutor(tx as PostgresDriver)));
       },
     };
   }
 
   // pg Pool Sniffing
-  if ("connect" in driver && typeof driver.connect === "function") {
-    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    const pool = driver as PgPool;
+  if (isPgPool(driver)) {
+    const pool = driver;
     return {
       query: async (querySql: string, params: unknown[]) => {
         const result = await pool.query(querySql, params);
         // pg's result.rows is any[], cast to proper type
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
         return result.rows as Record<string, unknown>[];
       },
       transaction: async (fn) => {
         const client = await pool.connect();
         try {
           await client.query("BEGIN");
-          // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
           const result = await fn(createExecutor(client as PostgresDriver));
           await client.query("COMMIT");
           return result;
@@ -86,15 +97,13 @@ function createExecutor(driver: PostgresDriver): PostgresExecutor {
   }
 
   // pg Client / PoolClient Sniffing
-  if ("query" in driver && typeof driver.query === "function") {
-    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    const client = driver as PgClient | PgPoolClient;
+  if (isPgClient(driver)) {
+    const client = driver;
     return {
       query: async (querySql: string, params: unknown[]) => {
         const result = await client.query(querySql, params);
         // pg's result.rows is any[], cast to proper type
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
         return result.rows as Record<string, unknown>[];
       },
       transaction: async (fn) => {
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 84e7a2a..2bffa4a 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -49,19 +49,13 @@ interface SyncDriver {
  */
 function createExecutor(driver: SqliteDriver): SqliteExecutor {
   // If it's already an executor, return it
-  if (objIsObject(driver) && "run" in driver && "get" in driver && "all" in driver) {
-    // Already implements SqliteExecutor interface
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    return driver as SqliteExecutor;
+  if (isSqliteExecutor(driver)) {
+    return driver;
   }
 
   // Sniff for Sync Drivers (Bun or Better-Sqlite3)
-  const isSync = checkIsSyncDriver(driver);
-
-  if (isSync) {
-    // Duck-typing check: runtime inspection cannot narrow TypeScript union types
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    const syncDb = driver as SyncDriver;
+  if (isSyncDriver(driver)) {
+    const syncDb = driver as SyncDriver & (BunDatabase | BetterSqlite3Database);
     return {
       run: (sql, params) => {
         const stmt = syncDb.prepare(sql);
@@ -89,6 +83,7 @@ function createExecutor(driver: SqliteDriver): SqliteExecutor {
   }
 
   // Otherwise assume it matches SqliteDatabase (async sqlite driver)
+  // Intentional assertion: ruled out executor and sync driver, remaining union member is SqliteDatabase
   // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
   return driver as SqliteExecutor;
 }
@@ -97,14 +92,21 @@ function objIsObject(obj: unknown): obj is Record<string, unknown> {
   return obj !== null && typeof obj === "object";
 }
 
-function checkIsSyncDriver(obj: unknown): boolean {
+function isSqliteExecutor(obj: unknown): obj is SqliteExecutor {
+  return objIsObject(obj) && "run" in obj && "get" in obj && "all" in obj;
+}
+
+function hasNonAsyncGetter(obj: Record<string, unknown>): boolean {
+  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+  const getFn = obj["get"] as { constructor: { name: string } };
+  return getFn.constructor.name !== "AsyncFunction";
+}
+
+function isSyncDriver(obj: unknown): obj is SyncDriver {
   if (!objIsObject(obj)) return false;
   if (!("prepare" in obj) || typeof obj["prepare"] !== "function") return false;
-  const hasAsyncGet = "get" in obj && typeof obj["get"] === "function";
-  if (hasAsyncGet) {
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    const getFn = obj["get"] as { constructor: { name: string } };
-    return getFn.constructor.name !== "AsyncFunction";
+  if ("get" in obj && typeof obj["get"] === "function") {
+    return hasNonAsyncGetter(obj);
   }
   return true;
 }

From 6ce209d4e4cd393213bd212dd4cf5e38facc1f1e Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Wed, 22 Apr 2026 14:07:34 +0800
Subject: [PATCH 14/24] fix: address H comments

---
 README.md                |  10 +-
 bun.lock                 |   4 +
 package.json             |   8 +
 src/adapters/common.ts   |  42 ++-
 src/adapters/memory.ts   | 398 ++++++++++----------
 src/adapters/postgres.ts | 788 +--------------------------------------
 src/adapters/sql.ts      | 627 +++++++++++++++++++++++++++++++
 src/adapters/sqlite.ts   | 754 +------------------------------------
 src/dialects/postgres.ts | 195 ++++++++++
 src/dialects/sqlite.ts   | 109 ++++++
 src/dialects/types.ts    |   8 +
 11 files changed, 1212 insertions(+), 1731 deletions(-)
 create mode 100644 src/adapters/sql.ts
 create mode 100644 src/dialects/postgres.ts
 create mode 100644 src/dialects/sqlite.ts
 create mode 100644 src/dialects/types.ts

diff --git a/README.md b/README.md
index 53a017a..dfc6487 100644
--- a/README.md
+++ b/README.md
@@ -57,11 +57,13 @@ await adapter.migrate();
 
 ### Postgres
 
+Supports `pg`, `postgres.js`, and Bun SQL.
+
 ```ts
-import { SQL } from "bun";
+import postgres from "postgres"; // or import { Pool } from "pg"
 import { PostgresAdapter } from "@8monkey/no-orm/adapters/postgres";
 
-const sql = new SQL(process.env.POSTGRES_URL!);
+const sql = postgres(process.env.POSTGRES_URL!);
 const adapter = new PostgresAdapter(schema, sql);
 
 await adapter.migrate();
@@ -72,8 +74,8 @@ await adapter.migrate();
 ```ts
 import { MemoryAdapter } from "@8monkey/no-orm/adapters/memory";
 
-const adapter = new MemoryAdapter(schema);
-await adapter.migrate({ schema });
+const adapter = new MemoryAdapter(schema, { maxSize: 100 });
+await adapter.migrate();
 ```
 
 ## CRUD
diff --git a/bun.lock b/bun.lock
index e31e194..52b1389 100644
--- a/bun.lock
+++ b/bun.lock
@@ -16,13 +16,17 @@
       },
       "peerDependencies": {
         "better-sqlite3": "^11.0.0",
+        "lru-cache": "^11.0.0",
         "pg": "^8.0.0",
+        "postgres": "^3.4.0",
         "sqlite": "^5.0.0",
         "sqlite3": "^5.0.0",
       },
       "optionalPeers": [
         "better-sqlite3",
+        "lru-cache",
         "pg",
+        "postgres",
         "sqlite",
         "sqlite3",
       ],
diff --git a/package.json b/package.json
index 2752b7d..d86ecbb 100644
--- a/package.json
+++ b/package.json
@@ -72,7 +72,9 @@
   },
   "peerDependencies": {
     "better-sqlite3": "^11.0.0",
+    "lru-cache": "^11.0.0",
     "pg": "^8.0.0",
+    "postgres": "^3.4.0",
     "sqlite": "^5.0.0",
     "sqlite3": "^5.0.0"
   },
@@ -80,9 +82,15 @@
     "better-sqlite3": {
       "optional": true
     },
+    "lru-cache": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     },
+    "postgres": {
+      "optional": true
+    },
     "sqlite": {
       "optional": true
     },
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index f3eb9ab..7e0b166 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -22,9 +22,6 @@ export function escapeLiteral(val: string): string {
 
 // --- Schema & Logic Helpers ---
 
-const JSON_PATH_SEGMENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
-export const JSON_PATH_INDEX = /^[0-9]+$/;
-
 export function getPrimaryKeyFields(model: Model): string[] {
   return Array.isArray(model.primaryKey) ? model.primaryKey : [model.primaryKey];
 }
@@ -38,7 +35,8 @@ export function getIdentityValues(
 ): Record<string, unknown> {
   const pkFields = getPrimaryKeyFields(model);
   const values: Record<string, unknown> = {};
-  for (const field of pkFields) {
+  for (let i = 0; i < pkFields.length; i++) {
+    const field = pkFields[i]!;
     const val = data[field];
     if (val === undefined) {
       throw new Error(`Missing primary key field: ${field}`);
@@ -49,9 +47,17 @@ export function getIdentityValues(
 }
 
 export function validateJsonPath(path: string[]): string[] {
-  for (const segment of path) {
-    if (!JSON_PATH_SEGMENT.test(segment) && !JSON_PATH_INDEX.test(segment)) {
-      throw new Error(`Invalid JSON path segment: ${segment}`);
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i]!;
+    // Faster validation without regex
+    for (let j = 0; j < segment.length; j++) {
+      const c = segment.codePointAt(j);
+      const isAlpha = (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+      const isDigit = c >= 48 && c <= 57;
+      const isUnderscore = c === 95;
+      if (!isAlpha && !isDigit && !isUnderscore) {
+        throw new Error(`Invalid JSON path segment: ${segment}`);
+      }
     }
   }
   return path;
@@ -65,16 +71,15 @@ export function buildIdentityFilter<T extends Record<string, unknown>>(
   source: Record<string, unknown>,
 ): Where<T> {
   const pkFields = getPrimaryKeyFields(model);
-  const clauses = pkFields.map((field) => {
-    // field is string from getPrimaryKeyFields, narrowing to FieldName<T> is safe
-    const fieldName = field as FieldName<T>; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-    const leaf: Where<T> = {
-      field: fieldName,
+  const clauses: Where<T>[] = [];
+  for (let i = 0; i < pkFields.length; i++) {
+    const field = pkFields[i]!;
+    clauses.push({
+      field: field as FieldName<T>,
       op: "eq" as const,
       value: source[field],
-    };
-    return leaf;
-  });
+    });
+  }
 
   if (clauses.length === 1) {
     return clauses[0]!;
@@ -87,10 +92,10 @@ export function assertNoPrimaryKeyUpdates(
   model: Model,
   data: Partial<Record<string, unknown>>,
 ): void {
-  for (const field of getPrimaryKeyFields(model)) {
+  const pkFields = getPrimaryKeyFields(model);
+  for (let i = 0; i < pkFields.length; i++) {
+    const field = pkFields[i]!;
     if (data[field] !== undefined) {
-      // Primary-key rewrites are intentionally out of scope for v1 because they
-      // complicate refetch, conflict handling, and adapter parity.
       throw new Error("Primary key updates are not supported.");
     }
   }
@@ -98,7 +103,6 @@ export function assertNoPrimaryKeyUpdates(
 
 /**
  * Maps database numeric values to JS numbers.
- * Note: bigint is intentionally not supported in v1 to keep the core tiny.
  */
 export function mapNumeric(value: unknown): number | null {
   return value === null || value === undefined ? null : Number(value);
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 5067bdd..922113d 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -13,40 +13,57 @@ import {
   getIdentityValues,
   getPrimaryKeyFields,
   isRecord,
+  mapNumeric,
 } from "./common";
 
 type Comparable = string | number;
 type RowData = Record<string, unknown>;
 
-/**
- * A zero-dependency, in-memory implementation of the no-orm Adapter interface.
- * Useful for testing, development, and small-scale caching.
- */
-export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<string, Map<string, RowData>>();
+let LRU: any;
+const lruPromise = import("lru-cache")
+  .then((m) => {
+    LRU = m.LRUCache;
+  })
+  .catch(() => {});
+
+export interface MemoryAdapterOptions {
+  maxSize?: number;
+}
 
-  constructor(private schema: S) {}
+export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private storage = new Map<string, any>();
+  private options: MemoryAdapterOptions;
+
+  constructor(
+    private schema: S,
+    options: MemoryAdapterOptions = {},
+  ) {
+    this.options = options;
+  }
 
-  migrate(_args: { schema: S }): Promise<void> {
-    for (const name of Object.keys(this.schema)) {
+  async migrate(): Promise<void> {
+    await lruPromise;
+    const keys = Object.keys(this.schema);
+    for (let i = 0; i < keys.length; i++) {
+      const name = keys[i]!;
       if (!this.storage.has(name)) {
-        this.storage.set(name, new Map());
+        if (this.options.maxSize && LRU) {
+          this.storage.set(name, new LRU({ max: this.options.maxSize }));
+        } else {
+          this.storage.set(name, new Map());
+        }
       }
     }
-    return Promise.resolve();
   }
 
-  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    // Basic execution for V1. In-memory snapshots for true isolation
-    // are deferred to future versions.
+  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
     return fn(this);
   }
 
-  create<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    data: T;
-    select?: Select<T>;
-  }): Promise<T> {
+  async create<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
     const { model, data, select } = args;
     const modelStorage = this.getModelStorage(model);
     const pkValue = this.getPrimaryKeyString(model, data);
@@ -58,28 +75,31 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const record = Object.assign({}, data);
     modelStorage.set(pkValue, record);
 
-    return Promise.resolve(this.applySelect(this.asModel(record), select));
+    return this.applySelect(record as any, select);
   }
 
-  find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    select?: Select<T>;
-  }): Promise<T | null> {
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
     const { model, where, select } = args;
     const modelStorage = this.getModelStorage(model);
 
-    for (const record of modelStorage.values()) {
-      const modelRecord = this.asModel<T>(record);
-      if (this.evaluateWhere(where, modelRecord)) {
-        return Promise.resolve(this.applySelect(modelRecord, select));
+    const values = Array.from(modelStorage.values());
+    for (let i = 0; i < values.length; i++) {
+      const record = values[i] as T;
+      if (this.evaluateWhere(where, record)) {
+        return this.applySelect(record, select);
       }
     }
 
-    return Promise.resolve(null);
+    return null;
   }
 
-  findMany<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+  async findMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
     where?: Where<T>;
     select?: Select<T>;
@@ -91,93 +111,106 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, select, sortBy, limit, offset, cursor } = args;
     const modelStorage = this.getModelStorage(model);
 
-    let results = Array.from(modelStorage.values()).map((r) => this.asModel<T>(r));
-
-    if (where) {
-      results = results.filter((record) => this.evaluateWhere(where, record));
+    let results: T[] = [];
+    const rawValues = Array.from(modelStorage.values());
+    for (let i = 0; i < rawValues.length; i++) {
+      const record = rawValues[i] as T;
+      if (!where || this.evaluateWhere(where, record)) {
+        results.push(record);
+      }
     }
 
     if (cursor) {
-      const cursorValues = cursor.after;
-      const sortCriteria =
-        sortBy !== undefined && sortBy.length > 0
-          ? sortBy
-              .filter((sort) => cursorValues[sort.field] !== undefined)
-              .map((sort) => ({
-                field: sort.field,
-                direction: sort.direction ?? "asc",
-                path: sort.path,
-              }))
-          : this.getFieldNames(cursor.after).map((field) => ({
-              field,
-              direction: "asc" as const,
-              path: undefined,
-            }));
-
-      if (sortCriteria.length > 0) {
-        results = results.filter((record) => {
+      const cursorValues = cursor.after as Record<string, unknown>;
+      const criteria = [];
+      if (sortBy && sortBy.length > 0) {
+        for (let i = 0; i < sortBy.length; i++) {
+          const s = sortBy[i]!;
+          if (cursorValues[s.field] !== undefined) {
+            criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
+          }
+        }
+      } else {
+        const keys = Object.keys(cursorValues);
+        for (let i = 0; i < keys.length; i++) {
+          criteria.push({ field: keys[i]!, direction: "asc" as const, path: undefined });
+        }
+      }
+
+      if (criteria.length > 0) {
+        const filtered: T[] = [];
+        for (let i = 0; i < results.length; i++) {
+          const record = results[i]!;
+          let match = false;
           // Lexicographic keyset pagination:
           // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
-          for (const current of sortCriteria) {
-            const recordVal = this.getValue(record, current.field, current.path);
-            const cursorVal = cursorValues[current.field];
+          for (let j = 0; j < criteria.length; j++) {
+            const curr = criteria[j]!;
+            const recordVal = this.getValue(record, curr.field as any, curr.path);
+            const cursorVal = cursorValues[curr.field as any];
             const comp = this.compareValues(recordVal, cursorVal);
 
             if (comp === 0) continue;
-
-            return current.direction === "desc" ? comp < 0 : comp > 0;
+            if (curr.direction === "desc" ? comp < 0 : comp > 0) {
+              match = true;
+            }
+            break;
           }
-          return false;
-        });
+          if (match) filtered.push(record);
+        }
+        results = filtered;
       }
     }
 
-    if (sortBy) {
+    if (sortBy && sortBy.length > 0) {
       results.sort((a, b) => {
-        for (const { field, direction, path } of sortBy) {
+        for (let i = 0; i < sortBy.length; i++) {
+          const { field, direction, path } = sortBy[i]!;
           const valA = this.getValue(a, field, path);
           const valB = this.getValue(b, field, path);
           if (valA === valB) continue;
-          const factor = direction === "desc" ? -1 : 1;
-          if (valA === undefined || valB === undefined) return 0;
           const comparison = this.compareValues(valA, valB);
           if (comparison === 0) continue;
-          return comparison * factor;
+          return direction === "desc" ? -comparison : comparison;
         }
         return 0;
       });
     }
 
     const start = offset ?? 0;
-    const end = limit === undefined ? undefined : start + limit;
-    results = results.slice(start, end);
+    const end = limit === undefined ? results.length : start + limit;
+    const finalResults: T[] = [];
+    for (let i = start; i < end && i < results.length; i++) {
+      finalResults.push(this.applySelect(results[i]!, select));
+    }
 
-    return Promise.resolve(results.map((record) => this.applySelect(record, select)));
+    return finalResults;
   }
 
-  update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    data: Partial<T>;
-  }): Promise<T | null> {
+  async update<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
     const { model, where, data } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, data);
     const modelStorage = this.getModelStorage(model);
 
-    for (const [pk, record] of modelStorage.entries()) {
-      const modelRecord = this.asModel<T>(record);
+    const entries = Array.from(modelStorage.entries());
+    for (let i = 0; i < entries.length; i++) {
+      const [pk, record] = entries[i]!;
+      const modelRecord = record as T;
       if (this.evaluateWhere(where, modelRecord)) {
         const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
-        return Promise.resolve(this.applySelect(this.asModel(updated)));
+        return this.applySelect(updated as any);
       }
     }
 
-    return Promise.resolve(null);
+    return null;
   }
 
-  updateMany<
+  async updateMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
@@ -187,8 +220,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const modelStorage = this.getModelStorage(model);
     let count = 0;
 
-    for (const [pk, record] of modelStorage.entries()) {
-      const modelRecord = this.asModel<T>(record);
+    const entries = Array.from(modelStorage.entries());
+    for (let i = 0; i < entries.length; i++) {
+      const [pk, record] = entries[i]!;
+      const modelRecord = record as T;
       if (where === undefined || this.evaluateWhere(where, modelRecord)) {
         const updated = Object.assign({}, modelRecord, data);
         modelStorage.set(pk, updated);
@@ -196,10 +231,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       }
     }
 
-    return Promise.resolve(count);
+    return count;
   }
 
-  upsert<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+  async upsert<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
     model: K;
     create: T;
     update: Partial<T>;
@@ -215,36 +253,36 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const existing = modelStorage.get(pkValue);
 
     if (existing !== undefined) {
-      const modelExisting = this.asModel<T>(existing);
-      // Use optional where predicate
+      const modelExisting = existing as T;
       if (where === undefined || this.evaluateWhere(where, modelExisting)) {
         const updated = Object.assign({}, modelExisting, update);
         modelStorage.set(pkValue, updated);
-        return Promise.resolve(this.applySelect(this.asModel(updated), select));
+        return this.applySelect(updated as any, select);
       }
-      return Promise.resolve(this.applySelect(modelExisting, select));
+      return this.applySelect(modelExisting, select);
     }
 
     return this.create({ model, data: create, select });
   }
 
-  delete<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-  }): Promise<void> {
+  async delete<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T> }): Promise<void> {
     const { model, where } = args;
     const modelStorage = this.getModelStorage(model);
 
-    for (const [pk, record] of modelStorage.entries()) {
-      if (this.evaluateWhere(where, this.asModel<T>(record))) {
+    const entries = Array.from(modelStorage.entries());
+    for (let i = 0; i < entries.length; i++) {
+      const [pk, record] = entries[i]!;
+      if (this.evaluateWhere(where, record as T)) {
         modelStorage.delete(pk);
-        return Promise.resolve();
+        return;
       }
     }
-    return Promise.resolve();
   }
 
-  deleteMany<
+  async deleteMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
@@ -252,138 +290,116 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const modelStorage = this.getModelStorage(model);
     let count = 0;
 
-    for (const [pk, record] of modelStorage.entries()) {
-      if (where === undefined || this.evaluateWhere(where, this.asModel<T>(record))) {
+    const entries = Array.from(modelStorage.entries());
+    for (let i = 0; i < entries.length; i++) {
+      const [pk, record] = entries[i]!;
+      if (where === undefined || this.evaluateWhere(where, record as T)) {
         modelStorage.delete(pk);
         count++;
       }
     }
 
-    return Promise.resolve(count);
+    return count;
   }
 
-  count<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-  }): Promise<number> {
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model, where } = args;
     const modelStorage = this.getModelStorage(model);
 
-    if (where === undefined) return Promise.resolve(modelStorage.size);
+    if (where === undefined) return modelStorage.size;
 
     let count = 0;
-    for (const record of modelStorage.values()) {
-      if (this.evaluateWhere(where, this.asModel<T>(record))) {
+    const values = Array.from(modelStorage.values());
+    for (let i = 0; i < values.length; i++) {
+      if (this.evaluateWhere(where, values[i] as T)) {
         count++;
       }
     }
-    return Promise.resolve(count);
-  }
-
-  // --- Helpers ---
-
-  private getFieldNames<T>(obj: Partial<Record<FieldName<T>, unknown>>): FieldName<T>[] {
-    // Object.keys always returns string[], narrowing to FieldName<T> is safe - keys come from typed cursor
-    return Object.keys(obj) as FieldName<T>[]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-  }
-
-  private asModel<T extends RowData>(record: RowData): T {
-    // Internal storage only contains RowData from previous operations; T is inferred from call site
-    return record as T; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    return count;
   }
 
-  private getModelStorage(model: string): Map<string, RowData> {
+  private getModelStorage(model: string): any {
     const storage = this.storage.get(model);
-    if (!storage) {
-      throw new Error(`Model ${model} not initialized. Call migrate() first.`);
-    }
+    if (!storage) throw new Error(`Model ${model} not initialized. Call migrate() first.`);
     return storage;
   }
 
-  private getModel<K extends keyof S & string>(model: K): S[K] {
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) {
-      throw new Error(`Model ${model} not found in schema`);
-    }
-    return modelSpec;
+  private getModel(model: string): S[keyof S] {
+    const spec = this.schema[model];
+    if (!spec) throw new Error(`Model ${model} not found in schema`);
+    return spec;
   }
 
   private getPrimaryKeyString(modelName: string, data: Record<string, unknown>): string {
-    const model = this.getModel(modelName as keyof S & string);
+    const model = this.getModel(modelName);
     const pkValues = getIdentityValues(model, data);
-    return getPrimaryKeyFields(model)
-      .map((field) => String(pkValues[field]))
-      .join("|");
+    const pkFields = getPrimaryKeyFields(model);
+    let res = "";
+    for (let i = 0; i < pkFields.length; i++) {
+      if (i > 0) res += "|";
+      res += String(pkValues[pkFields[i]!] ?? "");
+    }
+    return res;
   }
 
   private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
-    if (select === undefined) {
-      return Object.assign({}, record);
+    if (!select) return Object.assign({}, record);
+    const res = {} as T;
+    for (let i = 0; i < select.length; i++) {
+      const k = select[i]! as string;
+      (res as any)[k] = record[k] ?? null;
     }
-
-    // Empty object to be populated with selected fields only
-    const result = {} as T; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-    for (const field of select) {
-      const fieldName = field as FieldName<T>;
-      const val = record[fieldName];
-      this.setField(result, fieldName, val ?? null);
-    }
-
-    return result;
+    return res;
   }
 
-  private setField<T extends RowData, K extends FieldName<T>>(
-    obj: T,
-    key: K,
-    value: unknown,
-  ): void {
-    // Value is either from the record or defaulted to null - both are valid for T[K]
-    obj[key] = value as T[K]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-  }
-
-  private getValue<T extends RowData>(record: T, field: FieldName<T>, path?: string[]): unknown {
-    let value: unknown = record[field];
+  private getValue(record: any, field: string, path?: string[]): unknown {
+    let val = record[field];
     if (path && path.length > 0) {
-      for (const segment of path) {
-        if (!isRecord(value)) {
-          return undefined;
-        }
-        value = value[segment];
+      for (let i = 0; i < path.length; i++) {
+        if (!isRecord(val)) return undefined;
+        val = val[path[i]!];
       }
     }
-    return value;
+    return val;
   }
 
-  private evaluateWhere<T extends RowData>(where: Where<T>, record: T): boolean {
+  private evaluateWhere(where: Where<any>, record: any): boolean {
     if ("and" in where) {
-      return where.and.every((w) => this.evaluateWhere(w, record));
+      for (let i = 0; i < where.and.length; i++) {
+        if (!this.evaluateWhere(where.and[i]!, record)) return false;
+      }
+      return true;
     }
     if ("or" in where) {
-      return where.or.some((w) => this.evaluateWhere(w, record));
+      for (let i = 0; i < where.or.length; i++) {
+        if (this.evaluateWhere(where.or[i]!, record)) return true;
+      }
+      return false;
     }
 
-    if ("field" in where && "op" in where) {
-      const { field, op, value, path } = where;
-      const recordValue = this.getValue(record, field, path);
-
-      switch (op) {
-        case "eq":
-          return recordValue === value;
-        case "ne":
-          return recordValue !== value;
-        case "gt":
-          return this.compareValues(recordValue, value) > 0;
-        case "gte":
-          return this.compareValues(recordValue, value) >= 0;
-        case "lt":
-          return this.compareValues(recordValue, value) < 0;
-        case "lte":
-          return this.compareValues(recordValue, value) <= 0;
-        case "in":
-          return Array.isArray(value) && value.includes(recordValue);
-        case "not_in":
-          return Array.isArray(value) && !value.includes(recordValue);
-      }
+    const { field, op, value, path } = where as any;
+    const recordVal = this.getValue(record, field, path);
+
+    switch (op) {
+      case "eq":
+        return recordVal === value;
+      case "ne":
+        return recordVal !== value;
+      case "gt":
+        return this.compareValues(recordVal, value) > 0;
+      case "gte":
+        return this.compareValues(recordVal, value) >= 0;
+      case "lt":
+        return this.compareValues(recordVal, value) < 0;
+      case "lte":
+        return this.compareValues(recordVal, value) <= 0;
+      case "in":
+        return Array.isArray(value) && value.includes(recordVal);
+      case "not_in":
+        return Array.isArray(value) && !value.includes(recordVal);
     }
     return false;
   }
@@ -393,14 +409,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (left === null || left === undefined) return -1;
     if (right === null || right === undefined) return 1;
     if (typeof left !== typeof right) return 0;
-    if (this.isComparable(left) && this.isComparable(right)) {
-      if (left < right) return -1;
-      if (left > right) return 1;
+    if (typeof left === "string" || typeof left === "number") {
+      if (left < (right as any)) return -1;
+      if (left > (right as any)) return 1;
     }
     return 0;
   }
-
-  private isComparable(value: unknown): value is Comparable {
-    return typeof value === "string" || typeof value === "number";
-  }
 }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index fdc2bf7..098e4eb 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,777 +1,23 @@
-import type { SQL } from "bun";
-import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
-
-import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
-import {
-  assertNoPrimaryKeyUpdates,
-  buildIdentityFilter,
-  escapeLiteral,
-  getIdentityValues,
-  getPrimaryKeyFields,
-  isRecord,
-  mapNumeric,
-  quote,
-  validateJsonPath,
-} from "./common";
-
-/**
- * Internal interface to abstract away the differences between pg and Bun SQL.
- */
-interface PostgresExecutor {
-  query(sql: string, params: unknown[]): Promise<Record<string, unknown>[]>;
-  transaction<T>(fn: (executor: PostgresExecutor) => Promise<T>): Promise<T>;
-}
-
-export type PostgresDriver = SQL | PgClient | PgPool | PgPoolClient;
-
-/**
- * Internal interface for Bun SQL.
- */
-interface BunSQL {
-  unsafe<T>(sql: string, params?: unknown[]): Promise<T>;
-  transaction<T>(fn: (tx: BunSQL) => Promise<T>): Promise<T>;
-}
-
-function isBunSQL(obj: unknown): obj is BunSQL {
-  return objIsObject(obj) && "unsafe" in obj && typeof obj["unsafe"] === "function";
-}
-
-function isPgPool(obj: unknown): obj is PgPool {
-  return objIsObject(obj) && "connect" in obj && typeof obj["connect"] === "function";
-}
-
-function isPgClient(obj: unknown): obj is PgClient {
-  return (
-    objIsObject(obj) && "query" in obj && typeof obj["query"] === "function" && "release" in obj
-  );
-}
-
-function objIsObject(obj: unknown): obj is Record<string, unknown> {
-  return obj !== null && typeof obj === "object";
-}
-
-/**
- * Standardized way to wrap various Postgres drivers.
- * All driver-specific logic is localized here.
- */
-function createExecutor(driver: PostgresDriver): PostgresExecutor {
-  // Bun SQL Sniffing
-  if (isBunSQL(driver)) {
-    const sql = driver;
-    return {
-      query: async (querySql, params) => {
-        const rows = await sql.unsafe<Record<string, unknown>[]>(querySql, params);
-        return rows;
-      },
-      transaction: (fn) => {
-        return sql.transaction((tx) => fn(createExecutor(tx as PostgresDriver)));
-      },
-    };
-  }
-
-  // pg Pool Sniffing
-  if (isPgPool(driver)) {
-    const pool = driver;
-    return {
-      query: async (querySql: string, params: unknown[]) => {
-        const result = await pool.query(querySql, params);
-        // pg's result.rows is any[], cast to proper type
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        return result.rows as Record<string, unknown>[];
-      },
-      transaction: async (fn) => {
-        const client = await pool.connect();
-        try {
-          await client.query("BEGIN");
-          const result = await fn(createExecutor(client as PostgresDriver));
-          await client.query("COMMIT");
-          return result;
-        } catch (e) {
-          await client.query("ROLLBACK");
-          throw e;
-        } finally {
-          client.release();
-        }
-      },
-    };
-  }
-
-  // pg Client / PoolClient Sniffing
-  if (isPgClient(driver)) {
-    const client = driver;
-    return {
-      query: async (querySql: string, params: unknown[]) => {
-        const result = await client.query(querySql, params);
-        // pg's result.rows is any[], cast to proper type
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        return result.rows as Record<string, unknown>[];
-      },
-      transaction: async (fn) => {
-        await client.query("BEGIN");
-        try {
-          // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-          const result = await fn(createExecutor(client as PostgresDriver));
-          await client.query("COMMIT");
-          return result;
-        } catch (e) {
-          await client.query("ROLLBACK");
-          throw e;
-        }
-      },
-    };
-  }
-
-  throw new Error("Unsupported Postgres driver.");
-}
-
-export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private executor: PostgresExecutor;
-
-  constructor(
-    private schema: S,
-    driver: PostgresDriver,
-  ) {
-    this.executor = createExecutor(driver);
-  }
-
-  async migrate(): Promise<void> {
-    for (const [name, model] of Object.entries(this.schema)) {
-      const columns = Object.entries(model.fields).map(([fieldName, field]) => {
-        const nullable = field.nullable === true ? "" : " NOT NULL";
-        return `${quote(fieldName)} ${this.mapFieldType(field)}${nullable}`;
-      });
-
-      const pk = `PRIMARY KEY (${getPrimaryKeyFields(model)
-        .map((field) => quote(field))
-        .join(", ")})`;
-
-      // oxlint-disable-next-line eslint/no-await-in-loop
-      await this.executor.query(
-        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
-        [],
-      );
-
-      if (model.indexes === undefined) continue;
-
-      for (let i = 0; i < model.indexes.length; i++) {
-        const index = model.indexes[i];
-        if (index === undefined) continue;
-
-        const fields = (Array.isArray(index.field) ? index.field : [index.field])
-          .map((field) => `${quote(field)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
-          .join(", ");
-
-        // oxlint-disable-next-line eslint/no-await-in-loop
-        await this.executor.query(
-          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
-          [],
-        );
-      }
-    }
-  }
-
-  async create<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
-    const { model, data, select } = args;
-    const modelSpec = this.getModel(model);
-    const insertData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(insertData);
-    const values = fields.map((field) => insertData[field]);
-    const placeholders = fields.map((_, index) => `$${index + 1}`).join(", ");
-    const sql = `INSERT INTO ${quote(model)} (${fields.map((field) => quote(field)).join(", ")}) VALUES (${placeholders}) RETURNING ${this.buildSelect(select)}`;
-
-    const rows = await this.executor.query(sql, values);
-    const row = rows[0];
-    if (row === undefined) {
-      throw new Error("Failed to create record.");
-    }
-    return this.mapRow(model, row, select);
-  }
-
-  async find<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
-    const { model, where, select } = args;
-    const builtWhere = this.buildWhere(model, where);
-    const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const rows = await this.executor.query(sql, builtWhere.params);
-    const row = rows[0];
-    return row === undefined ? null : this.mapRow(model, row, select);
-  }
-
-  async findMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-    select?: Select<T>;
-    sortBy?: SortBy<T>[];
-    limit?: number;
-    offset?: number;
-    cursor?: Cursor<T>;
-  }): Promise<T[]> {
-    const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const parts: string[] = [`SELECT ${this.buildSelect(select)} FROM ${quote(model)}`];
-    const params: unknown[] = [];
-
-    if (where !== undefined || cursor !== undefined) {
-      const builtWhere = this.buildWhere(model, where, cursor, sortBy);
-      parts.push(`WHERE ${builtWhere.sql}`);
-      params.push(...builtWhere.params);
-    }
-
-    if (sortBy !== undefined && sortBy.length > 0) {
-      parts.push(
-        `ORDER BY ${sortBy
-          .map(
-            (sort) =>
-              `${this.buildSortExpr(model, sort.field as string, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
-          )
-          .join(", ")}`,
-      );
-    }
-
-    if (limit !== undefined) {
-      parts.push(`LIMIT $${params.length + 1}`);
-      params.push(limit);
-    }
-
-    if (offset !== undefined) {
-      parts.push(`OFFSET $${params.length + 1}`);
-      params.push(offset);
-    }
-
-    const rows = await this.executor.query(parts.join(" "), params);
-    return rows.map((row) => this.mapRow(model, row, select));
-  }
-
-  async update<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const updateData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(updateData);
-    if (fields.length === 0) {
-      return this.find({ model, where });
-    }
-
-    const assignments = fields.map((field, index) => `${quote(field)} = $${index + 1}`).join(", ");
-    const builtWhere = this.buildWhere(model, where, undefined, undefined, fields.length + 1);
-    const sql = `UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql} RETURNING *`;
-    const values = [...fields.map((field) => updateData[field]), ...builtWhere.params];
-    const rows = await this.executor.query(sql, values);
-    const row = rows[0];
-    return row === undefined ? null : this.mapRow(model, row);
-  }
-
-  async updateMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const updateData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(updateData);
-    if (fields.length === 0) {
-      return 0;
-    }
-
-    const assignments = fields.map((field, index) => `${quote(field)} = $${index + 1}`).join(", ");
-    const params = fields.map((field) => updateData[field]);
-    let sql = `UPDATE ${quote(model)} SET ${assignments}`;
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length + 1);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const rows = await this.executor.query(`${sql} RETURNING 1 as touched`, params);
-    return rows.length;
-  }
-
-  async upsert<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    create: T;
-    update: Partial<T>;
-    where?: Where<T>;
-    select?: Select<T>;
-  }): Promise<T> {
-    const { model, create, update, where, select } = args;
-    const modelSpec = this.getModel(model);
-    const identityValues = getIdentityValues(modelSpec, create);
-    assertNoPrimaryKeyUpdates(modelSpec, update);
-
-    const createData = this.mapInput(modelSpec.fields, create);
-    const createFields = Object.keys(createData);
-    const updateData = this.mapInput(modelSpec.fields, update);
-    const updateFields = Object.keys(updateData);
-    const pkFields = getPrimaryKeyFields(modelSpec);
-
-    const insertValues = createFields.map((field) => createData[field]);
-    const insertPlaceholders = createFields.map((_, index) => `$${index + 1}`).join(", ");
-    const conflictTarget = pkFields.map((field) => quote(field)).join(", ");
-
-    let updateClause =
-      updateFields.length > 0
-        ? updateFields
-            .map(
-              (field) =>
-                `${quote(field)} = $${insertValues.length + updateFields.indexOf(field) + 1}`,
-            )
-            .join(", ")
-        : `${quote(pkFields[0]!)} = EXCLUDED.${quote(pkFields[0]!)}`;
-
-    const params =
-      updateFields.length > 0
-        ? [...insertValues, ...updateFields.map((field) => updateData[field])]
-        : insertValues;
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length + 1);
-      updateClause += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const sql = `INSERT INTO ${quote(model)} (${createFields.map((field) => quote(field)).join(", ")}) VALUES (${insertPlaceholders}) ON CONFLICT (${conflictTarget}) DO UPDATE SET ${updateClause} RETURNING ${this.buildSelect(select)}`;
-    const rows = await this.executor.query(sql, params);
-    const row = rows[0];
-
-    if (row !== undefined) {
-      return this.mapRow(model, row, select);
-    }
-
-    const existing = await this.find<K, T>({
-      model,
-      where: buildIdentityFilter(modelSpec, identityValues),
-      select,
-    });
-    if (existing === null) {
-      throw new Error("Failed to refetch upserted record.");
-    }
-    return existing;
-  }
-
-  async delete<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T> }): Promise<void> {
-    const existing = await this.find<K, T>({ model: args.model, where: args.where });
-    if (existing === null) {
-      return;
-    }
-
-    const builtWhere = this.buildWhere(
-      args.model,
-      buildIdentityFilter(this.getModel(args.model), existing),
+import { PostgresDialect, createPostgresExecutor, type PostgresDriver } from "../dialects/postgres";
+import { isQueryExecutor, type QueryExecutor } from "../dialects/types";
+import type { Adapter, Schema } from "../types";
+import { SqlAdapter } from "./sql";
+
+export class PostgresAdapter<S extends Schema = Schema>
+  extends SqlAdapter<S>
+  implements Adapter<S>
+{
+  constructor(schema: S, driver: PostgresDriver | QueryExecutor) {
+    super(
+      schema,
+      isQueryExecutor(driver) ? driver : createPostgresExecutor(driver),
+      PostgresDialect,
     );
-    await this.executor.query(
-      `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
-      builtWhere.params,
-    );
-  }
-
-  async deleteMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `DELETE FROM ${quote(model)}`;
-    const params: unknown[] = [];
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const rows = await this.executor.query(`${sql} RETURNING 1 as touched`, params);
-    return rows.length;
-  }
-
-  async count<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `SELECT COUNT(*) as count FROM ${quote(model)}`;
-    const params: unknown[] = [];
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const rows = await this.executor.query(sql, params);
-    const row = rows[0];
-    return isRecord(row) && typeof row["count"] === "number"
-      ? row["count"]
-      : Number(row?.["count"] ?? 0);
   }
 
-  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    return this.executor.transaction((innerExecutor) => {
-      // Driver is not used in transaction adapter, only executor is injected
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript/no-explicit-any
-      const txAdapter = new PostgresAdapter(this.schema, null as unknown as PostgresDriver);
-      txAdapter.executor = innerExecutor;
-      return fn(txAdapter);
+  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    return this.executor.transaction(async (innerExecutor) => {
+      return fn(new PostgresAdapter(this.schema, innerExecutor));
     });
   }
-
-  private getModel<K extends keyof S & string>(model: K): S[K] {
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) {
-      throw new Error(`Model ${model} not found in schema.`);
-    }
-    return modelSpec;
-  }
-
-  private mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "DOUBLE PRECISION";
-      case "boolean":
-        return "BOOLEAN";
-      case "timestamp":
-        return "BIGINT";
-      case "json":
-      case "json[]":
-        return "JSONB";
-      default:
-        return "TEXT";
-    }
-  }
-
-  private buildSelect<T>(select?: Select<T>): string {
-    return select === undefined ? "*" : select.map((field) => quote(field as string)).join(", ");
-  }
-
-  private buildSortExpr(modelName: string, field: string, path?: string[]): string {
-    if (path === undefined || path.length === 0) {
-      return quote(field);
-    }
-    return this.buildColumnExpr(modelName, field, path);
-  }
-
-  private buildColumnExpr(
-    modelName: string,
-    field: string,
-    path?: string[],
-    value?: unknown,
-  ): string {
-    if (path === undefined || path.length === 0) {
-      return quote(field);
-    }
-
-    const model = this.schema[modelName as keyof S];
-    const fieldSpec = model?.fields[field];
-    if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
-      throw new Error(`Cannot use JSON path on non-JSON field: ${field}`);
-    }
-
-    const segments = validateJsonPath(path)
-      .map((segment) => `'${escapeLiteral(segment)}'`)
-      .join(", ");
-    const baseExpr = `jsonb_extract_path_text(${quote(field)}, ${segments})`;
-
-    if (typeof value === "number") {
-      return `(${baseExpr})::double precision`;
-    }
-    if (typeof value === "boolean") {
-      return `(${baseExpr})::boolean`;
-    }
-    return baseExpr;
-  }
-
-  private buildCursor<T>(
-    modelName: string,
-    cursor: Cursor<T>,
-    sortBy?: SortBy<T>[],
-    startIndex = 1,
-  ): { sql: string; params: unknown[]; nextIndex: number } {
-    type CursorSort = {
-      field: Extract<keyof T, string>;
-      direction: "asc" | "desc";
-      path?: string[];
-    };
-    const cursorValues = cursor.after as Partial<Record<string, unknown>>;
-    const sortCriteria: CursorSort[] =
-      sortBy !== undefined && sortBy.length > 0
-        ? sortBy
-            .filter((sort) => cursorValues[sort.field] !== undefined)
-            .map((sort) => ({
-              field: sort.field,
-              direction: sort.direction ?? "asc",
-              path: sort.path,
-            }))
-        : Object.keys(cursor.after).map((field) => ({
-            // Cursor keys come from the typed `Cursor<T>` surface.
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-            field: field as Extract<keyof T, string>,
-            direction: "asc" as const,
-            path: undefined,
-          }));
-
-    if (sortCriteria.length === 0) {
-      return { sql: "", params: [], nextIndex: startIndex };
-    }
-
-    const orClauses: string[] = [];
-    const params: unknown[] = [];
-    let nextIndex = startIndex;
-
-    for (let i = 0; i < sortCriteria.length; i++) {
-      const andClauses: string[] = [];
-
-      for (let j = 0; j < i; j++) {
-        const previous = sortCriteria[j]!;
-        andClauses.push(
-          `${this.buildColumnExpr(modelName, previous.field, previous.path, cursorValues[previous.field])} = $${nextIndex}`,
-        );
-        params.push(cursorValues[previous.field]);
-        nextIndex++;
-      }
-
-      const current = sortCriteria[i]!;
-      andClauses.push(
-        `${this.buildColumnExpr(modelName, current.field, current.path, cursorValues[current.field])} ${current.direction === "desc" ? "<" : ">"} $${nextIndex}`,
-      );
-      params.push(cursorValues[current.field]);
-      nextIndex++;
-      orClauses.push(`(${andClauses.join(" AND ")})`);
-    }
-
-    return {
-      sql: `(${orClauses.join(" OR ")})`,
-      params,
-      nextIndex,
-    };
-  }
-
-  private buildWhere<T>(
-    modelName: string,
-    where?: Where<T>,
-    cursor?: Cursor<T>,
-    sortBy?: SortBy<T>[],
-    startIndex = 1,
-  ): { sql: string; params: unknown[]; nextIndex: number } {
-    const parts: string[] = [];
-    const params: unknown[] = [];
-    let nextIndex = startIndex;
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhereRecursive(modelName, where, nextIndex);
-      parts.push(builtWhere.sql);
-      params.push(...builtWhere.params);
-      nextIndex = builtWhere.nextIndex;
-    }
-
-    if (cursor !== undefined) {
-      const builtCursor = this.buildCursor(modelName, cursor, sortBy, nextIndex);
-      if (builtCursor.sql !== "") {
-        parts.push(builtCursor.sql);
-        params.push(...builtCursor.params);
-        nextIndex = builtCursor.nextIndex;
-      }
-    }
-
-    return {
-      sql: parts.length > 0 ? parts.map((part) => `(${part})`).join(" AND ") : "1=1",
-      params,
-      nextIndex,
-    };
-  }
-
-  private buildWhereRecursive<T>(
-    modelName: string,
-    where: Where<T>,
-    startIndex: number,
-  ): { sql: string; params: unknown[]; nextIndex: number } {
-    if ("and" in where) {
-      const parts: string[] = [];
-      const params: unknown[] = [];
-      let nextIndex = startIndex;
-
-      for (const clause of where.and) {
-        const built = this.buildWhereRecursive(modelName, clause, nextIndex);
-        parts.push(`(${built.sql})`);
-        params.push(...built.params);
-        nextIndex = built.nextIndex;
-      }
-
-      return { sql: parts.join(" AND "), params, nextIndex };
-    }
-
-    if ("or" in where) {
-      const parts: string[] = [];
-      const params: unknown[] = [];
-      let nextIndex = startIndex;
-
-      for (const clause of where.or) {
-        const built = this.buildWhereRecursive(modelName, clause, nextIndex);
-        parts.push(`(${built.sql})`);
-        params.push(...built.params);
-        nextIndex = built.nextIndex;
-      }
-
-      return { sql: parts.join(" OR "), params, nextIndex };
-    }
-
-    const expr = this.buildColumnExpr(modelName, where.field as string, where.path, where.value);
-    const mappedValue = this.mapWhereValue(where.value);
-    switch (where.op) {
-      case "eq":
-        if (where.value === null) {
-          return { sql: `${expr} IS NULL`, params: [], nextIndex: startIndex };
-        }
-        return {
-          sql: `${expr} = $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "ne":
-        if (where.value === null) {
-          return { sql: `${expr} IS NOT NULL`, params: [], nextIndex: startIndex };
-        }
-        return {
-          sql: `${expr} != $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "gt":
-        return {
-          sql: `${expr} > $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "gte":
-        return {
-          sql: `${expr} >= $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "lt":
-        return {
-          sql: `${expr} < $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "lte":
-        return {
-          sql: `${expr} <= $${startIndex}`,
-          params: [mappedValue],
-          nextIndex: startIndex + 1,
-        };
-      case "in": {
-        if (where.value.length === 0) {
-          return { sql: "1=0", params: [], nextIndex: startIndex };
-        }
-        const inValues = where.value.map((v) => this.mapWhereValue(v));
-        return {
-          sql: `${expr} IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
-          params: inValues,
-          nextIndex: startIndex + where.value.length,
-        };
-      }
-      case "not_in": {
-        if (where.value.length === 0) {
-          return { sql: "1=1", params: [], nextIndex: startIndex };
-        }
-        const notInValues = where.value.map((v) => this.mapWhereValue(v));
-        return {
-          sql: `${expr} NOT IN (${where.value.map((_, index) => `$${startIndex + index}`).join(", ")})`,
-          params: notInValues,
-          nextIndex: startIndex + where.value.length,
-        };
-      }
-      default:
-        throw new Error(`Unsupported operator: ${(where as { op: string }).op}`);
-    }
-  }
-
-  private mapInput(
-    fields: Record<string, Field>,
-    data: Record<string, unknown> | Partial<Record<string, unknown>>,
-  ): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-
-    for (const [fieldName, field] of Object.entries(fields)) {
-      const value = data[fieldName];
-      if (value === undefined) continue;
-      if (value === null) {
-        result[fieldName] = null;
-        continue;
-      }
-
-      if (field.type === "json" || field.type === "json[]") {
-        result[fieldName] = value;
-      } else if (field.type === "boolean") {
-        result[fieldName] = value === true;
-      } else {
-        result[fieldName] = value;
-      }
-    }
-
-    return result;
-  }
-
-  private mapWhereValue(value: unknown): unknown {
-    if (value === null) return null;
-    if (typeof value === "boolean") return value;
-    if (typeof value === "object" && value !== null) {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-
-  private mapRow<K extends keyof S & string, T extends Record<string, unknown>>(
-    model: K,
-    row: Record<string, unknown>,
-    select?: Select<T>,
-  ): T {
-    const fieldSpecs = this.getModel(model).fields;
-    const output: Record<string, unknown> = {};
-    const selectedFields =
-      select === undefined ? Object.keys(row) : select.map((field) => field as string);
-
-    for (const fieldName of selectedFields) {
-      const fieldSpec = fieldSpecs[fieldName];
-      const value = row[fieldName];
-
-      if (fieldSpec === undefined || value === undefined || value === null) {
-        output[fieldName] = value;
-        continue;
-      }
-
-      if (fieldSpec.type === "json" || fieldSpec.type === "json[]") {
-        output[fieldName] = typeof value === "string" ? JSON.parse(value) : value;
-      } else if (fieldSpec.type === "boolean") {
-        output[fieldName] = value === true || value === 1;
-      } else if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
-        output[fieldName] = mapNumeric(value);
-      } else {
-        output[fieldName] = value;
-      }
-    }
-
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    return output as T;
-  }
 }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
new file mode 100644
index 0000000..1d2aa43
--- /dev/null
+++ b/src/adapters/sql.ts
@@ -0,0 +1,627 @@
+import type { QueryExecutor, SqlDialect } from "../dialects/types";
+import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
+import {
+  assertNoPrimaryKeyUpdates,
+  buildIdentityFilter,
+  getIdentityValues,
+  getPrimaryKeyFields,
+  isRecord,
+  mapNumeric,
+} from "./common";
+
+export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S> {
+  constructor(
+    protected schema: S,
+    protected executor: QueryExecutor,
+    protected dialect: SqlDialect,
+  ) {}
+
+  async migrate(): Promise<void> {
+    const models = Object.entries(this.schema);
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      const fields = Object.entries(model.fields);
+      const columns: string[] = [];
+      for (let j = 0; j < fields.length; j++) {
+        const [fieldName, field] = fields[j]!;
+        const nullable = field.nullable === true ? "" : " NOT NULL";
+        columns.push(
+          `${this.dialect.quote(fieldName)} ${this.dialect.mapFieldType(field)}${nullable}`,
+        );
+      }
+
+      const pkFields = getPrimaryKeyFields(model);
+      const quotedPkFields: string[] = [];
+      for (let j = 0; j < pkFields.length; j++) {
+        quotedPkFields.push(this.dialect.quote(pkFields[j]!));
+      }
+      const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
+
+      await this.executor.run(
+        `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
+        [],
+      );
+
+      if (model.indexes) {
+        for (let j = 0; j < model.indexes.length; j++) {
+          const index = model.indexes[j]!;
+          const indexFields = Array.isArray(index.field) ? index.field : [index.field];
+          const formattedFields: string[] = [];
+          for (let k = 0; k < indexFields.length; k++) {
+            formattedFields.push(
+              `${this.dialect.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
+            );
+          }
+          await this.executor.run(
+            `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
+            [],
+          );
+        }
+      }
+    }
+  }
+
+  async create<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+    const { model, data, select } = args;
+    const modelSpec = this.getModel(model);
+    const insertData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(insertData);
+
+    const quotedFields: string[] = [];
+    const placeholders: string[] = [];
+    const values: unknown[] = [];
+
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i]!;
+      quotedFields.push(this.dialect.quote(field));
+      placeholders.push(this.dialect.placeholder(i));
+      values.push(insertData[field]);
+    }
+
+    const sql = `INSERT INTO ${this.dialect.quote(model)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${this.buildSelect(select)}`;
+    const row = await this.executor.get<Record<string, unknown>>(sql, values);
+
+    if (!row) {
+      // Fallback for drivers that don't support RETURNING
+      return (await this.find({
+        model,
+        where: buildIdentityFilter(modelSpec, data),
+        select,
+      })) as T;
+    }
+
+    return this.mapRow(model, row, select);
+  }
+
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model, where, select } = args;
+    const builtWhere = this.buildWhere(model, where);
+    const sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
+    const row = await this.executor.get<Record<string, unknown>>(sql, builtWhere.params);
+    return row ? this.mapRow(model, row, select) : null;
+  }
+
+  async findMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }): Promise<T[]> {
+    const { model, where, select, sortBy, limit, offset, cursor } = args;
+    const params: unknown[] = [];
+    let sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)}`;
+
+    const builtWhere = this.buildWhere(model, where, cursor, sortBy, params.length);
+    if (builtWhere.sql !== "1=1") {
+      sql += ` WHERE ${builtWhere.sql}`;
+      for (let i = 0; i < builtWhere.params.length; i++) {
+        params.push(builtWhere.params[i]);
+      }
+    }
+
+    if (sortBy && sortBy.length > 0) {
+      const sortParts: string[] = [];
+      for (let i = 0; i < sortBy.length; i++) {
+        const sort = sortBy[i]!;
+        sortParts.push(
+          `${this.buildColumnExpr(model, sort.field as string, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
+        );
+      }
+      sql += ` ORDER BY ${sortParts.join(", ")}`;
+    }
+
+    if (limit !== undefined) {
+      sql += ` LIMIT ${this.dialect.placeholder(params.length)}`;
+      params.push(limit);
+    }
+
+    if (offset !== undefined) {
+      sql += ` OFFSET ${this.dialect.placeholder(params.length)}`;
+      params.push(offset);
+    }
+
+    const rows = await this.executor.all<Record<string, unknown>>(sql, params);
+    const result: T[] = [];
+    for (let i = 0; i < rows.length; i++) {
+      result.push(this.mapRow(model, rows[i], select));
+    }
+    return result;
+  }
+
+  async update<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+    const { model, where, data } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
+
+    const updateData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(updateData);
+    if (fields.length === 0) {
+      return this.find({ model, where });
+    }
+
+    const assignments: string[] = [];
+    const params: unknown[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i]!;
+      assignments.push(`${this.dialect.quote(field)} = ${this.dialect.placeholder(i)}`);
+      params.push(updateData[field]);
+    }
+
+    const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
+    const sql = `UPDATE ${this.dialect.quote(model)} SET ${assignments.join(", ")} WHERE ${builtWhere.sql} RETURNING *`;
+    for (let i = 0; i < builtWhere.params.length; i++) {
+      params.push(builtWhere.params[i]);
+    }
+
+    const row = await this.executor.get<Record<string, unknown>>(sql, params);
+    if (!row) {
+      // Check if it exists and return it if no changes were needed or RETURNING not supported
+      return this.find({ model, where });
+    }
+    return this.mapRow(model, row);
+  }
+
+  async updateMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    const { model, where, data } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, data);
+
+    const updateData = this.mapInput(modelSpec.fields, data);
+    const fields = Object.keys(updateData);
+    if (fields.length === 0) return 0;
+
+    const assignments: string[] = [];
+    const params: unknown[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i]!;
+      assignments.push(`${this.dialect.quote(field)} = ${this.dialect.placeholder(i)}`);
+      params.push(updateData[field]);
+    }
+
+    let sql = `UPDATE ${this.dialect.quote(model)} SET ${assignments.join(", ")}`;
+    if (where) {
+      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
+      sql += ` WHERE ${builtWhere.sql}`;
+      for (let i = 0; i < builtWhere.params.length; i++) {
+        params.push(builtWhere.params[i]);
+      }
+    }
+
+    const res = await this.executor.run(sql, params);
+    return res.changes;
+  }
+
+  async upsert<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    create: T;
+    update: Partial<T>;
+    where?: Where<T>;
+    select?: Select<T>;
+  }): Promise<T> {
+    const { model, create, update, where, select } = args;
+    const modelSpec = this.getModel(model);
+    assertNoPrimaryKeyUpdates(modelSpec, update);
+
+    const createData = this.mapInput(modelSpec.fields, create);
+    const createFields = Object.keys(createData);
+    const updateData = this.mapInput(modelSpec.fields, update);
+    const updateFields = Object.keys(updateData);
+    const pkFields = getPrimaryKeyFields(modelSpec);
+
+    const insertColumns: string[] = [];
+    const insertPlaceholders: string[] = [];
+    const params: unknown[] = [];
+    for (let i = 0; i < createFields.length; i++) {
+      const field = createFields[i]!;
+      insertColumns.push(this.dialect.quote(field));
+      insertPlaceholders.push(this.dialect.placeholder(i));
+      params.push(createData[field]);
+    }
+
+    const updateColumns: string[] = [];
+    for (let i = 0; i < updateFields.length; i++) {
+      const field = updateFields[i]!;
+      updateColumns.push(field);
+      params.push(updateData[field]);
+    }
+
+    let whereSql = "";
+    if (where) {
+      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
+      whereSql = builtWhere.sql;
+      for (let i = 0; i < builtWhere.params.length; i++) {
+        params.push(builtWhere.params[i]);
+      }
+    }
+
+    if (this.dialect.upsert) {
+      const { sql, params: upsertParams } = this.dialect.upsert({
+        table: model,
+        insertColumns,
+        insertPlaceholders,
+        updateColumns,
+        conflictColumns: pkFields,
+        select,
+        whereSql,
+      });
+      const row = await this.executor.get<Record<string, unknown>>(sql, upsertParams ?? params);
+      if (row) return this.mapRow(model, row, select);
+    } else {
+      // Generic fallback for ON CONFLICT (Postgres/SQLite)
+      const conflictTarget = [];
+      for (let i = 0; i < pkFields.length; i++)
+        conflictTarget.push(this.dialect.quote(pkFields[i]!));
+
+      let updateSet = "";
+      if (updateFields.length > 0) {
+        const sets = [];
+        for (let i = 0; i < updateFields.length; i++) {
+          const field = updateFields[i]!;
+          sets.push(
+            `${this.dialect.quote(field)} = ${this.dialect.placeholder(createFields.length + i)}`,
+          );
+        }
+        updateSet = `DO UPDATE SET ${sets.join(", ")}`;
+        if (whereSql) updateSet += ` WHERE ${whereSql}`;
+      } else {
+        updateSet = "DO NOTHING";
+      }
+
+      const sql = `INSERT INTO ${this.dialect.quote(model)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${this.buildSelect(select)}`;
+      const row = await this.executor.get<Record<string, unknown>>(sql, params);
+      if (row) return this.mapRow(model, row, select);
+    }
+
+    const identityValues = getIdentityValues(modelSpec, create);
+    const existing = await this.find({
+      model,
+      where: buildIdentityFilter(modelSpec, identityValues),
+      select,
+    });
+    if (!existing) throw new Error("Failed to refetch upserted record.");
+    return existing;
+  }
+
+  async delete<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T> }): Promise<void> {
+    const { model, where } = args;
+    const builtWhere = this.buildWhere(model, where);
+    await this.executor.run(
+      `DELETE FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql}`,
+      builtWhere.params,
+    );
+  }
+
+  async deleteMany<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model, where } = args;
+    let sql = `DELETE FROM ${this.dialect.quote(model)}`;
+    const params: unknown[] = [];
+    if (where) {
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      for (let i = 0; i < builtWhere.params.length; i++) params.push(builtWhere.params[i]);
+    }
+    const res = await this.executor.run(sql, params);
+    return res.changes;
+  }
+
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model, where } = args;
+    let sql = `SELECT COUNT(*) as count FROM ${this.dialect.quote(model)}`;
+    const params: unknown[] = [];
+    if (where) {
+      const builtWhere = this.buildWhere(model, where);
+      sql += ` WHERE ${builtWhere.sql}`;
+      for (let i = 0; i < builtWhere.params.length; i++) params.push(builtWhere.params[i]);
+    }
+    const row = await this.executor.get<Record<string, unknown>>(sql, params);
+    if (!row) return 0;
+    const count = row["count"];
+    return typeof count === "number" ? count : Number(count ?? 0);
+  }
+
+  // --- HELPERS ---
+
+  protected getModel(model: string): S[keyof S] {
+    const spec = this.schema[model];
+    if (!spec) throw new Error(`Model ${model} not found in schema.`);
+    return spec;
+  }
+
+  protected buildSelect(select?: Select<any>): string {
+    if (!select) return "*";
+    const parts = [];
+    for (let i = 0; i < select.length; i++) {
+      parts.push(this.dialect.quote(select[i]!));
+    }
+    return parts.join(", ");
+  }
+
+  protected buildColumnExpr(
+    modelName: string,
+    fieldName: string,
+    path?: string[],
+    value?: unknown,
+  ): string {
+    if (!path || path.length === 0) return this.dialect.quote(fieldName);
+
+    const model = this.getModel(modelName);
+    const field = model.fields[fieldName];
+    if (field?.type !== "json" && field?.type !== "json[]") {
+      throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
+    }
+
+    const isNumeric = typeof value === "number";
+    const isBoolean = typeof value === "boolean";
+    return this.dialect.buildJsonExtract(this.dialect.quote(fieldName), path, isNumeric, isBoolean);
+  }
+
+  protected buildWhere(
+    model: string,
+    where?: Where<any>,
+    cursor?: Cursor<any>,
+    sortBy?: SortBy<any>[],
+    startIndex = 0,
+  ): { sql: string; params: unknown[] } {
+    const parts: string[] = [];
+    const params: unknown[] = [];
+    let nextIndex = startIndex;
+
+    if (where) {
+      const built = this.buildWhereRecursive(model, where, nextIndex);
+      parts.push(`(${built.sql})`);
+      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+      nextIndex += built.params.length;
+    }
+
+    if (cursor) {
+      const built = this.buildCursor(model, cursor, sortBy, nextIndex);
+      if (built.sql) {
+        parts.push(`(${built.sql})`);
+        for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+        nextIndex += built.params.length;
+      }
+    }
+
+    return {
+      sql: parts.length > 0 ? parts.join(" AND ") : "1=1",
+      params,
+    };
+  }
+
+  private buildWhereRecursive(
+    model: string,
+    where: Where<any>,
+    startIndex: number,
+  ): { sql: string; params: unknown[] } {
+    if ("and" in where) {
+      const parts = [];
+      const params = [];
+      let currentIdx = startIndex;
+      for (let i = 0; i < where.and.length; i++) {
+        const built = this.buildWhereRecursive(model, where.and[i]!, currentIdx);
+        parts.push(`(${built.sql})`);
+        for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+        currentIdx += built.params.length;
+      }
+      return { sql: parts.join(" AND "), params };
+    }
+
+    if ("or" in where) {
+      const parts = [];
+      const params = [];
+      let currentIdx = startIndex;
+      for (let i = 0; i < where.or.length; i++) {
+        const built = this.buildWhereRecursive(model, where.or[i]!, currentIdx);
+        parts.push(`(${built.sql})`);
+        for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+        currentIdx += built.params.length;
+      }
+      return { sql: parts.join(" OR "), params };
+    }
+
+    const expr = this.buildColumnExpr(model, where.field, where.path, where.value);
+    const mappedValue = this.mapWhereValue(where.value);
+
+    switch (where.op) {
+      case "eq":
+        if (where.value === null) return { sql: `${expr} IS NULL`, params: [] };
+        return { sql: `${expr} = ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "ne":
+        if (where.value === null) return { sql: `${expr} IS NOT NULL`, params: [] };
+        return { sql: `${expr} != ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "gt":
+        return { sql: `${expr} > ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "gte":
+        return { sql: `${expr} >= ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "lt":
+        return { sql: `${expr} < ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "lte":
+        return { sql: `${expr} <= ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
+      case "in": {
+        if (where.value.length === 0) return { sql: "1=0", params: [] };
+        const phs = [];
+        const inParams = [];
+        for (let i = 0; i < where.value.length; i++) {
+          phs.push(this.dialect.placeholder(startIndex + i));
+          inParams.push(this.mapWhereValue(where.value[i]));
+        }
+        return { sql: `${expr} IN (${phs.join(", ")})`, params: inParams };
+      }
+      case "not_in": {
+        if (where.value.length === 0) return { sql: "1=1", params: [] };
+        const phs = [];
+        const inParams = [];
+        for (let i = 0; i < where.value.length; i++) {
+          phs.push(this.dialect.placeholder(startIndex + i));
+          inParams.push(this.mapWhereValue(where.value[i]));
+        }
+        return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
+      }
+    }
+    throw new Error(`Unsupported operator: ${(where as any).op}`);
+  }
+
+  private buildCursor(
+    model: string,
+    cursor: Cursor<any>,
+    sortBy?: SortBy<any>[],
+    startIndex = 0,
+  ): { sql: string; params: unknown[] } {
+    const cursorValues = cursor.after as Record<string, unknown>;
+    const criteria = [];
+    if (sortBy && sortBy.length > 0) {
+      for (let i = 0; i < sortBy.length; i++) {
+        const s = sortBy[i]!;
+        if (cursorValues[s.field] !== undefined) {
+          criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
+        }
+      }
+    } else {
+      const keys = Object.keys(cursorValues);
+      for (let i = 0; i < keys.length; i++) {
+        criteria.push({ field: keys[i]!, direction: "asc" as const, path: undefined });
+      }
+    }
+
+    if (criteria.length === 0) return { sql: "", params: [] };
+
+    const orClauses = [];
+    const params = [];
+    let currentIdx = startIndex;
+
+    for (let i = 0; i < criteria.length; i++) {
+      const andClauses = [];
+      for (let j = 0; j < i; j++) {
+        const prev = criteria[j]!;
+        andClauses.push(
+          `${this.buildColumnExpr(model, prev.field, prev.path, cursorValues[prev.field])} = ${this.dialect.placeholder(currentIdx++)}`,
+        );
+        params.push(cursorValues[prev.field]);
+      }
+      const curr = criteria[i]!;
+      const op = curr.direction === "desc" ? "<" : ">";
+      // Lexicographic keyset pagination:
+      // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
+      andClauses.push(
+        `${this.buildColumnExpr(model, curr.field, curr.path, cursorValues[curr.field])} ${op} ${this.dialect.placeholder(currentIdx++)}`,
+      );
+      params.push(cursorValues[curr.field]);
+      orClauses.push(`(${andClauses.join(" AND ")})`);
+    }
+
+    return { sql: `(${orClauses.join(" OR ")})`, params };
+  }
+
+  protected mapInput(
+    fields: Record<string, Field>,
+    data: Record<string, unknown>,
+  ): Record<string, unknown> {
+    const res: Record<string, unknown> = {};
+    const keys = Object.keys(data);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]!;
+      const val = data[k];
+      const spec = fields[k];
+      if (val === undefined) continue;
+      if (val === null) {
+        res[k] = null;
+        continue;
+      }
+      if (spec?.type === "json" || spec?.type === "json[]") {
+        res[k] = JSON.stringify(val);
+      } else if (spec?.type === "boolean") {
+        res[k] = val === true ? 1 : 0;
+      } else {
+        res[k] = val;
+      }
+    }
+    return res;
+  }
+
+  protected mapWhereValue(value: unknown): unknown {
+    if (
+      value === null ||
+      typeof value === "boolean" ||
+      typeof value === "number" ||
+      typeof value === "string"
+    )
+      return value;
+    return JSON.stringify(value);
+  }
+
+  protected mapRow(modelName: string, row: Record<string, unknown>, select?: Select<any>): any {
+    const fields = this.getModel(modelName).fields;
+    const res: Record<string, unknown> = {};
+    const keys = select ?? Object.keys(row);
+
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]!;
+      const val = row[k];
+      const spec = fields[k];
+      if (spec === undefined || val === undefined || val === null) {
+        res[k] = val;
+        continue;
+      }
+      if (spec.type === "json" || spec.type === "json[]") {
+        res[k] = typeof val === "string" ? JSON.parse(val) : val;
+      } else if (spec.type === "boolean") {
+        res[k] = val === true || val === 1;
+      } else if (spec.type === "number" || spec.type === "timestamp") {
+        res[k] = mapNumeric(val);
+      } else {
+        res[k] = val;
+      }
+    }
+    return res;
+  }
+}
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 2bffa4a..ecf9ae1 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,753 +1,19 @@
-import type { Database as BunDatabase } from "bun:sqlite";
+import { SqliteDialect, createSqliteExecutor, type SqliteDriver } from "../dialects/sqlite";
+import { isQueryExecutor, type QueryExecutor } from "../dialects/types";
+import type { Adapter, Schema } from "../types";
+import { SqlAdapter } from "./sql";
 
-import type { Database as BetterSqlite3Database } from "better-sqlite3";
-import type { Database as SqliteDatabase } from "sqlite";
-
-import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
-import {
-  assertNoPrimaryKeyUpdates,
-  buildIdentityFilter,
-  getIdentityValues,
-  getPrimaryKeyFields,
-  isRecord,
-  JSON_PATH_INDEX,
-  mapNumeric,
-  quote,
-  validateJsonPath,
-} from "./common";
-
-export type SqliteValue = string | number | Uint8Array | null;
-
-/**
- * Clean interface for SQLite execution.
- */
-interface SqliteExecutor {
-  run(sql: string, params: SqliteValue[]): Promise<{ changes: number }>;
-  get(sql: string, params: SqliteValue[]): Promise<Record<string, unknown> | null>;
-  all(sql: string, params: SqliteValue[]): Promise<Record<string, unknown>[]>;
-}
-
-export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database | SqliteExecutor;
-
-/**
- * Internal interface for synchronous SQLite drivers.
- * Both Bun and Better-Sqlite3 expose `prepare` which returns a statement with run/get/all.
- */
-interface SyncStatement {
-  run(...params: unknown[]): unknown;
-  get(...params: unknown[]): unknown;
-  all(...params: unknown[]): unknown;
-}
-
-interface SyncDriver {
-  prepare(sql: string): SyncStatement;
-}
-
-/**
- * Helper to wrap synchronous statements and handle casting.
- * All environment sniffing and "any" usage is localized here.
- */
-function createExecutor(driver: SqliteDriver): SqliteExecutor {
-  // If it's already an executor, return it
-  if (isSqliteExecutor(driver)) {
-    return driver;
-  }
-
-  // Sniff for Sync Drivers (Bun or Better-Sqlite3)
-  if (isSyncDriver(driver)) {
-    const syncDb = driver as SyncDriver & (BunDatabase | BetterSqlite3Database);
-    return {
-      run: (sql, params) => {
-        const stmt = syncDb.prepare(sql);
-        const result = stmt.run(...params);
-        return Promise.resolve({
-          changes:
-            isRecord(result) && typeof result["changes"] === "number" ? result["changes"] : 0,
-        });
-      },
-      get: (sql, params) => {
-        const stmt = syncDb.prepare(sql);
-        const row = stmt.get(...params);
-        return Promise.resolve(isRecord(row) ? row : null);
-      },
-      all: (sql, params) => {
-        const stmt = syncDb.prepare(sql);
-        const rows = stmt.all(...params);
-        return Promise.resolve(
-          Array.isArray(rows)
-            ? rows.filter((item): item is Record<string, unknown> => isRecord(item))
-            : [],
-        );
-      },
-    };
-  }
-
-  // Otherwise assume it matches SqliteDatabase (async sqlite driver)
-  // Intentional assertion: ruled out executor and sync driver, remaining union member is SqliteDatabase
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-  return driver as SqliteExecutor;
-}
-
-function objIsObject(obj: unknown): obj is Record<string, unknown> {
-  return obj !== null && typeof obj === "object";
-}
-
-function isSqliteExecutor(obj: unknown): obj is SqliteExecutor {
-  return objIsObject(obj) && "run" in obj && "get" in obj && "all" in obj;
-}
-
-function hasNonAsyncGetter(obj: Record<string, unknown>): boolean {
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-  const getFn = obj["get"] as { constructor: { name: string } };
-  return getFn.constructor.name !== "AsyncFunction";
-}
-
-function isSyncDriver(obj: unknown): obj is SyncDriver {
-  if (!objIsObject(obj)) return false;
-  if (!("prepare" in obj) || typeof obj["prepare"] !== "function") return false;
-  if ("get" in obj && typeof obj["get"] === "function") {
-    return hasNonAsyncGetter(obj);
-  }
-  return true;
-}
-
-export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private executor: SqliteExecutor;
-  private savepointCounter = 0;
+export class SqliteAdapter<S extends Schema = Schema> extends SqlAdapter<S> implements Adapter<S> {
   // Top-level SQLite transactions on one shared connection must be serialized.
   private transactionQueue = Promise.resolve();
-  private isTransaction = false;
-
-  constructor(
-    private schema: S,
-    driver: SqliteDriver,
-    _isTransaction = false,
-  ) {
-    this.executor = createExecutor(driver);
-    this.isTransaction = _isTransaction;
-  }
-
-  async migrate(): Promise<void> {
-    for (const [name, model] of Object.entries(this.schema)) {
-      const columns = Object.entries(model.fields).map(([fieldName, field]) => {
-        const nullable = field.nullable === true ? "" : " NOT NULL";
-        return `${quote(fieldName)} ${this.mapFieldType(field)}${nullable}`;
-      });
-
-      const pk = `PRIMARY KEY (${getPrimaryKeyFields(model)
-        .map((field) => quote(field))
-        .join(", ")})`;
-
-      // oxlint-disable-next-line eslint/no-await-in-loop
-      await this.executor.run(
-        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
-        [],
-      );
-
-      if (model.indexes === undefined) continue;
-
-      for (let i = 0; i < model.indexes.length; i++) {
-        const index = model.indexes[i];
-        if (index === undefined) continue;
-
-        const fields = (Array.isArray(index.field) ? index.field : [index.field])
-          .map((field) => `${quote(field)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`)
-          .join(", ");
-
-        // oxlint-disable-next-line eslint/no-await-in-loop
-        await this.executor.run(
-          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${i}`)} ON ${quote(name)} (${fields})`,
-          [],
-        );
-      }
-    }
-  }
-
-  async create<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
-    const { model, data, select } = args;
-    const modelSpec = this.getModel(model);
-    const mappedData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(mappedData);
-    const placeholders = fields.map(() => "?").join(", ");
-    const columns = fields.map((field) => quote(field)).join(", ");
-    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
-
-    await this.executor.run(
-      `INSERT INTO ${quote(model)} (${columns}) VALUES (${placeholders})`,
-      params,
-    );
-
-    const result = await this.find<K, T>({
-      model,
-      where: buildIdentityFilter(modelSpec, data),
-      select,
-    });
-
-    if (result === null) {
-      throw new Error("Failed to refetch created record.");
-    }
-    return result;
-  }
-
-  async find<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
-    const { model, where, select } = args;
-    const builtWhere = this.buildWhere(model, where);
-    const sql = `SELECT ${this.buildSelect(select)} FROM ${quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const row = await this.executor.get(sql, builtWhere.params);
-    return row === null ? null : this.mapRow(model, row, select);
-  }
-
-  async findMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-    select?: Select<T>;
-    sortBy?: SortBy<T>[];
-    limit?: number;
-    offset?: number;
-    cursor?: Cursor<T>;
-  }): Promise<T[]> {
-    const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const parts: string[] = [`SELECT ${this.buildSelect(select)} FROM ${quote(model)}`];
-    const params: SqliteValue[] = [];
-
-    if (where !== undefined || cursor !== undefined) {
-      const builtWhere = this.buildWhere(model, where, cursor, sortBy);
-      parts.push(`WHERE ${builtWhere.sql}`);
-      params.push(...builtWhere.params);
-    }
-
-    if (sortBy !== undefined && sortBy.length > 0) {
-      const order = sortBy
-        .map((sort) => {
-          const expr = this.buildColumnExpr(model, sort.field as string, sort.path);
-          return `${expr} ${(sort.direction ?? "asc").toUpperCase()}`;
-        })
-        .join(", ");
-      parts.push(`ORDER BY ${order}`);
-    }
-
-    if (limit !== undefined) {
-      parts.push("LIMIT ?");
-      params.push(limit);
-    }
-
-    if (offset !== undefined) {
-      parts.push("OFFSET ?");
-      params.push(offset);
-    }
-
-    const rows = await this.executor.all(parts.join(" "), params);
-    return rows.map((row) => this.mapRow(model, row, select));
-  }
-
-  async update<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const existing = await this.find<K, T>({ model, where });
-    if (existing === null) {
-      return null;
-    }
-
-    const mappedData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(mappedData);
-    if (fields.length === 0) {
-      return existing;
-    }
-
-    const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
-    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
-    const primaryKeyWhere: Where<T> = buildIdentityFilter(modelSpec, existing);
-    const builtWhere = this.buildWhere(model, primaryKeyWhere);
-
-    await this.executor.run(`UPDATE ${quote(model)} SET ${assignments} WHERE ${builtWhere.sql}`, [
-      ...params,
-      ...builtWhere.params,
-    ]);
-
-    return this.find<K, T>({ model, where: primaryKeyWhere });
-  }
-
-  async updateMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const mappedData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(mappedData);
-    if (fields.length === 0) {
-      return 0;
-    }
-
-    const assignments = fields.map((field) => `${quote(field)} = ?`).join(", ");
-    const params = fields.map((field) => this.toSqliteValue(mappedData[field]));
-    let sql = `UPDATE ${quote(model)} SET ${assignments}`;
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const result = await this.executor.run(sql, params);
-    return result.changes;
-  }
-
-  async upsert<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    create: T;
-    update: Partial<T>;
-    where?: Where<T>;
-    select?: Select<T>;
-  }): Promise<T> {
-    const { model, create, update, where, select } = args;
-    const modelSpec = this.getModel(model);
-    const identityValues = getIdentityValues(modelSpec, create);
-    assertNoPrimaryKeyUpdates(modelSpec, update);
-
-    const mappedCreate = this.mapInput(modelSpec.fields, create);
-    const createFields = Object.keys(mappedCreate);
-    const mappedUpdate = this.mapInput(modelSpec.fields, update);
-    const updateFields = Object.keys(mappedUpdate);
-    const primaryKeyFields = getPrimaryKeyFields(modelSpec);
-
-    const conflictColumns = primaryKeyFields.map((field) => quote(field)).join(", ");
-    const insertColumns = createFields.map((field) => quote(field)).join(", ");
-    const insertPlaceholders = createFields.map(() => "?").join(", ");
-
-    let updateClause =
-      updateFields.length > 0
-        ? updateFields.map((field) => `${quote(field)} = ?`).join(", ")
-        : `${quote(primaryKeyFields[0]!)} = excluded.${quote(primaryKeyFields[0]!)}`;
 
-    const params =
-      updateFields.length > 0
-        ? [
-            ...createFields.map((field) => this.toSqliteValue(mappedCreate[field])),
-            ...updateFields.map((field) => this.toSqliteValue(mappedUpdate[field])),
-          ]
-        : createFields.map((field) => this.toSqliteValue(mappedCreate[field]));
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      updateClause += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    await this.executor.run(
-      `INSERT INTO ${quote(model)} (${insertColumns}) VALUES (${insertPlaceholders}) ON CONFLICT(${conflictColumns}) DO UPDATE SET ${updateClause}`,
-      params,
-    );
-
-    const result = await this.find<K, T>({
-      model,
-      where: buildIdentityFilter(modelSpec, identityValues),
-      select,
-    });
-
-    if (result === null) {
-      throw new Error("Failed to refetch upserted record.");
-    }
-    return result;
-  }
-
-  async delete<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T> }): Promise<void> {
-    const existing = await this.find<K, T>({ model: args.model, where: args.where });
-    if (existing === null) {
-      return;
-    }
-
-    const builtWhere = this.buildWhere(
-      args.model,
-      buildIdentityFilter(this.getModel(args.model), existing),
-    );
-    await this.executor.run(
-      `DELETE FROM ${quote(args.model)} WHERE ${builtWhere.sql}`,
-      builtWhere.params,
-    );
-  }
-
-  async deleteMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `DELETE FROM ${quote(model)}`;
-    const params: SqliteValue[] = [];
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const result = await this.executor.run(sql, params);
-    return result.changes;
-  }
-
-  async count<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `SELECT COUNT(*) as count FROM ${quote(model)}`;
-    const params: SqliteValue[] = [];
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      params.push(...builtWhere.params);
-    }
-
-    const result = await this.executor.get(sql, params);
-    return isRecord(result) && typeof result["count"] === "number" ? result["count"] : 0;
-  }
-
-  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    if (this.isTransaction) {
-      return this.runSavepoint(this.executor, fn);
-    }
-    return this.withTransactionLock(() => this.runSavepoint(this.executor, fn));
+  constructor(schema: S, driver: SqliteDriver | QueryExecutor) {
+    super(schema, isQueryExecutor(driver) ? driver : createSqliteExecutor(driver), SqliteDialect);
   }
 
-  private async runSavepoint<T>(
-    db: SqliteExecutor,
-    fn: (tx: Adapter<S>) => Promise<T>,
-  ): Promise<T> {
-    // Nested transactions stay on the current connection and use savepoints.
-    const savepoint = quote(`sp_${this.savepointCounter++}`);
-    const txAdapter = new SqliteAdapter(this.schema, db, true);
-
-    await db.run(`SAVEPOINT ${savepoint}`, []);
-    try {
-      const result = await fn(txAdapter);
-      await db.run(`RELEASE SAVEPOINT ${savepoint}`, []);
-      return result;
-    } catch (error) {
-      await db.run(`ROLLBACK TO SAVEPOINT ${savepoint}`, []);
-      throw error;
-    }
-  }
-
-  private async withTransactionLock<T>(fn: () => Promise<T>): Promise<T> {
-    let release!: () => void;
-    const current = new Promise<void>((resolve) => {
-      release = resolve;
+  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    return this.executor.transaction(async (innerExecutor) => {
+      return fn(new SqliteAdapter(this.schema, innerExecutor));
     });
-    const previous = this.transactionQueue;
-    this.transactionQueue = previous.then(() => current);
-
-    await previous;
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  }
-
-  private getModel<K extends keyof S & string>(model: K): S[K] {
-    const modelSpec = this.schema[model];
-    if (modelSpec === undefined) {
-      throw new Error(`Model ${model} not found in schema.`);
-    }
-    return modelSpec;
-  }
-
-  private mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "REAL";
-      case "boolean":
-      case "timestamp":
-        return "INTEGER";
-      case "json":
-      case "json[]":
-        // SQLite has no dedicated JSON column type, so JSON is stored as TEXT.
-        return "TEXT";
-      default:
-        return "TEXT";
-    }
-  }
-
-  private buildSelect<T>(select?: Select<T>): string {
-    return select === undefined ? "*" : select.map((field) => quote(field as string)).join(", ");
-  }
-
-  private buildColumnExpr(modelName: string, field: string, path?: string[]): string {
-    if (path === undefined || path.length === 0) {
-      return quote(field);
-    }
-
-    const model = this.schema[modelName as keyof S];
-    const fieldSpec = model?.fields[field];
-    if (fieldSpec?.type !== "json" && fieldSpec?.type !== "json[]") {
-      throw new Error(`Cannot use JSON path on non-JSON field: ${field}`);
-    }
-
-    const jsonPath =
-      "$" +
-      validateJsonPath(path)
-        .map((segment) => (JSON_PATH_INDEX.test(segment) ? `[${segment}]` : `.${segment}`))
-        .join("");
-    return `json_extract(${quote(field)}, '${jsonPath}')`;
-  }
-
-  private buildCursor<T>(
-    modelName: string,
-    cursor: Cursor<T>,
-    sortBy?: SortBy<T>[],
-  ): { sql: string; params: SqliteValue[] } {
-    type CursorSort = {
-      field: Extract<keyof T, string>;
-      direction: "asc" | "desc";
-      path?: string[];
-    };
-    const cursorValues = cursor.after as Partial<Record<string, unknown>>;
-    const sortCriteria: CursorSort[] =
-      sortBy !== undefined && sortBy.length > 0
-        ? sortBy
-            .filter((sort) => cursorValues[sort.field] !== undefined)
-            .map((sort) => ({
-              field: sort.field,
-              direction: sort.direction ?? "asc",
-              path: sort.path,
-            }))
-        : Object.keys(cursor.after).map((field) => ({
-            // Cursor keys come from the typed `Cursor<T>` surface.
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-            field: field as Extract<keyof T, string>,
-            direction: "asc" as const,
-            path: undefined,
-          }));
-
-    if (sortCriteria.length === 0) {
-      return { sql: "", params: [] };
-    }
-
-    const orClauses: string[] = [];
-    const params: SqliteValue[] = [];
-
-    for (let i = 0; i < sortCriteria.length; i++) {
-      const andClauses: string[] = [];
-
-      for (let j = 0; j < i; j++) {
-        const previous = sortCriteria[j]!;
-        andClauses.push(`${this.buildColumnExpr(modelName, previous.field, previous.path)} = ?`);
-        params.push(this.mapWhereValue(cursorValues[previous.field]));
-      }
-
-      const current = sortCriteria[i]!;
-      andClauses.push(
-        `${this.buildColumnExpr(modelName, current.field, current.path)} ${current.direction === "desc" ? "<" : ">"} ?`,
-      );
-      params.push(this.mapWhereValue(cursorValues[current.field]));
-      orClauses.push(`(${andClauses.join(" AND ")})`);
-    }
-
-    return {
-      sql: `(${orClauses.join(" OR ")})`,
-      params,
-    };
-  }
-
-  private buildWhere<T>(
-    modelName: string,
-    where?: Where<T>,
-    cursor?: Cursor<T>,
-    sortBy?: SortBy<T>[],
-  ): { sql: string; params: SqliteValue[] } {
-    const parts: string[] = [];
-    const params: SqliteValue[] = [];
-
-    if (where !== undefined) {
-      const builtWhere = this.buildWhereRecursive(modelName, where);
-      parts.push(builtWhere.sql);
-      params.push(...builtWhere.params);
-    }
-
-    if (cursor !== undefined) {
-      const builtCursor = this.buildCursor(modelName, cursor, sortBy);
-      if (builtCursor.sql !== "") {
-        parts.push(builtCursor.sql);
-        params.push(...builtCursor.params);
-      }
-    }
-
-    return {
-      sql: parts.length > 0 ? parts.map((part) => `(${part})`).join(" AND ") : "1=1",
-      params,
-    };
-  }
-
-  private buildWhereRecursive<T>(
-    modelName: string,
-    where: Where<T>,
-  ): { sql: string; params: SqliteValue[] } {
-    if ("and" in where) {
-      const parts = where.and.map((clause) => this.buildWhereRecursive(modelName, clause));
-      return {
-        sql: parts.map((part) => `(${part.sql})`).join(" AND "),
-        params: parts.flatMap((part) => part.params),
-      };
-    }
-
-    if ("or" in where) {
-      const parts = where.or.map((clause) => this.buildWhereRecursive(modelName, clause));
-      return {
-        sql: parts.map((part) => `(${part.sql})`).join(" OR "),
-        params: parts.flatMap((part) => part.params),
-      };
-    }
-
-    const expr = this.buildColumnExpr(modelName, where.field as string, where.path);
-
-    switch (where.op) {
-      case "eq":
-        if (where.value === null) {
-          return { sql: `${expr} IS NULL`, params: [] };
-        }
-        return { sql: `${expr} = ?`, params: [this.mapWhereValue(where.value)] };
-      case "ne":
-        if (where.value === null) {
-          return { sql: `${expr} IS NOT NULL`, params: [] };
-        }
-        return { sql: `${expr} != ?`, params: [this.mapWhereValue(where.value)] };
-      case "gt":
-        return { sql: `${expr} > ?`, params: [this.mapWhereValue(where.value)] };
-      case "gte":
-        return { sql: `${expr} >= ?`, params: [this.mapWhereValue(where.value)] };
-      case "lt":
-        return { sql: `${expr} < ?`, params: [this.mapWhereValue(where.value)] };
-      case "lte":
-        return { sql: `${expr} <= ?`, params: [this.mapWhereValue(where.value)] };
-      case "in":
-        if (where.value.length === 0) {
-          return { sql: "1=0", params: [] };
-        }
-        return {
-          sql: `${expr} IN (${where.value.map(() => "?").join(", ")})`,
-          params: where.value.map((value) => this.mapWhereValue(value)),
-        };
-      case "not_in":
-        if (where.value.length === 0) {
-          return { sql: "1=1", params: [] };
-        }
-        return {
-          sql: `${expr} NOT IN (${where.value.map(() => "?").join(", ")})`,
-          params: where.value.map((value) => this.mapWhereValue(value)),
-        };
-      default:
-        throw new Error(`Unsupported operator: ${(where as { op: string }).op}`);
-    }
-  }
-
-  private mapInput(
-    fields: Record<string, Field>,
-    data: Record<string, unknown> | Partial<Record<string, unknown>>,
-  ): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-
-    for (const [fieldName, field] of Object.entries(fields)) {
-      const value = data[fieldName];
-      if (value === undefined) continue;
-      if (value === null) {
-        result[fieldName] = null;
-        continue;
-      }
-
-      if (field.type === "json" || field.type === "json[]") {
-        result[fieldName] = JSON.stringify(value);
-      } else if (field.type === "boolean") {
-        result[fieldName] = value === true ? 1 : 0;
-      } else {
-        result[fieldName] = value;
-      }
-    }
-
-    return result;
-  }
-
-  private mapRow<K extends keyof S & string, T extends Record<string, unknown>>(
-    model: K,
-    row: Record<string, unknown>,
-    select?: Select<T>,
-  ): T {
-    const fieldSpecs = this.getModel(model).fields;
-    const output: Record<string, unknown> = {};
-    const selectedFields =
-      select === undefined ? Object.keys(row) : select.map((field) => field as string);
-
-    for (const fieldName of selectedFields) {
-      const fieldSpec = fieldSpecs[fieldName];
-      const value = row[fieldName];
-
-      if (fieldSpec === undefined || value === undefined || value === null) {
-        output[fieldName] = value;
-        continue;
-      }
-
-      if ((fieldSpec.type === "json" || fieldSpec.type === "json[]") && typeof value === "string") {
-        output[fieldName] = JSON.parse(value);
-      } else if (fieldSpec.type === "boolean") {
-        output[fieldName] = value === 1 || value === true;
-      } else if (fieldSpec.type === "number" || fieldSpec.type === "timestamp") {
-        output[fieldName] = mapNumeric(value);
-      } else {
-        output[fieldName] = value;
-      }
-    }
-
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    return output as T;
-  }
-
-  private mapWhereValue(value: unknown): SqliteValue {
-    if (value === null) return null;
-    if (typeof value === "boolean") return value ? 1 : 0;
-    if (typeof value === "object" && !(value instanceof Uint8Array)) {
-      return JSON.stringify(value);
-    }
-    return this.toSqliteValue(value);
-  }
-
-  private toSqliteValue(value: unknown): SqliteValue {
-    if (
-      typeof value === "string" ||
-      typeof value === "number" ||
-      value instanceof Uint8Array ||
-      value === null
-    ) {
-      return value as SqliteValue;
-    }
-
-    if (typeof value === "boolean") {
-      return value ? 1 : 0;
-    }
-
-    return JSON.stringify(value);
   }
 }
diff --git a/src/dialects/postgres.ts b/src/dialects/postgres.ts
new file mode 100644
index 0000000..09afd9a
--- /dev/null
+++ b/src/dialects/postgres.ts
@@ -0,0 +1,195 @@
+import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
+import type { Sql as PostgresJsSql, TransactionSql } from "postgres";
+
+import type { Field } from "../types";
+import type { QueryExecutor, SqlDialect } from "./types";
+
+export type PostgresDriver =
+  | PgClient
+  | PgPool
+  | PgPoolClient
+  | PostgresJsSql
+  | TransactionSql
+  | any;
+
+let LRU: any;
+// @ts-expect-error
+import("lru-cache")
+  .then((m) => {
+    LRU = m.LRUCache;
+  })
+  .catch(() => {});
+
+const pgCacheMap = new WeakMap<any>();
+
+function getPgCache(client: any) {
+  let cache = pgCacheMap.get(client);
+  if (!cache && LRU) {
+    cache = new LRU({ max: 100 });
+    pgCacheMap.set(client, cache);
+  }
+  return cache;
+}
+
+let queryCount = 0;
+function getNamedQuery(sql: string, cache?: any) {
+  if (!cache) return { text: sql };
+  let name = cache.get(sql);
+  if (!name) {
+    name = `no_orm_${queryCount++}`;
+    cache.set(sql, name);
+  }
+  return { name, text: sql };
+}
+
+export const PostgresDialect: SqlDialect = {
+  placeholder: (i) => `$${i + 1}`,
+  quote: (s) => `"${s.replaceAll('"', '""')}"`,
+  escapeLiteral: (s) => s.replaceAll("'", "''"),
+  mapFieldType(field: Field): string {
+    switch (field.type) {
+      case "string":
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+      case "number":
+        return "DOUBLE PRECISION";
+      case "boolean":
+        return "BOOLEAN";
+      case "timestamp":
+        return "BIGINT";
+      case "json":
+      case "json[]":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  },
+  buildJsonPath(path: string[]): string {
+    let res = "";
+    for (let i = 0; i < path.length; i++) {
+      if (i > 0) res += ", ";
+      res += `'${this.escapeLiteral(path[i]!)}'`;
+    }
+    return res;
+  },
+  buildJsonExtract(
+    column: string,
+    path: string[],
+    isNumeric?: boolean,
+    isBoolean?: boolean,
+  ): string {
+    const segments = this.buildJsonPath(path);
+    const base = `jsonb_extract_path_text(${column}, ${segments})`;
+    if (isNumeric) return `(${base})::double precision`;
+    if (isBoolean) return `(${base})::boolean`;
+    return base;
+  },
+  upsert(args) {
+    const { table, insertColumns, insertPlaceholders, updateColumns, conflictColumns, whereSql } =
+      args;
+    const pk = [];
+    for (let i = 0; i < conflictColumns.length; i++) pk.push(this.quote(conflictColumns[i]));
+
+    let updateSet = "";
+    if (updateColumns.length > 0) {
+      const sets = [];
+      for (let i = 0; i < updateColumns.length; i++) {
+        const col = updateColumns[i]!;
+        sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
+      }
+      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
+      if (whereSql) updateSet += ` WHERE ${whereSql}`;
+    } else {
+      updateSet = "DO NOTHING";
+    }
+
+    return {
+      sql: `INSERT INTO ${this.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${pk.join(", ")}) ${updateSet} RETURNING *`,
+    };
+  },
+};
+
+function isPostgresJs(driver: any): driver is PostgresJsSql {
+  return typeof driver.unsafe === "function" && typeof driver.begin === "function";
+}
+
+function isBunSql(driver: any): boolean {
+  return typeof driver.unsafe === "function" && typeof driver.transaction === "function";
+}
+
+function isPg(driver: any): boolean {
+  return typeof driver.query === "function";
+}
+
+function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
+  return {
+    all: (query, params) => sql.unsafe(query, params, { prepare: true }),
+    get: async (query, params) => {
+      const rows = await sql.unsafe(query, params, { prepare: true });
+      return rows[0];
+    },
+    run: async (query, params) => {
+      const res = await sql.unsafe(query, params, { prepare: true });
+      return { changes: (res as any).count ?? 0 };
+    },
+    transaction: (fn) => sql.begin((tx) => fn(createPostgresJsExecutor(tx))),
+  };
+}
+
+function createBunExecutor(sql: any): QueryExecutor {
+  return {
+    all: (query, params) => sql.unsafe(query, params),
+    get: async (query, params) => {
+      const rows = await sql.unsafe(query, params);
+      return rows[0];
+    },
+    run: async (query, params) => {
+      const res = await sql.unsafe(query, params);
+      return { changes: res.count ?? res.affectedRows ?? 0 };
+    },
+    transaction: (fn) => sql.transaction((tx: any) => fn(createBunExecutor(tx))),
+  };
+}
+
+function createPgExecutor(driver: any): QueryExecutor {
+  const cache = getPgCache(driver);
+  const executor: QueryExecutor = {
+    all: async (sql, params) => {
+      const query = getNamedQuery(sql, cache);
+      const res = await driver.query({ ...query, values: params });
+      return res.rows;
+    },
+    get: async (sql, params) => {
+      const query = getNamedQuery(sql, cache);
+      const res = await driver.query({ ...query, values: params });
+      return res.rows[0];
+    },
+    run: async (sql, params) => {
+      const query = getNamedQuery(sql, cache);
+      const res = await driver.query({ ...query, values: params });
+      return { changes: res.rowCount ?? 0 };
+    },
+    transaction: async (fn) => {
+      const isPool = typeof driver.connect === "function";
+      const client = isPool ? await driver.connect() : driver;
+      try {
+        await client.query("BEGIN");
+        const res = await fn(createPgExecutor(client));
+        await client.query("COMMIT");
+        return res;
+      } catch (e) {
+        await client.query("ROLLBACK");
+        throw e;
+      } finally {
+        if (isPool) client.release();
+      }
+    },
+  };
+  return executor;
+}
+
+export function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
+  if (isPostgresJs(driver)) return createPostgresJsExecutor(driver);
+  if (isBunSql(driver)) return createBunExecutor(driver);
+  if (isPg(driver)) return createPgExecutor(driver);
+  throw new Error("Unsupported Postgres driver.");
+}
diff --git a/src/dialects/sqlite.ts b/src/dialects/sqlite.ts
new file mode 100644
index 0000000..70d0502
--- /dev/null
+++ b/src/dialects/sqlite.ts
@@ -0,0 +1,109 @@
+import type { Database as BunDatabase } from "bun:sqlite";
+
+import type { Database as BetterSqlite3Database } from "better-sqlite3";
+import type { Database as SqliteDatabase } from "sqlite";
+
+import type { Field } from "../types";
+import type { QueryExecutor, SqlDialect } from "./types";
+
+export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database | any;
+
+export const SqliteDialect: SqlDialect = {
+  placeholder: () => "?",
+  quote: (s) => `"${s.replaceAll('"', '""')}"`,
+  escapeLiteral: (s) => s.replaceAll("'", "''"),
+  mapFieldType(field: Field): string {
+    switch (field.type) {
+      case "string":
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+      case "number":
+        return "REAL";
+      case "boolean":
+      case "timestamp":
+        return "INTEGER";
+      case "json":
+      case "json[]":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  },
+  buildJsonPath(path: string[]): string {
+    let res = "$";
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i]!;
+      let isIndex = true;
+      for (let j = 0; j < segment.length; j++) {
+        const c = segment.codePointAt(j);
+        if (c < 48 || c > 57) {
+          isIndex = false;
+          break;
+        }
+      }
+      if (isIndex) {
+        res += `[${segment}]`;
+      } else {
+        res += `.${segment}`;
+      }
+    }
+    return res;
+  },
+  buildJsonExtract(column: string, path: string[]): string {
+    return `json_extract(${column}, '${this.buildJsonPath(path)}')`;
+  },
+};
+
+function isSyncSqlite(driver: any): boolean {
+  return typeof driver.prepare === "function" && driver.get?.constructor.name !== "AsyncFunction";
+}
+
+function createSyncSqliteExecutor(driver: any): QueryExecutor {
+  return {
+    all: async (sql, params) => driver.prepare(sql).all(...(params ?? [])),
+    get: async (sql, params) => driver.prepare(sql).get(...(params ?? [])),
+    run: async (sql, params) => {
+      const res = driver.prepare(sql).run(...(params ?? []));
+      return { changes: res?.changes ?? 0 };
+    },
+    transaction: async (fn) => {
+      // Nested transactions stay on the current connection and use savepoints.
+      driver.prepare("BEGIN").run();
+      try {
+        const res = await fn(createSyncSqliteExecutor(driver));
+        driver.prepare("COMMIT").run();
+        return res;
+      } catch (e) {
+        driver.prepare("ROLLBACK").run();
+        throw e;
+      }
+    },
+  };
+}
+
+function createAsyncSqliteExecutor(driver: any): QueryExecutor {
+  return {
+    all: (sql, params) => driver.all(sql, params),
+    get: (sql, params) => driver.get(sql, params),
+    run: async (sql, params) => {
+      const res = await driver.run(sql, params);
+      return { changes: res?.changes ?? 0 };
+    },
+    transaction: async (fn) => {
+      // Nested transactions stay on the current connection and use savepoints.
+      await driver.run("BEGIN");
+      try {
+        const res = await fn(createAsyncSqliteExecutor(driver));
+        await driver.run("COMMIT");
+        return res;
+      } catch (e) {
+        await driver.run("ROLLBACK");
+        throw e;
+      }
+    },
+  };
+}
+
+export function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
+  if (isSyncSqlite(driver)) return createSyncSqliteExecutor(driver);
+  return createAsyncSqliteExecutor(driver);
+}
diff --git a/src/dialects/types.ts b/src/dialects/types.ts
new file mode 100644
index 0000000..58ad2e8
--- /dev/null
+++ b/src/dialects/types.ts
@@ -0,0 +1,8 @@
+export function isQueryExecutor(obj: any): obj is QueryExecutor {
+  return (
+    obj !== null &&
+    typeof obj === "object" &&
+    typeof obj.all === "function" &&
+    typeof obj.run === "function"
+  );
+}

From df88a92aac4f037131646e628f413c71f8055f22 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Wed, 22 Apr 2026 15:08:06 +0800
Subject: [PATCH 15/24] fix: bun typecheck

---
 src/adapters/common.ts      |  45 +++--
 src/adapters/memory.test.ts |  14 +-
 src/adapters/memory.ts      | 368 +++++++++++++++++++++++-------------
 src/adapters/postgres.ts    |   4 +-
 src/adapters/sql.ts         |  66 ++++---
 src/adapters/sqlite.ts      |   7 +-
 src/dialects/postgres.ts    | 168 ++++++++++------
 src/dialects/sqlite.ts      |  59 ++++--
 src/dialects/types.ts       |  44 ++++-
 src/types.ts                |   2 +-
 src/types/bun-sqlite.d.ts   |  20 ++
 src/types/lru-cache.d.ts    |  31 +++
 src/types/postgres.d.ts     |  16 ++
 13 files changed, 575 insertions(+), 269 deletions(-)
 create mode 100644 src/types/bun-sqlite.d.ts
 create mode 100644 src/types/lru-cache.d.ts
 create mode 100644 src/types/postgres.d.ts

diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 7e0b166..191f8fa 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -29,14 +29,15 @@ export function getPrimaryKeyFields(model: Model): string[] {
 /**
  * Extracts primary key values from a data object based on the model schema.
  */
-export function getIdentityValues(
+export function getIdentityValues<T extends Record<string, unknown>>(
   model: Model,
-  data: Record<string, unknown>,
-): Record<string, unknown> {
+  data: T,
+): Partial<T> {
   const pkFields = getPrimaryKeyFields(model);
-  const values: Record<string, unknown> = {};
+  const values: Partial<T> = {};
   for (let i = 0; i < pkFields.length; i++) {
-    const field = pkFields[i]!;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const field = pkFields[i]! as FieldName<T>;
     const val = data[field];
     if (val === undefined) {
       throw new Error(`Missing primary key field: ${field}`);
@@ -52,6 +53,9 @@ export function validateJsonPath(path: string[]): string[] {
     // Faster validation without regex
     for (let j = 0; j < segment.length; j++) {
       const c = segment.codePointAt(j);
+      if (c === undefined) {
+        throw new Error(`Invalid JSON path segment: ${segment}`);
+      }
       const isAlpha = (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
       const isDigit = c >= 48 && c <= 57;
       const isUnderscore = c === 95;
@@ -68,34 +72,43 @@ export function validateJsonPath(path: string[]): string[] {
  */
 export function buildIdentityFilter<T extends Record<string, unknown>>(
   model: Model,
-  source: Record<string, unknown>,
+  source: Partial<T>,
 ): Where<T> {
   const pkFields = getPrimaryKeyFields(model);
+  if (pkFields.length === 0) {
+    throw new Error("Model has no primary key defined.");
+  }
+  if (pkFields.length === 1) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const field = pkFields[0]! as FieldName<T>;
+    return {
+      field,
+      op: "eq" as const,
+      value: source[field],
+    };
+  }
+
   const clauses: Where<T>[] = [];
   for (let i = 0; i < pkFields.length; i++) {
-    const field = pkFields[i]!;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const field = pkFields[i]! as FieldName<T>;
     clauses.push({
-      field: field as FieldName<T>,
+      field,
       op: "eq" as const,
       value: source[field],
     });
   }
 
-  if (clauses.length === 1) {
-    return clauses[0]!;
-  }
-
   return { and: clauses };
 }
-
-export function assertNoPrimaryKeyUpdates(
+export function assertNoPrimaryKeyUpdates<T extends Record<string, unknown>>(
   model: Model,
-  data: Partial<Record<string, unknown>>,
+  data: Partial<T>,
 ): void {
   const pkFields = getPrimaryKeyFields(model);
   for (let i = 0; i < pkFields.length; i++) {
     const field = pkFields[i]!;
-    if (data[field] !== undefined) {
+    if ((data as Record<string, unknown>)[field] !== undefined) {
       throw new Error("Primary key updates are not supported.");
     }
   }
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index f9ecc61..26a1bd5 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -24,7 +24,7 @@ describe("MemoryAdapter", () => {
 
   beforeEach(async () => {
     adapter = new MemoryAdapter(schema);
-    await adapter.migrate({ schema });
+    await adapter.migrate();
   });
 
   it("should create and find a record", async () => {
@@ -128,13 +128,14 @@ describe("MemoryAdapter", () => {
       data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
     });
 
-    expect(() =>
+    // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
+    await expect(
       adapter.update<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
         data: { id: "u2" },
       }),
-    ).toThrow("Primary key updates are not supported.");
+    ).rejects.toThrow("Primary key updates are not supported.");
   });
 
   it("should delete a record", async () => {
@@ -288,7 +289,7 @@ describe("MemoryAdapter", () => {
       expect(found?.age).toBe(30);
     });
 
-    it("should throw error if primary key is missing in 'create' data", () => {
+    it("should throw error if primary key is missing in 'create' data", async () => {
       // Intentionally passing incomplete data to test validation
       // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
       const invalidData = {
@@ -296,13 +297,14 @@ describe("MemoryAdapter", () => {
         age: 20,
       } as unknown as User;
 
-      expect(() =>
+      // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
+      await expect(
         adapter.upsert({
           model: "users",
           create: invalidData,
           update: { age: 21 },
         }),
-      ).toThrow("Missing primary key field: id");
+      ).rejects.toThrow("Missing primary key field: id");
     });
   });
 
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 922113d..9b1301a 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -1,62 +1,60 @@
-import type {
-  Adapter,
-  Cursor,
-  FieldName,
-  InferModel,
-  Schema,
-  Select,
-  SortBy,
-  Where,
-} from "../types";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const LRUCache = require("lru-cache");
+
+import type { Adapter, Cursor, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
   getIdentityValues,
   getPrimaryKeyFields,
   isRecord,
-  mapNumeric,
 } from "./common";
 
-type Comparable = string | number;
 type RowData = Record<string, unknown>;
 
-let LRU: any;
-const lruPromise = import("lru-cache")
-  .then((m) => {
-    LRU = m.LRUCache;
-  })
-  .catch(() => {});
+const DEFAULT_MAX_SIZE = 1000;
+
+interface LRU {
+  has(key: string): boolean;
+  get(key: string): unknown;
+  set(key: string, value: unknown): void;
+  delete(key: string): void;
+  del(key: string): void;
+  forEach(cb: (value: unknown, key: string) => void): void;
+  entries?(): IterableIterator<[string, unknown]>;
+  keys?(): string[];
+  peek?(key: string): unknown;
+  size: number;
+}
 
 export interface MemoryAdapterOptions {
   maxSize?: number;
 }
 
 export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<string, any>();
-  private options: MemoryAdapterOptions;
+  private storage = new Map<keyof S, LRU>();
 
   constructor(
     private schema: S,
-    options: MemoryAdapterOptions = {},
-  ) {
-    this.options = options;
-  }
-
-  async migrate(): Promise<void> {
-    await lruPromise;
-    const keys = Object.keys(this.schema);
-    for (let i = 0; i < keys.length; i++) {
-      const name = keys[i]!;
-      if (!this.storage.has(name)) {
-        if (this.options.maxSize && LRU) {
-          this.storage.set(name, new LRU({ max: this.options.maxSize }));
-        } else {
-          this.storage.set(name, new Map());
-        }
+    private options?: MemoryAdapterOptions,
+  ) {}
+
+  migrate(): Promise<void> {
+    const keys = Object.keys(this.schema) as (keyof S)[];
+    for (const key of keys) {
+      const existing = this.storage.get(key);
+      if (existing === undefined) {
+        const max = this.options?.maxSize ?? DEFAULT_MAX_SIZE;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access
+        const LRUClass = (LRUCache.default ?? LRUCache) as new (o: { max: number }) => LRU;
+        this.storage.set(key, new LRUClass({ max }));
       }
     }
+    return Promise.resolve();
   }
 
-  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
     return fn(this);
   }
 
@@ -64,6 +62,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+    await Promise.resolve();
     const { model, data, select } = args;
     const modelStorage = this.getModelStorage(model);
     const pkValue = this.getPrimaryKeyString(model, data);
@@ -72,24 +71,29 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
-    const record = Object.assign({}, data);
+    const record: RowData = { ...data };
     modelStorage.set(pkValue, record);
 
-    return this.applySelect(record as any, select);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return this.applySelect(record as T, select);
   }
 
   async find<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    await Promise.resolve();
     const { model, where, select } = args;
     const modelStorage = this.getModelStorage(model);
 
-    const values = Array.from(modelStorage.values());
-    for (let i = 0; i < values.length; i++) {
-      const record = values[i] as T;
-      if (this.evaluateWhere(where, record)) {
-        return this.applySelect(record, select);
+    for (const [, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return this.applySelect(value as T, select);
       }
     }
 
@@ -108,22 +112,28 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     offset?: number;
     cursor?: Cursor<T>;
   }): Promise<T[]> {
+    await Promise.resolve();
     const { model, where, select, sortBy, limit, offset, cursor } = args;
     const modelStorage = this.getModelStorage(model);
 
-    let results: T[] = [];
-    const rawValues = Array.from(modelStorage.values());
-    for (let i = 0; i < rawValues.length; i++) {
-      const record = rawValues[i] as T;
-      if (!where || this.evaluateWhere(where, record)) {
-        results.push(record);
+    const results: T[] = [];
+    for (const [, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        results.push(value as T);
       }
     }
 
-    if (cursor) {
+    let processedResults = [...results];
+
+    if (cursor !== undefined) {
       const cursorValues = cursor.after as Record<string, unknown>;
-      const criteria = [];
-      if (sortBy && sortBy.length > 0) {
+      const criteria: { field: string; direction: "asc" | "desc"; path?: string[] }[] = [];
+      if (sortBy !== undefined && sortBy.length > 0) {
         for (let i = 0; i < sortBy.length; i++) {
           const s = sortBy[i]!;
           if (cursorValues[s.field] !== undefined) {
@@ -133,21 +143,21 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       } else {
         const keys = Object.keys(cursorValues);
         for (let i = 0; i < keys.length; i++) {
-          criteria.push({ field: keys[i]!, direction: "asc" as const, path: undefined });
+          const k = keys[i]!;
+          criteria.push({ field: k, direction: "asc", path: undefined });
         }
       }
 
       if (criteria.length > 0) {
         const filtered: T[] = [];
-        for (let i = 0; i < results.length; i++) {
-          const record = results[i]!;
+        for (let i = 0; i < processedResults.length; i++) {
+          const record = processedResults[i]!;
           let match = false;
-          // Lexicographic keyset pagination:
-          // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
           for (let j = 0; j < criteria.length; j++) {
             const curr = criteria[j]!;
-            const recordVal = this.getValue(record, curr.field as any, curr.path);
-            const cursorVal = cursorValues[curr.field as any];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            const recordVal = this.getValue(record as unknown as RowData, curr.field, curr.path);
+            const cursorVal = cursorValues[curr.field];
             const comp = this.compareValues(recordVal, cursorVal);
 
             if (comp === 0) continue;
@@ -158,16 +168,21 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
           }
           if (match) filtered.push(record);
         }
-        results = filtered;
+        processedResults = filtered;
       }
     }
 
-    if (sortBy && sortBy.length > 0) {
-      results.sort((a, b) => {
+    if (sortBy !== undefined && sortBy.length > 0) {
+      processedResults.sort((a, b) => {
         for (let i = 0; i < sortBy.length; i++) {
-          const { field, direction, path } = sortBy[i]!;
-          const valA = this.getValue(a, field, path);
-          const valB = this.getValue(b, field, path);
+          const s = sortBy[i]!;
+          const field = s.field;
+          const direction = s.direction;
+          const path = s.path;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          const valA = this.getValue(a as unknown as RowData, field, path);
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          const valB = this.getValue(b as unknown as RowData, field, path);
           if (valA === valB) continue;
           const comparison = this.compareValues(valA, valB);
           if (comparison === 0) continue;
@@ -178,32 +193,35 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const start = offset ?? 0;
-    const end = limit === undefined ? results.length : start + limit;
-    const finalResults: T[] = [];
-    for (let i = start; i < end && i < results.length; i++) {
-      finalResults.push(this.applySelect(results[i]!, select));
+    const end = limit === undefined ? processedResults.length : start + limit;
+    const paginatedResults: T[] = [];
+    for (let i = start; i < end && i < processedResults.length; i++) {
+      paginatedResults.push(this.applySelect(processedResults[i]!, select));
     }
 
-    return finalResults;
+    return paginatedResults;
   }
 
   async update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+    await Promise.resolve();
     const { model, where, data } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, data);
     const modelStorage = this.getModelStorage(model);
 
-    const entries = Array.from(modelStorage.entries());
-    for (let i = 0; i < entries.length; i++) {
-      const [pk, record] = entries[i]!;
-      const modelRecord = record as T;
-      if (this.evaluateWhere(where, modelRecord)) {
-        const updated = Object.assign({}, modelRecord, data);
-        modelStorage.set(pk, updated);
-        return this.applySelect(updated as any);
+    for (const [key, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        this.evaluateWhere(where as unknown as Where, value)
+      ) {
+        const updated: RowData = { ...(value as object), ...(data as object) };
+        modelStorage.set(key, updated);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return this.applySelect(updated as T);
       }
     }
 
@@ -214,24 +232,33 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    await Promise.resolve();
     const { model, where, data } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, data);
     const modelStorage = this.getModelStorage(model);
-    let count = 0;
 
-    const entries = Array.from(modelStorage.entries());
-    for (let i = 0; i < entries.length; i++) {
-      const [pk, record] = entries[i]!;
-      const modelRecord = record as T;
-      if (where === undefined || this.evaluateWhere(where, modelRecord)) {
-        const updated = Object.assign({}, modelRecord, data);
-        modelStorage.set(pk, updated);
-        count++;
+    const updates: { key: string; record: T }[] = [];
+    for (const [key, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        updates.push({ key, record: value as T });
       }
     }
 
-    return count;
+    for (let i = 0; i < updates.length; i++) {
+      const item = updates[i]!;
+      const key = item.key;
+      const record = item.record;
+      const updated: RowData = { ...(record as object), ...(data as object) };
+      modelStorage.set(key, updated);
+    }
+
+    return updates.length;
   }
 
   async upsert<
@@ -244,6 +271,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where?: Where<T>;
     select?: Select<T>;
   }): Promise<T> {
+    await Promise.resolve();
     const { model, create, update, where, select } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, update);
@@ -252,14 +280,19 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const modelStorage = this.getModelStorage(model);
     const existing = modelStorage.get(pkValue);
 
-    if (existing !== undefined) {
-      const modelExisting = existing as T;
-      if (where === undefined || this.evaluateWhere(where, modelExisting)) {
-        const updated = Object.assign({}, modelExisting, update);
+    if (existing !== undefined && isRecord(existing)) {
+      if (
+        where === undefined ||
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        this.evaluateWhere(where as unknown as Where, existing)
+      ) {
+        const updated: RowData = { ...(existing as object), ...(update as object) };
         modelStorage.set(pkValue, updated);
-        return this.applySelect(updated as any, select);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return this.applySelect(updated as T, select);
       }
-      return this.applySelect(modelExisting, select);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      return this.applySelect(existing as T, select);
     }
 
     return this.create({ model, data: create, select });
@@ -269,14 +302,17 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T> }): Promise<void> {
+    await Promise.resolve();
     const { model, where } = args;
     const modelStorage = this.getModelStorage(model);
 
-    const entries = Array.from(modelStorage.entries());
-    for (let i = 0; i < entries.length; i++) {
-      const [pk, record] = entries[i]!;
-      if (this.evaluateWhere(where, record as T)) {
-        modelStorage.delete(pk);
+    for (const [key, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        this.evaluateWhere(where as unknown as Where, value)
+      ) {
+        this.lruDelete(modelStorage, key);
         return;
       }
     }
@@ -286,50 +322,86 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
+    await Promise.resolve();
     const { model, where } = args;
     const modelStorage = this.getModelStorage(model);
-    let count = 0;
-
-    const entries = Array.from(modelStorage.entries());
-    for (let i = 0; i < entries.length; i++) {
-      const [pk, record] = entries[i]!;
-      if (where === undefined || this.evaluateWhere(where, record as T)) {
-        modelStorage.delete(pk);
-        count++;
+    const toDelete: string[] = [];
+
+    for (const [key, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
+      ) {
+        toDelete.push(key);
       }
     }
 
-    return count;
+    for (let i = 0; i < toDelete.length; i++) {
+      this.lruDelete(modelStorage, toDelete[i]!);
+    }
+
+    return toDelete.length;
   }
 
   async count<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
+    await Promise.resolve();
     const { model, where } = args;
     const modelStorage = this.getModelStorage(model);
 
     if (where === undefined) return modelStorage.size;
 
     let count = 0;
-    const values = Array.from(modelStorage.values());
-    for (let i = 0; i < values.length; i++) {
-      if (this.evaluateWhere(where, values[i] as T)) {
+    for (const [, value] of this.getEntries(modelStorage)) {
+      if (
+        isRecord(value) &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        this.evaluateWhere(where as unknown as Where, value)
+      ) {
         count++;
       }
     }
     return count;
   }
 
-  private getModelStorage(model: string): any {
+  private lruDelete(lru: LRU, key: string): void {
+    if (typeof lru.delete === "function") {
+      lru.delete(key);
+    } else if (typeof lru.del === "function") {
+      lru.del(key);
+    }
+  }
+
+  private *getEntries(lru: LRU): IterableIterator<[string, unknown]> {
+    if (typeof lru.entries === "function") {
+      yield* lru.entries();
+    } else if (typeof lru.keys === "function") {
+      const keys = lru.keys();
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i]!;
+        const v = typeof lru.peek === "function" ? lru.peek(k) : lru.get(k);
+        yield [k, v];
+      }
+    } else {
+      const entries: [string, unknown][] = [];
+      lru.forEach((v, k) => entries.push([k, v]));
+      yield* entries;
+    }
+  }
+
+  private getModelStorage<K extends keyof S & string>(model: K): LRU {
     const storage = this.storage.get(model);
-    if (!storage) throw new Error(`Model ${model} not initialized. Call migrate() first.`);
+    if (storage === undefined)
+      throw new Error(`Model ${model} not initialized. Call migrate() first.`);
     return storage;
   }
 
-  private getModel(model: string): S[keyof S] {
+  private getModel<K extends keyof S & string>(model: K): S[K] {
     const spec = this.schema[model];
-    if (!spec) throw new Error(`Model ${model} not found in schema`);
+    if (spec === undefined) throw new Error(`Model ${model} not found in schema`);
     return spec;
   }
 
@@ -340,47 +412,65 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     let res = "";
     for (let i = 0; i < pkFields.length; i++) {
       if (i > 0) res += "|";
-      res += String(pkValues[pkFields[i]!] ?? "");
+      const pkField = pkFields[i]!;
+      const val = pkValues[pkField];
+      if (val !== null && val !== undefined) {
+        if (typeof val === "object") {
+          res += JSON.stringify(val);
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-base-to-string
+          res += String(val);
+        }
+      }
     }
     return res;
   }
 
   private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
-    if (!select) return Object.assign({}, record);
-    const res = {} as T;
+    if (select === undefined) {
+      return { ...record };
+    }
+    const res: RowData = {};
     for (let i = 0; i < select.length; i++) {
-      const k = select[i]! as string;
-      (res as any)[k] = record[k] ?? null;
+      const k = select[i]!;
+      res[k] = record[k] ?? null;
     }
-    return res;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return res as T;
   }
 
-  private getValue(record: any, field: string, path?: string[]): unknown {
+  private getValue(record: RowData, field: string, path?: string[]): unknown {
     let val = record[field];
-    if (path && path.length > 0) {
+    if (path !== undefined && path.length > 0) {
       for (let i = 0; i < path.length; i++) {
         if (!isRecord(val)) return undefined;
-        val = val[path[i]!];
+        const subKey = path[i]!;
+        val = val[subKey];
       }
     }
     return val;
   }
 
-  private evaluateWhere(where: Where<any>, record: any): boolean {
+  private evaluateWhere(where: Where, record: RowData): boolean {
     if ("and" in where) {
-      for (let i = 0; i < where.and.length; i++) {
-        if (!this.evaluateWhere(where.and[i]!, record)) return false;
+      const and = where.and;
+      for (let i = 0; i < and.length; i++) {
+        if (!this.evaluateWhere(and[i]!, record)) return false;
       }
       return true;
     }
     if ("or" in where) {
-      for (let i = 0; i < where.or.length; i++) {
-        if (this.evaluateWhere(where.or[i]!, record)) return true;
+      const or = where.or;
+      for (let i = 0; i < or.length; i++) {
+        if (this.evaluateWhere(or[i]!, record)) return true;
       }
       return false;
     }
 
-    const { field, op, value, path } = where as any;
+    const field = where.field;
+    const op = where.op;
+    const value = where.value;
+    const path = where.path;
     const recordVal = this.getValue(record, field, path);
 
     switch (op) {
@@ -406,12 +496,18 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
   private compareValues(left: unknown, right: unknown): number {
     if (left === right) return 0;
-    if (left === null || left === undefined) return -1;
-    if (right === null || right === undefined) return 1;
+    if (left === undefined) return -1;
+    if (right === undefined) return 1;
+    if (left === null) return -1;
+    if (right === null) return 1;
     if (typeof left !== typeof right) return 0;
-    if (typeof left === "string" || typeof left === "number") {
-      if (left < (right as any)) return -1;
-      if (left > (right as any)) return 1;
+    if (typeof left === "string" && typeof right === "string") {
+      if (left < right) return -1;
+      if (left > right) return 1;
+    }
+    if (typeof left === "number" && typeof right === "number") {
+      if (left < right) return -1;
+      if (left > right) return 1;
     }
     return 0;
   }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 098e4eb..007d79d 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -15,8 +15,8 @@ export class PostgresAdapter<S extends Schema = Schema>
     );
   }
 
-  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    return this.executor.transaction(async (innerExecutor) => {
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    return this.executor.transaction((innerExecutor) => {
       return fn(new PostgresAdapter(this.schema, innerExecutor));
     });
   }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 1d2aa43..3f0d609 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -5,7 +5,6 @@ import {
   buildIdentityFilter,
   getIdentityValues,
   getPrimaryKeyFields,
-  isRecord,
   mapNumeric,
 } from "./common";
 
@@ -18,6 +17,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   async migrate(): Promise<void> {
     const models = Object.entries(this.schema);
+    const runPromises: Promise<unknown>[] = [];
     for (let i = 0; i < models.length; i++) {
       const [name, model] = models[i]!;
       const fields = Object.entries(model.fields);
@@ -25,6 +25,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       for (let j = 0; j < fields.length; j++) {
         const [fieldName, field] = fields[j]!;
         const nullable = field.nullable === true ? "" : " NOT NULL";
+
         columns.push(
           `${this.dialect.quote(fieldName)} ${this.dialect.mapFieldType(field)}${nullable}`,
         );
@@ -37,9 +38,11 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       }
       const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
 
-      await this.executor.run(
-        `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
-        [],
+      runPromises.push(
+        this.executor.run(
+          `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
+          [],
+        ),
       );
 
       if (model.indexes) {
@@ -52,13 +55,16 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
               `${this.dialect.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
             );
           }
-          await this.executor.run(
-            `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
-            [],
+          runPromises.push(
+            this.executor.run(
+              `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
+              [],
+            ),
           );
         }
       }
     }
+    await Promise.all(runPromises);
   }
 
   async create<
@@ -67,6 +73,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
   >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
     const { model, data, select } = args;
     const modelSpec = this.getModel(model);
+
     const insertData = this.mapInput(modelSpec.fields, data);
     const fields = Object.keys(insertData);
 
@@ -82,17 +89,20 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     }
 
     const sql = `INSERT INTO ${this.dialect.quote(model)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${this.buildSelect(select)}`;
-    const row = await this.executor.get<Record<string, unknown>>(sql, values);
+    const row = await this.executor.get(sql, values);
 
     if (!row) {
       // Fallback for drivers that don't support RETURNING
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
       return (await this.find({
         model,
-        where: buildIdentityFilter(modelSpec, data),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        where: buildIdentityFilter(modelSpec, data) as unknown as Where<T>,
         select,
       })) as T;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return this.mapRow(model, row, select);
   }
 
@@ -103,7 +113,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     const { model, where, select } = args;
     const builtWhere = this.buildWhere(model, where);
     const sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const row = await this.executor.get<Record<string, unknown>>(sql, builtWhere.params);
+    const row = await this.executor.get(sql, builtWhere.params);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return row ? this.mapRow(model, row, select) : null;
   }
 
@@ -152,10 +163,14 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       params.push(offset);
     }
 
-    const rows = await this.executor.all<Record<string, unknown>>(sql, params);
+    const rows = await this.executor.all(sql, params);
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
-      result.push(this.mapRow(model, rows[i], select));
+      const row = rows[i];
+      if (row) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-argument
+        result.push(this.mapRow(model, row, select));
+      }
     }
     return result;
   }
@@ -188,11 +203,12 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       params.push(builtWhere.params[i]);
     }
 
-    const row = await this.executor.get<Record<string, unknown>>(sql, params);
+    const row = await this.executor.get(sql, params);
     if (!row) {
       // Check if it exists and return it if no changes were needed or RETURNING not supported
       return this.find({ model, where });
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return this.mapRow(model, row);
   }
 
@@ -285,8 +301,10 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
         select,
         whereSql,
       });
-      const row = await this.executor.get<Record<string, unknown>>(sql, upsertParams ?? params);
-      if (row) return this.mapRow(model, row, select);
+      const row = await this.executor.get(sql, upsertParams ?? params);
+      if (row)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
+        return this.mapRow(model, row, select);
     } else {
       // Generic fallback for ON CONFLICT (Postgres/SQLite)
       const conflictTarget = [];
@@ -309,14 +327,17 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       }
 
       const sql = `INSERT INTO ${this.dialect.quote(model)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${this.buildSelect(select)}`;
-      const row = await this.executor.get<Record<string, unknown>>(sql, params);
-      if (row) return this.mapRow(model, row, select);
+      const row = await this.executor.get(sql, params);
+      if (row)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
+        return this.mapRow(model, row, select);
     }
 
     const identityValues = getIdentityValues(modelSpec, create);
     const existing = await this.find({
       model,
-      where: buildIdentityFilter(modelSpec, identityValues),
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      where: buildIdentityFilter(modelSpec, identityValues) as unknown as Where<T>,
       select,
     });
     if (!existing) throw new Error("Failed to refetch upserted record.");
@@ -363,7 +384,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       sql += ` WHERE ${builtWhere.sql}`;
       for (let i = 0; i < builtWhere.params.length; i++) params.push(builtWhere.params[i]);
     }
-    const row = await this.executor.get<Record<string, unknown>>(sql, params);
+    const row = await this.executor.get(sql, params);
     if (!row) return 0;
     const count = row["count"];
     return typeof count === "number" ? count : Number(count ?? 0);
@@ -371,7 +392,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   // --- HELPERS ---
 
-  protected getModel(model: string): S[keyof S] {
+  protected getModel<K extends keyof S & string>(model: K): S[K] {
     const spec = this.schema[model];
     if (!spec) throw new Error(`Model ${model} not found in schema.`);
     return spec;
@@ -508,7 +529,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
         return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
       }
     }
-    throw new Error(`Unsupported operator: ${(where as any).op}`);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access
+    throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
   }
 
   private buildCursor(
@@ -517,7 +539,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     sortBy?: SortBy<any>[],
     startIndex = 0,
   ): { sql: string; params: unknown[] } {
-    const cursorValues = cursor.after as Record<string, unknown>;
+    const cursorValues = cursor.after;
     const criteria = [];
     if (sortBy && sortBy.length > 0) {
       for (let i = 0; i < sortBy.length; i++) {
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index ecf9ae1..9cd9470 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -4,15 +4,12 @@ import type { Adapter, Schema } from "../types";
 import { SqlAdapter } from "./sql";
 
 export class SqliteAdapter<S extends Schema = Schema> extends SqlAdapter<S> implements Adapter<S> {
-  // Top-level SQLite transactions on one shared connection must be serialized.
-  private transactionQueue = Promise.resolve();
-
   constructor(schema: S, driver: SqliteDriver | QueryExecutor) {
     super(schema, isQueryExecutor(driver) ? driver : createSqliteExecutor(driver), SqliteDialect);
   }
 
-  async transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    return this.executor.transaction(async (innerExecutor) => {
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    return this.executor.transaction((innerExecutor) => {
       return fn(new SqliteAdapter(this.schema, innerExecutor));
     });
   }
diff --git a/src/dialects/postgres.ts b/src/dialects/postgres.ts
index 09afd9a..2648a19 100644
--- a/src/dialects/postgres.ts
+++ b/src/dialects/postgres.ts
@@ -10,35 +10,16 @@ export type PostgresDriver =
   | PgPoolClient
   | PostgresJsSql
   | TransactionSql
-  | any;
-
-let LRU: any;
-// @ts-expect-error
-import("lru-cache")
-  .then((m) => {
-    LRU = m.LRUCache;
-  })
-  .catch(() => {});
-
-const pgCacheMap = new WeakMap<any>();
-
-function getPgCache(client: any) {
-  let cache = pgCacheMap.get(client);
-  if (!cache && LRU) {
-    cache = new LRU({ max: 100 });
-    pgCacheMap.set(client, cache);
-  }
-  return cache;
+  | BunSqlDriver;
+
+export interface BunSqlDriver {
+  unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
+  transaction<T>(fn: (tx: BunSqlDriver) => Promise<T>): Promise<T>;
 }
 
 let queryCount = 0;
-function getNamedQuery(sql: string, cache?: any) {
-  if (!cache) return { text: sql };
-  let name = cache.get(sql);
-  if (!name) {
-    name = `no_orm_${queryCount++}`;
-    cache.set(sql, name);
-  }
+function getNamedQuery(sql: string) {
+  const name = `no_orm_${queryCount++}`;
   return { name, text: sql };
 }
 
@@ -79,15 +60,18 @@ export const PostgresDialect: SqlDialect = {
   ): string {
     const segments = this.buildJsonPath(path);
     const base = `jsonb_extract_path_text(${column}, ${segments})`;
-    if (isNumeric) return `(${base})::double precision`;
-    if (isBoolean) return `(${base})::boolean`;
+    if (isNumeric === true) return `(${base})::double precision`;
+    if (isBoolean === true) return `(${base})::boolean`;
     return base;
   },
   upsert(args) {
     const { table, insertColumns, insertPlaceholders, updateColumns, conflictColumns, whereSql } =
       args;
-    const pk = [];
-    for (let i = 0; i < conflictColumns.length; i++) pk.push(this.quote(conflictColumns[i]));
+    const pk: string[] = [];
+    for (let i = 0; i < conflictColumns.length; i++) {
+      const col = conflictColumns[i];
+      if (col !== undefined) pk.push(this.quote(col));
+    }
 
     let updateSet = "";
     if (updateColumns.length > 0) {
@@ -97,7 +81,7 @@ export const PostgresDialect: SqlDialect = {
         sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
       }
       updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-      if (whereSql) updateSet += ` WHERE ${whereSql}`;
+      if (whereSql !== undefined) updateSet += ` WHERE ${whereSql}`;
     } else {
       updateSet = "DO NOTHING";
     }
@@ -108,34 +92,92 @@ export const PostgresDialect: SqlDialect = {
   },
 };
 
-function isPostgresJs(driver: any): driver is PostgresJsSql {
-  return typeof driver.unsafe === "function" && typeof driver.begin === "function";
+function isPostgresJs(driver: unknown): driver is PostgresJsSql {
+  if (typeof driver !== "object" || driver === null) return false;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const record = driver as Record<string, unknown>;
+  return (
+    "unsafe" in record &&
+    "begin" in record &&
+    typeof record["unsafe"] === "function" &&
+    typeof record["begin"] === "function"
+  );
 }
 
-function isBunSql(driver: any): boolean {
-  return typeof driver.unsafe === "function" && typeof driver.transaction === "function";
+function isBunSql(driver: unknown): driver is BunSqlDriver {
+  if (typeof driver !== "object" || driver === null) return false;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const record = driver as Record<string, unknown>;
+  return (
+    "unsafe" in record &&
+    "transaction" in record &&
+    typeof record["unsafe"] === "function" &&
+    typeof record["transaction"] === "function"
+  );
 }
 
-function isPg(driver: any): boolean {
-  return typeof driver.query === "function";
+function isPg(driver: unknown): driver is PgClient | PgPool | PgPoolClient {
+  if (typeof driver !== "object" || driver === null) return false;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const record = driver as Record<string, unknown>;
+  return "query" in record && typeof record["query"] === "function";
 }
 
 function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
   return {
-    all: (query, params) => sql.unsafe(query, params, { prepare: true }),
+    all: (query, params) => sql.unsafe(query, params),
     get: async (query, params) => {
-      const rows = await sql.unsafe(query, params, { prepare: true });
+      const rows = await sql.unsafe(query, params);
       return rows[0];
     },
     run: async (query, params) => {
-      const res = await sql.unsafe(query, params, { prepare: true });
-      return { changes: (res as any).count ?? 0 };
+      const res = await sql.unsafe(query, params);
+      const count = getPgQueryResultCount(res);
+      return { changes: count };
     },
     transaction: (fn) => sql.begin((tx) => fn(createPostgresJsExecutor(tx))),
   };
 }
 
-function createBunExecutor(sql: any): QueryExecutor {
+function getPgQueryResultRows<T = unknown[]>(result: unknown): T {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  if (Array.isArray(result)) return result as T;
+  if (typeof result === "object" && result !== null && "rows" in result) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return (result as Record<string, unknown>)["rows"] as T;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  return [] as T;
+}
+
+function getPgQueryResultCount(result: unknown): number {
+  if (typeof result === "object" && result !== null) {
+    const possibleProps = ["count", "rowCount", "rowsAffected"];
+    for (const prop of possibleProps) {
+      if (prop in result) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const val = (result as Record<string, unknown>)[prop];
+        if (typeof val === "number") return val;
+      }
+    }
+  }
+  return 0;
+}
+
+function getBunQueryResultCount(result: unknown): number {
+  if (typeof result === "object" && result !== null) {
+    const possibleProps = ["changes", "rowCount", "rowsAffected", "affectedRows"];
+    for (const prop of possibleProps) {
+      if (prop in result) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const val = (result as Record<string, unknown>)[prop];
+        if (typeof val === "number") return val;
+      }
+    }
+  }
+  return 0;
+}
+function createBunExecutor(sql: BunSqlDriver): QueryExecutor {
   return {
     all: (query, params) => sql.unsafe(query, params),
     get: async (query, params) => {
@@ -144,47 +186,59 @@ function createBunExecutor(sql: any): QueryExecutor {
     },
     run: async (query, params) => {
       const res = await sql.unsafe(query, params);
-      return { changes: res.count ?? res.affectedRows ?? 0 };
+      const count = getBunQueryResultCount(res);
+      return { changes: count };
     },
-    transaction: (fn) => sql.transaction((tx: any) => fn(createBunExecutor(tx))),
+    transaction: (fn) => sql.transaction((tx) => fn(createBunExecutor(tx))),
   };
 }
 
-function createPgExecutor(driver: any): QueryExecutor {
-  const cache = getPgCache(driver);
-  const executor: QueryExecutor = {
+function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
+  return {
     all: async (sql, params) => {
-      const query = getNamedQuery(sql, cache);
+      const query = getNamedQuery(sql);
       const res = await driver.query({ ...query, values: params });
-      return res.rows;
+      return getPgQueryResultRows(res);
     },
     get: async (sql, params) => {
-      const query = getNamedQuery(sql, cache);
+      const query = getNamedQuery(sql);
       const res = await driver.query({ ...query, values: params });
-      return res.rows[0];
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      const rows = getPgQueryResultRows(res) as Record<string, unknown>[];
+      return rows[0];
     },
     run: async (sql, params) => {
-      const query = getNamedQuery(sql, cache);
+      const query = getNamedQuery(sql);
       const res = await driver.query({ ...query, values: params });
-      return { changes: res.rowCount ?? 0 };
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      const typed = res as unknown as Record<string, unknown>;
+      const changes = typed["rowsAffected"] ?? typed["rowCount"] ?? 0;
+      return { changes: typeof changes === "number" ? changes : 0 };
     },
     transaction: async (fn) => {
-      const isPool = typeof driver.connect === "function";
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      const poolDriver = driver as unknown as Record<string, unknown>;
+      const isPool = "release" in poolDriver && typeof poolDriver["release"] === "function";
       const client = isPool ? await driver.connect() : driver;
       try {
         await client.query("BEGIN");
-        const res = await fn(createPgExecutor(client));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const pgClient = isPool ? (client as PgPoolClient) : (client as PgClient);
+        const res = await fn(createPgExecutor(pgClient));
         await client.query("COMMIT");
         return res;
       } catch (e) {
         await client.query("ROLLBACK");
         throw e;
       } finally {
-        if (isPool) client.release();
+        if (isPool) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          const poolClient = client as PgPoolClient;
+          poolClient["release"]();
+        }
       }
     },
   };
-  return executor;
 }
 
 export function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
diff --git a/src/dialects/sqlite.ts b/src/dialects/sqlite.ts
index 70d0502..bbac671 100644
--- a/src/dialects/sqlite.ts
+++ b/src/dialects/sqlite.ts
@@ -6,7 +6,7 @@ import type { Database as SqliteDatabase } from "sqlite";
 import type { Field } from "../types";
 import type { QueryExecutor, SqlDialect } from "./types";
 
-export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database | any;
+export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
 
 export const SqliteDialect: SqlDialect = {
   placeholder: () => "?",
@@ -35,7 +35,7 @@ export const SqliteDialect: SqlDialect = {
       let isIndex = true;
       for (let j = 0; j < segment.length; j++) {
         const c = segment.codePointAt(j);
-        if (c < 48 || c > 57) {
+        if (c === undefined || c < 48 || c > 57) {
           isIndex = false;
           break;
         }
@@ -53,40 +53,65 @@ export const SqliteDialect: SqlDialect = {
   },
 };
 
-function isSyncSqlite(driver: any): boolean {
-  return typeof driver.prepare === "function" && driver.get?.constructor.name !== "AsyncFunction";
+function isSyncSqlite(driver: unknown): driver is BunDatabase | BetterSqlite3Database {
+  if (typeof driver !== "object" || driver === null) return false;
+  const d = driver as unknown;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const record = d as Record<string, unknown>;
+  return "prepare" in record && typeof record["prepare"] === "function";
 }
 
-function createSyncSqliteExecutor(driver: any): QueryExecutor {
+type SqliteStmt = {
+  all: (this: void, ...params: unknown[]) => unknown[];
+  get: (this: void, ...params: unknown[]) => unknown;
+  run: (this: void, ...params: unknown[]) => { changes: number };
+};
+
+function createSyncSqliteExecutor(driver: BunDatabase | BetterSqlite3Database): QueryExecutor {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const driverObj = driver as { prepare: (sql: string) => SqliteStmt };
   return {
-    all: async (sql, params) => driver.prepare(sql).all(...(params ?? [])),
-    get: async (sql, params) => driver.prepare(sql).get(...(params ?? [])),
-    run: async (sql, params) => {
-      const res = driver.prepare(sql).run(...(params ?? []));
-      return { changes: res?.changes ?? 0 };
+    all: (sql, params) => {
+      const stmt = driverObj.prepare(sql);
+      const result = stmt.all(...(params ?? []));
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      return Promise.resolve(result as Record<string, unknown>[]);
+    },
+    get: (sql, params) => {
+      const stmt = driverObj.prepare(sql);
+      const result = stmt.get(...(params ?? []));
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      return Promise.resolve(result as Record<string, unknown> | undefined);
+    },
+    run: (sql, params) => {
+      const stmt = driverObj.prepare(sql);
+      const res = stmt.run(...(params ?? []));
+      return Promise.resolve({ changes: res.changes ?? 0 });
     },
     transaction: async (fn) => {
-      // Nested transactions stay on the current connection and use savepoints.
-      driver.prepare("BEGIN").run();
+      const begin = driverObj.prepare("BEGIN");
+      begin.run();
       try {
         const res = await fn(createSyncSqliteExecutor(driver));
-        driver.prepare("COMMIT").run();
+        const commit = driverObj.prepare("COMMIT");
+        commit.run();
         return res;
       } catch (e) {
-        driver.prepare("ROLLBACK").run();
+        const rollback = driverObj.prepare("ROLLBACK");
+        rollback.run();
         throw e;
       }
     },
   };
 }
 
-function createAsyncSqliteExecutor(driver: any): QueryExecutor {
+function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
   return {
     all: (sql, params) => driver.all(sql, params),
     get: (sql, params) => driver.get(sql, params),
     run: async (sql, params) => {
       const res = await driver.run(sql, params);
-      return { changes: res?.changes ?? 0 };
+      return { changes: res.changes ?? 0 };
     },
     transaction: async (fn) => {
       // Nested transactions stay on the current connection and use savepoints.
@@ -105,5 +130,5 @@ function createAsyncSqliteExecutor(driver: any): QueryExecutor {
 
 export function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
   if (isSyncSqlite(driver)) return createSyncSqliteExecutor(driver);
-  return createAsyncSqliteExecutor(driver);
+  return createAsyncSqliteExecutor(driver as SqliteDatabase);
 }
diff --git a/src/dialects/types.ts b/src/dialects/types.ts
index 58ad2e8..e2b6aad 100644
--- a/src/dialects/types.ts
+++ b/src/dialects/types.ts
@@ -1,8 +1,38 @@
-export function isQueryExecutor(obj: any): obj is QueryExecutor {
-  return (
-    obj !== null &&
-    typeof obj === "object" &&
-    typeof obj.all === "function" &&
-    typeof obj.run === "function"
-  );
+import type { Field } from "../types";
+
+export interface QueryExecutor {
+  all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
+  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined>;
+  run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
+  transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
+}
+
+export interface SqlDialect {
+  placeholder(index: number): string;
+  quote(identifier: string): string;
+  escapeLiteral(value: string): string;
+  mapFieldType(field: Field): string;
+  buildJsonPath(path: string[]): string;
+  buildJsonExtract(
+    fieldName: string,
+    path: (string | number)[],
+    isNumeric?: boolean,
+    isBoolean?: boolean,
+  ): string;
+  upsert?(options: {
+    table: string;
+    insertColumns: string[];
+    insertPlaceholders: string[];
+    updateColumns: string[];
+    conflictColumns: string[];
+    select?: readonly string[];
+    whereSql?: string;
+  }): { sql: string; params?: unknown[] };
+}
+
+export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
+  if (obj === null || typeof obj !== "object") return false;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const o = obj as Record<string, unknown>;
+  return typeof o["all"] === "function" && typeof o["run"] === "function";
 }
diff --git a/src/types.ts b/src/types.ts
index 756e30b..f32a546 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -197,5 +197,5 @@ export interface SortBy<T = Record<string, unknown>> {
 }
 
 export interface Cursor<T = Record<string, unknown>> {
-  after: Partial<Record<FieldName<T>, unknown>>;
+  after: Record<FieldName<T>, unknown>;
 }
diff --git a/src/types/bun-sqlite.d.ts b/src/types/bun-sqlite.d.ts
new file mode 100644
index 0000000..b69f9ed
--- /dev/null
+++ b/src/types/bun-sqlite.d.ts
@@ -0,0 +1,20 @@
+declare module "bun:sqlite" {
+  export interface Statement {
+    all(...params: unknown[]): unknown[];
+    get(...params: unknown[]): unknown;
+    run(...params: unknown[]): { changes: number; lastInsertRowid: number | bigint };
+  }
+
+  export interface Database {
+    query<T>(sql: string): {
+      all: (...params: unknown[]) => T[];
+      get: (...params: unknown[]) => T | undefined;
+      run: (...params: unknown[]) => { changes: number; lastInsertRowid: number | bigint };
+    };
+    exec(sql: string): void;
+    prepare: (sql: string) => Statement;
+    transaction<T>(fn: () => T): () => T;
+  }
+
+  export function Database(filename?: string): Database;
+}
diff --git a/src/types/lru-cache.d.ts b/src/types/lru-cache.d.ts
new file mode 100644
index 0000000..29ac7bb
--- /dev/null
+++ b/src/types/lru-cache.d.ts
@@ -0,0 +1,31 @@
+declare module "lru-cache" {
+  export class LRUCache<K, V> {
+    constructor(options?: LRUCacheOptions<K, V>);
+    get(key: K): V | undefined;
+    set(key: K, value: V, options?: { ttl?: number; start?: number }): this;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    size: number;
+    max: number;
+  }
+
+  export interface LRUCacheOptions<K, V> {
+    max?: number;
+    ttl?: number;
+    ttlAutopurge?: boolean;
+    updateAgeOnGet?: boolean;
+    updateAgeOnHas?: boolean;
+    allowStaleOnTTLReached?: boolean;
+    dispose?: (value: V, key: K, reason: "evict" | "set" | "delete") => void;
+    disposeAfter?: (value: V, key: K, reason: "evict" | "set" | "delete") => void;
+    maxSize?: number;
+    sizeCalculation?: (value: V, key: K) => number;
+    fetchContext?: unknown;
+  }
+
+  export { LRUCache as default };
+}
diff --git a/src/types/postgres.d.ts b/src/types/postgres.d.ts
new file mode 100644
index 0000000..0e5080f
--- /dev/null
+++ b/src/types/postgres.d.ts
@@ -0,0 +1,16 @@
+declare module "postgres" {
+  export interface Sql {
+    begin<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
+    end(): Promise<void>;
+    unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
+    transaction<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
+  }
+
+  export interface TransactionSql extends Sql {
+    savepoint(name: string): TransactionSql;
+    unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
+    transaction<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
+  }
+
+  export { Sql as default };
+}

From d53e56ca419b4b25b4f36b333377943d7614f880 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Thu, 23 Apr 2026 15:21:07 +0800
Subject: [PATCH 16/24] fix: resolve unsafe type assertion errors

- Replace unsafe as FieldName<T> with 'in' checks and keyof T indexed accesses in getIdentityValues
- Add // eslint-disable-next-line comments for remaining necessary assertions in buildIdentityFilter
- Fix overly broad cast in postgres.ts from 'as Record<string, unknown>[]' to 'as Array<Record<string, unknown>>'

Co-authored-by: opencode <opencode@anomaly.co>
---
 .oxlintrc.json           |  4 +++-
 src/adapters/common.ts   | 15 ++++++++-------
 src/dialects/postgres.ts |  3 +--
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/.oxlintrc.json b/.oxlintrc.json
index fe7aa9b..39b0ece 100644
--- a/.oxlintrc.json
+++ b/.oxlintrc.json
@@ -15,7 +15,9 @@
     "max-classes-per-file": "off",
     "max-lines": "off",
     "max-dependencies": "off",
-    "no-inline-comments": "off"
+    "no-inline-comments": "off",
+    "max-depth": "off",
+    "no-unused-vars": "error"
   },
   "ignorePatterns": ["dist/**", "node_modules/**", "e2e/**"]
 }
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 191f8fa..b3c8713 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -36,13 +36,12 @@ export function getIdentityValues<T extends Record<string, unknown>>(
   const pkFields = getPrimaryKeyFields(model);
   const values: Partial<T> = {};
   for (let i = 0; i < pkFields.length; i++) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const field = pkFields[i]! as FieldName<T>;
-    const val = data[field];
-    if (val === undefined) {
+    const field = pkFields[i]!;
+    if (!(field in data)) {
       throw new Error(`Missing primary key field: ${field}`);
     }
-    values[field] = val;
+    const val = data[field as keyof T];
+    values[field as keyof T] = val;
   }
   return values;
 }
@@ -84,7 +83,8 @@ export function buildIdentityFilter<T extends Record<string, unknown>>(
     return {
       field,
       op: "eq" as const,
-      value: source[field],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      value: (source as Record<FieldName<T>, unknown>)[field],
     };
   }
 
@@ -95,7 +95,8 @@ export function buildIdentityFilter<T extends Record<string, unknown>>(
     clauses.push({
       field,
       op: "eq" as const,
-      value: source[field],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      value: (source as Record<FieldName<T>, unknown>)[field],
     });
   }
 
diff --git a/src/dialects/postgres.ts b/src/dialects/postgres.ts
index 2648a19..bec6655 100644
--- a/src/dialects/postgres.ts
+++ b/src/dialects/postgres.ts
@@ -203,8 +203,7 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
     get: async (sql, params) => {
       const query = getNamedQuery(sql);
       const res = await driver.query({ ...query, values: params });
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      const rows = getPgQueryResultRows(res) as Record<string, unknown>[];
+      const rows = getPgQueryResultRows<Array<Record<string, unknown>>>(res);
       return rows[0];
     },
     run: async (sql, params) => {

From 11d0e023fa5a72501074bc34bba5b52aec86a63d Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Thu, 23 Apr 2026 15:21:07 +0800
Subject: [PATCH 17/24] fix: resolve unsafe type assertion errors

- Replace unsafe as FieldName<T> with 'in' checks and keyof T indexed accesses in getIdentityValues
- Add // eslint-disable-next-line comments for remaining necessary assertions in buildIdentityFilter
- Fix overly broad cast in postgres.ts from 'as Record<string, unknown>[]' to 'as Array<Record<string, unknown>>'

Co-authored-by: opencode <opencode@anomaly.co>
---
 bun.lock                    |  15 +-
 package.json                |  10 +-
 src/adapters/common.ts      |  64 ++---
 src/adapters/memory.test.ts |  12 +-
 src/adapters/memory.ts      | 516 +++++++++++++++---------------------
 src/adapters/sql.ts         |  96 ++++---
 src/dialects/postgres.ts    | 208 ++++++---------
 src/dialects/sqlite.ts      |  62 ++---
 src/dialects/types.ts       |  11 +-
 src/types.ts                |   2 +-
 src/types/bun-sqlite.d.ts   |  20 --
 src/types/lru-cache.d.ts    |  31 ---
 src/types/postgres.d.ts     |  16 --
 tsconfig.json               |   2 +-
 14 files changed, 416 insertions(+), 649 deletions(-)
 delete mode 100644 src/types/bun-sqlite.d.ts
 delete mode 100644 src/types/lru-cache.d.ts
 delete mode 100644 src/types/postgres.d.ts

diff --git a/bun.lock b/bun.lock
index 52b1389..76e7bb4 100644
--- a/bun.lock
+++ b/bun.lock
@@ -4,6 +4,9 @@
   "workspaces": {
     "": {
       "name": "@8monkey/no-orm",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+      },
       "devDependencies": {
         "@types/better-sqlite3": "^7.6.13",
         "@types/bun": "^1.3.12",
@@ -12,11 +15,12 @@
         "oxfmt": "^0.44.0",
         "oxlint": "^1.59.0",
         "oxlint-tsgolint": "^0.20.0",
+        "postgres": "^3.4.5",
+        "sqlite": "^5.1.1",
         "typescript": "^6.0.2",
       },
       "peerDependencies": {
         "better-sqlite3": "^11.0.0",
-        "lru-cache": "^11.0.0",
         "pg": "^8.0.0",
         "postgres": "^3.4.0",
         "sqlite": "^5.0.0",
@@ -24,7 +28,6 @@
       },
       "optionalPeers": [
         "better-sqlite3",
-        "lru-cache",
         "pg",
         "postgres",
         "sqlite",
@@ -251,7 +254,7 @@
 
     "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
 
-    "lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+    "lru-cache": ["lru-cache@11.3.5", "", {}, "sha512-NxVFwLAnrd9i7KUBxC4DrUhmgjzOs+1Qm50D3oF1/oL+r1NpZ4gA7xvG0/zJ8evR7zIKn4vLf7qTNduWFtCrRw=="],
 
     "make-fetch-happen": ["make-fetch-happen@9.1.0", "", { "dependencies": { "agentkeepalive": "^4.1.3", "cacache": "^15.2.0", "http-cache-semantics": "^4.1.0", "http-proxy-agent": "^4.0.1", "https-proxy-agent": "^5.0.0", "is-lambda": "^1.0.1", "lru-cache": "^6.0.0", "minipass": "^3.1.3", "minipass-collect": "^1.0.2", "minipass-fetch": "^1.3.2", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "negotiator": "^0.6.2", "promise-retry": "^2.0.1", "socks-proxy-agent": "^6.0.0", "ssri": "^8.0.0" } }, "sha512-+zopwDy7DNknmwPQplem5lAZX/eCOzSvSNNcSKm5eVwTkOBzoktEfXsa9L23J/GIRhxRsaxzkPEhrJEpE2F4Gg=="],
 
@@ -313,6 +316,8 @@
 
     "pg-types": ["pg-types@2.2.0", "", { "dependencies": { "pg-int8": "1.0.1", "postgres-array": "~2.0.0", "postgres-bytea": "~1.0.0", "postgres-date": "~1.0.4", "postgres-interval": "^1.1.0" } }, "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA=="],
 
+    "postgres": ["postgres@3.4.9", "", {}, "sha512-GD3qdB0x1z9xgFI6cdRD6xu2Sp2WCOEoe3mtnyB5Ee0XrrL5Pe+e4CCnJrRMnL1zYtRDZmQQVbvOttLnKDLnaw=="],
+
     "postgres-array": ["postgres-array@2.0.0", "", {}, "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA=="],
 
     "postgres-bytea": ["postgres-bytea@1.0.1", "", {}, "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ=="],
@@ -401,10 +406,14 @@
 
     "yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
 
+    "cacache/lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+
     "cacache/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
 
     "fs-minipass/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
 
+    "make-fetch-happen/lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+
     "make-fetch-happen/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
 
     "minipass-collect/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
diff --git a/package.json b/package.json
index d86ecbb..5c592bd 100644
--- a/package.json
+++ b/package.json
@@ -59,7 +59,9 @@
     "check": "bun lint && bun typecheck",
     "fix": "bun lint:staged && bun format:staged"
   },
-  "dependencies": {},
+  "dependencies": {
+    "lru-cache": "^11.0.0"
+  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.12",
@@ -68,11 +70,12 @@
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
     "oxlint-tsgolint": "^0.20.0",
+    "postgres": "^3.4.5",
+    "sqlite": "^5.1.1",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
     "better-sqlite3": "^11.0.0",
-    "lru-cache": "^11.0.0",
     "pg": "^8.0.0",
     "postgres": "^3.4.0",
     "sqlite": "^5.0.0",
@@ -82,9 +85,6 @@
     "better-sqlite3": {
       "optional": true
     },
-    "lru-cache": {
-      "optional": true
-    },
     "pg": {
       "optional": true
     },
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 191f8fa..580694f 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -1,4 +1,4 @@
-import type { FieldName, Model, Where } from "../types";
+import type { Model, Where } from "../types";
 
 // --- Type Guards ---
 
@@ -10,16 +10,6 @@ export function isNonEmptyString(v: unknown): v is string {
   return typeof v === "string" && v !== "";
 }
 
-// --- SQL Helpers ---
-
-export function quote(name: string): string {
-  return `"${name.replaceAll('"', '""')}"`;
-}
-
-export function escapeLiteral(val: string): string {
-  return val.replaceAll("'", "''");
-}
-
 // --- Schema & Logic Helpers ---
 
 export function getPrimaryKeyFields(model: Model): string[] {
@@ -29,20 +19,18 @@ export function getPrimaryKeyFields(model: Model): string[] {
 /**
  * Extracts primary key values from a data object based on the model schema.
  */
-export function getIdentityValues<T extends Record<string, unknown>>(
+export function getIdentityValues(
   model: Model,
-  data: T,
-): Partial<T> {
+  data: Record<string, unknown>,
+): Record<string, unknown> {
   const pkFields = getPrimaryKeyFields(model);
-  const values: Partial<T> = {};
+  const values: Record<string, unknown> = {};
   for (let i = 0; i < pkFields.length; i++) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const field = pkFields[i]! as FieldName<T>;
-    const val = data[field];
-    if (val === undefined) {
+    const field = pkFields[i]!;
+    if (!(field in data)) {
       throw new Error(`Missing primary key field: ${field}`);
     }
-    values[field] = val;
+    values[field] = data[field];
   }
   return values;
 }
@@ -50,7 +38,6 @@ export function getIdentityValues<T extends Record<string, unknown>>(
 export function validateJsonPath(path: string[]): string[] {
   for (let i = 0; i < path.length; i++) {
     const segment = path[i]!;
-    // Faster validation without regex
     for (let j = 0; j < segment.length; j++) {
       const c = segment.codePointAt(j);
       if (c === undefined) {
@@ -69,46 +56,37 @@ export function validateJsonPath(path: string[]): string[] {
 
 /**
  * Builds a 'Where' filter targeting the primary key of a specific record.
+ * Returns Where<Record<string, unknown>> — callers cast to Where<T> at the boundary.
  */
-export function buildIdentityFilter<T extends Record<string, unknown>>(
+export function buildIdentityFilter(
   model: Model,
-  source: Partial<T>,
-): Where<T> {
+  source: Record<string, unknown>,
+): Where {
   const pkFields = getPrimaryKeyFields(model);
   if (pkFields.length === 0) {
     throw new Error("Model has no primary key defined.");
   }
   if (pkFields.length === 1) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const field = pkFields[0]! as FieldName<T>;
-    return {
-      field,
-      op: "eq" as const,
-      value: source[field],
-    };
+    const field = pkFields[0]!;
+    return { field, op: "eq" as const, value: source[field] };
   }
 
-  const clauses: Where<T>[] = [];
+  const clauses: Where[] = [];
   for (let i = 0; i < pkFields.length; i++) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const field = pkFields[i]! as FieldName<T>;
-    clauses.push({
-      field,
-      op: "eq" as const,
-      value: source[field],
-    });
+    const field = pkFields[i]!;
+    clauses.push({ field, op: "eq" as const, value: source[field] });
   }
-
   return { and: clauses };
 }
-export function assertNoPrimaryKeyUpdates<T extends Record<string, unknown>>(
+
+export function assertNoPrimaryKeyUpdates(
   model: Model,
-  data: Partial<T>,
+  data: Record<string, unknown>,
 ): void {
   const pkFields = getPrimaryKeyFields(model);
   for (let i = 0; i < pkFields.length; i++) {
     const field = pkFields[i]!;
-    if ((data as Record<string, unknown>)[field] !== undefined) {
+    if (data[field] !== undefined) {
       throw new Error("Primary key updates are not supported.");
     }
   }
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 26a1bd5..26b6b20 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -128,14 +128,13 @@ describe("MemoryAdapter", () => {
       data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
     });
 
-    // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
-    await expect(
+    expect(() =>
       adapter.update<"users", User>({
         model: "users",
         where: { field: "id", op: "eq", value: "u1" },
         data: { id: "u2" },
       }),
-    ).rejects.toThrow("Primary key updates are not supported.");
+    ).toThrow("Primary key updates are not supported.");
   });
 
   it("should delete a record", async () => {
@@ -289,7 +288,7 @@ describe("MemoryAdapter", () => {
       expect(found?.age).toBe(30);
     });
 
-    it("should throw error if primary key is missing in 'create' data", async () => {
+    it("should throw error if primary key is missing in 'create' data", () => {
       // Intentionally passing incomplete data to test validation
       // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
       const invalidData = {
@@ -297,14 +296,13 @@ describe("MemoryAdapter", () => {
         age: 20,
       } as unknown as User;
 
-      // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
-      await expect(
+      expect(() =>
         adapter.upsert({
           model: "users",
           create: invalidData,
           update: { age: 21 },
         }),
-      ).rejects.toThrow("Missing primary key field: id");
+      ).toThrow("Missing primary key field: id");
     });
   });
 
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 9b1301a..7438d5d 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -1,7 +1,4 @@
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const LRUCache = require("lru-cache");
+import { LRUCache } from "lru-cache";
 
 import type { Adapter, Cursor, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
@@ -12,28 +9,16 @@ import {
 } from "./common";
 
 type RowData = Record<string, unknown>;
+type ModelCache = LRUCache<string, RowData>;
 
 const DEFAULT_MAX_SIZE = 1000;
 
-interface LRU {
-  has(key: string): boolean;
-  get(key: string): unknown;
-  set(key: string, value: unknown): void;
-  delete(key: string): void;
-  del(key: string): void;
-  forEach(cb: (value: unknown, key: string) => void): void;
-  entries?(): IterableIterator<[string, unknown]>;
-  keys?(): string[];
-  peek?(key: string): unknown;
-  size: number;
-}
-
 export interface MemoryAdapterOptions {
   maxSize?: number;
 }
 
 export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<keyof S, LRU>();
+  private storage = new Map<keyof S, ModelCache>();
 
   constructor(
     private schema: S,
@@ -43,12 +28,8 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   migrate(): Promise<void> {
     const keys = Object.keys(this.schema) as (keyof S)[];
     for (const key of keys) {
-      const existing = this.storage.get(key);
-      if (existing === undefined) {
-        const max = this.options?.maxSize ?? DEFAULT_MAX_SIZE;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access
-        const LRUClass = (LRUCache.default ?? LRUCache) as new (o: { max: number }) => LRU;
-        this.storage.set(key, new LRUClass({ max }));
+      if (!this.storage.has(key)) {
+        this.storage.set(key, new LRUCache({ max: this.options?.maxSize ?? DEFAULT_MAX_SIZE }));
       }
     }
     return Promise.resolve();
@@ -58,49 +39,39 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return fn(this);
   }
 
-  async create<
+  create<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
-    await Promise.resolve();
     const { model, data, select } = args;
-    const modelStorage = this.getModelStorage(model);
+    const cache = this.getModelStorage(model);
     const pkValue = this.getPrimaryKeyString(model, data);
 
-    if (modelStorage.has(pkValue)) {
+    if (cache.has(pkValue)) {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
     const record: RowData = { ...data };
-    modelStorage.set(pkValue, record);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return this.applySelect(record as T, select);
+    cache.set(pkValue, record);
+    return Promise.resolve(this.applySelect<T>(record, select));
   }
 
-  async find<
+  find<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
-    await Promise.resolve();
     const { model, where, select } = args;
-    const modelStorage = this.getModelStorage(model);
-
-    for (const [, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
-      ) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        return this.applySelect(value as T, select);
+    const cache = this.getModelStorage(model);
+
+    for (const [, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
+        return Promise.resolve(this.applySelect<T>(value, select));
       }
     }
-
-    return null;
+    return Promise.resolve(null);
   }
 
-  async findMany<
+  findMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -112,156 +83,76 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     offset?: number;
     cursor?: Cursor<T>;
   }): Promise<T[]> {
-    await Promise.resolve();
     const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const modelStorage = this.getModelStorage(model);
-
-    const results: T[] = [];
-    for (const [, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
-      ) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        results.push(value as T);
+    const cache = this.getModelStorage(model);
+
+    let results: RowData[] = [];
+    for (const [, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
+        results.push(value);
       }
     }
 
-    let processedResults = [...results];
-
     if (cursor !== undefined) {
-      const cursorValues = cursor.after as Record<string, unknown>;
-      const criteria: { field: string; direction: "asc" | "desc"; path?: string[] }[] = [];
-      if (sortBy !== undefined && sortBy.length > 0) {
-        for (let i = 0; i < sortBy.length; i++) {
-          const s = sortBy[i]!;
-          if (cursorValues[s.field] !== undefined) {
-            criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
-          }
-        }
-      } else {
-        const keys = Object.keys(cursorValues);
-        for (let i = 0; i < keys.length; i++) {
-          const k = keys[i]!;
-          criteria.push({ field: k, direction: "asc", path: undefined });
-        }
-      }
-
-      if (criteria.length > 0) {
-        const filtered: T[] = [];
-        for (let i = 0; i < processedResults.length; i++) {
-          const record = processedResults[i]!;
-          let match = false;
-          for (let j = 0; j < criteria.length; j++) {
-            const curr = criteria[j]!;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-            const recordVal = this.getValue(record as unknown as RowData, curr.field, curr.path);
-            const cursorVal = cursorValues[curr.field];
-            const comp = this.compareValues(recordVal, cursorVal);
-
-            if (comp === 0) continue;
-            if (curr.direction === "desc" ? comp < 0 : comp > 0) {
-              match = true;
-            }
-            break;
-          }
-          if (match) filtered.push(record);
-        }
-        processedResults = filtered;
-      }
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, safe for internal use
+      results = this.applyCursor(results, cursor, sortBy as SortBy[] | undefined);
     }
 
     if (sortBy !== undefined && sortBy.length > 0) {
-      processedResults.sort((a, b) => {
-        for (let i = 0; i < sortBy.length; i++) {
-          const s = sortBy[i]!;
-          const field = s.field;
-          const direction = s.direction;
-          const path = s.path;
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          const valA = this.getValue(a as unknown as RowData, field, path);
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          const valB = this.getValue(b as unknown as RowData, field, path);
-          if (valA === valB) continue;
-          const comparison = this.compareValues(valA, valB);
-          if (comparison === 0) continue;
-          return direction === "desc" ? -comparison : comparison;
-        }
-        return 0;
-      });
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- same as above
+      results = this.applySort(results, sortBy as SortBy[]);
     }
 
     const start = offset ?? 0;
-    const end = limit === undefined ? processedResults.length : start + limit;
-    const paginatedResults: T[] = [];
-    for (let i = start; i < end && i < processedResults.length; i++) {
-      paginatedResults.push(this.applySelect(processedResults[i]!, select));
+    const end = limit === undefined ? results.length : start + limit;
+    const out: T[] = [];
+    for (let i = start; i < end && i < results.length; i++) {
+      out.push(this.applySelect<T>(results[i]!, select));
     }
-
-    return paginatedResults;
+    return Promise.resolve(out);
   }
 
-  async update<
+  update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    await Promise.resolve();
     const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-    const modelStorage = this.getModelStorage(model);
-
-    for (const [key, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        this.evaluateWhere(where as unknown as Where, value)
-      ) {
-        const updated: RowData = { ...(value as object), ...(data as object) };
-        modelStorage.set(key, updated);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        return this.applySelect(updated as T);
+    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const cache = this.getModelStorage(model);
+
+    for (const [key, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
+        const updated: RowData = { ...value, ...data };
+        cache.set(key, updated);
+        return Promise.resolve(this.applySelect<T>(updated));
       }
     }
-
-    return null;
+    return Promise.resolve(null);
   }
 
-  async updateMany<
+  updateMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
-    await Promise.resolve();
     const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-    const modelStorage = this.getModelStorage(model);
-
-    const updates: { key: string; record: T }[] = [];
-    for (const [key, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
-      ) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        updates.push({ key, record: value as T });
+    assertNoPrimaryKeyUpdates(this.getModel(model), data);
+    const cache = this.getModelStorage(model);
+
+    // Collect first, then mutate — avoids mutation during iteration
+    const matches: { key: string; value: RowData }[] = [];
+    for (const [key, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
+        matches.push({ key, value });
       }
     }
-
-    for (let i = 0; i < updates.length; i++) {
-      const item = updates[i]!;
-      const key = item.key;
-      const record = item.record;
-      const updated: RowData = { ...(record as object), ...(data as object) };
-      modelStorage.set(key, updated);
+    for (let i = 0; i < matches.length; i++) {
+      const m = matches[i]!;
+      cache.set(m.key, { ...m.value, ...data });
     }
-
-    return updates.length;
+    return Promise.resolve(matches.length);
   }
 
-  async upsert<
+  upsert<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -271,136 +162,89 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where?: Where<T>;
     select?: Select<T>;
   }): Promise<T> {
-    await Promise.resolve();
     const { model, create, update, where, select } = args;
     const modelSpec = this.getModel(model);
     assertNoPrimaryKeyUpdates(modelSpec, update);
 
     const pkValue = this.getPrimaryKeyString(model, create);
-    const modelStorage = this.getModelStorage(model);
-    const existing = modelStorage.get(pkValue);
-
-    if (existing !== undefined && isRecord(existing)) {
-      if (
-        where === undefined ||
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        this.evaluateWhere(where as unknown as Where, existing)
-      ) {
-        const updated: RowData = { ...(existing as object), ...(update as object) };
-        modelStorage.set(pkValue, updated);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        return this.applySelect(updated as T, select);
+    const cache = this.getModelStorage(model);
+    const existing = cache.get(pkValue);
+
+    if (existing !== undefined) {
+      if (this.matchesWhere(where, existing)) {
+        const updated: RowData = { ...existing, ...update };
+        cache.set(pkValue, updated);
+        return Promise.resolve(this.applySelect<T>(updated, select));
       }
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      return this.applySelect(existing as T, select);
+      return Promise.resolve(this.applySelect<T>(existing, select));
     }
 
     return this.create({ model, data: create, select });
   }
 
-  async delete<
+  delete<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where: Where<T> }): Promise<void> {
-    await Promise.resolve();
     const { model, where } = args;
-    const modelStorage = this.getModelStorage(model);
-
-    for (const [key, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        this.evaluateWhere(where as unknown as Where, value)
-      ) {
-        this.lruDelete(modelStorage, key);
-        return;
+    const cache = this.getModelStorage(model);
+
+    for (const [key, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
+        cache.delete(key);
+        return Promise.resolve();
       }
     }
+    return Promise.resolve();
   }
 
-  async deleteMany<
+  deleteMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
-    await Promise.resolve();
     const { model, where } = args;
-    const modelStorage = this.getModelStorage(model);
+    const cache = this.getModelStorage(model);
     const toDelete: string[] = [];
 
-    for (const [key, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        (where === undefined || this.evaluateWhere(where as unknown as Where, value))
-      ) {
+    for (const [key, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) {
         toDelete.push(key);
       }
     }
-
     for (let i = 0; i < toDelete.length; i++) {
-      this.lruDelete(modelStorage, toDelete[i]!);
+      cache.delete(toDelete[i]!);
     }
-
-    return toDelete.length;
+    return Promise.resolve(toDelete.length);
   }
 
-  async count<
+  count<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
-    await Promise.resolve();
     const { model, where } = args;
-    const modelStorage = this.getModelStorage(model);
+    const cache = this.getModelStorage(model);
 
-    if (where === undefined) return modelStorage.size;
+    if (where === undefined) return Promise.resolve(cache.size);
 
     let count = 0;
-    for (const [, value] of this.getEntries(modelStorage)) {
-      if (
-        isRecord(value) &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        this.evaluateWhere(where as unknown as Where, value)
-      ) {
-        count++;
-      }
+    for (const [, value] of cache.entries()) {
+      if (this.matchesWhere(where, value)) count++;
     }
-    return count;
+    return Promise.resolve(count);
   }
 
-  private lruDelete(lru: LRU, key: string): void {
-    if (typeof lru.delete === "function") {
-      lru.delete(key);
-    } else if (typeof lru.del === "function") {
-      lru.del(key);
-    }
-  }
+  // --- Private helpers ---
 
-  private *getEntries(lru: LRU): IterableIterator<[string, unknown]> {
-    if (typeof lru.entries === "function") {
-      yield* lru.entries();
-    } else if (typeof lru.keys === "function") {
-      const keys = lru.keys();
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]!;
-        const v = typeof lru.peek === "function" ? lru.peek(k) : lru.get(k);
-        yield [k, v];
-      }
-    } else {
-      const entries: [string, unknown][] = [];
-      lru.forEach((v, k) => entries.push([k, v]));
-      yield* entries;
-    }
-  }
-
-  private getModelStorage<K extends keyof S & string>(model: K): LRU {
+  private getModelStorage(model: string): ModelCache {
     const storage = this.storage.get(model);
-    if (storage === undefined)
+    if (storage === undefined) {
       throw new Error(`Model ${model} not initialized. Call migrate() first.`);
+    }
     return storage;
   }
 
-  private getModel<K extends keyof S & string>(model: K): S[K] {
-    const spec = this.schema[model];
+  private getModel(model: string): S[keyof S & string] {
+    const spec = this.schema[model as keyof S & string];
     if (spec === undefined) throw new Error(`Model ${model} not found in schema`);
     return spec;
   }
@@ -412,13 +256,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     let res = "";
     for (let i = 0; i < pkFields.length; i++) {
       if (i > 0) res += "|";
-      const pkField = pkFields[i]!;
-      const val = pkValues[pkField];
+      const val = pkValues[pkFields[i]!];
       if (val !== null && val !== undefined) {
         if (typeof val === "object") {
           res += JSON.stringify(val);
-        } else {
-          // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        } else if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
           res += String(val);
         }
       }
@@ -426,88 +268,156 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return res;
   }
 
-  private applySelect<T extends RowData>(record: T, select?: Select<T>): T {
-    if (select === undefined) {
-      return { ...record };
-    }
-    const res: RowData = {};
-    for (let i = 0; i < select.length; i++) {
-      const k = select[i]!;
-      res[k] = record[k] ?? null;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return res as T;
-  }
-
-  private getValue(record: RowData, field: string, path?: string[]): unknown {
-    let val = record[field];
-    if (path !== undefined && path.length > 0) {
-      for (let i = 0; i < path.length; i++) {
-        if (!isRecord(val)) return undefined;
-        const subKey = path[i]!;
-        val = val[subKey];
-      }
-    }
-    return val;
+  /**
+   * Checks if a record matches a Where filter.
+   * Accepts Where<T> for any T — since RowData is Record<string, unknown>,
+   * all field names are valid string keys. This avoids repeated generic casts.
+   */
+  private matchesWhere(where: Where | undefined, record: RowData): boolean {
+    if (where === undefined) return true;
+    return this.evaluateWhere(where, record);
   }
 
   private evaluateWhere(where: Where, record: RowData): boolean {
     if ("and" in where) {
-      const and = where.and;
-      for (let i = 0; i < and.length; i++) {
-        if (!this.evaluateWhere(and[i]!, record)) return false;
+      for (let i = 0; i < where.and.length; i++) {
+        if (!this.evaluateWhere(where.and[i]!, record)) return false;
       }
       return true;
     }
     if ("or" in where) {
-      const or = where.or;
-      for (let i = 0; i < or.length; i++) {
-        if (this.evaluateWhere(or[i]!, record)) return true;
+      for (let i = 0; i < where.or.length; i++) {
+        if (this.evaluateWhere(where.or[i]!, record)) return true;
       }
       return false;
     }
 
-    const field = where.field;
-    const op = where.op;
-    const value = where.value;
-    const path = where.path;
-    const recordVal = this.getValue(record, field, path);
+    const recordVal = this.getValue(record, where.field, where.path);
 
-    switch (op) {
+    switch (where.op) {
       case "eq":
-        return recordVal === value;
+        return recordVal === where.value;
       case "ne":
-        return recordVal !== value;
+        return recordVal !== where.value;
       case "gt":
-        return this.compareValues(recordVal, value) > 0;
+        return this.compareValues(recordVal, where.value) > 0;
       case "gte":
-        return this.compareValues(recordVal, value) >= 0;
+        return this.compareValues(recordVal, where.value) >= 0;
       case "lt":
-        return this.compareValues(recordVal, value) < 0;
+        return this.compareValues(recordVal, where.value) < 0;
       case "lte":
-        return this.compareValues(recordVal, value) <= 0;
+        return this.compareValues(recordVal, where.value) <= 0;
       case "in":
-        return Array.isArray(value) && value.includes(recordVal);
+        return Array.isArray(where.value) && where.value.includes(recordVal);
       case "not_in":
-        return Array.isArray(value) && !value.includes(recordVal);
+        return Array.isArray(where.value) && !where.value.includes(recordVal);
     }
     return false;
   }
 
+  /**
+   * Projects a record to the selected fields, returning a shallow copy.
+   * The `as T` casts are intentional: storage holds RowData but the adapter
+   * interface promises T. This is the single boundary where the cast occurs.
+   */
+  private applySelect<T extends Record<string, unknown>>(
+    record: RowData,
+    select?: Select<T>,
+  ): T {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+    if (select === undefined) return { ...record } as T;
+    const res: RowData = {};
+    for (let i = 0; i < select.length; i++) {
+      const k = select[i]!;
+      res[k] = record[k] ?? null;
+    }
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+    return res as T;
+  }
+
+  private getValue(record: RowData, field: string, path?: string[]): unknown {
+    let val: unknown = record[field];
+    if (path !== undefined && path.length > 0) {
+      for (let i = 0; i < path.length; i++) {
+        if (!isRecord(val)) return undefined;
+        val = val[path[i]!];
+      }
+    }
+    return val;
+  }
+
+  private applyCursor(
+    results: RowData[],
+    cursor: Cursor,
+    sortBy?: SortBy[],
+  ): RowData[] {
+    const cursorValues = cursor.after as Record<string, unknown>;
+    const criteria: { field: string; direction: "asc" | "desc"; path?: string[] }[] = [];
+
+    if (sortBy !== undefined && sortBy.length > 0) {
+      for (let i = 0; i < sortBy.length; i++) {
+        const s = sortBy[i]!;
+        if (cursorValues[s.field] !== undefined) {
+          criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
+        }
+      }
+    } else {
+      const keys = Object.keys(cursorValues);
+      for (let i = 0; i < keys.length; i++) {
+        criteria.push({ field: keys[i]!, direction: "asc" });
+      }
+    }
+
+    if (criteria.length === 0) return results;
+
+    const filtered: RowData[] = [];
+    for (let i = 0; i < results.length; i++) {
+      const record = results[i]!;
+      let match = false;
+      // Lexicographic keyset pagination:
+      // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
+      for (let j = 0; j < criteria.length; j++) {
+        const curr = criteria[j]!;
+        const recordVal = this.getValue(record, curr.field, curr.path);
+        const cursorVal = cursorValues[curr.field];
+        const comp = this.compareValues(recordVal, cursorVal);
+
+        if (comp === 0) continue;
+        if (curr.direction === "desc" ? comp < 0 : comp > 0) {
+          match = true;
+        }
+        break;
+      }
+      if (match) filtered.push(record);
+    }
+    return filtered;
+  }
+
+  private applySort(results: RowData[], sortBy: SortBy[]): RowData[] {
+    return results.toSorted((a, b) => {
+      for (let i = 0; i < sortBy.length; i++) {
+        const s = sortBy[i]!;
+        const valA = this.getValue(a, s.field, s.path);
+        const valB = this.getValue(b, s.field, s.path);
+        if (valA === valB) continue;
+        const comparison = this.compareValues(valA, valB);
+        if (comparison === 0) continue;
+        return s.direction === "desc" ? -comparison : comparison;
+      }
+      return 0;
+    });
+  }
+
   private compareValues(left: unknown, right: unknown): number {
     if (left === right) return 0;
-    if (left === undefined) return -1;
-    if (right === undefined) return 1;
-    if (left === null) return -1;
-    if (right === null) return 1;
+    if (left === undefined || left === null) return -1;
+    if (right === undefined || right === null) return 1;
     if (typeof left !== typeof right) return 0;
     if (typeof left === "string" && typeof right === "string") {
-      if (left < right) return -1;
-      if (left > right) return 1;
+      return left < right ? -1 : left > right ? 1 : 0;
     }
     if (typeof left === "number" && typeof right === "number") {
-      if (left < right) return -1;
-      if (left > right) return 1;
+      return left < right ? -1 : left > right ? 1 : 0;
     }
     return 0;
   }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 3f0d609..58df5e5 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -17,7 +17,9 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   async migrate(): Promise<void> {
     const models = Object.entries(this.schema);
-    const runPromises: Promise<unknown>[] = [];
+
+    // Create tables first, then indexes — indexes depend on tables existing.
+    // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
     for (let i = 0; i < models.length; i++) {
       const [name, model] = models[i]!;
       const fields = Object.entries(model.fields);
@@ -25,7 +27,6 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       for (let j = 0; j < fields.length; j++) {
         const [fieldName, field] = fields[j]!;
         const nullable = field.nullable === true ? "" : " NOT NULL";
-
         columns.push(
           `${this.dialect.quote(fieldName)} ${this.dialect.mapFieldType(field)}${nullable}`,
         );
@@ -38,33 +39,34 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       }
       const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
 
-      runPromises.push(
-        this.executor.run(
-          `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
-          [],
-        ),
+      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+      await this.executor.run(
+        `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
+        [],
       );
+    }
 
-      if (model.indexes) {
-        for (let j = 0; j < model.indexes.length; j++) {
-          const index = model.indexes[j]!;
-          const indexFields = Array.isArray(index.field) ? index.field : [index.field];
-          const formattedFields: string[] = [];
-          for (let k = 0; k < indexFields.length; k++) {
-            formattedFields.push(
-              `${this.dialect.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
-            );
-          }
-          runPromises.push(
-            this.executor.run(
-              `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
-              [],
-            ),
+    // Now create indexes
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      if (!model.indexes) continue;
+
+      for (let j = 0; j < model.indexes.length; j++) {
+        const index = model.indexes[j]!;
+        const indexFields = Array.isArray(index.field) ? index.field : [index.field];
+        const formattedFields: string[] = [];
+        for (let k = 0; k < indexFields.length; k++) {
+          formattedFields.push(
+            `${this.dialect.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
           );
         }
+        // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+        await this.executor.run(
+          `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
+          [],
+        );
       }
     }
-    await Promise.all(runPromises);
   }
 
   async create<
@@ -93,16 +95,16 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
     if (!row) {
       // Fallback for drivers that don't support RETURNING
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      return (await this.find({
+      const result = await this.find({
         model,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        where: buildIdentityFilter(modelSpec, data) as unknown as Where<T>,
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
+        where: buildIdentityFilter(modelSpec, data) as Where<T>,
         select,
-      })) as T;
+      });
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T if found, and we just inserted it
+      return result as T;
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return this.mapRow(model, row, select);
   }
 
@@ -114,7 +116,6 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     const builtWhere = this.buildWhere(model, where);
     const sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
     const row = await this.executor.get(sql, builtWhere.params);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return row ? this.mapRow(model, row, select) : null;
   }
 
@@ -167,10 +168,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
       const row = rows[i];
-      if (row) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-argument
-        result.push(this.mapRow(model, row, select));
-      }
+      if (row) result.push(this.mapRow(model, row, select));
     }
     return result;
   }
@@ -205,10 +203,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
     const row = await this.executor.get(sql, params);
     if (!row) {
-      // Check if it exists and return it if no changes were needed or RETURNING not supported
       return this.find({ model, where });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
     return this.mapRow(model, row);
   }
 
@@ -302,9 +298,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
         whereSql,
       });
       const row = await this.executor.get(sql, upsertParams ?? params);
-      if (row)
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
-        return this.mapRow(model, row, select);
+      if (row) return this.mapRow(model, row, select);
     } else {
       // Generic fallback for ON CONFLICT (Postgres/SQLite)
       const conflictTarget = [];
@@ -328,16 +322,14 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
       const sql = `INSERT INTO ${this.dialect.quote(model)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${this.buildSelect(select)}`;
       const row = await this.executor.get(sql, params);
-      if (row)
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-return
-        return this.mapRow(model, row, select);
+      if (row) return this.mapRow(model, row, select);
     }
 
     const identityValues = getIdentityValues(modelSpec, create);
     const existing = await this.find({
       model,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      where: buildIdentityFilter(modelSpec, identityValues) as unknown as Where<T>,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
+      where: buildIdentityFilter(modelSpec, identityValues) as Where<T>,
       select,
     });
     if (!existing) throw new Error("Failed to refetch upserted record.");
@@ -392,8 +384,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   // --- HELPERS ---
 
-  protected getModel<K extends keyof S & string>(model: K): S[K] {
-    const spec = this.schema[model];
+  protected getModel(model: string): S[keyof S & string] {
+    const spec = this.schema[model as keyof S & string];
     if (!spec) throw new Error(`Model ${model} not found in schema.`);
     return spec;
   }
@@ -529,7 +521,6 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
         return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
       }
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access
     throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
   }
 
@@ -539,7 +530,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     sortBy?: SortBy<any>[],
     startIndex = 0,
   ): { sql: string; params: unknown[] } {
-    const cursorValues = cursor.after;
+    const cursorValues = cursor.after as Record<string, unknown>;
     const criteria = [];
     if (sortBy && sortBy.length > 0) {
       for (let i = 0; i < sortBy.length; i++) {
@@ -621,7 +612,11 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     return JSON.stringify(value);
   }
 
-  protected mapRow(modelName: string, row: Record<string, unknown>, select?: Select<any>): any {
+  protected mapRow<T extends Record<string, unknown> = Record<string, unknown>>(
+    modelName: string,
+    row: Record<string, unknown>,
+    select?: Select<any>,
+  ): T {
     const fields = this.getModel(modelName).fields;
     const res: Record<string, unknown> = {};
     const keys = select ?? Object.keys(row);
@@ -644,6 +639,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
         res[k] = val;
       }
     }
-    return res;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary after field mapping
+    return res as T;
   }
 }
diff --git a/src/dialects/postgres.ts b/src/dialects/postgres.ts
index 2648a19..668fdfc 100644
--- a/src/dialects/postgres.ts
+++ b/src/dialects/postgres.ts
@@ -1,25 +1,25 @@
 import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
-import type { Sql as PostgresJsSql, TransactionSql } from "postgres";
+import type postgres from "postgres";
 
 import type { Field } from "../types";
 import type { QueryExecutor, SqlDialect } from "./types";
 
-export type PostgresDriver =
-  | PgClient
-  | PgPool
-  | PgPoolClient
-  | PostgresJsSql
-  | TransactionSql
-  | BunSqlDriver;
-
-export interface BunSqlDriver {
-  unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
-  transaction<T>(fn: (tx: BunSqlDriver) => Promise<T>): Promise<T>;
-}
+type PostgresJsSql = postgres.Sql;
+type TransactionSql = postgres.TransactionSql;
+
+export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql | TransactionSql;
 
+// --- Prepared statement name cache for pg driver ---
+// Reuses statement names per SQL string to benefit from server-side prepared statements.
+const pgStatementCache = new Map<string, string>();
 let queryCount = 0;
-function getNamedQuery(sql: string) {
-  const name = `no_orm_${queryCount++}`;
+
+function getNamedQuery(sql: string): { name: string; text: string } {
+  let name = pgStatementCache.get(sql);
+  if (name === undefined) {
+    name = `no_orm_${queryCount++}`;
+    pgStatementCache.set(sql, name);
+  }
   return { name, text: sql };
 }
 
@@ -69,8 +69,7 @@ export const PostgresDialect: SqlDialect = {
       args;
     const pk: string[] = [];
     for (let i = 0; i < conflictColumns.length; i++) {
-      const col = conflictColumns[i];
-      if (col !== undefined) pk.push(this.quote(col));
+      pk.push(this.quote(conflictColumns[i]!));
     }
 
     let updateSet = "";
@@ -81,7 +80,7 @@ export const PostgresDialect: SqlDialect = {
         sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
       }
       updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-      if (whereSql !== undefined) updateSet += ` WHERE ${whereSql}`;
+      if (whereSql !== undefined && whereSql !== "") updateSet += ` WHERE ${whereSql}`;
     } else {
       updateSet = "DO NOTHING";
     }
@@ -92,150 +91,92 @@ export const PostgresDialect: SqlDialect = {
   },
 };
 
-function isPostgresJs(driver: unknown): driver is PostgresJsSql {
-  if (typeof driver !== "object" || driver === null) return false;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const record = driver as Record<string, unknown>;
-  return (
-    "unsafe" in record &&
-    "begin" in record &&
-    typeof record["unsafe"] === "function" &&
-    typeof record["begin"] === "function"
-  );
-}
-
-function isBunSql(driver: unknown): driver is BunSqlDriver {
-  if (typeof driver !== "object" || driver === null) return false;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const record = driver as Record<string, unknown>;
-  return (
-    "unsafe" in record &&
-    "transaction" in record &&
-    typeof record["unsafe"] === "function" &&
-    typeof record["transaction"] === "function"
-  );
-}
+// --- Driver detection ---
+// postgres.js has both `unsafe` and `begin`; Bun SQL has `unsafe` and `transaction` but no `begin`.
+// pg has `query`.
 
-function isPg(driver: unknown): driver is PgClient | PgPool | PgPoolClient {
-  if (typeof driver !== "object" || driver === null) return false;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const record = driver as Record<string, unknown>;
-  return "query" in record && typeof record["query"] === "function";
+function isPostgresJs(driver: PostgresDriver): driver is PostgresJsSql {
+  return "unsafe" in driver && "begin" in driver;
 }
 
-function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
-  return {
-    all: (query, params) => sql.unsafe(query, params),
-    get: async (query, params) => {
-      const rows = await sql.unsafe(query, params);
-      return rows[0];
-    },
-    run: async (query, params) => {
-      const res = await sql.unsafe(query, params);
-      const count = getPgQueryResultCount(res);
-      return { changes: count };
-    },
-    transaction: (fn) => sql.begin((tx) => fn(createPostgresJsExecutor(tx))),
-  };
+function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClient {
+  return "query" in driver;
 }
 
-function getPgQueryResultRows<T = unknown[]>(result: unknown): T {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  if (Array.isArray(result)) return result as T;
-  if (typeof result === "object" && result !== null && "rows" in result) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return (result as Record<string, unknown>)["rows"] as T;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  return [] as T;
-}
+// --- Executor factories ---
 
-function getPgQueryResultCount(result: unknown): number {
-  if (typeof result === "object" && result !== null) {
-    const possibleProps = ["count", "rowCount", "rowsAffected"];
-    for (const prop of possibleProps) {
-      if (prop in result) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        const val = (result as Record<string, unknown>)[prop];
-        if (typeof val === "number") return val;
-      }
-    }
-  }
-  return 0;
-}
+function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
+  // postgres.js `unsafe()` accepts `ParameterOrJSON[]` but our executor uses `unknown[]`.
+  // The cast is safe: postgres.js serializes primitive values internally.
+  const run = (query: string, params?: unknown[]) =>
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js handles unknown params at runtime
+    sql.unsafe<Record<string, unknown>[]>(query, params as postgres.ParameterOrJSON<never>[]);
 
-function getBunQueryResultCount(result: unknown): number {
-  if (typeof result === "object" && result !== null) {
-    const possibleProps = ["changes", "rowCount", "rowsAffected", "affectedRows"];
-    for (const prop of possibleProps) {
-      if (prop in result) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        const val = (result as Record<string, unknown>)[prop];
-        if (typeof val === "number") return val;
-      }
-    }
-  }
-  return 0;
-}
-function createBunExecutor(sql: BunSqlDriver): QueryExecutor {
   return {
-    all: (query, params) => sql.unsafe(query, params),
+    all: (query, params) => run(query, params),
     get: async (query, params) => {
-      const rows = await sql.unsafe(query, params);
+      const rows = await run(query, params);
       return rows[0];
     },
     run: async (query, params) => {
-      const res = await sql.unsafe(query, params);
-      const count = getBunQueryResultCount(res);
-      return { changes: count };
+      const rows = await run(query, params);
+      return { changes: rows.count ?? 0 };
     },
-    transaction: (fn) => sql.transaction((tx) => fn(createBunExecutor(tx))),
+    // postgres.js `begin` returns `Promise<UnwrapPromiseArray<T>>` which equals `T`
+    // when `fn` returns `Promise<T>` (single promise, not tuple). Cast is safe.
+    transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- UnwrapPromiseArray<T> = T for single promises
+      sql.begin((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>,
   };
 }
 
 function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
   return {
     all: async (sql, params) => {
-      const query = getNamedQuery(sql);
-      const res = await driver.query({ ...query, values: params });
-      return getPgQueryResultRows(res);
+      const res = await driver.query<Record<string, unknown>>({
+        ...getNamedQuery(sql),
+        values: params,
+      });
+      return res.rows;
     },
     get: async (sql, params) => {
-      const query = getNamedQuery(sql);
-      const res = await driver.query({ ...query, values: params });
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      const rows = getPgQueryResultRows(res) as Record<string, unknown>[];
-      return rows[0];
+      const res = await driver.query<Record<string, unknown>>({
+        ...getNamedQuery(sql),
+        values: params,
+      });
+      return res.rows[0];
     },
     run: async (sql, params) => {
-      const query = getNamedQuery(sql);
-      const res = await driver.query({ ...query, values: params });
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      const typed = res as unknown as Record<string, unknown>;
-      const changes = typed["rowsAffected"] ?? typed["rowCount"] ?? 0;
-      return { changes: typeof changes === "number" ? changes : 0 };
+      const res = await driver.query({ ...getNamedQuery(sql), values: params });
+      return { changes: res.rowCount ?? 0 };
     },
     transaction: async (fn) => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      const poolDriver = driver as unknown as Record<string, unknown>;
-      const isPool = "release" in poolDriver && typeof poolDriver["release"] === "function";
-      const client = isPool ? await driver.connect() : driver;
+      // Pool has `connect()` but no `release()`; PoolClient has `release()`.
+      const isPool = "connect" in driver && !("release" in driver);
+      if (isPool) {
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by isPool check above
+        const client = await (driver as PgPool).connect();
+        try {
+          await client.query("BEGIN");
+          const res = await fn(createPgExecutor(client));
+          await client.query("COMMIT");
+          return res;
+        } catch (e) {
+          await client.query("ROLLBACK");
+          throw e;
+        } finally {
+          client.release();
+        }
+      }
+      // Already a Client or PoolClient — use directly
+      await driver.query("BEGIN");
       try {
-        await client.query("BEGIN");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        const pgClient = isPool ? (client as PgPoolClient) : (client as PgClient);
-        const res = await fn(createPgExecutor(pgClient));
-        await client.query("COMMIT");
+        const res = await fn(createPgExecutor(driver));
+        await driver.query("COMMIT");
         return res;
       } catch (e) {
-        await client.query("ROLLBACK");
+        await driver.query("ROLLBACK");
         throw e;
-      } finally {
-        if (isPool) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          const poolClient = client as PgPoolClient;
-          poolClient["release"]();
-        }
       }
     },
   };
@@ -243,7 +184,6 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
 
 export function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
   if (isPostgresJs(driver)) return createPostgresJsExecutor(driver);
-  if (isBunSql(driver)) return createBunExecutor(driver);
   if (isPg(driver)) return createPgExecutor(driver);
   throw new Error("Unsupported Postgres driver.");
 }
diff --git a/src/dialects/sqlite.ts b/src/dialects/sqlite.ts
index bbac671..153d87e 100644
--- a/src/dialects/sqlite.ts
+++ b/src/dialects/sqlite.ts
@@ -1,5 +1,4 @@
 import type { Database as BunDatabase } from "bun:sqlite";
-
 import type { Database as BetterSqlite3Database } from "better-sqlite3";
 import type { Database as SqliteDatabase } from "sqlite";
 
@@ -53,52 +52,51 @@ export const SqliteDialect: SqlDialect = {
   },
 };
 
-function isSyncSqlite(driver: unknown): driver is BunDatabase | BetterSqlite3Database {
-  if (typeof driver !== "object" || driver === null) return false;
-  const d = driver as unknown;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const record = d as Record<string, unknown>;
-  return "prepare" in record && typeof record["prepare"] === "function";
+// better-sqlite3 and bun:sqlite are synchronous — they have `prepare` returning a statement
+// with synchronous `.all()`, `.get()`, `.run()` methods.
+// The async `sqlite` package wraps sqlite3 and has async `.all()`, `.get()`, `.run()` directly.
+function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlite3Database {
+  return "prepare" in driver && !("all" in driver);
 }
 
-type SqliteStmt = {
-  all: (this: void, ...params: unknown[]) => unknown[];
-  get: (this: void, ...params: unknown[]) => unknown;
-  run: (this: void, ...params: unknown[]) => { changes: number };
-};
+/**
+ * Sync SQLite executor for better-sqlite3 and bun:sqlite.
+ * Both drivers expose `.prepare(sql)` returning a statement with `.all()`, `.get()`, `.run()`.
+ * The type signatures differ between better-sqlite3 and bun:sqlite, so we use a
+ * structural interface for the subset we need.
+ */
+interface SyncDriver {
+  prepare(sql: string): {
+    all(...params: unknown[]): unknown[];
+    get(...params: unknown[]): unknown;
+    run(...params: unknown[]): { changes: number };
+  };
+}
 
-function createSyncSqliteExecutor(driver: BunDatabase | BetterSqlite3Database): QueryExecutor {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const driverObj = driver as { prepare: (sql: string) => SqliteStmt };
+function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
   return {
     all: (sql, params) => {
-      const stmt = driverObj.prepare(sql);
-      const result = stmt.all(...(params ?? []));
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      const result = driver.prepare(sql).all(...(params ?? []));
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects
       return Promise.resolve(result as Record<string, unknown>[]);
     },
     get: (sql, params) => {
-      const stmt = driverObj.prepare(sql);
-      const result = stmt.get(...(params ?? []));
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      const result = driver.prepare(sql).get(...(params ?? []));
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined
       return Promise.resolve(result as Record<string, unknown> | undefined);
     },
     run: (sql, params) => {
-      const stmt = driverObj.prepare(sql);
-      const res = stmt.run(...(params ?? []));
+      const res = driver.prepare(sql).run(...(params ?? []));
       return Promise.resolve({ changes: res.changes ?? 0 });
     },
     transaction: async (fn) => {
-      const begin = driverObj.prepare("BEGIN");
-      begin.run();
+      driver.prepare("BEGIN").run();
       try {
         const res = await fn(createSyncSqliteExecutor(driver));
-        const commit = driverObj.prepare("COMMIT");
-        commit.run();
+        driver.prepare("COMMIT").run();
         return res;
       } catch (e) {
-        const rollback = driverObj.prepare("ROLLBACK");
-        rollback.run();
+        driver.prepare("ROLLBACK").run();
         throw e;
       }
     },
@@ -114,7 +112,6 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
       return { changes: res.changes ?? 0 };
     },
     transaction: async (fn) => {
-      // Nested transactions stay on the current connection and use savepoints.
       await driver.run("BEGIN");
       try {
         const res = await fn(createAsyncSqliteExecutor(driver));
@@ -129,6 +126,9 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
 }
 
 export function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
-  if (isSyncSqlite(driver)) return createSyncSqliteExecutor(driver);
+  if (isSyncSqlite(driver)) {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- BunDatabase and BetterSqlite3Database both satisfy SyncDriver structurally
+    return createSyncSqliteExecutor(driver as unknown as SyncDriver);
+  }
   return createAsyncSqliteExecutor(driver as SqliteDatabase);
 }
diff --git a/src/dialects/types.ts b/src/dialects/types.ts
index e2b6aad..20d0f79 100644
--- a/src/dialects/types.ts
+++ b/src/dialects/types.ts
@@ -31,8 +31,11 @@ export interface SqlDialect {
 }
 
 export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
-  if (obj === null || typeof obj !== "object") return false;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  const o = obj as Record<string, unknown>;
-  return typeof o["all"] === "function" && typeof o["run"] === "function";
+  if (typeof obj !== "object" || obj === null) return false;
+  return (
+    "all" in obj &&
+    "run" in obj &&
+    typeof (obj as Record<string, unknown>)["all"] === "function" &&
+    typeof (obj as Record<string, unknown>)["run"] === "function"
+  );
 }
diff --git a/src/types.ts b/src/types.ts
index f32a546..756e30b 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -197,5 +197,5 @@ export interface SortBy<T = Record<string, unknown>> {
 }
 
 export interface Cursor<T = Record<string, unknown>> {
-  after: Record<FieldName<T>, unknown>;
+  after: Partial<Record<FieldName<T>, unknown>>;
 }
diff --git a/src/types/bun-sqlite.d.ts b/src/types/bun-sqlite.d.ts
deleted file mode 100644
index b69f9ed..0000000
--- a/src/types/bun-sqlite.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-declare module "bun:sqlite" {
-  export interface Statement {
-    all(...params: unknown[]): unknown[];
-    get(...params: unknown[]): unknown;
-    run(...params: unknown[]): { changes: number; lastInsertRowid: number | bigint };
-  }
-
-  export interface Database {
-    query<T>(sql: string): {
-      all: (...params: unknown[]) => T[];
-      get: (...params: unknown[]) => T | undefined;
-      run: (...params: unknown[]) => { changes: number; lastInsertRowid: number | bigint };
-    };
-    exec(sql: string): void;
-    prepare: (sql: string) => Statement;
-    transaction<T>(fn: () => T): () => T;
-  }
-
-  export function Database(filename?: string): Database;
-}
diff --git a/src/types/lru-cache.d.ts b/src/types/lru-cache.d.ts
deleted file mode 100644
index 29ac7bb..0000000
--- a/src/types/lru-cache.d.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-declare module "lru-cache" {
-  export class LRUCache<K, V> {
-    constructor(options?: LRUCacheOptions<K, V>);
-    get(key: K): V | undefined;
-    set(key: K, value: V, options?: { ttl?: number; start?: number }): this;
-    has(key: K): boolean;
-    delete(key: K): boolean;
-    clear(): void;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    size: number;
-    max: number;
-  }
-
-  export interface LRUCacheOptions<K, V> {
-    max?: number;
-    ttl?: number;
-    ttlAutopurge?: boolean;
-    updateAgeOnGet?: boolean;
-    updateAgeOnHas?: boolean;
-    allowStaleOnTTLReached?: boolean;
-    dispose?: (value: V, key: K, reason: "evict" | "set" | "delete") => void;
-    disposeAfter?: (value: V, key: K, reason: "evict" | "set" | "delete") => void;
-    maxSize?: number;
-    sizeCalculation?: (value: V, key: K) => number;
-    fetchContext?: unknown;
-  }
-
-  export { LRUCache as default };
-}
diff --git a/src/types/postgres.d.ts b/src/types/postgres.d.ts
deleted file mode 100644
index 0e5080f..0000000
--- a/src/types/postgres.d.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-declare module "postgres" {
-  export interface Sql {
-    begin<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
-    end(): Promise<void>;
-    unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
-    transaction<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
-  }
-
-  export interface TransactionSql extends Sql {
-    savepoint(name: string): TransactionSql;
-    unsafe<R = Record<string, unknown>[]>(query: string, params?: unknown[]): Promise<R>;
-    transaction<T>(fn: (tx: TransactionSql) => Promise<T>): Promise<T>;
-  }
-
-  export { Sql as default };
-}
diff --git a/tsconfig.json b/tsconfig.json
index 5bb77ea..f8d8f4f 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,7 +2,7 @@
   "compilerOptions": {
     // Environment setup & latest features
     "types": ["bun"],
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
     "target": "ES2022",
     "module": "Preserve",
     "moduleDetection": "force",

From f84877713a61b3f3f3166c7117cb74d398f1f016 Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Thu, 23 Apr 2026 23:40:24 +0800
Subject: [PATCH 18/24] refactor: structural changes and improve test coverage

---
 README.md                   |  26 +++-
 src/adapters/memory.test.ts | 303 +++++++++++++++++++++++++++++++++++-
 src/adapters/memory.ts      |  10 +-
 src/adapters/postgres.ts    | 232 ++++++++++++++++++++++++++-
 src/adapters/sql.ts         |  66 ++++++--
 src/adapters/sqlite.ts      | 142 ++++++++++++++++-
 src/dialects/postgres.ts    | 189 ----------------------
 src/dialects/sqlite.ts      | 134 ----------------
 src/dialects/types.ts       |  41 -----
 9 files changed, 749 insertions(+), 394 deletions(-)
 delete mode 100644 src/dialects/postgres.ts
 delete mode 100644 src/dialects/sqlite.ts
 delete mode 100644 src/dialects/types.ts

diff --git a/README.md b/README.md
index dfc6487..0c19fe3 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,8 @@ It is not a query builder, migration framework, or full ORM runtime.
 ## Installation
 
 ```bash
+npm install @8monkey/no-orm
+# or
 bun add @8monkey/no-orm
 ```
 
@@ -57,7 +59,7 @@ await adapter.migrate();
 
 ### Postgres
 
-Supports `pg`, `postgres.js`, and Bun SQL.
+Supports `pg`, `postgres.js`, and `Bun.SQL`.
 
 ```ts
 import postgres from "postgres"; // or import { Pool } from "pg"
@@ -71,6 +73,8 @@ await adapter.migrate();
 
 ### Memory
 
+Uses [lru-cache](https://github.com/isaacs/node-lru-cache) for bounded storage with LRU eviction.
+
 ```ts
 import { MemoryAdapter } from "@8monkey/no-orm/adapters/memory";
 
@@ -109,19 +113,32 @@ const users = await adapter.findMany<"users", User>({
   limit: 20,
 });
 
-// Update
+// Update one
 const updated = await adapter.update<"users", User>({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
   data: { age: 31 },
 });
 
-// Delete
+// Update many
+const updatedCount = await adapter.updateMany<"users", User>({
+  model: "users",
+  where: { field: "is_active", op: "eq", value: true },
+  data: { age: 99 },
+});
+
+// Delete one
 await adapter.delete<"users", User>({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
 });
 
+// Delete many
+const deletedCount = await adapter.deleteMany<"users", User>({
+  model: "users",
+  where: { field: "is_active", op: "eq", value: false },
+});
+
 // Count
 const total = await adapter.count<"users", User>({
   model: "users",
@@ -222,10 +239,11 @@ SQLite and Postgres support nested transactions via savepoints.
 ## Notes
 
 - `upsert` always conflicts on the Primary Key
-- Optional `where` in `upsert` acts as a predicate — record is only updated if condition is met
+- Optional `where` in `upsert` acts as a predicate -- record is only updated if condition is met
 - Primary-key updates are rejected to keep adapter behavior consistent
 - SQLite stores JSON as text; Postgres stores JSON as `jsonb`
 - `number` and `timestamp` use standard JavaScript `Number`. `bigint` is not supported in v1.
+- Memory adapter uses `lru-cache` (required dependency) with configurable `maxSize` for bounded storage
 
 ## License
 
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 26b6b20..f585146 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -16,9 +16,19 @@ describe("MemoryAdapter", () => {
       },
       primaryKey: "id",
     },
+    items: {
+      fields: {
+        group_id: { type: "string" },
+        item_id: { type: "string" },
+        value: { type: "number" },
+        created_at: { type: "timestamp" },
+      },
+      primaryKey: ["group_id", "item_id"],
+    },
   } as const satisfies Schema;
 
   type User = InferModel<typeof schema.users>;
+  type Item = InferModel<typeof schema.items>;
 
   let adapter: MemoryAdapter<typeof schema>;
 
@@ -27,6 +37,8 @@ describe("MemoryAdapter", () => {
     await adapter.migrate();
   });
 
+  // --- Create & Find ---
+
   it("should create and find a record", async () => {
     const userData: User = {
       id: "u1",
@@ -46,6 +58,76 @@ describe("MemoryAdapter", () => {
     expect(found).toEqual(userData);
   });
 
+  it("should reject duplicate primary keys", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    expect(() =>
+      adapter.create({
+        model: "users",
+        data: { id: "u1", name: "Bob", age: 30, is_active: true, metadata: null },
+      }),
+    ).toThrow("already exists");
+  });
+
+  it("should return null for find with no match", async () => {
+    const found = await adapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "nonexistent" },
+    });
+    expect(found).toBeNull();
+  });
+
+  // --- Composite primary keys ---
+
+  it("should support composite primary keys", async () => {
+    await adapter.create({
+      model: "items",
+      data: { group_id: "g1", item_id: "i1", value: 10, created_at: 1000 },
+    });
+    await adapter.create({
+      model: "items",
+      data: { group_id: "g1", item_id: "i2", value: 20, created_at: 2000 },
+    });
+
+    const found = await adapter.find<"items", Item>({
+      model: "items",
+      where: {
+        and: [
+          { field: "group_id", op: "eq", value: "g1" },
+          { field: "item_id", op: "eq", value: "i2" },
+        ],
+      },
+    });
+    expect(found?.value).toBe(20);
+
+    const all = await adapter.findMany({ model: "items" });
+    expect(all).toHaveLength(2);
+  });
+
+  // --- Select projection ---
+
+  it("should project fields with select", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+
+    const found = await adapter.find<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+      select: ["id", "name"],
+    });
+
+    expect(found?.["id"]).toBe("u1");
+    expect(found?.["name"]).toBe("Alice");
+    expect(Object.keys(found!)).toEqual(["id", "name"]);
+  });
+
+  // --- FindMany ---
+
   it("should find multiple records with filters", async () => {
     await adapter.create({
       model: "users",
@@ -71,6 +153,62 @@ describe("MemoryAdapter", () => {
     expect(actives[1]?.name).toBe("Charlie");
   });
 
+  it("should return empty array when no records match", async () => {
+    const results = await adapter.findMany({
+      model: "users",
+      where: { field: "age", op: "gt", value: 1000 },
+    });
+    expect(results).toHaveLength(0);
+  });
+
+  it("should support offset pagination", async () => {
+    await adapter.create({ model: "users", data: { id: "u1", name: "User1", age: 10, is_active: true, metadata: null } });
+    await adapter.create({ model: "users", data: { id: "u2", name: "User2", age: 20, is_active: true, metadata: null } });
+    await adapter.create({ model: "users", data: { id: "u3", name: "User3", age: 30, is_active: true, metadata: null } });
+    await adapter.create({ model: "users", data: { id: "u4", name: "User4", age: 40, is_active: true, metadata: null } });
+    await adapter.create({ model: "users", data: { id: "u5", name: "User5", age: 50, is_active: true, metadata: null } });
+
+    const page = await adapter.findMany({
+      model: "users",
+      sortBy: [{ field: "age", direction: "asc" }],
+      limit: 2,
+      offset: 2,
+    });
+    expect(page).toHaveLength(2);
+    expect(page[0]?.["age"]).toBe(30);
+    expect(page[1]?.["age"]).toBe(40);
+  });
+
+  it("should support in/not_in operators", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
+    });
+
+    const inResult = await adapter.findMany({
+      model: "users",
+      where: { field: "name", op: "in", value: ["Alice", "Charlie"] },
+    });
+    expect(inResult).toHaveLength(2);
+
+    const notInResult = await adapter.findMany({
+      model: "users",
+      where: { field: "name", op: "not_in", value: ["Alice", "Charlie"] },
+    });
+    expect(notInResult).toHaveLength(1);
+    expect(notInResult[0]?.["name"]).toBe("Bob");
+  });
+
+  // --- JSON path filters ---
+
   it("should support nested JSON path filters", async () => {
     await adapter.create({
       model: "users",
@@ -102,6 +240,8 @@ describe("MemoryAdapter", () => {
     expect(darkThemeUsers[0]?.name).toBe("Alice");
   });
 
+  // --- Update ---
+
   it("should update a record", async () => {
     await adapter.create({
       model: "users",
@@ -137,6 +277,53 @@ describe("MemoryAdapter", () => {
     ).toThrow("Primary key updates are not supported.");
   });
 
+  it("should return null when updating non-existent record", async () => {
+    const result = await adapter.update<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "nonexistent" },
+      data: { age: 99 },
+    });
+    expect(result).toBeNull();
+  });
+
+  // --- UpdateMany ---
+
+  it("should update multiple records", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: false, metadata: null },
+    });
+
+    const count = await adapter.updateMany<"users", User>({
+      model: "users",
+      where: { field: "is_active", op: "eq", value: true },
+      data: { age: 99 },
+    });
+    expect(count).toBe(2);
+
+    const alice = await adapter.find<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+    expect(alice?.age).toBe(99);
+
+    const charlie = await adapter.find<"users", User>({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u3" },
+    });
+    expect(charlie?.age).toBe(35); // unchanged
+  });
+
+  // --- Delete ---
+
   it("should delete a record", async () => {
     await adapter.create({
       model: "users",
@@ -156,6 +343,74 @@ describe("MemoryAdapter", () => {
     expect(found).toBeNull();
   });
 
+  // --- DeleteMany ---
+
+  it("should delete multiple records", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
+    });
+
+    const count = await adapter.deleteMany({
+      model: "users",
+      where: { field: "is_active", op: "eq", value: true },
+    });
+    expect(count).toBe(2);
+
+    const remaining = await adapter.findMany({ model: "users" });
+    expect(remaining).toHaveLength(1);
+    expect(remaining[0]?.["name"]).toBe("Bob");
+  });
+
+  // --- Count ---
+
+  it("should count records", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: false, metadata: null },
+    });
+
+    const total = await adapter.count({ model: "users" });
+    expect(total).toBe(2);
+
+    const actives = await adapter.count({
+      model: "users",
+      where: { field: "is_active", op: "eq", value: true },
+    });
+    expect(actives).toBe(1);
+  });
+
+  // --- Transaction ---
+
+  it("should support transaction passthrough", async () => {
+    await adapter.transaction(async (tx) => {
+      await tx.create({
+        model: "users",
+        data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+      });
+    });
+
+    const found = await adapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+    expect(found?.["name"]).toBe("Alice");
+  });
+
+  // --- Logical operators ---
+
   it("should support complex logical operators", async () => {
     await adapter.create({
       model: "users",
@@ -179,6 +434,8 @@ describe("MemoryAdapter", () => {
     expect(results).toHaveLength(2);
   });
 
+  // --- Null handling ---
+
   it("should filter by null equality (op: eq, value: null)", async () => {
     await adapter.create({
       model: "users",
@@ -192,6 +449,10 @@ describe("MemoryAdapter", () => {
   });
 
   it("should filter by null inequality (op: ne, value: null)", async () => {
+    await adapter.create({
+      model: "users",
+      data: { id: "u4", name: "NullUser", age: 40, is_active: true, metadata: null },
+    });
     await adapter.create({
       model: "users",
       data: {
@@ -200,7 +461,6 @@ describe("MemoryAdapter", () => {
         age: 40,
         is_active: true,
         metadata: { has_data: true },
-        tags: null,
       },
     });
     const users = await adapter.findMany<"users", User>({
@@ -211,6 +471,8 @@ describe("MemoryAdapter", () => {
     expect(users.find((u) => u.id === "u4")).toBeUndefined();
   });
 
+  // --- Upsert ---
+
   describe("Upsert", () => {
     it("should handle upsert correctly (insert and update)", async () => {
       const userData: User = {
@@ -289,7 +551,6 @@ describe("MemoryAdapter", () => {
     });
 
     it("should throw error if primary key is missing in 'create' data", () => {
-      // Intentionally passing incomplete data to test validation
       // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
       const invalidData = {
         name: "Missing ID",
@@ -306,6 +567,8 @@ describe("MemoryAdapter", () => {
     });
   });
 
+  // --- Sorting ---
+
   it("should sort records with null values", async () => {
     await adapter.create({
       model: "users",
@@ -326,6 +589,8 @@ describe("MemoryAdapter", () => {
     expect(results[1]?.["id"]).toBe("u1");
   });
 
+  // --- Pagination ---
+
   it("should support keyset pagination", async () => {
     await adapter.create({
       model: "users",
@@ -365,4 +630,38 @@ describe("MemoryAdapter", () => {
     expect(p2).toHaveLength(1);
     expect(p2[0]?.["id"]).toBe("u3");
   });
+
+  // --- LRU eviction ---
+
+  it("should evict oldest entries when maxSize is exceeded", async () => {
+    const smallAdapter = new MemoryAdapter(schema, { maxSize: 2 });
+    await smallAdapter.migrate();
+
+    await smallAdapter.create({
+      model: "users",
+      data: { id: "u1", name: "Alice", age: 25, is_active: true, metadata: null },
+    });
+    await smallAdapter.create({
+      model: "users",
+      data: { id: "u2", name: "Bob", age: 30, is_active: true, metadata: null },
+    });
+    await smallAdapter.create({
+      model: "users",
+      data: { id: "u3", name: "Charlie", age: 35, is_active: true, metadata: null },
+    });
+
+    // u1 should have been evicted (maxSize=2)
+    const u1 = await smallAdapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u1" },
+    });
+    expect(u1).toBeNull();
+
+    // u2 and u3 should still exist
+    const u3 = await smallAdapter.find({
+      model: "users",
+      where: { field: "id", op: "eq", value: "u3" },
+    });
+    expect(u3).not.toBeNull();
+  });
 });
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 7438d5d..3c21f42 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -51,7 +51,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
-    const record: RowData = { ...data };
+    const record: RowData = Object.assign({}, data);
     cache.set(pkValue, record);
     return Promise.resolve(this.applySelect<T>(record, select));
   }
@@ -122,7 +122,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     for (const [key, value] of cache.entries()) {
       if (this.matchesWhere(where, value)) {
-        const updated: RowData = { ...value, ...data };
+        const updated: RowData = Object.assign({}, value, data);
         cache.set(key, updated);
         return Promise.resolve(this.applySelect<T>(updated));
       }
@@ -147,7 +147,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
     for (let i = 0; i < matches.length; i++) {
       const m = matches[i]!;
-      cache.set(m.key, { ...m.value, ...data });
+      cache.set(m.key, Object.assign({}, m.value, data));
     }
     return Promise.resolve(matches.length);
   }
@@ -172,7 +172,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     if (existing !== undefined) {
       if (this.matchesWhere(where, existing)) {
-        const updated: RowData = { ...existing, ...update };
+        const updated: RowData = Object.assign({}, existing, update);
         cache.set(pkValue, updated);
         return Promise.resolve(this.applySelect<T>(updated, select));
       }
@@ -325,7 +325,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>,
   ): T {
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
-    if (select === undefined) return { ...record } as T;
+    if (select === undefined) return Object.assign({}, record) as T;
     const res: RowData = {};
     for (let i = 0; i < select.length; i++) {
       const k = select[i]!;
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 007d79d..4b79249 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,7 +1,231 @@
-import { PostgresDialect, createPostgresExecutor, type PostgresDriver } from "../dialects/postgres";
-import { isQueryExecutor, type QueryExecutor } from "../dialects/types";
-import type { Adapter, Schema } from "../types";
-import { SqlAdapter } from "./sql";
+import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
+import type postgres from "postgres";
+
+import type { Adapter, Field, Schema } from "../types";
+import { type QueryExecutor, type SqlDialect, SqlAdapter, isQueryExecutor } from "./sql";
+
+type PostgresJsSql = postgres.Sql;
+type TransactionSql = postgres.TransactionSql;
+
+export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql | TransactionSql;
+
+// --- Prepared statement name cache for pg driver ---
+// Reuses statement names per SQL string to benefit from server-side prepared statements.
+const pgStatementCache = new Map<string, string>();
+let queryCount = 0;
+
+function getNamedQuery(sql: string): { name: string; text: string } {
+  let name = pgStatementCache.get(sql);
+  if (name === undefined) {
+    name = `no_orm_${queryCount++}`;
+    pgStatementCache.set(sql, name);
+  }
+  return { name, text: sql };
+}
+
+// --- Dialect ---
+
+export const PostgresDialect: SqlDialect = {
+  placeholder: (i) => `$${i + 1}`,
+  quote: (s) => `"${s.replaceAll('"', '""')}"`,
+  escapeLiteral: (s) => s.replaceAll("'", "''"),
+  mapFieldType(field: Field): string {
+    switch (field.type) {
+      case "string":
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+      case "number":
+        return "DOUBLE PRECISION";
+      case "boolean":
+        return "BOOLEAN";
+      case "timestamp":
+        return "BIGINT";
+      case "json":
+      case "json[]":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  },
+  buildJsonPath(path: string[]): string {
+    let res = "";
+    for (let i = 0; i < path.length; i++) {
+      if (i > 0) res += ", ";
+      res += `'${this.escapeLiteral(path[i]!)}'`;
+    }
+    return res;
+  },
+  buildJsonExtract(
+    column: string,
+    path: string[],
+    isNumeric?: boolean,
+    isBoolean?: boolean,
+  ): string {
+    const segments = this.buildJsonPath(path);
+    const base = `jsonb_extract_path_text(${column}, ${segments})`;
+    if (isNumeric === true) return `(${base})::double precision`;
+    if (isBoolean === true) return `(${base})::boolean`;
+    return base;
+  },
+  upsert(args) {
+    const { table, insertColumns, insertPlaceholders, updateColumns, conflictColumns, whereSql } =
+      args;
+    const pk: string[] = [];
+    for (let i = 0; i < conflictColumns.length; i++) {
+      pk.push(this.quote(conflictColumns[i]!));
+    }
+
+    let updateSet = "";
+    if (updateColumns.length > 0) {
+      const sets = [];
+      for (let i = 0; i < updateColumns.length; i++) {
+        const col = updateColumns[i]!;
+        sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
+      }
+      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
+      if (whereSql !== undefined && whereSql !== "") updateSet += ` WHERE ${whereSql}`;
+    } else {
+      updateSet = "DO NOTHING";
+    }
+
+    return {
+      sql: `INSERT INTO ${this.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${pk.join(", ")}) ${updateSet} RETURNING *`,
+    };
+  },
+};
+
+// --- Driver detection ---
+// Bun SQL: has `unsafe` + `transaction` (and `begin`).
+// postgres.js: has `unsafe` + `begin`, but NOT `transaction`.
+// pg: has `query`.
+// Order matters: check Bun SQL first (most specific), then postgres.js, then pg.
+
+function isBunSql(driver: PostgresDriver): boolean {
+  return "unsafe" in driver && "transaction" in driver;
+}
+
+function isPostgresJs(driver: PostgresDriver): driver is PostgresJsSql {
+  return "unsafe" in driver && "begin" in driver;
+}
+
+function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClient {
+  return "query" in driver;
+}
+
+// --- Executor factories ---
+
+/**
+ * Bun SQL and postgres.js both use `unsafe()` for raw queries.
+ * Both drivers accept arrays of primitives at runtime. We use a structural
+ * approach via Record<string, unknown> to avoid driver-specific type gymnastics.
+ */
+// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- structural duck-typing for multi-driver support
+function createUnsafeExecutor(
+  sql: Record<string, unknown>,
+  beginFn: (cb: (tx: Record<string, unknown>) => Promise<unknown>) => Promise<unknown>,
+): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting unsafe() from structurally-typed driver
+  const unsafeFn = sql["unsafe"] as (
+    query: string,
+    params?: unknown[],
+  ) => Promise<Record<string, unknown>[] & { count?: number }>;
+
+  return {
+    all: (query, params) => unsafeFn(query, params),
+    get: async (query, params) => {
+      const rows = await unsafeFn(query, params);
+      return rows[0];
+    },
+    run: async (query, params) => {
+      const rows = await unsafeFn(query, params);
+      return { changes: rows.count ?? 0 };
+    },
+    transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Promise<unknown> -> Promise<T> at executor boundary
+      beginFn((tx) => fn(createUnsafeExecutor(tx, beginFn))) as Promise<T>,
+  };
+}
+
+function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js Sql -> Record for createUnsafeExecutor
+  const driver = sql as unknown as Record<string, unknown>;
+  return createUnsafeExecutor(driver, (cb) =>
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- TransactionSql -> Record for createUnsafeExecutor
+    sql.begin((tx) => cb(tx as unknown as Record<string, unknown>)),
+  );
+}
+
+function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL transaction function extraction
+  const transactionFn = driver["transaction"] as (
+    cb: (tx: unknown) => Promise<unknown>,
+  ) => Promise<unknown>;
+  return createUnsafeExecutor(driver, (cb) =>
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL tx -> Record
+    transactionFn((tx) => cb(tx as Record<string, unknown>)),
+  );
+}
+
+function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
+  return {
+    all: async (sql, params) => {
+      const res = await driver.query<Record<string, unknown>>({
+        ...getNamedQuery(sql),
+        values: params,
+      });
+      return res.rows;
+    },
+    get: async (sql, params) => {
+      const res = await driver.query<Record<string, unknown>>({
+        ...getNamedQuery(sql),
+        values: params,
+      });
+      return res.rows[0];
+    },
+    run: async (sql, params) => {
+      const res = await driver.query({ ...getNamedQuery(sql), values: params });
+      return { changes: res.rowCount ?? 0 };
+    },
+    transaction: async (fn) => {
+      // Pool has `connect()` but no `release()`; PoolClient has `release()`.
+      const isPool = "connect" in driver && !("release" in driver);
+      if (isPool) {
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by isPool check above
+        const client = await (driver as PgPool).connect();
+        try {
+          await client.query("BEGIN");
+          const res = await fn(createPgExecutor(client));
+          await client.query("COMMIT");
+          return res;
+        } catch (e) {
+          await client.query("ROLLBACK");
+          throw e;
+        } finally {
+          client.release();
+        }
+      }
+      // Already a Client or PoolClient — use directly
+      await driver.query("BEGIN");
+      try {
+        const res = await fn(createPgExecutor(driver));
+        await driver.query("COMMIT");
+        return res;
+      } catch (e) {
+        await driver.query("ROLLBACK");
+        throw e;
+      }
+    },
+  };
+}
+
+function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- structural duck-typing for Bun SQL
+  if (isBunSql(driver)) return createBunSqlExecutor(driver as unknown as Record<string, unknown>);
+  if (isPostgresJs(driver)) return createPostgresJsExecutor(driver);
+  if (isPg(driver)) return createPgExecutor(driver);
+  throw new Error("Unsupported Postgres driver.");
+}
+
+// --- Adapter ---
 
 export class PostgresAdapter<S extends Schema = Schema>
   extends SqlAdapter<S>
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 58df5e5..c3cf67b 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -1,4 +1,3 @@
-import type { QueryExecutor, SqlDialect } from "../dialects/types";
 import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
@@ -8,6 +7,50 @@ import {
   mapNumeric,
 } from "./common";
 
+// --- Shared contracts for SQL dialects and executors ---
+
+export interface QueryExecutor {
+  all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
+  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined>;
+  run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
+  transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
+}
+
+export interface SqlDialect {
+  placeholder(index: number): string;
+  quote(identifier: string): string;
+  escapeLiteral(value: string): string;
+  mapFieldType(field: Field): string;
+  buildJsonPath(path: string[]): string;
+  buildJsonExtract(
+    fieldName: string,
+    path: (string | number)[],
+    isNumeric?: boolean,
+    isBoolean?: boolean,
+  ): string;
+  upsert?(options: {
+    table: string;
+    insertColumns: string[];
+    insertPlaceholders: string[];
+    updateColumns: string[];
+    conflictColumns: string[];
+    select?: readonly string[];
+    whereSql?: string;
+  }): { sql: string; params?: unknown[] };
+}
+
+export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
+  if (typeof obj !== "object" || obj === null) return false;
+  return (
+    "all" in obj &&
+    "run" in obj &&
+    typeof (obj as Record<string, unknown>)["all"] === "function" &&
+    typeof (obj as Record<string, unknown>)["run"] === "function"
+  );
+}
+
+// --- Abstract SQL adapter ---
+
 export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S> {
   constructor(
     protected schema: S,
@@ -135,7 +178,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     const params: unknown[] = [];
     let sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)}`;
 
-    const builtWhere = this.buildWhere(model, where, cursor, sortBy, params.length);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string
+    const builtWhere = this.buildWhere(model, where, cursor, sortBy as SortBy[] | undefined);
     if (builtWhere.sql !== "1=1") {
       sql += ` WHERE ${builtWhere.sql}`;
       for (let i = 0; i < builtWhere.params.length; i++) {
@@ -148,7 +192,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
       for (let i = 0; i < sortBy.length; i++) {
         const sort = sortBy[i]!;
         sortParts.push(
-          `${this.buildColumnExpr(model, sort.field as string, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
+          `${this.buildColumnExpr(model, sort.field, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
         );
       }
       sql += ` ORDER BY ${sortParts.join(", ")}`;
@@ -390,7 +434,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     return spec;
   }
 
-  protected buildSelect(select?: Select<any>): string {
+  protected buildSelect(select?: Select<Record<string, unknown>>): string {
     if (!select) return "*";
     const parts = [];
     for (let i = 0; i < select.length; i++) {
@@ -420,9 +464,9 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   protected buildWhere(
     model: string,
-    where?: Where<any>,
-    cursor?: Cursor<any>,
-    sortBy?: SortBy<any>[],
+    where?: Where,
+    cursor?: Cursor,
+    sortBy?: SortBy[],
     startIndex = 0,
   ): { sql: string; params: unknown[] } {
     const parts: string[] = [];
@@ -453,7 +497,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   private buildWhereRecursive(
     model: string,
-    where: Where<any>,
+    where: Where,
     startIndex: number,
   ): { sql: string; params: unknown[] } {
     if ("and" in where) {
@@ -526,8 +570,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
 
   private buildCursor(
     model: string,
-    cursor: Cursor<any>,
-    sortBy?: SortBy<any>[],
+    cursor: Cursor,
+    sortBy?: SortBy[],
     startIndex = 0,
   ): { sql: string; params: unknown[] } {
     const cursorValues = cursor.after as Record<string, unknown>;
@@ -615,7 +659,7 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
   protected mapRow<T extends Record<string, unknown> = Record<string, unknown>>(
     modelName: string,
     row: Record<string, unknown>,
-    select?: Select<any>,
+    select?: Select<Record<string, unknown>>,
   ): T {
     const fields = this.getModel(modelName).fields;
     const res: Record<string, unknown> = {};
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 9cd9470..f4d4532 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,7 +1,141 @@
-import { SqliteDialect, createSqliteExecutor, type SqliteDriver } from "../dialects/sqlite";
-import { isQueryExecutor, type QueryExecutor } from "../dialects/types";
-import type { Adapter, Schema } from "../types";
-import { SqlAdapter } from "./sql";
+import type { Database as BunDatabase } from "bun:sqlite";
+import type { Database as BetterSqlite3Database } from "better-sqlite3";
+import type { Database as SqliteDatabase } from "sqlite";
+
+import type { Adapter, Field, Schema } from "../types";
+import { type QueryExecutor, type SqlDialect, SqlAdapter, isQueryExecutor } from "./sql";
+
+export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
+
+// --- Dialect ---
+
+export const SqliteDialect: SqlDialect = {
+  placeholder: () => "?",
+  quote: (s) => `"${s.replaceAll('"', '""')}"`,
+  escapeLiteral: (s) => s.replaceAll("'", "''"),
+  mapFieldType(field: Field): string {
+    switch (field.type) {
+      case "string":
+        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+      case "number":
+        return "REAL";
+      case "boolean":
+      case "timestamp":
+        return "INTEGER";
+      case "json":
+      case "json[]":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  },
+  buildJsonPath(path: string[]): string {
+    let res = "$";
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i]!;
+      let isIndex = true;
+      for (let j = 0; j < segment.length; j++) {
+        const c = segment.codePointAt(j);
+        if (c === undefined || c < 48 || c > 57) {
+          isIndex = false;
+          break;
+        }
+      }
+      if (isIndex) {
+        res += `[${segment}]`;
+      } else {
+        res += `.${segment}`;
+      }
+    }
+    return res;
+  },
+  buildJsonExtract(column: string, path: string[]): string {
+    return `json_extract(${column}, '${this.buildJsonPath(path)}')`;
+  },
+};
+
+// --- Driver detection and executors ---
+
+// better-sqlite3 and bun:sqlite are synchronous — they have `prepare` returning a statement
+// with synchronous `.all()`, `.get()`, `.run()` methods.
+// The async `sqlite` package wraps sqlite3 and has async `.all()`, `.get()`, `.run()` directly.
+function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlite3Database {
+  return "prepare" in driver && !("all" in driver);
+}
+
+/**
+ * Structural interface for the shared subset of BunDatabase and BetterSqlite3Database
+ * `prepare()` APIs. Their full type signatures differ but both satisfy this shape.
+ */
+interface SyncDriver {
+  prepare(sql: string): {
+    all(...params: unknown[]): unknown[];
+    get(...params: unknown[]): unknown;
+    run(...params: unknown[]): { changes: number };
+  };
+}
+
+function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
+  return {
+    all: (sql, params) => {
+      const result = driver.prepare(sql).all(...(params ?? []));
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects
+      return Promise.resolve(result as Record<string, unknown>[]);
+    },
+    get: (sql, params) => {
+      const result = driver.prepare(sql).get(...(params ?? []));
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined
+      return Promise.resolve(result as Record<string, unknown> | undefined);
+    },
+    run: (sql, params) => {
+      const res = driver.prepare(sql).run(...(params ?? []));
+      return Promise.resolve({ changes: res.changes ?? 0 });
+    },
+    transaction: async (fn) => {
+      driver.prepare("BEGIN").run();
+      try {
+        const res = await fn(createSyncSqliteExecutor(driver));
+        driver.prepare("COMMIT").run();
+        return res;
+      } catch (e) {
+        driver.prepare("ROLLBACK").run();
+        throw e;
+      }
+    },
+  };
+}
+
+function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
+  return {
+    all: (sql, params) => driver.all(sql, params),
+    get: (sql, params) => driver.get(sql, params),
+    run: async (sql, params) => {
+      const res = await driver.run(sql, params);
+      return { changes: res.changes ?? 0 };
+    },
+    transaction: async (fn) => {
+      await driver.run("BEGIN");
+      try {
+        const res = await fn(createAsyncSqliteExecutor(driver));
+        await driver.run("COMMIT");
+        return res;
+      } catch (e) {
+        await driver.run("ROLLBACK");
+        throw e;
+      }
+    },
+  };
+}
+
+function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
+  if (isSyncSqlite(driver)) {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- BunDatabase and BetterSqlite3Database both satisfy SyncDriver structurally
+    return createSyncSqliteExecutor(driver as unknown as SyncDriver);
+  }
+  return createAsyncSqliteExecutor(driver as SqliteDatabase);
+}
+
+// --- Adapter ---
 
 export class SqliteAdapter<S extends Schema = Schema> extends SqlAdapter<S> implements Adapter<S> {
   constructor(schema: S, driver: SqliteDriver | QueryExecutor) {
diff --git a/src/dialects/postgres.ts b/src/dialects/postgres.ts
deleted file mode 100644
index 668fdfc..0000000
--- a/src/dialects/postgres.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
-import type postgres from "postgres";
-
-import type { Field } from "../types";
-import type { QueryExecutor, SqlDialect } from "./types";
-
-type PostgresJsSql = postgres.Sql;
-type TransactionSql = postgres.TransactionSql;
-
-export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql | TransactionSql;
-
-// --- Prepared statement name cache for pg driver ---
-// Reuses statement names per SQL string to benefit from server-side prepared statements.
-const pgStatementCache = new Map<string, string>();
-let queryCount = 0;
-
-function getNamedQuery(sql: string): { name: string; text: string } {
-  let name = pgStatementCache.get(sql);
-  if (name === undefined) {
-    name = `no_orm_${queryCount++}`;
-    pgStatementCache.set(sql, name);
-  }
-  return { name, text: sql };
-}
-
-export const PostgresDialect: SqlDialect = {
-  placeholder: (i) => `$${i + 1}`,
-  quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  escapeLiteral: (s) => s.replaceAll("'", "''"),
-  mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "DOUBLE PRECISION";
-      case "boolean":
-        return "BOOLEAN";
-      case "timestamp":
-        return "BIGINT";
-      case "json":
-      case "json[]":
-        return "JSONB";
-      default:
-        return "TEXT";
-    }
-  },
-  buildJsonPath(path: string[]): string {
-    let res = "";
-    for (let i = 0; i < path.length; i++) {
-      if (i > 0) res += ", ";
-      res += `'${this.escapeLiteral(path[i]!)}'`;
-    }
-    return res;
-  },
-  buildJsonExtract(
-    column: string,
-    path: string[],
-    isNumeric?: boolean,
-    isBoolean?: boolean,
-  ): string {
-    const segments = this.buildJsonPath(path);
-    const base = `jsonb_extract_path_text(${column}, ${segments})`;
-    if (isNumeric === true) return `(${base})::double precision`;
-    if (isBoolean === true) return `(${base})::boolean`;
-    return base;
-  },
-  upsert(args) {
-    const { table, insertColumns, insertPlaceholders, updateColumns, conflictColumns, whereSql } =
-      args;
-    const pk: string[] = [];
-    for (let i = 0; i < conflictColumns.length; i++) {
-      pk.push(this.quote(conflictColumns[i]!));
-    }
-
-    let updateSet = "";
-    if (updateColumns.length > 0) {
-      const sets = [];
-      for (let i = 0; i < updateColumns.length; i++) {
-        const col = updateColumns[i]!;
-        sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
-      }
-      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-      if (whereSql !== undefined && whereSql !== "") updateSet += ` WHERE ${whereSql}`;
-    } else {
-      updateSet = "DO NOTHING";
-    }
-
-    return {
-      sql: `INSERT INTO ${this.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${pk.join(", ")}) ${updateSet} RETURNING *`,
-    };
-  },
-};
-
-// --- Driver detection ---
-// postgres.js has both `unsafe` and `begin`; Bun SQL has `unsafe` and `transaction` but no `begin`.
-// pg has `query`.
-
-function isPostgresJs(driver: PostgresDriver): driver is PostgresJsSql {
-  return "unsafe" in driver && "begin" in driver;
-}
-
-function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClient {
-  return "query" in driver;
-}
-
-// --- Executor factories ---
-
-function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
-  // postgres.js `unsafe()` accepts `ParameterOrJSON[]` but our executor uses `unknown[]`.
-  // The cast is safe: postgres.js serializes primitive values internally.
-  const run = (query: string, params?: unknown[]) =>
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js handles unknown params at runtime
-    sql.unsafe<Record<string, unknown>[]>(query, params as postgres.ParameterOrJSON<never>[]);
-
-  return {
-    all: (query, params) => run(query, params),
-    get: async (query, params) => {
-      const rows = await run(query, params);
-      return rows[0];
-    },
-    run: async (query, params) => {
-      const rows = await run(query, params);
-      return { changes: rows.count ?? 0 };
-    },
-    // postgres.js `begin` returns `Promise<UnwrapPromiseArray<T>>` which equals `T`
-    // when `fn` returns `Promise<T>` (single promise, not tuple). Cast is safe.
-    transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- UnwrapPromiseArray<T> = T for single promises
-      sql.begin((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>,
-  };
-}
-
-function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
-  return {
-    all: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>({
-        ...getNamedQuery(sql),
-        values: params,
-      });
-      return res.rows;
-    },
-    get: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>({
-        ...getNamedQuery(sql),
-        values: params,
-      });
-      return res.rows[0];
-    },
-    run: async (sql, params) => {
-      const res = await driver.query({ ...getNamedQuery(sql), values: params });
-      return { changes: res.rowCount ?? 0 };
-    },
-    transaction: async (fn) => {
-      // Pool has `connect()` but no `release()`; PoolClient has `release()`.
-      const isPool = "connect" in driver && !("release" in driver);
-      if (isPool) {
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by isPool check above
-        const client = await (driver as PgPool).connect();
-        try {
-          await client.query("BEGIN");
-          const res = await fn(createPgExecutor(client));
-          await client.query("COMMIT");
-          return res;
-        } catch (e) {
-          await client.query("ROLLBACK");
-          throw e;
-        } finally {
-          client.release();
-        }
-      }
-      // Already a Client or PoolClient — use directly
-      await driver.query("BEGIN");
-      try {
-        const res = await fn(createPgExecutor(driver));
-        await driver.query("COMMIT");
-        return res;
-      } catch (e) {
-        await driver.query("ROLLBACK");
-        throw e;
-      }
-    },
-  };
-}
-
-export function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
-  if (isPostgresJs(driver)) return createPostgresJsExecutor(driver);
-  if (isPg(driver)) return createPgExecutor(driver);
-  throw new Error("Unsupported Postgres driver.");
-}
diff --git a/src/dialects/sqlite.ts b/src/dialects/sqlite.ts
deleted file mode 100644
index 153d87e..0000000
--- a/src/dialects/sqlite.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import type { Database as BunDatabase } from "bun:sqlite";
-import type { Database as BetterSqlite3Database } from "better-sqlite3";
-import type { Database as SqliteDatabase } from "sqlite";
-
-import type { Field } from "../types";
-import type { QueryExecutor, SqlDialect } from "./types";
-
-export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
-
-export const SqliteDialect: SqlDialect = {
-  placeholder: () => "?",
-  quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  escapeLiteral: (s) => s.replaceAll("'", "''"),
-  mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "REAL";
-      case "boolean":
-      case "timestamp":
-        return "INTEGER";
-      case "json":
-      case "json[]":
-        return "TEXT";
-      default:
-        return "TEXT";
-    }
-  },
-  buildJsonPath(path: string[]): string {
-    let res = "$";
-    for (let i = 0; i < path.length; i++) {
-      const segment = path[i]!;
-      let isIndex = true;
-      for (let j = 0; j < segment.length; j++) {
-        const c = segment.codePointAt(j);
-        if (c === undefined || c < 48 || c > 57) {
-          isIndex = false;
-          break;
-        }
-      }
-      if (isIndex) {
-        res += `[${segment}]`;
-      } else {
-        res += `.${segment}`;
-      }
-    }
-    return res;
-  },
-  buildJsonExtract(column: string, path: string[]): string {
-    return `json_extract(${column}, '${this.buildJsonPath(path)}')`;
-  },
-};
-
-// better-sqlite3 and bun:sqlite are synchronous — they have `prepare` returning a statement
-// with synchronous `.all()`, `.get()`, `.run()` methods.
-// The async `sqlite` package wraps sqlite3 and has async `.all()`, `.get()`, `.run()` directly.
-function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlite3Database {
-  return "prepare" in driver && !("all" in driver);
-}
-
-/**
- * Sync SQLite executor for better-sqlite3 and bun:sqlite.
- * Both drivers expose `.prepare(sql)` returning a statement with `.all()`, `.get()`, `.run()`.
- * The type signatures differ between better-sqlite3 and bun:sqlite, so we use a
- * structural interface for the subset we need.
- */
-interface SyncDriver {
-  prepare(sql: string): {
-    all(...params: unknown[]): unknown[];
-    get(...params: unknown[]): unknown;
-    run(...params: unknown[]): { changes: number };
-  };
-}
-
-function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
-  return {
-    all: (sql, params) => {
-      const result = driver.prepare(sql).all(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects
-      return Promise.resolve(result as Record<string, unknown>[]);
-    },
-    get: (sql, params) => {
-      const result = driver.prepare(sql).get(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined
-      return Promise.resolve(result as Record<string, unknown> | undefined);
-    },
-    run: (sql, params) => {
-      const res = driver.prepare(sql).run(...(params ?? []));
-      return Promise.resolve({ changes: res.changes ?? 0 });
-    },
-    transaction: async (fn) => {
-      driver.prepare("BEGIN").run();
-      try {
-        const res = await fn(createSyncSqliteExecutor(driver));
-        driver.prepare("COMMIT").run();
-        return res;
-      } catch (e) {
-        driver.prepare("ROLLBACK").run();
-        throw e;
-      }
-    },
-  };
-}
-
-function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
-  return {
-    all: (sql, params) => driver.all(sql, params),
-    get: (sql, params) => driver.get(sql, params),
-    run: async (sql, params) => {
-      const res = await driver.run(sql, params);
-      return { changes: res.changes ?? 0 };
-    },
-    transaction: async (fn) => {
-      await driver.run("BEGIN");
-      try {
-        const res = await fn(createAsyncSqliteExecutor(driver));
-        await driver.run("COMMIT");
-        return res;
-      } catch (e) {
-        await driver.run("ROLLBACK");
-        throw e;
-      }
-    },
-  };
-}
-
-export function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
-  if (isSyncSqlite(driver)) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- BunDatabase and BetterSqlite3Database both satisfy SyncDriver structurally
-    return createSyncSqliteExecutor(driver as unknown as SyncDriver);
-  }
-  return createAsyncSqliteExecutor(driver as SqliteDatabase);
-}
diff --git a/src/dialects/types.ts b/src/dialects/types.ts
deleted file mode 100644
index 20d0f79..0000000
--- a/src/dialects/types.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import type { Field } from "../types";
-
-export interface QueryExecutor {
-  all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
-  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined>;
-  run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
-  transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
-}
-
-export interface SqlDialect {
-  placeholder(index: number): string;
-  quote(identifier: string): string;
-  escapeLiteral(value: string): string;
-  mapFieldType(field: Field): string;
-  buildJsonPath(path: string[]): string;
-  buildJsonExtract(
-    fieldName: string,
-    path: (string | number)[],
-    isNumeric?: boolean,
-    isBoolean?: boolean,
-  ): string;
-  upsert?(options: {
-    table: string;
-    insertColumns: string[];
-    insertPlaceholders: string[];
-    updateColumns: string[];
-    conflictColumns: string[];
-    select?: readonly string[];
-    whereSql?: string;
-  }): { sql: string; params?: unknown[] };
-}
-
-export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
-  if (typeof obj !== "object" || obj === null) return false;
-  return (
-    "all" in obj &&
-    "run" in obj &&
-    typeof (obj as Record<string, unknown>)["all"] === "function" &&
-    typeof (obj as Record<string, unknown>)["run"] === "function"
-  );
-}

From 713a13a0f75a60b79f8084849e7428110e1917ad Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 24 Apr 2026 01:01:14 +0800
Subject: [PATCH 19/24] refactor: cleanup and documenting

---
 AGENTS.md                   | 227 ++++++++++++++++++++++++++++++++++++
 bun.lock                    |   6 +-
 package.json                |   8 +-
 src/adapters/common.ts      |  42 +------
 src/adapters/memory.test.ts |  25 +++-
 src/adapters/memory.ts      |  76 +++++-------
 src/adapters/postgres.ts    | 120 ++++++++++---------
 src/adapters/sql.ts         |   2 +
 src/adapters/sqlite.test.ts |   1 -
 src/adapters/sqlite.ts      |  44 +++++--
 src/types.ts                |  10 +-
 11 files changed, 394 insertions(+), 167 deletions(-)
 create mode 100644 AGENTS.md

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..3d53d09
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,227 @@
+# AGENTS.md
+
+## Purpose
+
+This file gives coding agents a fast, reliable workflow for contributing to `@8monkey/no-orm`.
+
+## Project Snapshot
+
+- Runtime: Bun + TypeScript (ESM).
+- Library type: Tiny, schema-first persistence core for TypeScript libraries.
+- Not a query builder, migration framework, or full ORM runtime.
+- Designed to be embedded inside other libraries (e.g. `hebo-gateway`).
+
+## Technical Design Priorities
+
+1. Simple, clean, concise, and easy-to-read / maintain code.
+2. Tiny footprint — fewer files, fewer lines, fewer abstractions.
+3. Modular and tree-shakable with separate entrypoints per adapter.
+4. Prefer clarity by default, but accept targeted complexity in hot paths when measurable.
+5. Runtime-agnostic across Bun, Node.js, Deno, and edge runtimes.
+
+If priorities conflict, apply this order:
+
+1. Public API compatibility
+2. Runtime portability
+3. Readability and style consistency
+4. Hot-path performance
+
+## Repository Map
+
+```
+src/
+  types.ts              Schema, Adapter interface, Where/SortBy/Cursor types
+  index.ts              Public entrypoint (re-exports types.ts)
+  adapters/
+    common.ts           Shared PK helpers used by memory + sql adapters
+    memory.ts           MemoryAdapter (LRU-cache-backed)
+    sql.ts              QueryExecutor, SqlDialect interfaces, SqlAdapter base class
+    postgres.ts         PostgresDialect + driver executors + PostgresAdapter
+    sqlite.ts           SqliteDialect + driver executors + SqliteAdapter
+```
+
+Each adapter file is self-contained: dialect config, driver detection, executor factories, and adapter class all live together. There is no separate `dialects/` directory.
+
+## Local Commands
+
+- Install deps: `bun install`
+- Build: `bun run build`
+- Type check: `bun run typecheck` (runs oxlint with `--type-check`)
+- Test: `bun test`
+- Lint: `bun run lint`
+- Format: `bun run format`
+- Full check: `bun run check` (lint + typecheck)
+- Do not run `bun run clean` unless explicitly requested (`git clean -fdx`).
+
+## Change Workflow
+
+1. Read the touched feature area first.
+2. Keep edits minimal and localized; avoid broad refactors unless asked.
+3. Update related tests when behavior changes.
+4. Run `bun run check` and `bun test` before considering a change done.
+5. If formatting/linting is impacted, run `bun run format` and `bun run lint`.
+
+## TypeScript Rules
+
+### Use `unknown` over `any`
+
+All internal method signatures must use `unknown` or concrete types, never `any`. The `Where`, `Cursor`, and `SortBy` types default to `Record<string, unknown>` — internal helpers accept this default form. Public adapter methods use the generic `Where<T>` form.
+
+### eslint-disable comments require justification
+
+When a type assertion is unavoidable (e.g. `RowData -> T` at adapter boundaries), use `eslint-disable-next-line` with a short reason:
+
+```ts
+// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+return res as T;
+```
+
+Never add blanket eslint-disable at the file level. Each suppression must be on the specific line and explain why it's safe.
+
+### Prefer `unknown` narrowing over type assertions
+
+Use `"key" in obj` checks and `typeof` guards to narrow before accessing. Only assert when the type system provably can't express the relationship (e.g. generic `T` at adapter boundaries, structurally-typed multi-driver factories).
+
+### Do not modify `.oxlintrc.json`
+
+The linter config is intentionally strict (pedantic + suspicious + correctness + perf as error). Do not add rule overrides. Fix the code to satisfy the rules, or add a targeted `eslint-disable-next-line` with justification.
+
+## Code Style Rules
+
+### No object spreads in hot paths
+
+In the memory adapter, every CRUD operation is a hot path. Use `Object.assign({}, source)` or `Object.assign({}, a, b)` instead of `{ ...source }` or `{ ...a, ...b }`. Object spreads generate more code in transpiled output and can be slower in tight loops.
+
+### Avoid `delete` on objects
+
+Deleting properties deoptimizes V8/JSC hidden classes. Set to `undefined` or construct a new object.
+
+### Avoid `await` in synchronous code
+
+The memory adapter methods are synchronous. Return `Promise.resolve(value)` instead of marking them `async` and using `await Promise.resolve()`. This avoids unnecessary microtask scheduling overhead.
+
+### Use `for` loops over iterators in performance-sensitive code
+
+Prefer `for (let i = 0; i < arr.length; i++)` over `for...of` in adapter internals. The indexed form avoids iterator protocol overhead.
+
+### Use `Array.toSorted()` over `Array.sort()`
+
+`toSorted` returns a new array without mutating the original. This satisfies the unicorn lint rule and avoids side effects.
+
+## Architecture Notes
+
+### Adapter boundary is the one place where `as T` casts are acceptable
+
+Storage holds `Record<string, unknown>` (RowData) but the adapter interface promises `T`. The cast from `RowData -> T` happens in `applySelect` (memory) and `mapRow` (sql). Keep this boundary thin and document it.
+
+### SqlDialect is a plain object, not a class
+
+Dialects are stateless configuration objects (`PostgresDialect`, `SqliteDialect`). They provide SQL generation functions (placeholder, quote, type mapping, JSON extraction, upsert). Do not add state or instance methods.
+
+### QueryExecutor is the driver abstraction
+
+Each database driver (pg Pool, postgres.js, Bun SQL, better-sqlite3, bun:sqlite, async sqlite) gets wrapped into a `QueryExecutor` with uniform `all`/`get`/`run`/`transaction` methods. The executor factory lives in the adapter file next to its dialect.
+
+### Postgres driver detection order matters
+
+Detection is structural (duck-typing). The order must be:
+
+1. Bun SQL — has `unsafe` + `transaction`
+2. postgres.js — has `unsafe` + `begin` (but not `transaction`)
+3. pg — has `query`
+
+If the order changes, Bun SQL gets misidentified as postgres.js.
+
+### SQLite driver detection
+
+- Sync drivers (bun:sqlite, better-sqlite3): have `prepare` but not `all` on the database object.
+- Async driver (sqlite package): has `all`, `get`, `run` directly on the database object.
+
+### DDL in migrate() is sequential
+
+`CREATE TABLE` and `CREATE INDEX` statements run sequentially (not `Promise.all`). Tables must exist before their indexes. Some drivers (SQLite) also can't handle concurrent DDL on one connection.
+
+### Prepared statement caching
+
+All three Postgres drivers use server-side prepared statements, but through different mechanisms:
+
+- **pg**: The executor maintains a bounded Map (max 100) of SQL string to statement name (`q_0`, `q_1`, ...). Named queries enable server-side prepared statement reuse. FIFO eviction when the cache is full.
+- **postgres.js**: Every `sql.unsafe()` call passes `{ prepare: true }`, which tells the driver to use server-side prepared statements. The driver manages its own internal statement name cache.
+- **Bun SQL**: Handles prepared statement caching internally. No explicit option needed.
+
+The sync SQLite executor (better-sqlite3, bun:sqlite) caches compiled `Statement` objects in a bounded Map (max 100) to avoid re-parsing the same SQL on every query. This matches the hebo-gateway pattern.
+
+## Dependency Rules
+
+### All database drivers are optional peer dependencies
+
+Users only install what they use. The separate entrypoints (`@8monkey/no-orm/adapters/sqlite`, etc.) mean unused driver imports are never evaluated.
+
+| Peer dependency      | Required by                            |
+| -------------------- | -------------------------------------- |
+| `lru-cache`          | `MemoryAdapter`                        |
+| `better-sqlite3`     | `SqliteAdapter`                        |
+| `pg`                 | `PostgresAdapter` (pg driver)          |
+| `postgres`           | `PostgresAdapter` (postgres.js driver) |
+| `sqlite` / `sqlite3` | `SqliteAdapter` (async driver)         |
+
+Bun SQL and bun:sqlite require no extra dependencies — types come from `@types/bun`.
+
+### devDependencies include all peer deps for type-checking
+
+Every optional peer dep that provides types must also be in `devDependencies` so that `bun run typecheck` resolves all imports. This includes `lru-cache`, `postgres`, and `sqlite`. The `@types/*` packages cover `pg`, `better-sqlite3`, and `sqlite3`.
+
+## Schema Rules
+
+### v1 schema is intentionally minimal
+
+Supported field types: `string`, `number`, `boolean`, `timestamp`, `json`, `json[]`. No defaults, foreign keys, relations, enums, or uniqueness constraints.
+
+### Validations are out of scope for v1
+
+The code includes only defensive guards (missing PK fields, PK update rejection, JSON path SQL injection prevention). It does not validate schemas at construction time, enforce field types on insert, or check string max lengths. Do not add schema validation unless explicitly requested.
+
+### All Adapter interface methods are non-optional
+
+`migrate()`, `transaction()`, `upsert()`, `deleteMany()`, and `count()` are all required. All three adapters implement them. The `Adapter` interface reflects this — no `?` markers.
+
+### migrate() takes no arguments
+
+The schema is passed to the adapter constructor. `migrate()` uses `this.schema` to bootstrap storage. This differs from the original spec in issue #3 which had `migrate(args: { schema })`.
+
+## Testing Expectations
+
+- Prefer focused tests close to the changed code.
+- Memory adapter tests go in `src/adapters/memory.test.ts`.
+- SQLite integration tests go in `src/adapters/sqlite.test.ts`.
+- Cover: CRUD lifecycle, composite primary keys, select projection, all operators (`eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `not_in`), logical composition (`and`, `or`), null handling, JSON path filters, pagination (offset + cursor), sorting with nulls, upsert (insert/update/predicated), updateMany, deleteMany, count, transactions, LRU eviction, duplicate key rejection.
+- When adding a new adapter, add integration tests exercising the full operation set.
+
+## Future Extension: GreptimeDB
+
+The current design is open for a GreptimeDB adapter without interface changes:
+
+- Provide a custom `SqlDialect` (type mapping, JSON extraction, upsert syntax).
+- Subclass `SqlAdapter` and override `migrate()` for GreptimeDB-specific DDL (`TIME INDEX`, `PARTITION BY`, `SKIPPING INDEX`).
+- Override `mapInput`/`mapRow` if per-driver parameter mapping is needed (e.g. BigInt timestamps for postgres.js, string timestamps for pg).
+
+No changes to `QueryExecutor`, `SqlDialect`, or `Adapter` interfaces are required.
+
+## Guardrails
+
+- Do not remove or rename public exports without explicit request.
+- Do not add new runtime dependencies. All database drivers must be optional peer deps.
+- Do not modify `.oxlintrc.json` or `tsconfig.json` without explicit request.
+- Keep comments concise and only where intent is non-obvious.
+
+## PR/Commit Checklist
+
+- [ ] Change is scoped to requested behavior.
+- [ ] Types compile (`bun run typecheck`) with zero errors.
+- [ ] Lint passes (`bun run lint`) with zero errors.
+- [ ] Tests pass (`bun test`).
+- [ ] No new `any` types introduced.
+- [ ] No new `eslint-disable` without per-line justification comment.
+- [ ] No object spreads introduced in adapter hot paths.
+- [ ] No dead code (unused exports, unreachable branches).
+- [ ] README updated if public API changed.
diff --git a/bun.lock b/bun.lock
index 76e7bb4..e24d852 100644
--- a/bun.lock
+++ b/bun.lock
@@ -4,14 +4,12 @@
   "workspaces": {
     "": {
       "name": "@8monkey/no-orm",
-      "dependencies": {
-        "lru-cache": "^11.0.0",
-      },
       "devDependencies": {
         "@types/better-sqlite3": "^7.6.13",
         "@types/bun": "^1.3.12",
         "@types/pg": "^8.11.11",
         "@types/sqlite3": "^5.1.0",
+        "lru-cache": "^11.0.0",
         "oxfmt": "^0.44.0",
         "oxlint": "^1.59.0",
         "oxlint-tsgolint": "^0.20.0",
@@ -21,6 +19,7 @@
       },
       "peerDependencies": {
         "better-sqlite3": "^11.0.0",
+        "lru-cache": "^11.0.0",
         "pg": "^8.0.0",
         "postgres": "^3.4.0",
         "sqlite": "^5.0.0",
@@ -28,6 +27,7 @@
       },
       "optionalPeers": [
         "better-sqlite3",
+        "lru-cache",
         "pg",
         "postgres",
         "sqlite",
diff --git a/package.json b/package.json
index 5c592bd..a461afa 100644
--- a/package.json
+++ b/package.json
@@ -59,14 +59,12 @@
     "check": "bun lint && bun typecheck",
     "fix": "bun lint:staged && bun format:staged"
   },
-  "dependencies": {
-    "lru-cache": "^11.0.0"
-  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.12",
     "@types/pg": "^8.11.11",
     "@types/sqlite3": "^5.1.0",
+    "lru-cache": "^11.0.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
     "oxlint-tsgolint": "^0.20.0",
@@ -76,6 +74,7 @@
   },
   "peerDependencies": {
     "better-sqlite3": "^11.0.0",
+    "lru-cache": "^11.0.0",
     "pg": "^8.0.0",
     "postgres": "^3.4.0",
     "sqlite": "^5.0.0",
@@ -85,6 +84,9 @@
     "better-sqlite3": {
       "optional": true
     },
+    "lru-cache": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     },
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 580694f..f6eaac3 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -1,15 +1,5 @@
 import type { Model, Where } from "../types";
 
-// --- Type Guards ---
-
-export function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-export function isNonEmptyString(v: unknown): v is string {
-  return typeof v === "string" && v !== "";
-}
-
 // --- Schema & Logic Helpers ---
 
 export function getPrimaryKeyFields(model: Model): string[] {
@@ -35,37 +25,12 @@ export function getIdentityValues(
   return values;
 }
 
-export function validateJsonPath(path: string[]): string[] {
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i]!;
-    for (let j = 0; j < segment.length; j++) {
-      const c = segment.codePointAt(j);
-      if (c === undefined) {
-        throw new Error(`Invalid JSON path segment: ${segment}`);
-      }
-      const isAlpha = (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
-      const isDigit = c >= 48 && c <= 57;
-      const isUnderscore = c === 95;
-      if (!isAlpha && !isDigit && !isUnderscore) {
-        throw new Error(`Invalid JSON path segment: ${segment}`);
-      }
-    }
-  }
-  return path;
-}
-
 /**
  * Builds a 'Where' filter targeting the primary key of a specific record.
  * Returns Where<Record<string, unknown>> — callers cast to Where<T> at the boundary.
  */
-export function buildIdentityFilter(
-  model: Model,
-  source: Record<string, unknown>,
-): Where {
+export function buildIdentityFilter(model: Model, source: Record<string, unknown>): Where {
   const pkFields = getPrimaryKeyFields(model);
-  if (pkFields.length === 0) {
-    throw new Error("Model has no primary key defined.");
-  }
   if (pkFields.length === 1) {
     const field = pkFields[0]!;
     return { field, op: "eq" as const, value: source[field] };
@@ -79,10 +44,7 @@ export function buildIdentityFilter(
   return { and: clauses };
 }
 
-export function assertNoPrimaryKeyUpdates(
-  model: Model,
-  data: Record<string, unknown>,
-): void {
+export function assertNoPrimaryKeyUpdates(model: Model, data: Record<string, unknown>): void {
   const pkFields = getPrimaryKeyFields(model);
   for (let i = 0; i < pkFields.length; i++) {
     const field = pkFields[i]!;
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index f585146..2fcbc25 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -162,11 +162,26 @@ describe("MemoryAdapter", () => {
   });
 
   it("should support offset pagination", async () => {
-    await adapter.create({ model: "users", data: { id: "u1", name: "User1", age: 10, is_active: true, metadata: null } });
-    await adapter.create({ model: "users", data: { id: "u2", name: "User2", age: 20, is_active: true, metadata: null } });
-    await adapter.create({ model: "users", data: { id: "u3", name: "User3", age: 30, is_active: true, metadata: null } });
-    await adapter.create({ model: "users", data: { id: "u4", name: "User4", age: 40, is_active: true, metadata: null } });
-    await adapter.create({ model: "users", data: { id: "u5", name: "User5", age: 50, is_active: true, metadata: null } });
+    await adapter.create({
+      model: "users",
+      data: { id: "u1", name: "User1", age: 10, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u2", name: "User2", age: 20, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u3", name: "User3", age: 30, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u4", name: "User4", age: 40, is_active: true, metadata: null },
+    });
+    await adapter.create({
+      model: "users",
+      data: { id: "u5", name: "User5", age: 50, is_active: true, metadata: null },
+    });
 
     const page = await adapter.findMany({
       model: "users",
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 3c21f42..943ce3e 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -1,12 +1,7 @@
 import { LRUCache } from "lru-cache";
 
 import type { Adapter, Cursor, InferModel, Schema, Select, SortBy, Where } from "../types";
-import {
-  assertNoPrimaryKeyUpdates,
-  getIdentityValues,
-  getPrimaryKeyFields,
-  isRecord,
-} from "./common";
+import { assertNoPrimaryKeyUpdates, getIdentityValues, getPrimaryKeyFields } from "./common";
 
 type RowData = Record<string, unknown>;
 type ModelCache = LRUCache<string, RowData>;
@@ -39,10 +34,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return fn(this);
   }
 
-  create<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+  create<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    data: T;
+    select?: Select<T>;
+  }): Promise<T> {
     const { model, data, select } = args;
     const cache = this.getModelStorage(model);
     const pkValue = this.getPrimaryKeyString(model, data);
@@ -56,10 +52,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(this.applySelect<T>(record, select));
   }
 
-  find<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+  find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    select?: Select<T>;
+  }): Promise<T | null> {
     const { model, where, select } = args;
     const cache = this.getModelStorage(model);
 
@@ -71,10 +68,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(null);
   }
 
-  findMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
+  findMany<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;
     select?: Select<T>;
@@ -112,10 +106,11 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(out);
   }
 
-  update<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+  update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    data: Partial<T>;
+  }): Promise<T | null> {
     const { model, where, data } = args;
     assertNoPrimaryKeyUpdates(this.getModel(model), data);
     const cache = this.getModelStorage(model);
@@ -152,10 +147,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(matches.length);
   }
 
-  upsert<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
+  upsert<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     create: T;
     update: Partial<T>;
@@ -182,10 +174,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return this.create({ model, data: create, select });
   }
 
-  delete<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T> }): Promise<void> {
+  delete<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+  }): Promise<void> {
     const { model, where } = args;
     const cache = this.getModelStorage(model);
 
@@ -217,10 +209,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return Promise.resolve(toDelete.length);
   }
 
-  count<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
+  count<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where?: Where<T>;
+  }): Promise<number> {
     const { model, where } = args;
     const cache = this.getModelStorage(model);
 
@@ -320,10 +312,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
    * The `as T` casts are intentional: storage holds RowData but the adapter
    * interface promises T. This is the single boundary where the cast occurs.
    */
-  private applySelect<T extends Record<string, unknown>>(
-    record: RowData,
-    select?: Select<T>,
-  ): T {
+  private applySelect<T extends Record<string, unknown>>(record: RowData, select?: Select<T>): T {
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
     if (select === undefined) return Object.assign({}, record) as T;
     const res: RowData = {};
@@ -339,18 +328,15 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     let val: unknown = record[field];
     if (path !== undefined && path.length > 0) {
       for (let i = 0; i < path.length; i++) {
-        if (!isRecord(val)) return undefined;
-        val = val[path[i]!];
+        if (typeof val !== "object" || val === null || Array.isArray(val)) return undefined;
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by object check above
+        val = (val as RowData)[path[i]!];
       }
     }
     return val;
   }
 
-  private applyCursor(
-    results: RowData[],
-    cursor: Cursor,
-    sortBy?: SortBy[],
-  ): RowData[] {
+  private applyCursor(results: RowData[], cursor: Cursor, sortBy?: SortBy[]): RowData[] {
     const cursorValues = cursor.after as Record<string, unknown>;
     const criteria: { field: string; direction: "asc" | "desc"; path?: string[] }[] = [];
 
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 4b79249..a60176e 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -9,19 +9,7 @@ type TransactionSql = postgres.TransactionSql;
 
 export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql | TransactionSql;
 
-// --- Prepared statement name cache for pg driver ---
-// Reuses statement names per SQL string to benefit from server-side prepared statements.
-const pgStatementCache = new Map<string, string>();
-let queryCount = 0;
-
-function getNamedQuery(sql: string): { name: string; text: string } {
-  let name = pgStatementCache.get(sql);
-  if (name === undefined) {
-    name = `no_orm_${queryCount++}`;
-    pgStatementCache.set(sql, name);
-  }
-  return { name, text: sql };
-}
+const MAX_CACHE_SIZE = 100;
 
 // --- Dialect ---
 
@@ -113,21 +101,52 @@ function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClien
 
 // --- Executor factories ---
 
-/**
- * Bun SQL and postgres.js both use `unsafe()` for raw queries.
- * Both drivers accept arrays of primitives at runtime. We use a structural
- * approach via Record<string, unknown> to avoid driver-specific type gymnastics.
- */
-// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- structural duck-typing for multi-driver support
-function createUnsafeExecutor(
-  sql: Record<string, unknown>,
-  beginFn: (cb: (tx: Record<string, unknown>) => Promise<unknown>) => Promise<unknown>,
-): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting unsafe() from structurally-typed driver
-  const unsafeFn = sql["unsafe"] as (
+// postgres.js: uses `sql.unsafe(query, params, { prepare: true })` for server-side
+// prepared statements. The driver manages statement name caching internally.
+// Works for both Sql (top-level) and TransactionSql (inside begin/savepoint) since
+// both extend ISql which provides `unsafe()`.
+function createPostgresJsExecutor(sql: postgres.Sql | postgres.TransactionSql): QueryExecutor {
+  const run = (query: string, params?: unknown[]) =>
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js params type is narrower than unknown[]
+    sql.unsafe(query, params as postgres.ParameterOrJSON<never>[], { prepare: true });
+
+  return {
+    all: async (query, params) => {
+      const rows = await run(query, params);
+      return rows as Record<string, unknown>[];
+    },
+    get: async (query, params) => {
+      const rows = await run(query, params);
+      return rows[0] as Record<string, unknown> | undefined;
+    },
+    run: async (query, params) => {
+      const rows = await run(query, params);
+      return { changes: rows.count ?? 0 };
+    },
+    transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) => {
+      // Top-level Sql uses begin(); TransactionSql uses savepoint() for nesting
+      if ("begin" in sql) {
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- UnwrapPromiseArray<T> = T for single promises
+        return sql.begin((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>;
+      }
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- same as above
+      return sql.savepoint((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>;
+    },
+  };
+}
+
+// Bun SQL: uses `sql.unsafe(query, params)`. No prepare option — the driver
+// manages prepared statements internally.
+function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting unsafe() from Bun SQL driver
+  const unsafeFn = driver["unsafe"] as (
     query: string,
     params?: unknown[],
   ) => Promise<Record<string, unknown>[] & { count?: number }>;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting transaction() from Bun SQL driver
+  const transactionFn = driver["transaction"] as (
+    cb: (tx: unknown) => Promise<unknown>,
+  ) => Promise<unknown>;
 
   return {
     all: (query, params) => unsafeFn(query, params),
@@ -141,48 +160,41 @@ function createUnsafeExecutor(
     },
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Promise<unknown> -> Promise<T> at executor boundary
-      beginFn((tx) => fn(createUnsafeExecutor(tx, beginFn))) as Promise<T>,
+      transactionFn((tx) => fn(createBunSqlExecutor(tx as Record<string, unknown>))) as Promise<T>,
   };
 }
 
-function createPostgresJsExecutor(sql: PostgresJsSql): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js Sql -> Record for createUnsafeExecutor
-  const driver = sql as unknown as Record<string, unknown>;
-  return createUnsafeExecutor(driver, (cb) =>
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- TransactionSql -> Record for createUnsafeExecutor
-    sql.begin((tx) => cb(tx as unknown as Record<string, unknown>)),
-  );
-}
+// pg: uses named queries with a bounded LRU cache for server-side prepared
+// statement reuse. Each unique SQL string gets a stable name (e.g. `q_0`).
+function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
+  const cache = new Map<string, string>();
+  let count = 0;
 
-function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL transaction function extraction
-  const transactionFn = driver["transaction"] as (
-    cb: (tx: unknown) => Promise<unknown>,
-  ) => Promise<unknown>;
-  return createUnsafeExecutor(driver, (cb) =>
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL tx -> Record
-    transactionFn((tx) => cb(tx as Record<string, unknown>)),
-  );
-}
+  function getQuery(sql: string, values?: unknown[]) {
+    let name = cache.get(sql);
+    if (name === undefined) {
+      // Evict oldest entry when cache is full
+      if (cache.size >= MAX_CACHE_SIZE) {
+        const first = cache.keys().next();
+        if (first.done !== true) cache.delete(first.value);
+      }
+      name = `q_${count++}`;
+      cache.set(sql, name);
+    }
+    return { name, text: sql, values };
+  }
 
-function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
   return {
     all: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>({
-        ...getNamedQuery(sql),
-        values: params,
-      });
+      const res = await driver.query<Record<string, unknown>>(getQuery(sql, params));
       return res.rows;
     },
     get: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>({
-        ...getNamedQuery(sql),
-        values: params,
-      });
+      const res = await driver.query<Record<string, unknown>>(getQuery(sql, params));
       return res.rows[0];
     },
     run: async (sql, params) => {
-      const res = await driver.query({ ...getNamedQuery(sql), values: params });
+      const res = await driver.query(getQuery(sql, params));
       return { changes: res.rowCount ?? 0 };
     },
     transaction: async (fn) => {
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index c3cf67b..5e520e9 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -58,6 +58,8 @@ export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S
     protected dialect: SqlDialect,
   ) {}
 
+  abstract transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
+
   async migrate(): Promise<void> {
     const models = Object.entries(this.schema);
 
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 463c396..c3d59de 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -316,7 +316,6 @@ describe("SqliteAdapter", () => {
 
     it("should handle nested transactions with savepoints", async () => {
       await adapter.transaction(async (outer) => {
-        if (!outer.transaction) throw new Error("Transactions not supported");
         await outer.create({
           model: "users",
           data: { id: "n1", name: "Outer1", age: 20, is_active: true, metadata: null, tags: null },
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index f4d4532..904df96 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -1,4 +1,5 @@
 import type { Database as BunDatabase } from "bun:sqlite";
+
 import type { Database as BetterSqlite3Database } from "better-sqlite3";
 import type { Database as SqliteDatabase } from "sqlite";
 
@@ -54,6 +55,8 @@ export const SqliteDialect: SqlDialect = {
   },
 };
 
+const MAX_CACHE_SIZE = 100;
+
 // --- Driver detection and executors ---
 
 // better-sqlite3 and bun:sqlite are synchronous — they have `prepare` returning a statement
@@ -67,38 +70,57 @@ function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlit
  * Structural interface for the shared subset of BunDatabase and BetterSqlite3Database
  * `prepare()` APIs. Their full type signatures differ but both satisfy this shape.
  */
+type SyncStatement = {
+  all(...params: unknown[]): unknown[];
+  get(...params: unknown[]): unknown;
+  run(...params: unknown[]): { changes: number };
+};
+
 interface SyncDriver {
-  prepare(sql: string): {
-    all(...params: unknown[]): unknown[];
-    get(...params: unknown[]): unknown;
-    run(...params: unknown[]): { changes: number };
-  };
+  prepare(sql: string): SyncStatement;
 }
 
+// Caches compiled Statement objects per SQL string to avoid re-parsing on every query.
+// Uses a simple Map with FIFO eviction at MAX_CACHE_SIZE.
 function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
+  const cache = new Map<string, SyncStatement>();
+
+  function getStmt(sql: string): SyncStatement {
+    let stmt = cache.get(sql);
+    if (stmt === undefined) {
+      if (cache.size >= MAX_CACHE_SIZE) {
+        const first = cache.keys().next();
+        if (first.done !== true) cache.delete(first.value);
+      }
+      stmt = driver.prepare(sql);
+      cache.set(sql, stmt);
+    }
+    return stmt;
+  }
+
   return {
     all: (sql, params) => {
-      const result = driver.prepare(sql).all(...(params ?? []));
+      const result = getStmt(sql).all(...(params ?? []));
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects
       return Promise.resolve(result as Record<string, unknown>[]);
     },
     get: (sql, params) => {
-      const result = driver.prepare(sql).get(...(params ?? []));
+      const result = getStmt(sql).get(...(params ?? []));
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined
       return Promise.resolve(result as Record<string, unknown> | undefined);
     },
     run: (sql, params) => {
-      const res = driver.prepare(sql).run(...(params ?? []));
+      const res = getStmt(sql).run(...(params ?? []));
       return Promise.resolve({ changes: res.changes ?? 0 });
     },
     transaction: async (fn) => {
-      driver.prepare("BEGIN").run();
+      getStmt("BEGIN").run();
       try {
         const res = await fn(createSyncSqliteExecutor(driver));
-        driver.prepare("COMMIT").run();
+        getStmt("COMMIT").run();
         return res;
       } catch (e) {
-        driver.prepare("ROLLBACK").run();
+        getStmt("ROLLBACK").run();
         throw e;
       }
     },
diff --git a/src/types.ts b/src/types.ts
index 756e30b..05d7621 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -58,13 +58,13 @@ export interface Adapter<S extends Schema = Schema> {
   /**
    * Initializes the database schema. Should be idempotent.
    */
-  migrate?(args: { schema: S }): Promise<void>;
+  migrate(): Promise<void>;
 
   /**
    * Executes a callback within a database transaction.
    * Implementation may vary by adapter (e.g., in-memory vs SQL).
    */
-  transaction?<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
 
   /**
    * Inserts a new record.
@@ -107,7 +107,7 @@ export interface Adapter<S extends Schema = Schema> {
    * If the record exists, 'update' is applied only if it satisfies the optional 'where' predicate.
    * If the record does not exist, 'create' is applied.
    */
-  upsert?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+  upsert<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     create: T;
     update: Partial<T>;
@@ -127,7 +127,7 @@ export interface Adapter<S extends Schema = Schema> {
    * Deletes multiple records matching the 'where' clause.
    * @returns The number of records deleted.
    */
-  deleteMany?<
+  deleteMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -160,7 +160,7 @@ export interface Adapter<S extends Schema = Schema> {
   /**
    * Returns the count of records matching the 'where' clause.
    */
-  count?<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+  count<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
     model: K;
     where?: Where<T>;
   }): Promise<number>;

From e8f05f7a0cff84c2a896122cf8ae818dc0e20a2c Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 24 Apr 2026 18:58:29 +0800
Subject: [PATCH 20/24] refactor: No redundant abstractions and interfaces,
 address DRY concerns

---
 AGENTS.md                |   75 +--
 src/adapters/common.ts   |   48 +-
 src/adapters/memory.ts   |   84 ++-
 src/adapters/postgres.ts |  149 +++--
 src/adapters/sql.ts      | 1156 +++++++++++++++++++-------------------
 src/adapters/sqlite.ts   |  132 ++++-
 src/types.ts             |    6 +-
 7 files changed, 909 insertions(+), 741 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 3d53d09..06825d5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -33,14 +33,14 @@ src/
   types.ts              Schema, Adapter interface, Where/SortBy/Cursor types
   index.ts              Public entrypoint (re-exports types.ts)
   adapters/
-    common.ts           Shared PK helpers used by memory + sql adapters
+    common.ts           Shared PK, pagination, and value helpers
     memory.ts           MemoryAdapter (LRU-cache-backed)
-    sql.ts              QueryExecutor, SqlDialect interfaces, SqlAdapter base class
-    postgres.ts         PostgresDialect + driver executors + PostgresAdapter
-    sqlite.ts           SqliteDialect + driver executors + SqliteAdapter
+    sql.ts              QueryExecutor, SqlFormat interfaces, functional helpers
+    postgres.ts         PostgresAdapter (uses sql.ts helpers)
+    sqlite.ts           SqliteAdapter (uses sql.ts helpers)
 ```
 
-Each adapter file is self-contained: dialect config, driver detection, executor factories, and adapter class all live together. There is no separate `dialects/` directory.
+Each adapter file is self-contained: formatting hooks, driver detection, executor factories, and adapter class all live together.
 
 ## Local Commands
 
@@ -57,9 +57,12 @@ Each adapter file is self-contained: dialect config, driver detection, executor
 
 1. Read the touched feature area first.
 2. Keep edits minimal and localized; avoid broad refactors unless asked.
-3. Update related tests when behavior changes.
-4. Run `bun run check` and `bun test` before considering a change done.
-5. If formatting/linting is impacted, run `bun run format` and `bun run lint`.
+3. Retain existing architectural and defensive comments that explain "why" (e.g. sequential DDL, driver detection order, V8 optimizations).
+4. Update related tests when behavior changes.
+5. Run `bun run check` and `bun test` before considering a change done.
+6. If formatting/linting is impacted, run `bun run format` and `bun run lint`.
+
+- Update this file with new "Lessons Learned" or "Mistakes to Avoid" if a significant architectural shift or subtle bug is encountered.
 
 ## TypeScript Rules
 
@@ -112,44 +115,19 @@ Prefer `for (let i = 0; i < arr.length; i++)` over `for...of` in adapter interna
 
 ### Adapter boundary is the one place where `as T` casts are acceptable
 
-Storage holds `Record<string, unknown>` (RowData) but the adapter interface promises `T`. The cast from `RowData -> T` happens in `applySelect` (memory) and `mapRow` (sql). Keep this boundary thin and document it.
-
-### SqlDialect is a plain object, not a class
-
-Dialects are stateless configuration objects (`PostgresDialect`, `SqliteDialect`). They provide SQL generation functions (placeholder, quote, type mapping, JSON extraction, upsert). Do not add state or instance methods.
-
-### QueryExecutor is the driver abstraction
-
-Each database driver (pg Pool, postgres.js, Bun SQL, better-sqlite3, bun:sqlite, async sqlite) gets wrapped into a `QueryExecutor` with uniform `all`/`get`/`run`/`transaction` methods. The executor factory lives in the adapter file next to its dialect.
-
-### Postgres driver detection order matters
-
-Detection is structural (duck-typing). The order must be:
-
-1. Bun SQL — has `unsafe` + `transaction`
-2. postgres.js — has `unsafe` + `begin` (but not `transaction`)
-3. pg — has `query`
-
-If the order changes, Bun SQL gets misidentified as postgres.js.
+Storage holds `Record<string, unknown>` (RowData) but the adapter interface promises `T`. The cast from `RowData -> T` happens in `applySelect` (memory) and `toRow` (sql). Keep this boundary thin and document it.
 
-### SQLite driver detection
+### SqlFormat is a plain object, not a class
 
-- Sync drivers (bun:sqlite, better-sqlite3): have `prepare` but not `all` on the database object.
-- Async driver (sqlite package): has `all`, `get`, `run` directly on the database object.
+Formatting hooks (quoting, placeholders, type mapping, JSON extraction) are defined as stateless configuration objects (`pg`, `sqlite`). Functional helpers in `sql.ts` receive these hooks to generate database-specific SQL.
 
-### DDL in migrate() is sequential
+### SQL logic is functional and composable
 
-`CREATE TABLE` and `CREATE INDEX` statements run sequentially (not `Promise.all`). Tables must exist before their indexes. Some drivers (SQLite) also can't handle concurrent DDL on one connection.
+Instead of a base class, `sql.ts` provides pure functions (`find`, `create`, `update`, etc.) that orchestrate SQL generation and execution. Each SQL adapter class (`PostgresAdapter`, `SqliteAdapter`) implements the `Adapter` interface by delegating to these helpers. This composition significantly reduces abstraction leaks and improves readability.
 
-### Prepared statement caching
-
-All three Postgres drivers use server-side prepared statements, but through different mechanisms:
-
-- **pg**: The executor maintains a bounded Map (max 100) of SQL string to statement name (`q_0`, `q_1`, ...). Named queries enable server-side prepared statement reuse. FIFO eviction when the cache is full.
-- **postgres.js**: Every `sql.unsafe()` call passes `{ prepare: true }`, which tells the driver to use server-side prepared statements. The driver manages its own internal statement name cache.
-- **Bun SQL**: Handles prepared statement caching internally. No explicit option needed.
+### QueryExecutor is the driver abstraction
 
-The sync SQLite executor (better-sqlite3, bun:sqlite) caches compiled `Statement` objects in a bounded Map (max 100) to avoid re-parsing the same SQL on every query. This matches the hebo-gateway pattern.
+Each database driver (pg Pool, postgres.js, Bun SQL, better-sqlite3, bun:sqlite, async sqlite) gets wrapped into a `QueryExecutor` with uniform `all`/`get`/`run`/`transaction` methods. The executor factory lives in the adapter file next to its formatting hooks.
 
 ## Dependency Rules
 
@@ -175,7 +153,7 @@ Every optional peer dep that provides types must also be in `devDependencies` so
 
 ### v1 schema is intentionally minimal
 
-Supported field types: `string`, `number`, `boolean`, `timestamp`, `json`, `json[]`. No defaults, foreign keys, relations, enums, or uniqueness constraints.
+Supported field types: `string`, `number`, `boolean`, `timestamp`, `json`, `json[]`. No defaults, foreign key fields are just primitive types. No relations or automated joins.
 
 ### Validations are out of scope for v1
 
@@ -197,16 +175,6 @@ The schema is passed to the adapter constructor. `migrate()` uses `this.schema`
 - Cover: CRUD lifecycle, composite primary keys, select projection, all operators (`eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `not_in`), logical composition (`and`, `or`), null handling, JSON path filters, pagination (offset + cursor), sorting with nulls, upsert (insert/update/predicated), updateMany, deleteMany, count, transactions, LRU eviction, duplicate key rejection.
 - When adding a new adapter, add integration tests exercising the full operation set.
 
-## Future Extension: GreptimeDB
-
-The current design is open for a GreptimeDB adapter without interface changes:
-
-- Provide a custom `SqlDialect` (type mapping, JSON extraction, upsert syntax).
-- Subclass `SqlAdapter` and override `migrate()` for GreptimeDB-specific DDL (`TIME INDEX`, `PARTITION BY`, `SKIPPING INDEX`).
-- Override `mapInput`/`mapRow` if per-driver parameter mapping is needed (e.g. BigInt timestamps for postgres.js, string timestamps for pg).
-
-No changes to `QueryExecutor`, `SqlDialect`, or `Adapter` interfaces are required.
-
 ## Guardrails
 
 - Do not remove or rename public exports without explicit request.
@@ -225,3 +193,8 @@ No changes to `QueryExecutor`, `SqlDialect`, or `Adapter` interfaces are require
 - [ ] No object spreads introduced in adapter hot paths.
 - [ ] No dead code (unused exports, unreachable branches).
 - [ ] README updated if public API changed.
+
+## Lessons Learned & Mistakes to Avoid
+
+- **V8 hot paths**: Avoid object spreads and `delete` in adapter CRUD loops to maintain peak performance (hidden class stability).
+- **Unified Logic**: Shared logic for keyset pagination (criteria building) and JSON path extraction should live in `common.ts` to ensure consistency between Memory and SQL adapters.
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index f6eaac3..5d5ef3b 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -1,4 +1,4 @@
-import type { Model, Where } from "../types";
+import type { Cursor, Model, SortBy, Where } from "../types";
 
 // --- Schema & Logic Helpers ---
 
@@ -60,3 +60,49 @@ export function assertNoPrimaryKeyUpdates(model: Model, data: Record<string, unk
 export function mapNumeric(value: unknown): number | null {
   return value === null || value === undefined ? null : Number(value);
 }
+
+// --- Value & Comparison Helpers ---
+
+/**
+ * Extracts a value from a record, supporting nested JSON paths.
+ */
+export function getNestedValue(
+  record: Record<string, unknown>,
+  field: string,
+  path?: string[],
+): unknown {
+  let val: unknown = record[field];
+  if (path !== undefined && path.length > 0) {
+    for (let i = 0; i < path.length; i++) {
+      if (typeof val !== "object" || val === null || Array.isArray(val)) return undefined;
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by object check above
+      val = (val as Record<string, unknown>)[path[i]!];
+    }
+  }
+  return val;
+}
+
+/**
+ * Normalizes pagination criteria from a cursor and optional sort parameters.
+ */
+export function getPaginationCriteria(
+  cursor: Cursor,
+  sortBy?: SortBy[],
+): { field: string; direction: "asc" | "desc"; path?: string[] }[] {
+  const cursorValues = cursor.after as Record<string, unknown>;
+  const criteria = [];
+  if (sortBy !== undefined && sortBy.length > 0) {
+    for (let i = 0; i < sortBy.length; i++) {
+      const s = sortBy[i]!;
+      if (cursorValues[s.field] !== undefined) {
+        criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
+      }
+    }
+  } else {
+    const keys = Object.keys(cursorValues);
+    for (let i = 0; i < keys.length; i++) {
+      criteria.push({ field: keys[i]!, direction: "asc" as const, path: undefined });
+    }
+  }
+  return criteria;
+}
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 943ce3e..115b517 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -1,7 +1,13 @@
 import { LRUCache } from "lru-cache";
 
 import type { Adapter, Cursor, InferModel, Schema, Select, SortBy, Where } from "../types";
-import { assertNoPrimaryKeyUpdates, getIdentityValues, getPrimaryKeyFields } from "./common";
+import {
+  assertNoPrimaryKeyUpdates,
+  getIdentityValues,
+  getNestedValue,
+  getPaginationCriteria,
+  getPrimaryKeyFields,
+} from "./common";
 
 type RowData = Record<string, unknown>;
 type ModelCache = LRUCache<string, RowData>;
@@ -284,7 +290,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       return false;
     }
 
-    const recordVal = this.getValue(record, where.field, where.path);
+    const recordVal = getNestedValue(record, where.field, where.path);
 
     switch (where.op) {
       case "eq":
@@ -292,13 +298,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       case "ne":
         return recordVal !== where.value;
       case "gt":
-        return this.compareValues(recordVal, where.value) > 0;
+        return compareValues(recordVal, where.value) > 0;
       case "gte":
-        return this.compareValues(recordVal, where.value) >= 0;
+        return compareValues(recordVal, where.value) >= 0;
       case "lt":
-        return this.compareValues(recordVal, where.value) < 0;
+        return compareValues(recordVal, where.value) < 0;
       case "lte":
-        return this.compareValues(recordVal, where.value) <= 0;
+        return compareValues(recordVal, where.value) <= 0;
       case "in":
         return Array.isArray(where.value) && where.value.includes(recordVal);
       case "not_in":
@@ -324,35 +330,9 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return res as T;
   }
 
-  private getValue(record: RowData, field: string, path?: string[]): unknown {
-    let val: unknown = record[field];
-    if (path !== undefined && path.length > 0) {
-      for (let i = 0; i < path.length; i++) {
-        if (typeof val !== "object" || val === null || Array.isArray(val)) return undefined;
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by object check above
-        val = (val as RowData)[path[i]!];
-      }
-    }
-    return val;
-  }
-
   private applyCursor(results: RowData[], cursor: Cursor, sortBy?: SortBy[]): RowData[] {
     const cursorValues = cursor.after as Record<string, unknown>;
-    const criteria: { field: string; direction: "asc" | "desc"; path?: string[] }[] = [];
-
-    if (sortBy !== undefined && sortBy.length > 0) {
-      for (let i = 0; i < sortBy.length; i++) {
-        const s = sortBy[i]!;
-        if (cursorValues[s.field] !== undefined) {
-          criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
-        }
-      }
-    } else {
-      const keys = Object.keys(cursorValues);
-      for (let i = 0; i < keys.length; i++) {
-        criteria.push({ field: keys[i]!, direction: "asc" });
-      }
-    }
+    const criteria = getPaginationCriteria(cursor, sortBy);
 
     if (criteria.length === 0) return results;
 
@@ -364,9 +344,9 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
       for (let j = 0; j < criteria.length; j++) {
         const curr = criteria[j]!;
-        const recordVal = this.getValue(record, curr.field, curr.path);
+        const recordVal = getNestedValue(record, curr.field, curr.path);
         const cursorVal = cursorValues[curr.field];
-        const comp = this.compareValues(recordVal, cursorVal);
+        const comp = compareValues(recordVal, cursorVal);
 
         if (comp === 0) continue;
         if (curr.direction === "desc" ? comp < 0 : comp > 0) {
@@ -383,28 +363,32 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return results.toSorted((a, b) => {
       for (let i = 0; i < sortBy.length; i++) {
         const s = sortBy[i]!;
-        const valA = this.getValue(a, s.field, s.path);
-        const valB = this.getValue(b, s.field, s.path);
+        const valA = getNestedValue(a, s.field, s.path);
+        const valB = getNestedValue(b, s.field, s.path);
         if (valA === valB) continue;
-        const comparison = this.compareValues(valA, valB);
+        const comparison = compareValues(valA, valB);
         if (comparison === 0) continue;
         return s.direction === "desc" ? -comparison : comparison;
       }
       return 0;
     });
   }
+}
 
-  private compareValues(left: unknown, right: unknown): number {
-    if (left === right) return 0;
-    if (left === undefined || left === null) return -1;
-    if (right === undefined || right === null) return 1;
-    if (typeof left !== typeof right) return 0;
-    if (typeof left === "string" && typeof right === "string") {
-      return left < right ? -1 : left > right ? 1 : 0;
-    }
-    if (typeof left === "number" && typeof right === "number") {
-      return left < right ? -1 : left > right ? 1 : 0;
-    }
-    return 0;
+/**
+ * Null-safe comparison of primitive values.
+ * Treats null/undefined as the smallest possible values.
+ */
+function compareValues(left: unknown, right: unknown): number {
+  if (left === right) return 0;
+  if (left === undefined || left === null) return -1;
+  if (right === undefined || right === null) return 1;
+  if (typeof left !== typeof right) return 0;
+  if (typeof left === "string" && typeof right === "string") {
+    return left < right ? -1 : left > right ? 1 : 0;
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return left < right ? -1 : left > right ? 1 : 0;
   }
+  return 0;
 }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index a60176e..f98bb7a 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,8 +1,22 @@
 import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
 import type postgres from "postgres";
 
-import type { Adapter, Field, Schema } from "../types";
-import { type QueryExecutor, type SqlDialect, SqlAdapter, isQueryExecutor } from "./sql";
+import type { Adapter, Field, InferModel, Schema, Select, SortBy, Where, Cursor } from "../types";
+import {
+  type QueryExecutor,
+  type SqlFormat,
+  isQueryExecutor,
+  migrate,
+  create,
+  find,
+  findMany,
+  update,
+  updateMany,
+  upsert,
+  remove,
+  removeMany,
+  count,
+} from "./sql";
 
 type PostgresJsSql = postgres.Sql;
 type TransactionSql = postgres.TransactionSql;
@@ -11,12 +25,11 @@ export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql |
 
 const MAX_CACHE_SIZE = 100;
 
-// --- Dialect ---
+// --- Formatting Hooks ---
 
-export const PostgresDialect: SqlDialect = {
+const pg: SqlFormat = {
   placeholder: (i) => `$${i + 1}`,
   quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  escapeLiteral: (s) => s.replaceAll("'", "''"),
   mapFieldType(field: Field): string {
     switch (field.type) {
       case "string":
@@ -34,21 +47,12 @@ export const PostgresDialect: SqlDialect = {
         return "TEXT";
     }
   },
-  buildJsonPath(path: string[]): string {
-    let res = "";
+  jsonExtract(column: string, path: string[], isNumeric?: boolean, isBoolean?: boolean): string {
+    let segments = "";
     for (let i = 0; i < path.length; i++) {
-      if (i > 0) res += ", ";
-      res += `'${this.escapeLiteral(path[i]!)}'`;
+      if (i > 0) segments += ", ";
+      segments += `'${path[i]!.replaceAll("'", "''")}'`;
     }
-    return res;
-  },
-  buildJsonExtract(
-    column: string,
-    path: string[],
-    isNumeric?: boolean,
-    isBoolean?: boolean,
-  ): string {
-    const segments = this.buildJsonPath(path);
     const base = `jsonb_extract_path_text(${column}, ${segments})`;
     if (isNumeric === true) return `(${base})::double precision`;
     if (isBoolean === true) return `(${base})::boolean`;
@@ -168,17 +172,16 @@ function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
 // statement reuse. Each unique SQL string gets a stable name (e.g. `q_0`).
 function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
   const cache = new Map<string, string>();
-  let count = 0;
+  let statementCount = 0;
 
   function getQuery(sql: string, values?: unknown[]) {
     let name = cache.get(sql);
     if (name === undefined) {
-      // Evict oldest entry when cache is full
       if (cache.size >= MAX_CACHE_SIZE) {
         const first = cache.keys().next();
         if (first.done !== true) cache.delete(first.value);
       }
-      name = `q_${count++}`;
+      name = `q_${statementCount++}`;
       cache.set(sql, name);
     }
     return { name, text: sql, values };
@@ -198,7 +201,6 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
       return { changes: res.rowCount ?? 0 };
     },
     transaction: async (fn) => {
-      // Pool has `connect()` but no `release()`; PoolClient has `release()`.
       const isPool = "connect" in driver && !("release" in driver);
       if (isPool) {
         // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by isPool check above
@@ -215,7 +217,6 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
           client.release();
         }
       }
-      // Already a Client or PoolClient — use directly
       await driver.query("BEGIN");
       try {
         const res = await fn(createPgExecutor(driver));
@@ -239,21 +240,97 @@ function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
 
 // --- Adapter ---
 
-export class PostgresAdapter<S extends Schema = Schema>
-  extends SqlAdapter<S>
-  implements Adapter<S>
-{
-  constructor(schema: S, driver: PostgresDriver | QueryExecutor) {
-    super(
-      schema,
-      isQueryExecutor(driver) ? driver : createPostgresExecutor(driver),
-      PostgresDialect,
-    );
+export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private executor: QueryExecutor;
+
+  constructor(
+    private schema: S,
+    driver: PostgresDriver | QueryExecutor,
+  ) {
+    this.executor = isQueryExecutor(driver) ? driver : createPostgresExecutor(driver);
   }
 
+  migrate = () => migrate(this.executor, this.schema, pg);
+
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    return this.executor.transaction((innerExecutor) => {
-      return fn(new PostgresAdapter(this.schema, innerExecutor));
-    });
+    return this.executor.transaction((exec) => fn(new PostgresAdapter(this.schema, exec)));
   }
+
+  create = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    data: T;
+    select?: Select<T>;
+  }) => create(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  find = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    select?: Select<T>;
+  }) => find(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  findMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }) => findMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  update = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: Where<T>;
+    data: Partial<T>;
+  }) => update(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  updateMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    data: Partial<T>;
+  }) => updateMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  upsert = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    create: T;
+    update: Partial<T>;
+    where?: Where<T>;
+    select?: Select<T>;
+  }) => upsert(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  delete = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: Where<T>;
+  }) => remove(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  deleteMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+  }) => removeMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+
+  count = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where?: Where<T>;
+  }) => count(this.executor, args.model, this.schema[args.model]!, pg, args);
 }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 5e520e9..97bbb46 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -1,13 +1,14 @@
-import type { Adapter, Cursor, Field, InferModel, Schema, Select, SortBy, Where } from "../types";
+import type { Cursor, Field, Model, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
   buildIdentityFilter,
   getIdentityValues,
+  getPaginationCriteria,
   getPrimaryKeyFields,
   mapNumeric,
 } from "./common";
 
-// --- Shared contracts for SQL dialects and executors ---
+// --- Shared contracts for SQL executors and formatting ---
 
 export interface QueryExecutor {
   all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
@@ -16,19 +17,14 @@ export interface QueryExecutor {
   transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
 }
 
-export interface SqlDialect {
+export interface SqlFormat {
   placeholder(index: number): string;
   quote(identifier: string): string;
-  escapeLiteral(value: string): string;
   mapFieldType(field: Field): string;
-  buildJsonPath(path: string[]): string;
-  buildJsonExtract(
-    fieldName: string,
-    path: (string | number)[],
-    isNumeric?: boolean,
-    isBoolean?: boolean,
-  ): string;
-  upsert?(options: {
+  jsonExtract(column: string, path: string[], isNumeric?: boolean, isBoolean?: boolean): string;
+  /** Maps a boolean to its SQL parameter value. Defaults to pass-through if omitted. */
+  mapBoolean?(value: boolean): unknown;
+  upsert?(args: {
     table: string;
     insertColumns: string[];
     insertPlaceholders: string[];
@@ -49,643 +45,641 @@ export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
   );
 }
 
-// --- Abstract SQL adapter ---
-
-export abstract class SqlAdapter<S extends Schema = Schema> implements Adapter<S> {
-  constructor(
-    protected schema: S,
-    protected executor: QueryExecutor,
-    protected dialect: SqlDialect,
-  ) {}
-
-  abstract transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T>;
-
-  async migrate(): Promise<void> {
-    const models = Object.entries(this.schema);
-
-    // Create tables first, then indexes — indexes depend on tables existing.
-    // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
-    for (let i = 0; i < models.length; i++) {
-      const [name, model] = models[i]!;
-      const fields = Object.entries(model.fields);
-      const columns: string[] = [];
-      for (let j = 0; j < fields.length; j++) {
-        const [fieldName, field] = fields[j]!;
-        const nullable = field.nullable === true ? "" : " NOT NULL";
-        columns.push(
-          `${this.dialect.quote(fieldName)} ${this.dialect.mapFieldType(field)}${nullable}`,
-        );
-      }
-
-      const pkFields = getPrimaryKeyFields(model);
-      const quotedPkFields: string[] = [];
-      for (let j = 0; j < pkFields.length; j++) {
-        quotedPkFields.push(this.dialect.quote(pkFields[j]!));
-      }
-      const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
-
-      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-      await this.executor.run(
-        `CREATE TABLE IF NOT EXISTS ${this.dialect.quote(name)} (${columns.join(", ")}, ${pk})`,
-        [],
-      );
-    }
+// --- SQL Builders & Mappers ---
 
-    // Now create indexes
-    for (let i = 0; i < models.length; i++) {
-      const [name, model] = models[i]!;
-      if (!model.indexes) continue;
-
-      for (let j = 0; j < model.indexes.length; j++) {
-        const index = model.indexes[j]!;
-        const indexFields = Array.isArray(index.field) ? index.field : [index.field];
-        const formattedFields: string[] = [];
-        for (let k = 0; k < indexFields.length; k++) {
-          formattedFields.push(
-            `${this.dialect.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
-          );
-        }
-        // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-        await this.executor.run(
-          `CREATE INDEX IF NOT EXISTS ${this.dialect.quote(`idx_${name}_${j}`)} ON ${this.dialect.quote(name)} (${formattedFields.join(", ")})`,
-          [],
-        );
-      }
-    }
+export function toSelect(fmt: SqlFormat, select?: Select<Record<string, unknown>>): string {
+  if (!select) return "*";
+  const parts: string[] = [];
+  for (let i = 0; i < select.length; i++) {
+    parts.push(fmt.quote(select[i]!));
   }
+  return parts.join(", ");
+}
 
-  async create<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
-    const { model, data, select } = args;
-    const modelSpec = this.getModel(model);
-
-    const insertData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(insertData);
-
-    const quotedFields: string[] = [];
-    const placeholders: string[] = [];
-    const values: unknown[] = [];
-
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i]!;
-      quotedFields.push(this.dialect.quote(field));
-      placeholders.push(this.dialect.placeholder(i));
-      values.push(insertData[field]);
+export function toInput(
+  fields: Record<string, Field>,
+  data: Record<string, unknown>,
+  fmt: SqlFormat,
+): Record<string, unknown> {
+  const res: Record<string, unknown> = {};
+  const keys = Object.keys(data);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = data[k];
+    const spec = fields[k];
+    if (val === undefined) continue;
+    if (val === null) {
+      res[k] = null;
+      continue;
+    }
+    if (spec?.type === "json" || spec?.type === "json[]") {
+      res[k] = JSON.stringify(val);
+    } else if (spec?.type === "boolean") {
+      res[k] = fmt.mapBoolean ? fmt.mapBoolean(val === true) : val;
+    } else {
+      res[k] = val;
     }
+  }
+  return res;
+}
 
-    const sql = `INSERT INTO ${this.dialect.quote(model)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${this.buildSelect(select)}`;
-    const row = await this.executor.get(sql, values);
-
-    if (!row) {
-      // Fallback for drivers that don't support RETURNING
-      const result = await this.find({
-        model,
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
-        where: buildIdentityFilter(modelSpec, data) as Where<T>,
-        select,
-      });
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T if found, and we just inserted it
-      return result as T;
+export function toRow<T extends Record<string, unknown>>(
+  model: Model,
+  row: Record<string, unknown>,
+  select?: Select<Record<string, unknown>>,
+): T {
+  const fields = model.fields;
+  const res: Record<string, unknown> = {};
+  const keys = select ?? Object.keys(row);
+
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = row[k];
+    const spec = fields[k];
+    if (spec === undefined || val === undefined || val === null) {
+      res[k] = val;
+      continue;
+    }
+    if (spec.type === "json" || spec.type === "json[]") {
+      res[k] = typeof val === "string" ? JSON.parse(val) : val;
+    } else if (spec.type === "boolean") {
+      res[k] = val === true || val === 1;
+    } else if (spec.type === "number" || spec.type === "timestamp") {
+      res[k] = mapNumeric(val);
+    } else {
+      res[k] = val;
     }
-
-    return this.mapRow(model, row, select);
   }
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary after field mapping
+  return res as T;
+}
 
-  async find<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
-    const { model, where, select } = args;
-    const builtWhere = this.buildWhere(model, where);
-    const sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql} LIMIT 1`;
-    const row = await this.executor.get(sql, builtWhere.params);
-    return row ? this.mapRow(model, row, select) : null;
+function toColumnExpr(
+  fmt: SqlFormat,
+  model: Model,
+  fieldName: string,
+  path?: string[],
+  value?: unknown,
+): string {
+  if (!path || path.length === 0) return fmt.quote(fieldName);
+
+  const field = model.fields[fieldName];
+  if (field?.type !== "json" && field?.type !== "json[]") {
+    throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
   }
 
-  async findMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-    select?: Select<T>;
-    sortBy?: SortBy<T>[];
-    limit?: number;
-    offset?: number;
-    cursor?: Cursor<T>;
-  }): Promise<T[]> {
-    const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const params: unknown[] = [];
-    let sql = `SELECT ${this.buildSelect(select)} FROM ${this.dialect.quote(model)}`;
-
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string
-    const builtWhere = this.buildWhere(model, where, cursor, sortBy as SortBy[] | undefined);
-    if (builtWhere.sql !== "1=1") {
-      sql += ` WHERE ${builtWhere.sql}`;
-      for (let i = 0; i < builtWhere.params.length; i++) {
-        params.push(builtWhere.params[i]);
-      }
-    }
-
-    if (sortBy && sortBy.length > 0) {
-      const sortParts: string[] = [];
-      for (let i = 0; i < sortBy.length; i++) {
-        const sort = sortBy[i]!;
-        sortParts.push(
-          `${this.buildColumnExpr(model, sort.field, sort.path)} ${(sort.direction ?? "asc").toUpperCase()}`,
-        );
-      }
-      sql += ` ORDER BY ${sortParts.join(", ")}`;
-    }
-
-    if (limit !== undefined) {
-      sql += ` LIMIT ${this.dialect.placeholder(params.length)}`;
-      params.push(limit);
-    }
+  const isNumeric = typeof value === "number";
+  const isBoolean = typeof value === "boolean";
+  return fmt.jsonExtract(fmt.quote(fieldName), path, isNumeric, isBoolean);
+}
 
-    if (offset !== undefined) {
-      sql += ` OFFSET ${this.dialect.placeholder(params.length)}`;
-      params.push(offset);
-    }
+function mapWhereValue(fmt: SqlFormat, val: unknown): unknown {
+  if (val === null) return null;
+  if (typeof val === "boolean") return fmt.mapBoolean ? fmt.mapBoolean(val) : val;
+  if (typeof val === "number" || typeof val === "string") return val;
+  return JSON.stringify(val);
+}
 
-    const rows = await this.executor.all(sql, params);
-    const result: T[] = [];
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      if (row) result.push(this.mapRow(model, row, select));
+function toWhereRecursive(
+  fmt: SqlFormat,
+  model: Model,
+  where: Where,
+  startIndex: number,
+): { sql: string; params: unknown[] } {
+  if ("and" in where) {
+    const parts = [];
+    const params = [];
+    let currentIdx = startIndex;
+    for (let i = 0; i < where.and.length; i++) {
+      const built = toWhereRecursive(fmt, model, where.and[i]!, currentIdx);
+      parts.push(`(${built.sql})`);
+      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+      currentIdx += built.params.length;
     }
-    return result;
+    return { sql: parts.join(" AND "), params };
   }
 
-  async update<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const updateData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(updateData);
-    if (fields.length === 0) {
-      return this.find({ model, where });
+  if ("or" in where) {
+    const parts = [];
+    const params = [];
+    let currentIdx = startIndex;
+    for (let i = 0; i < where.or.length; i++) {
+      const built = toWhereRecursive(fmt, model, where.or[i]!, currentIdx);
+      parts.push(`(${built.sql})`);
+      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+      currentIdx += built.params.length;
     }
+    return { sql: parts.join(" OR "), params };
+  }
 
-    const assignments: string[] = [];
-    const params: unknown[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i]!;
-      assignments.push(`${this.dialect.quote(field)} = ${this.dialect.placeholder(i)}`);
-      params.push(updateData[field]);
+  const expr = toColumnExpr(fmt, model, where.field, where.path, where.value);
+  const mappedValue = mapWhereValue(fmt, where.value);
+
+  switch (where.op) {
+    case "eq":
+      if (where.value === null) return { sql: `${expr} IS NULL`, params: [] };
+      return { sql: `${expr} = ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "ne":
+      if (where.value === null) return { sql: `${expr} IS NOT NULL`, params: [] };
+      return { sql: `${expr} != ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "gt":
+      return { sql: `${expr} > ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "gte":
+      return { sql: `${expr} >= ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "lt":
+      return { sql: `${expr} < ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "lte":
+      return { sql: `${expr} <= ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
+    case "in": {
+      if (where.value.length === 0) return { sql: "1=0", params: [] };
+      const phs = [];
+      const inParams = [];
+      for (let i = 0; i < where.value.length; i++) {
+        phs.push(fmt.placeholder(startIndex + i));
+        inParams.push(mapWhereValue(fmt, where.value[i]));
+      }
+      return { sql: `${expr} IN (${phs.join(", ")})`, params: inParams };
+    }
+    case "not_in": {
+      if (where.value.length === 0) return { sql: "1=1", params: [] };
+      const phs = [];
+      const inParams = [];
+      for (let i = 0; i < where.value.length; i++) {
+        phs.push(fmt.placeholder(startIndex + i));
+        inParams.push(mapWhereValue(fmt, where.value[i]));
+      }
+      return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
     }
+    default:
+      throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
+  }
+}
 
-    const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
-    const sql = `UPDATE ${this.dialect.quote(model)} SET ${assignments.join(", ")} WHERE ${builtWhere.sql} RETURNING *`;
-    for (let i = 0; i < builtWhere.params.length; i++) {
-      params.push(builtWhere.params[i]);
-    }
+export function toWhere(
+  fmt: SqlFormat,
+  model: Model,
+  where?: Where,
+  cursor?: Cursor,
+  sortBy?: SortBy[],
+  startIndex = 0,
+): { sql: string; params: unknown[] } {
+  const parts: string[] = [];
+  const params: unknown[] = [];
+  let nextIndex = startIndex;
+
+  if (where) {
+    const built = toWhereRecursive(fmt, model, where, nextIndex);
+    parts.push(`(${built.sql})`);
+    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+    nextIndex += built.params.length;
+  }
 
-    const row = await this.executor.get(sql, params);
-    if (!row) {
-      return this.find({ model, where });
+  if (cursor) {
+    const cursorValues = cursor.after as Record<string, unknown>;
+    const criteria = getPaginationCriteria(cursor, sortBy);
+
+    if (criteria.length > 0) {
+      const orClauses = [];
+      for (let i = 0; i < criteria.length; i++) {
+        const andClauses = [];
+        for (let j = 0; j < i; j++) {
+          const prev = criteria[j]!;
+          andClauses.push(
+            `${toColumnExpr(fmt, model, prev.field, prev.path, cursorValues[prev.field])} = ${fmt.placeholder(nextIndex++)}`,
+          );
+          params.push(cursorValues[prev.field]);
+        }
+        const curr = criteria[i]!;
+        const op = curr.direction === "desc" ? "<" : ">";
+        andClauses.push(
+          `${toColumnExpr(fmt, model, curr.field, curr.path, cursorValues[curr.field])} ${op} ${fmt.placeholder(nextIndex++)}`,
+        );
+        params.push(cursorValues[curr.field]);
+        orClauses.push(`(${andClauses.join(" AND ")})`);
+      }
+      parts.push(`(${orClauses.join(" OR ")})`);
     }
-    return this.mapRow(model, row);
   }
 
-  async updateMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
-    const { model, where, data } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, data);
-
-    const updateData = this.mapInput(modelSpec.fields, data);
-    const fields = Object.keys(updateData);
-    if (fields.length === 0) return 0;
-
-    const assignments: string[] = [];
-    const params: unknown[] = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i]!;
-      assignments.push(`${this.dialect.quote(field)} = ${this.dialect.placeholder(i)}`);
-      params.push(updateData[field]);
-    }
+  return {
+    sql: parts.length > 0 ? parts.join(" AND ") : "1=1",
+    params,
+  };
+}
 
-    let sql = `UPDATE ${this.dialect.quote(model)} SET ${assignments.join(", ")}`;
-    if (where) {
-      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
-      sql += ` WHERE ${builtWhere.sql}`;
-      for (let i = 0; i < builtWhere.params.length; i++) {
-        params.push(builtWhere.params[i]);
-      }
-    }
+// --- Functional Helpers ---
 
-    const res = await this.executor.run(sql, params);
-    return res.changes;
-  }
+export async function migrate(exec: QueryExecutor, schema: Schema, fmt: SqlFormat): Promise<void> {
+  const models = Object.entries(schema);
 
-  async upsert<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    create: T;
-    update: Partial<T>;
-    where?: Where<T>;
-    select?: Select<T>;
-  }): Promise<T> {
-    const { model, create, update, where, select } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, update);
-
-    const createData = this.mapInput(modelSpec.fields, create);
-    const createFields = Object.keys(createData);
-    const updateData = this.mapInput(modelSpec.fields, update);
-    const updateFields = Object.keys(updateData);
-    const pkFields = getPrimaryKeyFields(modelSpec);
-
-    const insertColumns: string[] = [];
-    const insertPlaceholders: string[] = [];
-    const params: unknown[] = [];
-    for (let i = 0; i < createFields.length; i++) {
-      const field = createFields[i]!;
-      insertColumns.push(this.dialect.quote(field));
-      insertPlaceholders.push(this.dialect.placeholder(i));
-      params.push(createData[field]);
+  // Create tables first, then indexes — indexes depend on tables existing.
+  // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
+  for (let i = 0; i < models.length; i++) {
+    const [name, model] = models[i]!;
+    const fields = Object.entries(model.fields);
+    const columns: string[] = [];
+    for (let j = 0; j < fields.length; j++) {
+      const [fieldName, field] = fields[j]!;
+      const nullable = field.nullable === true ? "" : " NOT NULL";
+      columns.push(`${fmt.quote(fieldName)} ${fmt.mapFieldType(field)}${nullable}`);
     }
 
-    const updateColumns: string[] = [];
-    for (let i = 0; i < updateFields.length; i++) {
-      const field = updateFields[i]!;
-      updateColumns.push(field);
-      params.push(updateData[field]);
+    const pkFields = getPrimaryKeyFields(model);
+    const quotedPkFields: string[] = [];
+    for (let j = 0; j < pkFields.length; j++) {
+      quotedPkFields.push(fmt.quote(pkFields[j]!));
     }
+    const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
 
-    let whereSql = "";
-    if (where) {
-      const builtWhere = this.buildWhere(model, where, undefined, undefined, params.length);
-      whereSql = builtWhere.sql;
-      for (let i = 0; i < builtWhere.params.length; i++) {
-        params.push(builtWhere.params[i]);
+    // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+    await exec.run(
+      `CREATE TABLE IF NOT EXISTS ${fmt.quote(name)} (${columns.join(", ")}, ${pk})`,
+      [],
+    );
+  }
+
+  // Now create indexes
+  for (let i = 0; i < models.length; i++) {
+    const [name, model] = models[i]!;
+    if (!model.indexes) continue;
+
+    for (let j = 0; j < model.indexes.length; j++) {
+      const index = model.indexes[j]!;
+      const indexFields = Array.isArray(index.field) ? index.field : [index.field];
+      const formattedFields: string[] = [];
+      for (let k = 0; k < indexFields.length; k++) {
+        formattedFields.push(
+          `${fmt.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
+        );
       }
+      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+      await exec.run(
+        `CREATE INDEX IF NOT EXISTS ${fmt.quote(`idx_${name}_${j}`)} ON ${fmt.quote(name)} (${formattedFields.join(", ")})`,
+        [],
+      );
     }
+  }
+}
 
-    if (this.dialect.upsert) {
-      const { sql, params: upsertParams } = this.dialect.upsert({
-        table: model,
-        insertColumns,
-        insertPlaceholders,
-        updateColumns,
-        conflictColumns: pkFields,
-        select,
-        whereSql,
-      });
-      const row = await this.executor.get(sql, upsertParams ?? params);
-      if (row) return this.mapRow(model, row, select);
-    } else {
-      // Generic fallback for ON CONFLICT (Postgres/SQLite)
-      const conflictTarget = [];
-      for (let i = 0; i < pkFields.length; i++)
-        conflictTarget.push(this.dialect.quote(pkFields[i]!));
-
-      let updateSet = "";
-      if (updateFields.length > 0) {
-        const sets = [];
-        for (let i = 0; i < updateFields.length; i++) {
-          const field = updateFields[i]!;
-          sets.push(
-            `${this.dialect.quote(field)} = ${this.dialect.placeholder(createFields.length + i)}`,
-          );
-        }
-        updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-        if (whereSql) updateSet += ` WHERE ${whereSql}`;
-      } else {
-        updateSet = "DO NOTHING";
-      }
+export async function create<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { data: T; select?: Select<T> },
+): Promise<T> {
+  const { data, select } = args;
+  const insertData = toInput(model.fields, data, fmt);
+  const fields = Object.keys(insertData);
+
+  const quotedFields: string[] = [];
+  const placeholders: string[] = [];
+  const values: unknown[] = [];
+
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i]!;
+    quotedFields.push(fmt.quote(field));
+    placeholders.push(fmt.placeholder(i));
+    values.push(insertData[field]);
+  }
 
-      const sql = `INSERT INTO ${this.dialect.quote(model)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${this.buildSelect(select)}`;
-      const row = await this.executor.get(sql, params);
-      if (row) return this.mapRow(model, row, select);
-    }
+  const sql = `INSERT INTO ${fmt.quote(table)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${toSelect(
+    fmt,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    select as Select<Record<string, unknown>>,
+  )}`;
+  const row = await exec.get(sql, values);
 
-    const identityValues = getIdentityValues(modelSpec, create);
-    const existing = await this.find({
-      model,
+  if (!row) {
+    const result = await find(exec, table, model, fmt, {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
-      where: buildIdentityFilter(modelSpec, identityValues) as Where<T>,
+      where: buildIdentityFilter(model, data) as Where<T>,
       select,
     });
-    if (!existing) throw new Error("Failed to refetch upserted record.");
-    return existing;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T if found, and we just inserted it
+    return result as T;
   }
 
-  async delete<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T> }): Promise<void> {
-    const { model, where } = args;
-    const builtWhere = this.buildWhere(model, where);
-    await this.executor.run(
-      `DELETE FROM ${this.dialect.quote(model)} WHERE ${builtWhere.sql}`,
-      builtWhere.params,
-    );
-  }
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+  return toRow(model, row, select as Select<Record<string, unknown>>);
+}
 
-  async deleteMany<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `DELETE FROM ${this.dialect.quote(model)}`;
-    const params: unknown[] = [];
-    if (where) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      for (let i = 0; i < builtWhere.params.length; i++) params.push(builtWhere.params[i]);
-    }
-    const res = await this.executor.run(sql, params);
-    return res.changes;
+export async function find<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where: Where<T>; select?: Select<T> },
+): Promise<T | null> {
+  const { where, select } = args;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where);
+  const sql = `SELECT ${toSelect(
+    fmt,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    select as Select<Record<string, unknown>>,
+  )} FROM ${fmt.quote(table)} WHERE ${built.sql} LIMIT 1`;
+  const row = await exec.get(sql, built.params);
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+  return row ? toRow(model, row, select as Select<Record<string, unknown>>) : null;
+}
+
+export async function findMany<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: {
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  },
+): Promise<T[]> {
+  const { where, select, sortBy, limit, offset, cursor } = args;
+  const params: unknown[] = [];
+  const sqlSelect = toSelect(
+    fmt,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    select as Select<Record<string, unknown>>,
+  );
+  let sql = `SELECT ${sqlSelect} FROM ${fmt.quote(table)}`;
+
+  const built = toWhere(
+    fmt,
+    model,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+    where as Where,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Cursor<T> -> Cursor is safe for SQL gen
+    cursor as Cursor,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>[] -> SortBy[] is safe for SQL gen
+    sortBy as SortBy[] | undefined,
+  );
+  if (built.sql !== "1=1") {
+    sql += ` WHERE ${built.sql}`;
+    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
   }
 
-  async count<
-    K extends keyof S & string,
-    T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where?: Where<T> }): Promise<number> {
-    const { model, where } = args;
-    let sql = `SELECT COUNT(*) as count FROM ${this.dialect.quote(model)}`;
-    const params: unknown[] = [];
-    if (where) {
-      const builtWhere = this.buildWhere(model, where);
-      sql += ` WHERE ${builtWhere.sql}`;
-      for (let i = 0; i < builtWhere.params.length; i++) params.push(builtWhere.params[i]);
+  if (sortBy && sortBy.length > 0) {
+    const sortParts: string[] = [];
+    for (let i = 0; i < sortBy.length; i++) {
+      const s = sortBy[i]!;
+      sortParts.push(
+        `${toColumnExpr(fmt, model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
+      );
     }
-    const row = await this.executor.get(sql, params);
-    if (!row) return 0;
-    const count = row["count"];
-    return typeof count === "number" ? count : Number(count ?? 0);
+    sql += ` ORDER BY ${sortParts.join(", ")}`;
   }
 
-  // --- HELPERS ---
-
-  protected getModel(model: string): S[keyof S & string] {
-    const spec = this.schema[model as keyof S & string];
-    if (!spec) throw new Error(`Model ${model} not found in schema.`);
-    return spec;
+  if (limit !== undefined) {
+    sql += ` LIMIT ${fmt.placeholder(params.length)}`;
+    params.push(limit);
   }
 
-  protected buildSelect(select?: Select<Record<string, unknown>>): string {
-    if (!select) return "*";
-    const parts = [];
-    for (let i = 0; i < select.length; i++) {
-      parts.push(this.dialect.quote(select[i]!));
-    }
-    return parts.join(", ");
+  if (offset !== undefined) {
+    sql += ` OFFSET ${fmt.placeholder(params.length)}`;
+    params.push(offset);
   }
 
-  protected buildColumnExpr(
-    modelName: string,
-    fieldName: string,
-    path?: string[],
-    value?: unknown,
-  ): string {
-    if (!path || path.length === 0) return this.dialect.quote(fieldName);
-
-    const model = this.getModel(modelName);
-    const field = model.fields[fieldName];
-    if (field?.type !== "json" && field?.type !== "json[]") {
-      throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
-    }
+  const rows = await exec.all(sql, params);
+  const result: T[] = [];
+  for (let i = 0; i < rows.length; i++) {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+    result.push(toRow(model, rows[i]!, select as Select<Record<string, unknown>>));
+  }
+  return result;
+}
 
-    const isNumeric = typeof value === "number";
-    const isBoolean = typeof value === "boolean";
-    return this.dialect.buildJsonExtract(this.dialect.quote(fieldName), path, isNumeric, isBoolean);
+export async function update<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where: Where<T>; data: Partial<T> },
+): Promise<T | null> {
+  const { where, data } = args;
+  assertNoPrimaryKeyUpdates(model, data);
+
+  const updateData = toInput(model.fields, data, fmt);
+  const fields = Object.keys(updateData);
+  if (fields.length === 0) return find(exec, table, model, fmt, { where });
+
+  const assignments: string[] = [];
+  const params: unknown[] = [];
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i]!;
+    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(i)}`);
+    params.push(updateData[field]);
   }
 
-  protected buildWhere(
-    model: string,
-    where?: Where,
-    cursor?: Cursor,
-    sortBy?: SortBy[],
-    startIndex = 0,
-  ): { sql: string; params: unknown[] } {
-    const parts: string[] = [];
-    const params: unknown[] = [];
-    let nextIndex = startIndex;
-
-    if (where) {
-      const built = this.buildWhereRecursive(model, where, nextIndex);
-      parts.push(`(${built.sql})`);
-      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-      nextIndex += built.params.length;
-    }
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
+  const sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
+  for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
 
-    if (cursor) {
-      const built = this.buildCursor(model, cursor, sortBy, nextIndex);
-      if (built.sql) {
-        parts.push(`(${built.sql})`);
-        for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-        nextIndex += built.params.length;
-      }
-    }
+  const row = await exec.get(sql, params);
+  if (!row) return find(exec, table, model, fmt, { where });
+  return toRow(model, row);
+}
 
-    return {
-      sql: parts.length > 0 ? parts.join(" AND ") : "1=1",
-      params,
-    };
+export async function updateMany<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where?: Where<T>; data: Partial<T> },
+): Promise<number> {
+  const { where, data } = args;
+  assertNoPrimaryKeyUpdates(model, data);
+
+  const updateData = toInput(model.fields, data, fmt);
+  const fields = Object.keys(updateData);
+  if (fields.length === 0) return 0;
+
+  const assignments: string[] = [];
+  const params: unknown[] = [];
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i]!;
+    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(i)}`);
+    params.push(updateData[field]);
   }
 
-  private buildWhereRecursive(
-    model: string,
-    where: Where,
-    startIndex: number,
-  ): { sql: string; params: unknown[] } {
-    if ("and" in where) {
-      const parts = [];
-      const params = [];
-      let currentIdx = startIndex;
-      for (let i = 0; i < where.and.length; i++) {
-        const built = this.buildWhereRecursive(model, where.and[i]!, currentIdx);
-        parts.push(`(${built.sql})`);
-        for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-        currentIdx += built.params.length;
-      }
-      return { sql: parts.join(" AND "), params };
-    }
+  let sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")}`;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
+  if (built.sql !== "1=1") {
+    sql += ` WHERE ${built.sql}`;
+    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+  }
 
-    if ("or" in where) {
-      const parts = [];
-      const params = [];
-      let currentIdx = startIndex;
-      for (let i = 0; i < where.or.length; i++) {
-        const built = this.buildWhereRecursive(model, where.or[i]!, currentIdx);
-        parts.push(`(${built.sql})`);
-        for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-        currentIdx += built.params.length;
-      }
-      return { sql: parts.join(" OR "), params };
-    }
+  const res = await exec.run(sql, params);
+  return res.changes;
+}
 
-    const expr = this.buildColumnExpr(model, where.field, where.path, where.value);
-    const mappedValue = this.mapWhereValue(where.value);
-
-    switch (where.op) {
-      case "eq":
-        if (where.value === null) return { sql: `${expr} IS NULL`, params: [] };
-        return { sql: `${expr} = ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "ne":
-        if (where.value === null) return { sql: `${expr} IS NOT NULL`, params: [] };
-        return { sql: `${expr} != ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "gt":
-        return { sql: `${expr} > ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "gte":
-        return { sql: `${expr} >= ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "lt":
-        return { sql: `${expr} < ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "lte":
-        return { sql: `${expr} <= ${this.dialect.placeholder(startIndex)}`, params: [mappedValue] };
-      case "in": {
-        if (where.value.length === 0) return { sql: "1=0", params: [] };
-        const phs = [];
-        const inParams = [];
-        for (let i = 0; i < where.value.length; i++) {
-          phs.push(this.dialect.placeholder(startIndex + i));
-          inParams.push(this.mapWhereValue(where.value[i]));
-        }
-        return { sql: `${expr} IN (${phs.join(", ")})`, params: inParams };
-      }
-      case "not_in": {
-        if (where.value.length === 0) return { sql: "1=1", params: [] };
-        const phs = [];
-        const inParams = [];
-        for (let i = 0; i < where.value.length; i++) {
-          phs.push(this.dialect.placeholder(startIndex + i));
-          inParams.push(this.mapWhereValue(where.value[i]));
-        }
-        return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
-      }
-    }
-    throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
+export async function upsert<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: {
+    create: T;
+    update: Partial<T>;
+    where?: Where<T>;
+    select?: Select<T>;
+  },
+): Promise<T> {
+  const { create: cData, update: uData, where, select } = args;
+  assertNoPrimaryKeyUpdates(model, uData);
+
+  const createData = toInput(model.fields, cData, fmt);
+  const createFields = Object.keys(createData);
+  const updateData = toInput(model.fields, uData, fmt);
+  const updateFields = Object.keys(updateData);
+  const pkFields = getPrimaryKeyFields(model);
+
+  const insertColumns: string[] = [];
+  const insertPlaceholders: string[] = [];
+  const params: unknown[] = [];
+  for (let i = 0; i < createFields.length; i++) {
+    const field = createFields[i]!;
+    insertColumns.push(fmt.quote(field));
+    insertPlaceholders.push(fmt.placeholder(i));
+    params.push(createData[field]);
   }
 
-  private buildCursor(
-    model: string,
-    cursor: Cursor,
-    sortBy?: SortBy[],
-    startIndex = 0,
-  ): { sql: string; params: unknown[] } {
-    const cursorValues = cursor.after as Record<string, unknown>;
-    const criteria = [];
-    if (sortBy && sortBy.length > 0) {
-      for (let i = 0; i < sortBy.length; i++) {
-        const s = sortBy[i]!;
-        if (cursorValues[s.field] !== undefined) {
-          criteria.push({ field: s.field, direction: s.direction ?? "asc", path: s.path });
-        }
-      }
-    } else {
-      const keys = Object.keys(cursorValues);
-      for (let i = 0; i < keys.length; i++) {
-        criteria.push({ field: keys[i]!, direction: "asc" as const, path: undefined });
-      }
-    }
-
-    if (criteria.length === 0) return { sql: "", params: [] };
+  const updateColumns: string[] = [];
+  for (let i = 0; i < updateFields.length; i++) {
+    const field = updateFields[i]!;
+    updateColumns.push(field);
+    params.push(updateData[field]);
+  }
 
-    const orClauses = [];
-    const params = [];
-    let currentIdx = startIndex;
+  let whereSql = "";
+  if (where) {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+    const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
+    whereSql = built.sql;
+    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+  }
 
-    for (let i = 0; i < criteria.length; i++) {
-      const andClauses = [];
-      for (let j = 0; j < i; j++) {
-        const prev = criteria[j]!;
-        andClauses.push(
-          `${this.buildColumnExpr(model, prev.field, prev.path, cursorValues[prev.field])} = ${this.dialect.placeholder(currentIdx++)}`,
-        );
-        params.push(cursorValues[prev.field]);
+  if (fmt.upsert) {
+    const { sql, params: upsertParams } = fmt.upsert({
+      table,
+      insertColumns,
+      insertPlaceholders,
+      updateColumns,
+      conflictColumns: pkFields,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> string[] is safe for upsert hook
+      select: select as string[] | undefined,
+      whereSql,
+    });
+    const row = await exec.get(sql, upsertParams ?? params);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+    if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
+  } else {
+    const conflictTarget = [];
+    for (let i = 0; i < pkFields.length; i++) conflictTarget.push(fmt.quote(pkFields[i]!));
+
+    let updateSet = "";
+    if (updateFields.length > 0) {
+      const sets = [];
+      for (let i = 0; i < updateFields.length; i++) {
+        const field = updateFields[i]!;
+        sets.push(`${fmt.quote(field)} = ${fmt.placeholder(createFields.length + i)}`);
       }
-      const curr = criteria[i]!;
-      const op = curr.direction === "desc" ? "<" : ">";
-      // Lexicographic keyset pagination:
-      // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
-      andClauses.push(
-        `${this.buildColumnExpr(model, curr.field, curr.path, cursorValues[curr.field])} ${op} ${this.dialect.placeholder(currentIdx++)}`,
-      );
-      params.push(cursorValues[curr.field]);
-      orClauses.push(`(${andClauses.join(" AND ")})`);
+      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
+      if (whereSql) updateSet += ` WHERE ${whereSql}`;
+    } else {
+      updateSet = "DO NOTHING";
     }
 
-    return { sql: `(${orClauses.join(" OR ")})`, params };
+    const sql = `INSERT INTO ${fmt.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${toSelect(
+      fmt,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+      select as Select<Record<string, unknown>>,
+    )}`;
+    const row = await exec.get(sql, params);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+    if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
   }
 
-  protected mapInput(
-    fields: Record<string, Field>,
-    data: Record<string, unknown>,
-  ): Record<string, unknown> {
-    const res: Record<string, unknown> = {};
-    const keys = Object.keys(data);
-    for (let i = 0; i < keys.length; i++) {
-      const k = keys[i]!;
-      const val = data[k];
-      const spec = fields[k];
-      if (val === undefined) continue;
-      if (val === null) {
-        res[k] = null;
-        continue;
-      }
-      if (spec?.type === "json" || spec?.type === "json[]") {
-        res[k] = JSON.stringify(val);
-      } else if (spec?.type === "boolean") {
-        res[k] = val === true ? 1 : 0;
-      } else {
-        res[k] = val;
-      }
-    }
-    return res;
-  }
+  const identityValues = getIdentityValues(model, cData);
+  const existing = await find(exec, table, model, fmt, {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
+    where: buildIdentityFilter(model, identityValues) as Where<T>,
+    select,
+  });
+  if (!existing) throw new Error("Failed to refetch upserted record.");
+  return existing;
+}
 
-  protected mapWhereValue(value: unknown): unknown {
-    if (
-      value === null ||
-      typeof value === "boolean" ||
-      typeof value === "number" ||
-      typeof value === "string"
-    )
-      return value;
-    return JSON.stringify(value);
-  }
+export async function remove<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where: Where<T> },
+): Promise<void> {
+  const { where } = args;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where);
+  await exec.run(`DELETE FROM ${fmt.quote(table)} WHERE ${built.sql}`, built.params);
+}
 
-  protected mapRow<T extends Record<string, unknown> = Record<string, unknown>>(
-    modelName: string,
-    row: Record<string, unknown>,
-    select?: Select<Record<string, unknown>>,
-  ): T {
-    const fields = this.getModel(modelName).fields;
-    const res: Record<string, unknown> = {};
-    const keys = select ?? Object.keys(row);
-
-    for (let i = 0; i < keys.length; i++) {
-      const k = keys[i]!;
-      const val = row[k];
-      const spec = fields[k];
-      if (spec === undefined || val === undefined || val === null) {
-        res[k] = val;
-        continue;
-      }
-      if (spec.type === "json" || spec.type === "json[]") {
-        res[k] = typeof val === "string" ? JSON.parse(val) : val;
-      } else if (spec.type === "boolean") {
-        res[k] = val === true || val === 1;
-      } else if (spec.type === "number" || spec.type === "timestamp") {
-        res[k] = mapNumeric(val);
-      } else {
-        res[k] = val;
-      }
-    }
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary after field mapping
-    return res as T;
-  }
+export async function removeMany<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where?: Where<T> },
+): Promise<number> {
+  const { where } = args;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where);
+  let sql = `DELETE FROM ${fmt.quote(table)}`;
+  if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
+  const res = await exec.run(sql, built.params);
+  return res.changes;
+}
+
+export async function count<T extends Record<string, unknown>>(
+  exec: QueryExecutor,
+  table: string,
+  model: Model,
+  fmt: SqlFormat,
+  args: { where?: Where<T> },
+): Promise<number> {
+  const { where } = args;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  const built = toWhere(fmt, model, where as Where);
+  let sql = `SELECT COUNT(*) as count FROM ${fmt.quote(table)}`;
+  if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
+  const row = await exec.get(sql, built.params);
+  if (!row) return 0;
+  const val = row["count"];
+  return typeof val === "number" ? val : Number(val ?? 0);
 }
+
+/**
+ * FUTURE EXTENSION: GreptimeDB
+ *
+ * To implement a GreptimeDB adapter using these helpers:
+ *
+ * 1. Provide a custom `SqlFormat` object for GreptimeDB syntax:
+ *    - Quoting identifiers (e.g. backticks).
+ *    - Type mapping (e.g. `TIMESTAMP` for time-series columns).
+ *    - JSON extraction syntax (if supported).
+ *    - Upsert syntax (GreptimeDB uses `INSERT INTO ... ON DUPLICATE KEY UPDATE` style or similar).
+ *
+ * 2. Implement the `Adapter` interface and delegate to `sql.ts` helpers.
+ *
+ * 3. Override `migrate()` logic if GreptimeDB-specific DDL is needed:
+ *    - `TIME INDEX` is mandatory for GreptimeDB tables.
+ *    - `PARTITION BY` for horizontal scaling.
+ *    - `SKIPPING INDEX` for performance optimizations.
+ *
+ * 4. Override `toInput`/`toRow` logic if per-driver parameter mapping is needed
+ *    (e.g. BigInt timestamps for one driver vs ISO strings for another).
+ */
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 904df96..fde8a3e 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -3,17 +3,31 @@ import type { Database as BunDatabase } from "bun:sqlite";
 import type { Database as BetterSqlite3Database } from "better-sqlite3";
 import type { Database as SqliteDatabase } from "sqlite";
 
-import type { Adapter, Field, Schema } from "../types";
-import { type QueryExecutor, type SqlDialect, SqlAdapter, isQueryExecutor } from "./sql";
+import type { Adapter, Field, InferModel, Schema, Select, SortBy, Where, Cursor } from "../types";
+import {
+  type QueryExecutor,
+  type SqlFormat,
+  isQueryExecutor,
+  migrate,
+  create,
+  find,
+  findMany,
+  update,
+  updateMany,
+  upsert,
+  remove,
+  removeMany,
+  count,
+} from "./sql";
 
 export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
 
-// --- Dialect ---
+// --- Formatting Hooks ---
 
-export const SqliteDialect: SqlDialect = {
+const sqlite: SqlFormat = {
   placeholder: () => "?",
   quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  escapeLiteral: (s) => s.replaceAll("'", "''"),
+  mapBoolean: (v) => (v ? 1 : 0),
   mapFieldType(field: Field): string {
     switch (field.type) {
       case "string":
@@ -30,8 +44,8 @@ export const SqliteDialect: SqlDialect = {
         return "TEXT";
     }
   },
-  buildJsonPath(path: string[]): string {
-    let res = "$";
+  jsonExtract(column: string, path: string[]): string {
+    let jsonPath = "$";
     for (let i = 0; i < path.length; i++) {
       const segment = path[i]!;
       let isIndex = true;
@@ -43,15 +57,12 @@ export const SqliteDialect: SqlDialect = {
         }
       }
       if (isIndex) {
-        res += `[${segment}]`;
+        jsonPath += `[${segment}]`;
       } else {
-        res += `.${segment}`;
+        jsonPath += `.${segment}`;
       }
     }
-    return res;
-  },
-  buildJsonExtract(column: string, path: string[]): string {
-    return `json_extract(${column}, '${this.buildJsonPath(path)}')`;
+    return `json_extract(${column}, '${jsonPath}')`;
   },
 };
 
@@ -159,14 +170,97 @@ function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
 
 // --- Adapter ---
 
-export class SqliteAdapter<S extends Schema = Schema> extends SqlAdapter<S> implements Adapter<S> {
-  constructor(schema: S, driver: SqliteDriver | QueryExecutor) {
-    super(schema, isQueryExecutor(driver) ? driver : createSqliteExecutor(driver), SqliteDialect);
+export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
+  private executor: QueryExecutor;
+
+  constructor(
+    private schema: S,
+    driver: SqliteDriver | QueryExecutor,
+  ) {
+    this.executor = isQueryExecutor(driver) ? driver : createSqliteExecutor(driver);
   }
 
+  migrate = () => migrate(this.executor, this.schema, sqlite);
+
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    return this.executor.transaction((innerExecutor) => {
-      return fn(new SqliteAdapter(this.schema, innerExecutor));
-    });
+    return this.executor.transaction((exec) => fn(new SqliteAdapter(this.schema, exec)));
   }
+
+  create = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    data: T;
+    select?: Select<T>;
+  }) => create(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  find = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where: Where<T>;
+    select?: Select<T>;
+  }) => find(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  findMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    select?: Select<T>;
+    sortBy?: SortBy<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: Cursor<T>;
+  }) => findMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  update = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: Where<T>;
+    data: Partial<T>;
+  }) => update(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  updateMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+    data: Partial<T>;
+  }) => updateMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  upsert = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    create: T;
+    update: Partial<T>;
+    where?: Where<T>;
+    select?: Select<T>;
+  }) => upsert(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  delete = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where: Where<T>;
+  }) => remove(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  deleteMany = <
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: {
+    model: K;
+    where?: Where<T>;
+  }) => removeMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+
+  count = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
+    model: K;
+    where?: Where<T>;
+  }) => count(this.executor, args.model, this.schema[args.model]!, sqlite, args);
 }
diff --git a/src/types.ts b/src/types.ts
index 05d7621..ed6bf37 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2,7 +2,7 @@
  * no-orm Core v1: Canonical Schema and Adapter Specification
  */
 
-// --- SCHEMA SPEC V1 (#2) ---
+// --- SCHEMA SPEC V1 ---
 
 export type Schema = Record<string, Model>;
 
@@ -26,7 +26,7 @@ export interface Index {
   order?: "asc" | "desc";
 }
 
-// --- TYPE INFERENCE V1 (#1) ---
+// --- TYPE INFERENCE V1 ---
 
 export type InferModel<M extends Model> = {
   [K in keyof M["fields"] as M["fields"][K]["nullable"] extends true ? K : never]?: ResolveTSValue<
@@ -52,7 +52,7 @@ type ResolveTSValue<T extends FieldType> = T extends "string"
             ? unknown[]
             : never;
 
-// --- ADAPTER SPEC V1 (#3) ---
+// --- ADAPTER SPEC V1 ---
 
 export interface Adapter<S extends Schema = Schema> {
   /**

From f02328b39633926e0ec3301b0af297a9b20cba3c Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Sat, 25 Apr 2026 22:15:23 +0800
Subject: [PATCH 21/24] refactor: address DRY concerns

---
 AGENTS.md                   |   2 +-
 src/adapters/common.ts      |  33 ++++-
 src/adapters/memory.ts      |  36 ++----
 src/adapters/postgres.ts    |  92 +++++++-------
 src/adapters/sql.ts         | 235 +++++++++++++++++++-----------------
 src/adapters/sqlite.test.ts |   7 +-
 src/adapters/sqlite.ts      |  22 ++--
 7 files changed, 241 insertions(+), 186 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 06825d5..560b3e2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -75,7 +75,7 @@ All internal method signatures must use `unknown` or concrete types, never `any`
 When a type assertion is unavoidable (e.g. `RowData -> T` at adapter boundaries), use `eslint-disable-next-line` with a short reason:
 
 ```ts
-// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
 return res as T;
 ```
 
diff --git a/src/adapters/common.ts b/src/adapters/common.ts
index 5d5ef3b..5d4b674 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/common.ts
@@ -75,13 +75,44 @@ export function getNestedValue(
   if (path !== undefined && path.length > 0) {
     for (let i = 0; i < path.length; i++) {
       if (typeof val !== "object" || val === null || Array.isArray(val)) return undefined;
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by object check above
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- val is checked to be an object and not null above
       val = (val as Record<string, unknown>)[path[i]!];
     }
   }
   return val;
 }
 
+export function getPaginationFilter(cursor: Cursor, sortBy?: SortBy[]): Where | undefined {
+  const criteria = getPaginationCriteria(cursor, sortBy);
+  if (criteria.length === 0) return undefined;
+
+  const cursorValues = cursor.after as Record<string, unknown>;
+  const orClauses: Where[] = [];
+
+  for (let i = 0; i < criteria.length; i++) {
+    const andClauses: Where[] = [];
+    for (let j = 0; j < i; j++) {
+      const prev = criteria[j]!;
+      andClauses.push({
+        field: prev.field,
+        path: prev.path,
+        op: "eq",
+        value: cursorValues[prev.field],
+      });
+    }
+    const curr = criteria[i]!;
+    andClauses.push({
+      field: curr.field,
+      path: curr.path,
+      op: curr.direction === "desc" ? "lt" : "gt",
+      value: cursorValues[curr.field],
+    });
+    orClauses.push({ and: andClauses });
+  }
+
+  return orClauses.length === 1 ? orClauses[0] : { or: orClauses };
+}
+
 /**
  * Normalizes pagination criteria from a cursor and optional sort parameters.
  */
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 115b517..8ef6886 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -5,7 +5,7 @@ import {
   assertNoPrimaryKeyUpdates,
   getIdentityValues,
   getNestedValue,
-  getPaginationCriteria,
+  getPaginationFilter,
   getPrimaryKeyFields,
 } from "./common";
 
@@ -37,6 +37,9 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    // MemoryAdapter is synchronous and doesn't support real ACID transactions.
+    // We simply return the current instance to satisfy the interface and
+    // support nesting by reusing the same adapter.
     return fn(this);
   }
 
@@ -94,12 +97,12 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     if (cursor !== undefined) {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, safe for internal use
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, which matches the Record key type
       results = this.applyCursor(results, cursor, sortBy as SortBy[] | undefined);
     }
 
     if (sortBy !== undefined && sortBy.length > 0) {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- same as above
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, which matches the Record key type
       results = this.applySort(results, sortBy as SortBy[]);
     }
 
@@ -319,42 +322,27 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
    * interface promises T. This is the single boundary where the cast occurs.
    */
   private applySelect<T extends Record<string, unknown>>(record: RowData, select?: Select<T>): T {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- record is mapped to T via shallow copy and optional projection
     if (select === undefined) return Object.assign({}, record) as T;
     const res: RowData = {};
     for (let i = 0; i < select.length; i++) {
       const k = select[i]!;
       res[k] = record[k] ?? null;
     }
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- record is mapped to T via shallow copy and optional projection
     return res as T;
   }
 
   private applyCursor(results: RowData[], cursor: Cursor, sortBy?: SortBy[]): RowData[] {
-    const cursorValues = cursor.after as Record<string, unknown>;
-    const criteria = getPaginationCriteria(cursor, sortBy);
-
-    if (criteria.length === 0) return results;
+    const paginationWhere = getPaginationFilter(cursor, sortBy);
+    if (!paginationWhere) return results;
 
     const filtered: RowData[] = [];
     for (let i = 0; i < results.length; i++) {
       const record = results[i]!;
-      let match = false;
-      // Lexicographic keyset pagination:
-      // (a > ?) OR (a = ? AND b > ?) OR (a = ? AND b = ? AND c > ?)
-      for (let j = 0; j < criteria.length; j++) {
-        const curr = criteria[j]!;
-        const recordVal = getNestedValue(record, curr.field, curr.path);
-        const cursorVal = cursorValues[curr.field];
-        const comp = compareValues(recordVal, cursorVal);
-
-        if (comp === 0) continue;
-        if (curr.direction === "desc" ? comp < 0 : comp > 0) {
-          match = true;
-        }
-        break;
+      if (this.evaluateWhere(paginationWhere, record)) {
+        filtered.push(record);
       }
-      if (match) filtered.push(record);
     }
     return filtered;
   }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index f98bb7a..df8cd98 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -58,31 +58,6 @@ const pg: SqlFormat = {
     if (isBoolean === true) return `(${base})::boolean`;
     return base;
   },
-  upsert(args) {
-    const { table, insertColumns, insertPlaceholders, updateColumns, conflictColumns, whereSql } =
-      args;
-    const pk: string[] = [];
-    for (let i = 0; i < conflictColumns.length; i++) {
-      pk.push(this.quote(conflictColumns[i]!));
-    }
-
-    let updateSet = "";
-    if (updateColumns.length > 0) {
-      const sets = [];
-      for (let i = 0; i < updateColumns.length; i++) {
-        const col = updateColumns[i]!;
-        sets.push(`${this.quote(col)} = EXCLUDED.${this.quote(col)}`);
-      }
-      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-      if (whereSql !== undefined && whereSql !== "") updateSet += ` WHERE ${whereSql}`;
-    } else {
-      updateSet = "DO NOTHING";
-    }
-
-    return {
-      sql: `INSERT INTO ${this.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${pk.join(", ")}) ${updateSet} RETURNING *`,
-    };
-  },
 };
 
 // --- Driver detection ---
@@ -109,9 +84,12 @@ function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClien
 // prepared statements. The driver manages statement name caching internally.
 // Works for both Sql (top-level) and TransactionSql (inside begin/savepoint) since
 // both extend ISql which provides `unsafe()`.
-function createPostgresJsExecutor(sql: postgres.Sql | postgres.TransactionSql): QueryExecutor {
+function createPostgresJsExecutor(
+  sql: postgres.Sql | postgres.TransactionSql,
+  inTransaction = false,
+): QueryExecutor {
   const run = (query: string, params?: unknown[]) =>
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js params type is narrower than unknown[]
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js params type is a stricter version of unknown[]
     sql.unsafe(query, params as postgres.ParameterOrJSON<never>[], { prepare: true });
 
   return {
@@ -130,24 +108,30 @@ function createPostgresJsExecutor(sql: postgres.Sql | postgres.TransactionSql):
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) => {
       // Top-level Sql uses begin(); TransactionSql uses savepoint() for nesting
       if ("begin" in sql) {
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- UnwrapPromiseArray<T> = T for single promises
-        return sql.begin((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>;
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- T matches return type of fn
+        return sql.begin((tx) => fn(createPostgresJsExecutor(tx, true))) as Promise<T>;
       }
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- same as above
-      return sql.savepoint((tx) => fn(createPostgresJsExecutor(tx))) as Promise<T>;
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- T matches return type of fn
+      return sql.savepoint((tx) => fn(createPostgresJsExecutor(tx, true))) as Promise<T>;
     },
+    inTransaction,
   };
 }
 
 // Bun SQL: uses `sql.unsafe(query, params)`. No prepare option — the driver
 // manages prepared statements internally.
-function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting unsafe() from Bun SQL driver
+function createBunSqlExecutor(
+  driver: Record<string, unknown>,
+  inTransaction = false,
+): QueryExecutor {
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isBunSql
   const unsafeFn = driver["unsafe"] as (
     query: string,
     params?: unknown[],
-  ) => Promise<Record<string, unknown>[] & { count?: number }>;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- extracting transaction() from Bun SQL driver
+  ) => Promise<
+    Record<string, unknown>[] & { count?: number; affectedRows?: number; command?: string }
+  >;
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isBunSql
   const transactionFn = driver["transaction"] as (
     cb: (tx: unknown) => Promise<unknown>,
   ) => Promise<unknown>;
@@ -160,17 +144,33 @@ function createBunSqlExecutor(driver: Record<string, unknown>): QueryExecutor {
     },
     run: async (query, params) => {
       const rows = await unsafeFn(query, params);
-      return { changes: rows.count ?? 0 };
+      let changes = rows.affectedRows ?? rows.count ?? 0;
+
+      // Special treat for GreptimeDB over Postgres wire protocol:
+      // command string might be "OK 1" while count/affectedRows is 0.
+      if (changes === 0 && rows.command !== undefined && rows.command.startsWith("OK ")) {
+        const parsed = parseInt(rows.command.slice(3), 10);
+        if (!isNaN(parsed)) changes = parsed;
+      }
+
+      return { changes };
     },
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Promise<unknown> -> Promise<T> at executor boundary
-      transactionFn((tx) => fn(createBunSqlExecutor(tx as Record<string, unknown>))) as Promise<T>,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- T matches return type of fn
+      transactionFn((tx) =>
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL transaction provides a driver-like object
+        fn(createBunSqlExecutor(tx as Record<string, unknown>, true)),
+      ) as Promise<T>,
+    inTransaction,
   };
 }
 
 // pg: uses named queries with a bounded LRU cache for server-side prepared
 // statement reuse. Each unique SQL string gets a stable name (e.g. `q_0`).
-function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecutor {
+function createPgExecutor(
+  driver: PgClient | PgPool | PgPoolClient,
+  inTransaction = false,
+): QueryExecutor {
   const cache = new Map<string, string>();
   let statementCount = 0;
 
@@ -203,11 +203,11 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
     transaction: async (fn) => {
       const isPool = "connect" in driver && !("release" in driver);
       if (isPool) {
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- narrowed by isPool check above
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is guaranteed to be PgPool by isPool check
         const client = await (driver as PgPool).connect();
         try {
           await client.query("BEGIN");
-          const res = await fn(createPgExecutor(client));
+          const res = await fn(createPgExecutor(client, true));
           await client.query("COMMIT");
           return res;
         } catch (e) {
@@ -219,7 +219,7 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
       }
       await driver.query("BEGIN");
       try {
-        const res = await fn(createPgExecutor(driver));
+        const res = await fn(createPgExecutor(driver, true));
         await driver.query("COMMIT");
         return res;
       } catch (e) {
@@ -227,11 +227,12 @@ function createPgExecutor(driver: PgClient | PgPool | PgPoolClient): QueryExecut
         throw e;
       }
     },
+    inTransaction,
   };
 }
 
 function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- structural duck-typing for Bun SQL
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isBunSql
   if (isBunSql(driver)) return createBunSqlExecutor(driver as unknown as Record<string, unknown>);
   if (isPostgresJs(driver)) return createPostgresJsExecutor(driver);
   if (isPg(driver)) return createPgExecutor(driver);
@@ -253,6 +254,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   migrate = () => migrate(this.executor, this.schema, pg);
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (this.executor.inTransaction) {
+      // Re-use current adapter if already in a transaction. Nested transactions
+      // (SAVEPOINTs) are handled by the executor factories if called directly.
+      return fn(this);
+    }
     return this.executor.transaction((exec) => fn(new PostgresAdapter(this.schema, exec)));
   }
 
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 97bbb46..44206a6 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -3,7 +3,7 @@ import {
   assertNoPrimaryKeyUpdates,
   buildIdentityFilter,
   getIdentityValues,
-  getPaginationCriteria,
+  getPaginationFilter,
   getPrimaryKeyFields,
   mapNumeric,
 } from "./common";
@@ -15,6 +15,7 @@ export interface QueryExecutor {
   get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined>;
   run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
   transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
+  readonly inTransaction: boolean;
 }
 
 export interface SqlFormat {
@@ -24,15 +25,19 @@ export interface SqlFormat {
   jsonExtract(column: string, path: string[], isNumeric?: boolean, isBoolean?: boolean): string;
   /** Maps a boolean to its SQL parameter value. Defaults to pass-through if omitted. */
   mapBoolean?(value: boolean): unknown;
-  upsert?(args: {
+  /** Generates result projection, e.g. "RETURNING id, name" */
+  formatReturning?(select: string): string;
+  /**
+   * Generates a full upsert statement.
+   * This allows adapters to choose between ON CONFLICT, ON DUPLICATE KEY, or MERGE.
+   */
+  formatUpsert?(args: {
     table: string;
-    insertColumns: string[];
-    insertPlaceholders: string[];
-    updateColumns: string[];
-    conflictColumns: string[];
-    select?: readonly string[];
-    whereSql?: string;
-  }): { sql: string; params?: unknown[] };
+    insert: { columns: string[]; placeholders: string[] };
+    update?: { assignments: string[]; where?: string };
+    conflict: { columns: string[] };
+    returning?: string;
+  }): string;
 }
 
 export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
@@ -47,6 +52,39 @@ export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
 
 // --- SQL Builders & Mappers ---
 
+function getReturning(fmt: SqlFormat, select: string): string {
+  if (fmt.formatReturning) return fmt.formatReturning(select);
+  return `RETURNING ${select}`;
+}
+
+function getUpsert(
+  fmt: SqlFormat,
+  args: {
+    table: string;
+    insert: { columns: string[]; placeholders: string[] };
+    update?: { assignments: string[]; where?: string };
+    conflict: { columns: string[] };
+    returning?: string;
+  },
+): string {
+  if (fmt.formatUpsert) return fmt.formatUpsert(args);
+
+  const conflict = `ON CONFLICT (${args.conflict.columns.join(", ")})`;
+  let updateAction = "DO NOTHING";
+  if (args.update) {
+    updateAction = `DO UPDATE SET ${args.update.assignments.join(", ")}`;
+    if (args.update.where !== undefined && args.update.where !== "") {
+      updateAction += ` WHERE ${args.update.where}`;
+    }
+  }
+
+  let sql = `INSERT INTO ${fmt.quote(args.table)} (${args.insert.columns.join(", ")}) VALUES (${args.insert.placeholders.join(", ")}) ${conflict} ${updateAction}`;
+  if (args.returning !== undefined && args.returning !== "") {
+    sql += ` ${args.returning}`;
+  }
+  return sql;
+}
+
 export function toSelect(fmt: SqlFormat, select?: Select<Record<string, unknown>>): string {
   if (!select) return "*";
   const parts: string[] = [];
@@ -110,7 +148,7 @@ export function toRow<T extends Record<string, unknown>>(
       res[k] = val;
     }
   }
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RowData -> T at adapter boundary after field mapping
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
   return res as T;
 }
 
@@ -235,29 +273,12 @@ export function toWhere(
   }
 
   if (cursor) {
-    const cursorValues = cursor.after as Record<string, unknown>;
-    const criteria = getPaginationCriteria(cursor, sortBy);
-
-    if (criteria.length > 0) {
-      const orClauses = [];
-      for (let i = 0; i < criteria.length; i++) {
-        const andClauses = [];
-        for (let j = 0; j < i; j++) {
-          const prev = criteria[j]!;
-          andClauses.push(
-            `${toColumnExpr(fmt, model, prev.field, prev.path, cursorValues[prev.field])} = ${fmt.placeholder(nextIndex++)}`,
-          );
-          params.push(cursorValues[prev.field]);
-        }
-        const curr = criteria[i]!;
-        const op = curr.direction === "desc" ? "<" : ">";
-        andClauses.push(
-          `${toColumnExpr(fmt, model, curr.field, curr.path, cursorValues[curr.field])} ${op} ${fmt.placeholder(nextIndex++)}`,
-        );
-        params.push(cursorValues[curr.field]);
-        orClauses.push(`(${andClauses.join(" AND ")})`);
-      }
-      parts.push(`(${orClauses.join(" OR ")})`);
+    const paginationWhere = getPaginationFilter(cursor, sortBy);
+    if (paginationWhere) {
+      const built = toWhereRecursive(fmt, model, paginationWhere, nextIndex);
+      parts.push(`(${built.sql})`);
+      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+      nextIndex += built.params.length;
     }
   }
 
@@ -343,24 +364,25 @@ export async function create<T extends Record<string, unknown>>(
     values.push(insertData[field]);
   }
 
-  const sql = `INSERT INTO ${fmt.quote(table)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING ${toSelect(
+  const sqlSelect = toSelect(
     fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
     select as Select<Record<string, unknown>>,
-  )}`;
+  );
+  const sql = `INSERT INTO ${fmt.quote(table)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) ${getReturning(fmt, sqlSelect)}`;
   const row = await exec.get(sql, values);
 
   if (!row) {
     const result = await find(exec, table, model, fmt, {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field names in source T match model fields at runtime
       where: buildIdentityFilter(model, data) as Where<T>,
       select,
     });
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T if found, and we just inserted it
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T (or null) from find(), and we just inserted it
     return result as T;
   }
 
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
   return toRow(model, row, select as Select<Record<string, unknown>>);
 }
 
@@ -372,15 +394,15 @@ export async function find<T extends Record<string, unknown>>(
   args: { where: Where<T>; select?: Select<T> },
 ): Promise<T | null> {
   const { where, select } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where);
   const sql = `SELECT ${toSelect(
     fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
     select as Select<Record<string, unknown>>,
   )} FROM ${fmt.quote(table)} WHERE ${built.sql} LIMIT 1`;
   const row = await exec.get(sql, built.params);
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
   return row ? toRow(model, row, select as Select<Record<string, unknown>>) : null;
 }
 
@@ -402,7 +424,7 @@ export async function findMany<T extends Record<string, unknown>>(
   const params: unknown[] = [];
   const sqlSelect = toSelect(
     fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
     select as Select<Record<string, unknown>>,
   );
   let sql = `SELECT ${sqlSelect} FROM ${fmt.quote(table)}`;
@@ -410,11 +432,11 @@ export async function findMany<T extends Record<string, unknown>>(
   const built = toWhere(
     fmt,
     model,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
     where as Where,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Cursor<T> -> Cursor is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Cursor<T> is compatible with Cursor for SQL generation
     cursor as Cursor,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>[] -> SortBy[] is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>[] is compatible with SortBy[] for SQL generation
     sortBy as SortBy[] | undefined,
   );
   if (built.sql !== "1=1") {
@@ -446,7 +468,7 @@ export async function findMany<T extends Record<string, unknown>>(
   const rows = await exec.all(sql, params);
   const result: T[] = [];
   for (let i = 0; i < rows.length; i++) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- rows are mapped to T via toRow
     result.push(toRow(model, rows[i]!, select as Select<Record<string, unknown>>));
   }
   return result;
@@ -474,9 +496,9 @@ export async function update<T extends Record<string, unknown>>(
     params.push(updateData[field]);
   }
 
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
-  const sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
+  const sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")} WHERE ${built.sql} ${getReturning(fmt, "*")}`;
   for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
 
   const row = await exec.get(sql, params);
@@ -507,7 +529,7 @@ export async function updateMany<T extends Record<string, unknown>>(
   }
 
   let sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")}`;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
   if (built.sql !== "1=1") {
     sql += ` WHERE ${built.sql}`;
@@ -558,56 +580,39 @@ export async function upsert<T extends Record<string, unknown>>(
 
   let whereSql = "";
   if (where) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
     const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
     whereSql = built.sql;
     for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
   }
 
-  if (fmt.upsert) {
-    const { sql, params: upsertParams } = fmt.upsert({
-      table,
-      insertColumns,
-      insertPlaceholders,
-      updateColumns,
-      conflictColumns: pkFields,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> string[] is safe for upsert hook
-      select: select as string[] | undefined,
-      whereSql,
-    });
-    const row = await exec.get(sql, upsertParams ?? params);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
-    if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
-  } else {
-    const conflictTarget = [];
-    for (let i = 0; i < pkFields.length; i++) conflictTarget.push(fmt.quote(pkFields[i]!));
-
-    let updateSet = "";
-    if (updateFields.length > 0) {
-      const sets = [];
-      for (let i = 0; i < updateFields.length; i++) {
-        const field = updateFields[i]!;
-        sets.push(`${fmt.quote(field)} = ${fmt.placeholder(createFields.length + i)}`);
-      }
-      updateSet = `DO UPDATE SET ${sets.join(", ")}`;
-      if (whereSql) updateSet += ` WHERE ${whereSql}`;
-    } else {
-      updateSet = "DO NOTHING";
-    }
+  const sqlSelect = toSelect(
+    fmt,
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
+    select as Select<Record<string, unknown>>,
+  );
 
-    const sql = `INSERT INTO ${fmt.quote(table)} (${insertColumns.join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT (${conflictTarget.join(", ")}) ${updateSet} RETURNING ${toSelect(
-      fmt,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for SQL gen
-      select as Select<Record<string, unknown>>,
-    )}`;
-    const row = await exec.get(sql, params);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> -> Select<Record<string, unknown>> is safe for mapping
-    if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
+  const assignments: string[] = [];
+  for (let i = 0; i < updateFields.length; i++) {
+    const field = updateFields[i]!;
+    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(createFields.length + i)}`);
   }
 
+  const sql = getUpsert(fmt, {
+    table,
+    insert: { columns: insertColumns, placeholders: insertPlaceholders },
+    update: updateFields.length > 0 ? { assignments, where: whereSql || undefined } : undefined,
+    conflict: { columns: pkFields.map((f) => fmt.quote(f)) },
+    returning: getReturning(fmt, sqlSelect),
+  });
+
+  const row = await exec.get(sql, params);
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
+  if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
+
   const identityValues = getIdentityValues(model, cData);
   const existing = await find(exec, table, model, fmt, {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where -> Where<T>: field names match at runtime
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field names in identityValues match model fields at runtime
     where: buildIdentityFilter(model, identityValues) as Where<T>,
     select,
   });
@@ -623,7 +628,7 @@ export async function remove<T extends Record<string, unknown>>(
   args: { where: Where<T> },
 ): Promise<void> {
   const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where);
   await exec.run(`DELETE FROM ${fmt.quote(table)} WHERE ${built.sql}`, built.params);
 }
@@ -636,7 +641,7 @@ export async function removeMany<T extends Record<string, unknown>>(
   args: { where?: Where<T> },
 ): Promise<number> {
   const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where);
   let sql = `DELETE FROM ${fmt.quote(table)}`;
   if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
@@ -652,7 +657,7 @@ export async function count<T extends Record<string, unknown>>(
   args: { where?: Where<T> },
 ): Promise<number> {
   const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> -> Where is safe for SQL gen
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
   const built = toWhere(fmt, model, where as Where);
   let sql = `SELECT COUNT(*) as count FROM ${fmt.quote(table)}`;
   if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
@@ -663,23 +668,37 @@ export async function count<T extends Record<string, unknown>>(
 }
 
 /**
- * FUTURE EXTENSION: GreptimeDB
- *
- * To implement a GreptimeDB adapter using these helpers:
+ * FUTURE EXTENSION: GreptimeDB & MySQL
  *
- * 1. Provide a custom `SqlFormat` object for GreptimeDB syntax:
- *    - Quoting identifiers (e.g. backticks).
- *    - Type mapping (e.g. `TIMESTAMP` for time-series columns).
- *    - JSON extraction syntax (if supported).
- *    - Upsert syntax (GreptimeDB uses `INSERT INTO ... ON DUPLICATE KEY UPDATE` style or similar).
+ * Lessons learned from hebo-gateway and typical SQL quirks:
  *
- * 2. Implement the `Adapter` interface and delegate to `sql.ts` helpers.
+ * 1. GreptimeDB:
+ *    - Supports multiple protocols (Postgres, MySQL). When using Postgres wire protocol
+ *      (via `PostgresAdapter`), use double quotes (") for identifiers. When using MySQL
+ *      protocol, use backticks (`).
+ *    - Mutation responses over Bun.SQL might not populate `count` but provide a `command` string
+ *      like "OK 1". Parsed in `postgres.ts`.
+ *    - JSON strings can contain Rust-style Unicode escapes (\u{xxxx}) which are invalid JSON.
+ *      May need a `mapJsonOutput` hook in `SqlFormat`. Empty JSON strings ("") or "{}"
+ *      should be normalized to {}. To avoid driver crashes, JSON columns might need
+ *      to be cast to STRING on the wire (e.g. `col::STRING`).
+ *    - DDL: `TIME INDEX` is mandatory. May also need `PARTITION BY`, `WITH` (e.g. merge_mode),
+ *      or `SKIPPING INDEX` for performance optimizations.
+ *    - JSON: Specialized functions like `json_get_string` might be required instead of
+ *      standard Postgres operators like `->>`.
+ *    - Batch inserts: When using a time index as part of uniqueness, adding a slight offset
+ *      (e.g. +1ms) per item in a batch avoids timestamp collisions.
  *
- * 3. Override `migrate()` logic if GreptimeDB-specific DDL is needed:
- *    - `TIME INDEX` is mandatory for GreptimeDB tables.
- *    - `PARTITION BY` for horizontal scaling.
- *    - `SKIPPING INDEX` for performance optimizations.
+ * 2. MySQL / MariaDB:
+ *    - Quoting uses backticks (`) instead of double quotes ("). Note that backticks
+ *      within identifiers might need to be escaped by doubling them (``).
+ *    - Upsert uses `ON DUPLICATE KEY UPDATE` instead of `ON CONFLICT`.
+ *    - Does not support `CREATE INDEX IF NOT EXISTS`. Must be handled via try/catch in `migrate`.
+ *    - Does not support `RETURNING`. `create` and `upsert` must fall back to a second `find` call.
  *
- * 4. Override `toInput`/`toRow` logic if per-driver parameter mapping is needed
- *    (e.g. BigInt timestamps for one driver vs ISO strings for another).
+ * 3. General SQL:
+ *    - Some databases don't support parameters in `LIMIT` clauses. May need a `limitAsLiteral` flag.
+ *    - May need to override `toInput`/`toRow` logic if per-driver parameter mapping is needed
+ *      (e.g. Date to Number/BigInt, or BigInt to Number).
+ *    - Indexing: Different types like `BRIN` might not support `ASC`/`DESC` or require `USING` syntax.
  */
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index c3d59de..c3c770b 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -314,7 +314,7 @@ describe("SqliteAdapter", () => {
       expect(found).toBeNull();
     });
 
-    it("should handle nested transactions with savepoints", async () => {
+    it("should flatten nested transactions (no nested rollback support)", async () => {
       await adapter.transaction(async (outer) => {
         await outer.create({
           model: "users",
@@ -339,7 +339,10 @@ describe("SqliteAdapter", () => {
         model: "users",
         where: { field: "id", op: "eq", value: "n1" },
       });
-      expect(found?.age).toBe(20);
+      // Age is 40 because nested transactions are flattened; the inner update
+      // is part of the outer transaction and is NOT rolled back when the
+      // inner block throws.
+      expect(found?.age).toBe(40);
     });
   });
 
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index fde8a3e..fd7f9e8 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -80,6 +80,8 @@ function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlit
 /**
  * Structural interface for the shared subset of BunDatabase and BetterSqlite3Database
  * `prepare()` APIs. Their full type signatures differ but both satisfy this shape.
+ * This allows the adapter to work with both drivers without direct dependencies
+ * on their respective type libraries.
  */
 type SyncStatement = {
   all(...params: unknown[]): unknown[];
@@ -93,7 +95,7 @@ interface SyncDriver {
 
 // Caches compiled Statement objects per SQL string to avoid re-parsing on every query.
 // Uses a simple Map with FIFO eviction at MAX_CACHE_SIZE.
-function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
+function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): QueryExecutor {
   const cache = new Map<string, SyncStatement>();
 
   function getStmt(sql: string): SyncStatement {
@@ -112,12 +114,12 @@ function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
   return {
     all: (sql, params) => {
       const result = getStmt(sql).all(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects matching RowData
       return Promise.resolve(result as Record<string, unknown>[]);
     },
     get: (sql, params) => {
       const result = getStmt(sql).get(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined, matching RowData
       return Promise.resolve(result as Record<string, unknown> | undefined);
     },
     run: (sql, params) => {
@@ -127,7 +129,7 @@ function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
     transaction: async (fn) => {
       getStmt("BEGIN").run();
       try {
-        const res = await fn(createSyncSqliteExecutor(driver));
+        const res = await fn(createSyncSqliteExecutor(driver, true));
         getStmt("COMMIT").run();
         return res;
       } catch (e) {
@@ -135,10 +137,11 @@ function createSyncSqliteExecutor(driver: SyncDriver): QueryExecutor {
         throw e;
       }
     },
+    inTransaction,
   };
 }
 
-function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
+function createAsyncSqliteExecutor(driver: SqliteDatabase, inTransaction = false): QueryExecutor {
   return {
     all: (sql, params) => driver.all(sql, params),
     get: (sql, params) => driver.get(sql, params),
@@ -149,7 +152,7 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
     transaction: async (fn) => {
       await driver.run("BEGIN");
       try {
-        const res = await fn(createAsyncSqliteExecutor(driver));
+        const res = await fn(createAsyncSqliteExecutor(driver, true));
         await driver.run("COMMIT");
         return res;
       } catch (e) {
@@ -157,12 +160,13 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase): QueryExecutor {
         throw e;
       }
     },
+    inTransaction,
   };
 }
 
 function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
   if (isSyncSqlite(driver)) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- BunDatabase and BetterSqlite3Database both satisfy SyncDriver structurally
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally compatible with SyncDriver
     return createSyncSqliteExecutor(driver as unknown as SyncDriver);
   }
   return createAsyncSqliteExecutor(driver as SqliteDatabase);
@@ -183,6 +187,10 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   migrate = () => migrate(this.executor, this.schema, sqlite);
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (this.executor.inTransaction) {
+      // Re-use current adapter if already in a transaction.
+      return fn(this);
+    }
     return this.executor.transaction((exec) => fn(new SqliteAdapter(this.schema, exec)));
   }
 

From 88628e73bf1cf88bbcf2c842d7a83df0d19e806e Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Tue, 28 Apr 2026 16:36:05 +0800
Subject: [PATCH 22/24] refactor: make adapter logic self-contained

---
 AGENTS.md                |  20 +-
 src/adapters/postgres.ts | 502 ++++++++++++++++++++++++------
 src/adapters/sql.ts      | 636 +--------------------------------------
 src/adapters/sqlite.ts   | 526 +++++++++++++++++++++++++-------
 4 files changed, 841 insertions(+), 843 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 560b3e2..eaaee41 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -35,12 +35,12 @@ src/
   adapters/
     common.ts           Shared PK, pagination, and value helpers
     memory.ts           MemoryAdapter (LRU-cache-backed)
-    sql.ts              QueryExecutor, SqlFormat interfaces, functional helpers
-    postgres.ts         PostgresAdapter (uses sql.ts helpers)
-    sqlite.ts           SqliteAdapter (uses sql.ts helpers)
+    sql.ts              QueryExecutor interface and toRow helper (shared SQL logic)
+    postgres.ts         PostgresAdapter (Autonomous SQL + Execution)
+    sqlite.ts           SqliteAdapter (Autonomous SQL + Execution)
 ```
 
-Each adapter file is self-contained: formatting hooks, driver detection, executor factories, and adapter class all live together.
+Each adapter file is self-contained: SQL building, driver detection, executor factories, and adapter class all live together.
 
 ## Local Commands
 
@@ -115,19 +115,15 @@ Prefer `for (let i = 0; i < arr.length; i++)` over `for...of` in adapter interna
 
 ### Adapter boundary is the one place where `as T` casts are acceptable
 
-Storage holds `Record<string, unknown>` (RowData) but the adapter interface promises `T`. The cast from `RowData -> T` happens in `applySelect` (memory) and `toRow` (sql). Keep this boundary thin and document it.
+Storage holds `Record<string, unknown>` (RowData) but the adapter interface promises `T`. The cast from `RowData -> T` happens in `applySelect` (memory) and `toRow` (sql adapters). Keep this boundary thin and document it.
 
-### SqlFormat is a plain object, not a class
+### SQL logic is autonomous
 
-Formatting hooks (quoting, placeholders, type mapping, JSON extraction) are defined as stateless configuration objects (`pg`, `sqlite`). Functional helpers in `sql.ts` receive these hooks to generate database-specific SQL.
-
-### SQL logic is functional and composable
-
-Instead of a base class, `sql.ts` provides pure functions (`find`, `create`, `update`, etc.) that orchestrate SQL generation and execution. Each SQL adapter class (`PostgresAdapter`, `SqliteAdapter`) implements the `Adapter` interface by delegating to these helpers. This composition significantly reduces abstraction leaks and improves readability.
+Each SQL adapter class (`PostgresAdapter`, `SqliteAdapter`) implements the `Adapter` interface by owning its SQL generation and execution flow. This significantly reduces abstraction leaks, improves readability, and allows for database-specific optimizations (like `RETURNING` clauses). Shared domain logic (PKs, pagination AST) lives in `common.ts`.
 
 ### QueryExecutor is the driver abstraction
 
-Each database driver (pg Pool, postgres.js, Bun SQL, better-sqlite3, bun:sqlite, async sqlite) gets wrapped into a `QueryExecutor` with uniform `all`/`get`/`run`/`transaction` methods. The executor factory lives in the adapter file next to its formatting hooks.
+Each database driver (pg Pool, postgres.js, Bun SQL, better-sqlite3, bun:sqlite, async sqlite) gets wrapped into a `QueryExecutor` (localized to each adapter) with uniform `all`/`get`/`run`/`transaction` methods. The executor factory lives in the adapter file next to its SQL syntax helpers.
 
 ## Dependency Rules
 
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index df8cd98..7fc4947 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -1,22 +1,25 @@
 import type { Client as PgClient, Pool as PgPool, PoolClient as PgPoolClient } from "pg";
 import type postgres from "postgres";
 
-import type { Adapter, Field, InferModel, Schema, Select, SortBy, Where, Cursor } from "../types";
+import type {
+  Adapter,
+  Field,
+  InferModel,
+  Schema,
+  Select,
+  SortBy,
+  Where,
+  Cursor,
+  Model,
+} from "../types";
 import {
-  type QueryExecutor,
-  type SqlFormat,
-  isQueryExecutor,
-  migrate,
-  create,
-  find,
-  findMany,
-  update,
-  updateMany,
-  upsert,
-  remove,
-  removeMany,
-  count,
-} from "./sql";
+  assertNoPrimaryKeyUpdates,
+  buildIdentityFilter,
+  getIdentityValues,
+  getPaginationFilter,
+  getPrimaryKeyFields,
+} from "./common";
+import { type QueryExecutor, isQueryExecutor, toRow } from "./sql";
 
 type PostgresJsSql = postgres.Sql;
 type TransactionSql = postgres.TransactionSql;
@@ -25,40 +28,175 @@ export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql |
 
 const MAX_CACHE_SIZE = 100;
 
-// --- Formatting Hooks ---
-
-const pg: SqlFormat = {
-  placeholder: (i) => `$${i + 1}`,
-  quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "DOUBLE PRECISION";
-      case "boolean":
-        return "BOOLEAN";
-      case "timestamp":
-        return "BIGINT";
-      case "json":
-      case "json[]":
-        return "JSONB";
-      default:
-        return "TEXT";
+// --- Internal PG Syntax Helpers ---
+
+const quote = (s: string) => `"${s.replaceAll('"', '""')}"`;
+const placeholder = (i: number) => `$${i + 1}`;
+
+function mapFieldType(field: Field): string {
+  switch (field.type) {
+    case "string":
+      return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+    case "number":
+      return "DOUBLE PRECISION";
+    case "boolean":
+      return "BOOLEAN";
+    case "timestamp":
+      return "BIGINT";
+    case "json":
+    case "json[]":
+      return "JSONB";
+    default:
+      return "TEXT";
+  }
+}
+
+function jsonExtract(
+  column: string,
+  path: string[],
+  isNumeric?: boolean,
+  isBoolean?: boolean,
+): string {
+  let segments = "";
+  for (let i = 0; i < path.length; i++) {
+    if (i > 0) segments += ", ";
+    segments += `'${path[i]!.replaceAll("'", "''")}'`;
+  }
+  const base = `jsonb_extract_path_text(${column}, ${segments})`;
+  if (isNumeric === true) return `(${base})::double precision`;
+  if (isBoolean === true) return `(${base})::boolean`;
+  return base;
+}
+
+function toColumnExpr(model: Model, fieldName: string, path?: string[], value?: unknown): string {
+  if (!path || path.length === 0) return quote(fieldName);
+  const field = model.fields[fieldName];
+  if (field?.type !== "json" && field?.type !== "json[]") {
+    throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
+  }
+  return jsonExtract(quote(fieldName), path, typeof value === "number", typeof value === "boolean");
+}
+
+function toWhereRecursive(
+  model: Model,
+  where: Where,
+  startIndex: number,
+): { sql: string; params: unknown[] } {
+  if ("and" in where) {
+    const parts = [];
+    const params = [];
+    let currentIdx = startIndex;
+    for (let i = 0; i < where.and.length; i++) {
+      const built = toWhereRecursive(model, where.and[i]!, currentIdx);
+      parts.push(`(${built.sql})`);
+      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+      currentIdx += built.params.length;
+    }
+    return { sql: parts.join(" AND "), params };
+  }
+
+  if ("or" in where) {
+    const parts = [];
+    const params = [];
+    let currentIdx = startIndex;
+    for (let i = 0; i < where.or.length; i++) {
+      const built = toWhereRecursive(model, where.or[i]!, currentIdx);
+      parts.push(`(${built.sql})`);
+      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
+      currentIdx += built.params.length;
+    }
+    return { sql: parts.join(" OR "), params };
+  }
+
+  const expr = toColumnExpr(model, where.field, where.path, where.value);
+  const val = where.value;
+
+  switch (where.op) {
+    case "eq":
+      if (val === null) return { sql: `${expr} IS NULL`, params: [] };
+      return { sql: `${expr} = ${placeholder(startIndex)}`, params: [val] };
+    case "ne":
+      if (val === null) return { sql: `${expr} IS NOT NULL`, params: [] };
+      return { sql: `${expr} != ${placeholder(startIndex)}`, params: [val] };
+    case "gt":
+      return { sql: `${expr} > ${placeholder(startIndex)}`, params: [val] };
+    case "gte":
+      return { sql: `${expr} >= ${placeholder(startIndex)}`, params: [val] };
+    case "lt":
+      return { sql: `${expr} < ${placeholder(startIndex)}`, params: [val] };
+    case "lte":
+      return { sql: `${expr} <= ${placeholder(startIndex)}`, params: [val] };
+    case "in": {
+      if (!Array.isArray(val) || val.length === 0) return { sql: "1=0", params: [] };
+      const phs = [];
+      for (let i = 0; i < val.length; i++) phs.push(placeholder(startIndex + i));
+      return { sql: `${expr} IN (${phs.join(", ")})`, params: val };
     }
-  },
-  jsonExtract(column: string, path: string[], isNumeric?: boolean, isBoolean?: boolean): string {
-    let segments = "";
-    for (let i = 0; i < path.length; i++) {
-      if (i > 0) segments += ", ";
-      segments += `'${path[i]!.replaceAll("'", "''")}'`;
+    case "not_in": {
+      if (!Array.isArray(val) || val.length === 0) return { sql: "1=1", params: [] };
+      const phs = [];
+      for (let i = 0; i < val.length; i++) phs.push(placeholder(startIndex + i));
+      return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: val };
     }
-    const base = `jsonb_extract_path_text(${column}, ${segments})`;
-    if (isNumeric === true) return `(${base})::double precision`;
-    if (isBoolean === true) return `(${base})::boolean`;
-    return base;
-  },
-};
+    default:
+      throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
+  }
+}
+
+function toWhere(
+  model: Model,
+  where?: Where,
+  cursor?: Cursor,
+  sortBy?: SortBy[],
+  startIndex = 0,
+): { sql: string; params: unknown[] } {
+  const parts: string[] = [];
+  const params: unknown[] = [];
+  let nextIndex = startIndex;
+
+  if (where) {
+    const built = toWhereRecursive(model, where, nextIndex);
+    parts.push(`(${built.sql})`);
+    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+    nextIndex += built.params.length;
+  }
+
+  if (cursor) {
+    const paginationWhere = getPaginationFilter(cursor, sortBy);
+    if (paginationWhere) {
+      const built = toWhereRecursive(model, paginationWhere, nextIndex);
+      parts.push(`(${built.sql})`);
+      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
+      nextIndex += built.params.length;
+    }
+  }
+
+  return { sql: parts.length > 0 ? parts.join(" AND ") : "1=1", params };
+}
+
+function toInput(
+  fields: Record<string, Field>,
+  data: Record<string, unknown>,
+): Record<string, unknown> {
+  const res: Record<string, unknown> = {};
+  const keys = Object.keys(data);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = data[k];
+    const spec = fields[k];
+    if (val === undefined) continue;
+    if (val === null) {
+      res[k] = null;
+      continue;
+    }
+    if (spec?.type === "json" || spec?.type === "json[]") {
+      res[k] = JSON.stringify(val);
+    } else {
+      res[k] = val;
+    }
+  }
+  return res;
+}
 
 // --- Driver detection ---
 // Bun SQL: has `unsafe` + `transaction` (and `begin`).
@@ -152,7 +290,6 @@ function createBunSqlExecutor(
         const parsed = parseInt(rows.command.slice(3), 10);
         if (!isNaN(parsed)) changes = parsed;
       }
-
       return { changes };
     },
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
@@ -251,33 +388,88 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     this.executor = isQueryExecutor(driver) ? driver : createPostgresExecutor(driver);
   }
 
-  migrate = () => migrate(this.executor, this.schema, pg);
+  async migrate(): Promise<void> {
+    const models = Object.entries(this.schema);
+
+    // Create tables first, then indexes — indexes depend on tables existing.
+    // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      const fields = Object.entries(model.fields);
+      const columns: string[] = [];
+      for (let j = 0; j < fields.length; j++) {
+        const [fieldName, field] = fields[j]!;
+        const nullable = field.nullable === true ? "" : " NOT NULL";
+        columns.push(`${quote(fieldName)} ${mapFieldType(field)}${nullable}`);
+      }
+      const pkFields = getPrimaryKeyFields(model);
+      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
+      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+      await this.executor.run(
+        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
+      );
+    }
 
-  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    if (this.executor.inTransaction) {
-      // Re-use current adapter if already in a transaction. Nested transactions
-      // (SAVEPOINTs) are handled by the executor factories if called directly.
-      return fn(this);
+    // Now create indexes
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      if (!model.indexes) continue;
+      for (let j = 0; j < model.indexes.length; j++) {
+        const idx = model.indexes[j]!;
+        const fields = Array.isArray(idx.field) ? idx.field : [idx.field];
+        const formatted = fields.map(
+          (f) => `${quote(f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
+        );
+        // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+        await this.executor.run(
+          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${quote(name)} (${formatted.join(", ")})`,
+        );
+      }
     }
+  }
+
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (this.executor.inTransaction) return fn(this);
     return this.executor.transaction((exec) => fn(new PostgresAdapter(this.schema, exec)));
   }
 
-  create = <
+  async create<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    data: T;
-    select?: Select<T>;
-  }) => create(this.executor, args.model, this.schema[args.model]!, pg, args);
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+    const { model: modelName, data, select } = args;
+    const model = this.schema[modelName]!;
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    const sqlFields = fields.map((f) => quote(f)).join(", ");
+    const sqlValues = fields.map((_, i) => placeholder(i)).join(", ");
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+    const sql = `INSERT INTO ${quote(modelName)} (${sqlFields}) VALUES (${sqlValues}) RETURNING ${sqlSelect}`;
+    const row = await this.executor.get(
+      sql,
+      fields.map((f) => input[f]),
+    );
+    if (row === undefined || row === null) throw new Error("Failed to insert record");
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+  }
 
-  find = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    select?: Select<T>;
-  }) => find(this.executor, args.model, this.schema[args.model]!, pg, args);
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model: modelName, where, select } = args;
+    const model = this.schema[modelName]!;
+    const built = toWhere(model, where as Where);
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+    const sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql} LIMIT 1`;
+    const row = await this.executor.get(sql, built.params);
+    if (row === undefined || row === null) return null;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
+    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+  }
 
-  findMany = <
+  async findMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -288,27 +480,79 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     limit?: number;
     offset?: number;
     cursor?: Cursor<T>;
-  }) => findMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+  }): Promise<T[]> {
+    const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where/Cursor/SortBy types match at runtime
+    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[]);
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+    let sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql}`;
+
+    if (sortBy && sortBy.length > 0) {
+      const parts = sortBy.map(
+        (s) => `${toColumnExpr(model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
+      );
+      sql += ` ORDER BY ${parts.join(", ")}`;
+    }
+    if (limit !== undefined) {
+      sql += ` LIMIT ${placeholder(built.params.length)}`;
+      built.params.push(limit);
+    }
+    if (offset !== undefined) {
+      sql += ` OFFSET ${placeholder(built.params.length)}`;
+      built.params.push(offset);
+    }
+    const rows = await this.executor.all(sql, built.params);
 
-  update = <
+    const result: T[] = [];
+    for (let i = 0; i < rows.length; i++) {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+      result.push(toRow<T>(model, rows[i]!, select as Select<Record<string, unknown>>));
+    }
+    return result;
+  }
+
+  async update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where: Where<T>;
-    data: Partial<T>;
-  }) => update(this.executor, args.model, this.schema[args.model]!, pg, args);
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+    const { model: modelName, where, data } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, data);
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    if (fields.length === 0) return this.find({ model: modelName, where, select: undefined });
+
+    const assignments = fields.map((f, i) => `${quote(f)} = ${placeholder(i)}`);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where, undefined, undefined, fields.length);
+    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
+    const row = await this.executor.get(sql, [...fields.map((f) => input[f]), ...built.params]);
+    if (row === undefined || row === null) return null;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    return toRow<T>(model, row);
+  }
 
-  updateMany = <
+  async updateMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-    data: Partial<T>;
-  }) => updateMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    const { model: modelName, where, data } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, data);
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    if (fields.length === 0) return 0;
+
+    const assignments = fields.map((f, i) => `${quote(f)} = ${placeholder(i)}`);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where, undefined, undefined, fields.length);
+    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql}`;
+    const res = await this.executor.run(sql, [...fields.map((f) => input[f]), ...built.params]);
+    return res.changes;
+  }
 
-  upsert = <
+  async upsert<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -317,26 +561,94 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     update: Partial<T>;
     where?: Where<T>;
     select?: Select<T>;
-  }) => upsert(this.executor, args.model, this.schema[args.model]!, pg, args);
+  }): Promise<T> {
+    const { model: modelName, create: cData, update: uData, where, select } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, uData);
+
+    const cInput = toInput(model.fields, cData);
+    const cFields = Object.keys(cInput);
+    const uInput = toInput(model.fields, uData);
+    const uFields = Object.keys(uInput);
+    const pkFields = getPrimaryKeyFields(model);
+
+    const sqlColumns = cFields.map((f) => quote(f)).join(", ");
+    const sqlPlaceholders = cFields.map((_, i) => placeholder(i)).join(", ");
+    const sqlConflict = pkFields.map((f) => quote(f)).join(", ");
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+
+    let sql = `INSERT INTO ${quote(modelName)} (${sqlColumns}) VALUES (${sqlPlaceholders}) ON CONFLICT (${sqlConflict}) `;
+    const params = cFields.map((f) => cInput[f]);
+
+    if (uFields.length > 0) {
+      const assignments = uFields.map((f, i) => `${quote(f)} = ${placeholder(cFields.length + i)}`);
+      params.push(...uFields.map((f) => uInput[f]));
+      sql += `DO UPDATE SET ${assignments.join(", ")}`;
+      if (where) {
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+        const built = toWhere(model, where as Where, undefined, undefined, params.length);
+        sql += ` WHERE ${built.sql}`;
+        params.push(...built.params);
+      }
+    } else {
+      sql += "DO NOTHING";
+    }
+
+    sql += ` RETURNING ${sqlSelect}`;
+    const row = await this.executor.get(sql, params);
+    if (row !== undefined && row !== null) {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
+      return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    }
 
-  delete = <
+    const existing = await this.find({
+      model: modelName,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+      where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
+      select,
+    });
+    if (existing === null) throw new Error("Failed to refetch record after upsert");
+    return existing;
+  }
+
+  async delete<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where: Where<T>;
-  }) => remove(this.executor, args.model, this.schema[args.model]!, pg, args);
+  >(args: { model: K; where: Where<T> }): Promise<void> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    await this.executor.run(`DELETE FROM ${quote(modelName)} WHERE ${built.sql}`, built.params);
+  }
 
-  deleteMany = <
+  async deleteMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-  }) => removeMany(this.executor, args.model, this.schema[args.model]!, pg, args);
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const res = await this.executor.run(
+      `DELETE FROM ${quote(modelName)} WHERE ${built.sql}`,
+      built.params,
+    );
+    return res.changes;
+  }
 
-  count = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-  }) => count(this.executor, args.model, this.schema[args.model]!, pg, args);
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const row = await this.executor.get(
+      `SELECT COUNT(*) as count FROM ${quote(modelName)} WHERE ${built.sql}`,
+      built.params,
+    );
+    return row === undefined || row === null ? 0 : Number(row["count"] ?? 0);
+  }
 }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
index 44206a6..b02a3e1 100644
--- a/src/adapters/sql.ts
+++ b/src/adapters/sql.ts
@@ -1,45 +1,16 @@
-import type { Cursor, Field, Model, Schema, Select, SortBy, Where } from "../types";
-import {
-  assertNoPrimaryKeyUpdates,
-  buildIdentityFilter,
-  getIdentityValues,
-  getPaginationFilter,
-  getPrimaryKeyFields,
-  mapNumeric,
-} from "./common";
+import type { Model, Select } from "../types";
+import { mapNumeric } from "./common";
 
-// --- Shared contracts for SQL executors and formatting ---
+/** Shared contracts for SQL executors */
 
 export interface QueryExecutor {
   all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
-  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined>;
+  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined | null>;
   run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
   transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
   readonly inTransaction: boolean;
 }
 
-export interface SqlFormat {
-  placeholder(index: number): string;
-  quote(identifier: string): string;
-  mapFieldType(field: Field): string;
-  jsonExtract(column: string, path: string[], isNumeric?: boolean, isBoolean?: boolean): string;
-  /** Maps a boolean to its SQL parameter value. Defaults to pass-through if omitted. */
-  mapBoolean?(value: boolean): unknown;
-  /** Generates result projection, e.g. "RETURNING id, name" */
-  formatReturning?(select: string): string;
-  /**
-   * Generates a full upsert statement.
-   * This allows adapters to choose between ON CONFLICT, ON DUPLICATE KEY, or MERGE.
-   */
-  formatUpsert?(args: {
-    table: string;
-    insert: { columns: string[]; placeholders: string[] };
-    update?: { assignments: string[]; where?: string };
-    conflict: { columns: string[] };
-    returning?: string;
-  }): string;
-}
-
 export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
   if (typeof obj !== "object" || obj === null) return false;
   return (
@@ -50,77 +21,10 @@ export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
   );
 }
 
-// --- SQL Builders & Mappers ---
-
-function getReturning(fmt: SqlFormat, select: string): string {
-  if (fmt.formatReturning) return fmt.formatReturning(select);
-  return `RETURNING ${select}`;
-}
-
-function getUpsert(
-  fmt: SqlFormat,
-  args: {
-    table: string;
-    insert: { columns: string[]; placeholders: string[] };
-    update?: { assignments: string[]; where?: string };
-    conflict: { columns: string[] };
-    returning?: string;
-  },
-): string {
-  if (fmt.formatUpsert) return fmt.formatUpsert(args);
-
-  const conflict = `ON CONFLICT (${args.conflict.columns.join(", ")})`;
-  let updateAction = "DO NOTHING";
-  if (args.update) {
-    updateAction = `DO UPDATE SET ${args.update.assignments.join(", ")}`;
-    if (args.update.where !== undefined && args.update.where !== "") {
-      updateAction += ` WHERE ${args.update.where}`;
-    }
-  }
-
-  let sql = `INSERT INTO ${fmt.quote(args.table)} (${args.insert.columns.join(", ")}) VALUES (${args.insert.placeholders.join(", ")}) ${conflict} ${updateAction}`;
-  if (args.returning !== undefined && args.returning !== "") {
-    sql += ` ${args.returning}`;
-  }
-  return sql;
-}
-
-export function toSelect(fmt: SqlFormat, select?: Select<Record<string, unknown>>): string {
-  if (!select) return "*";
-  const parts: string[] = [];
-  for (let i = 0; i < select.length; i++) {
-    parts.push(fmt.quote(select[i]!));
-  }
-  return parts.join(", ");
-}
-
-export function toInput(
-  fields: Record<string, Field>,
-  data: Record<string, unknown>,
-  fmt: SqlFormat,
-): Record<string, unknown> {
-  const res: Record<string, unknown> = {};
-  const keys = Object.keys(data);
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i]!;
-    const val = data[k];
-    const spec = fields[k];
-    if (val === undefined) continue;
-    if (val === null) {
-      res[k] = null;
-      continue;
-    }
-    if (spec?.type === "json" || spec?.type === "json[]") {
-      res[k] = JSON.stringify(val);
-    } else if (spec?.type === "boolean") {
-      res[k] = fmt.mapBoolean ? fmt.mapBoolean(val === true) : val;
-    } else {
-      res[k] = val;
-    }
-  }
-  return res;
-}
-
+/**
+ * Maps a raw database row to the inferred model type T.
+ * Handles JSON parsing, boolean conversion, and numeric mapping.
+ */
 export function toRow<T extends Record<string, unknown>>(
   model: Model,
   row: Record<string, unknown>,
@@ -152,521 +56,6 @@ export function toRow<T extends Record<string, unknown>>(
   return res as T;
 }
 
-function toColumnExpr(
-  fmt: SqlFormat,
-  model: Model,
-  fieldName: string,
-  path?: string[],
-  value?: unknown,
-): string {
-  if (!path || path.length === 0) return fmt.quote(fieldName);
-
-  const field = model.fields[fieldName];
-  if (field?.type !== "json" && field?.type !== "json[]") {
-    throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
-  }
-
-  const isNumeric = typeof value === "number";
-  const isBoolean = typeof value === "boolean";
-  return fmt.jsonExtract(fmt.quote(fieldName), path, isNumeric, isBoolean);
-}
-
-function mapWhereValue(fmt: SqlFormat, val: unknown): unknown {
-  if (val === null) return null;
-  if (typeof val === "boolean") return fmt.mapBoolean ? fmt.mapBoolean(val) : val;
-  if (typeof val === "number" || typeof val === "string") return val;
-  return JSON.stringify(val);
-}
-
-function toWhereRecursive(
-  fmt: SqlFormat,
-  model: Model,
-  where: Where,
-  startIndex: number,
-): { sql: string; params: unknown[] } {
-  if ("and" in where) {
-    const parts = [];
-    const params = [];
-    let currentIdx = startIndex;
-    for (let i = 0; i < where.and.length; i++) {
-      const built = toWhereRecursive(fmt, model, where.and[i]!, currentIdx);
-      parts.push(`(${built.sql})`);
-      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-      currentIdx += built.params.length;
-    }
-    return { sql: parts.join(" AND "), params };
-  }
-
-  if ("or" in where) {
-    const parts = [];
-    const params = [];
-    let currentIdx = startIndex;
-    for (let i = 0; i < where.or.length; i++) {
-      const built = toWhereRecursive(fmt, model, where.or[i]!, currentIdx);
-      parts.push(`(${built.sql})`);
-      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-      currentIdx += built.params.length;
-    }
-    return { sql: parts.join(" OR "), params };
-  }
-
-  const expr = toColumnExpr(fmt, model, where.field, where.path, where.value);
-  const mappedValue = mapWhereValue(fmt, where.value);
-
-  switch (where.op) {
-    case "eq":
-      if (where.value === null) return { sql: `${expr} IS NULL`, params: [] };
-      return { sql: `${expr} = ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "ne":
-      if (where.value === null) return { sql: `${expr} IS NOT NULL`, params: [] };
-      return { sql: `${expr} != ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "gt":
-      return { sql: `${expr} > ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "gte":
-      return { sql: `${expr} >= ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "lt":
-      return { sql: `${expr} < ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "lte":
-      return { sql: `${expr} <= ${fmt.placeholder(startIndex)}`, params: [mappedValue] };
-    case "in": {
-      if (where.value.length === 0) return { sql: "1=0", params: [] };
-      const phs = [];
-      const inParams = [];
-      for (let i = 0; i < where.value.length; i++) {
-        phs.push(fmt.placeholder(startIndex + i));
-        inParams.push(mapWhereValue(fmt, where.value[i]));
-      }
-      return { sql: `${expr} IN (${phs.join(", ")})`, params: inParams };
-    }
-    case "not_in": {
-      if (where.value.length === 0) return { sql: "1=1", params: [] };
-      const phs = [];
-      const inParams = [];
-      for (let i = 0; i < where.value.length; i++) {
-        phs.push(fmt.placeholder(startIndex + i));
-        inParams.push(mapWhereValue(fmt, where.value[i]));
-      }
-      return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: inParams };
-    }
-    default:
-      throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
-  }
-}
-
-export function toWhere(
-  fmt: SqlFormat,
-  model: Model,
-  where?: Where,
-  cursor?: Cursor,
-  sortBy?: SortBy[],
-  startIndex = 0,
-): { sql: string; params: unknown[] } {
-  const parts: string[] = [];
-  const params: unknown[] = [];
-  let nextIndex = startIndex;
-
-  if (where) {
-    const built = toWhereRecursive(fmt, model, where, nextIndex);
-    parts.push(`(${built.sql})`);
-    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-    nextIndex += built.params.length;
-  }
-
-  if (cursor) {
-    const paginationWhere = getPaginationFilter(cursor, sortBy);
-    if (paginationWhere) {
-      const built = toWhereRecursive(fmt, model, paginationWhere, nextIndex);
-      parts.push(`(${built.sql})`);
-      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-      nextIndex += built.params.length;
-    }
-  }
-
-  return {
-    sql: parts.length > 0 ? parts.join(" AND ") : "1=1",
-    params,
-  };
-}
-
-// --- Functional Helpers ---
-
-export async function migrate(exec: QueryExecutor, schema: Schema, fmt: SqlFormat): Promise<void> {
-  const models = Object.entries(schema);
-
-  // Create tables first, then indexes — indexes depend on tables existing.
-  // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
-  for (let i = 0; i < models.length; i++) {
-    const [name, model] = models[i]!;
-    const fields = Object.entries(model.fields);
-    const columns: string[] = [];
-    for (let j = 0; j < fields.length; j++) {
-      const [fieldName, field] = fields[j]!;
-      const nullable = field.nullable === true ? "" : " NOT NULL";
-      columns.push(`${fmt.quote(fieldName)} ${fmt.mapFieldType(field)}${nullable}`);
-    }
-
-    const pkFields = getPrimaryKeyFields(model);
-    const quotedPkFields: string[] = [];
-    for (let j = 0; j < pkFields.length; j++) {
-      quotedPkFields.push(fmt.quote(pkFields[j]!));
-    }
-    const pk = `PRIMARY KEY (${quotedPkFields.join(", ")})`;
-
-    // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-    await exec.run(
-      `CREATE TABLE IF NOT EXISTS ${fmt.quote(name)} (${columns.join(", ")}, ${pk})`,
-      [],
-    );
-  }
-
-  // Now create indexes
-  for (let i = 0; i < models.length; i++) {
-    const [name, model] = models[i]!;
-    if (!model.indexes) continue;
-
-    for (let j = 0; j < model.indexes.length; j++) {
-      const index = model.indexes[j]!;
-      const indexFields = Array.isArray(index.field) ? index.field : [index.field];
-      const formattedFields: string[] = [];
-      for (let k = 0; k < indexFields.length; k++) {
-        formattedFields.push(
-          `${fmt.quote(indexFields[k]!)}${index.order ? ` ${index.order.toUpperCase()}` : ""}`,
-        );
-      }
-      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-      await exec.run(
-        `CREATE INDEX IF NOT EXISTS ${fmt.quote(`idx_${name}_${j}`)} ON ${fmt.quote(name)} (${formattedFields.join(", ")})`,
-        [],
-      );
-    }
-  }
-}
-
-export async function create<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { data: T; select?: Select<T> },
-): Promise<T> {
-  const { data, select } = args;
-  const insertData = toInput(model.fields, data, fmt);
-  const fields = Object.keys(insertData);
-
-  const quotedFields: string[] = [];
-  const placeholders: string[] = [];
-  const values: unknown[] = [];
-
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i]!;
-    quotedFields.push(fmt.quote(field));
-    placeholders.push(fmt.placeholder(i));
-    values.push(insertData[field]);
-  }
-
-  const sqlSelect = toSelect(
-    fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
-    select as Select<Record<string, unknown>>,
-  );
-  const sql = `INSERT INTO ${fmt.quote(table)} (${quotedFields.join(", ")}) VALUES (${placeholders.join(", ")}) ${getReturning(fmt, sqlSelect)}`;
-  const row = await exec.get(sql, values);
-
-  if (!row) {
-    const result = await find(exec, table, model, fmt, {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field names in source T match model fields at runtime
-      where: buildIdentityFilter(model, data) as Where<T>,
-      select,
-    });
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- result is T (or null) from find(), and we just inserted it
-    return result as T;
-  }
-
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
-  return toRow(model, row, select as Select<Record<string, unknown>>);
-}
-
-export async function find<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where: Where<T>; select?: Select<T> },
-): Promise<T | null> {
-  const { where, select } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where);
-  const sql = `SELECT ${toSelect(
-    fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
-    select as Select<Record<string, unknown>>,
-  )} FROM ${fmt.quote(table)} WHERE ${built.sql} LIMIT 1`;
-  const row = await exec.get(sql, built.params);
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
-  return row ? toRow(model, row, select as Select<Record<string, unknown>>) : null;
-}
-
-export async function findMany<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: {
-    where?: Where<T>;
-    select?: Select<T>;
-    sortBy?: SortBy<T>[];
-    limit?: number;
-    offset?: number;
-    cursor?: Cursor<T>;
-  },
-): Promise<T[]> {
-  const { where, select, sortBy, limit, offset, cursor } = args;
-  const params: unknown[] = [];
-  const sqlSelect = toSelect(
-    fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
-    select as Select<Record<string, unknown>>,
-  );
-  let sql = `SELECT ${sqlSelect} FROM ${fmt.quote(table)}`;
-
-  const built = toWhere(
-    fmt,
-    model,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-    where as Where,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Cursor<T> is compatible with Cursor for SQL generation
-    cursor as Cursor,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>[] is compatible with SortBy[] for SQL generation
-    sortBy as SortBy[] | undefined,
-  );
-  if (built.sql !== "1=1") {
-    sql += ` WHERE ${built.sql}`;
-    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-  }
-
-  if (sortBy && sortBy.length > 0) {
-    const sortParts: string[] = [];
-    for (let i = 0; i < sortBy.length; i++) {
-      const s = sortBy[i]!;
-      sortParts.push(
-        `${toColumnExpr(fmt, model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
-      );
-    }
-    sql += ` ORDER BY ${sortParts.join(", ")}`;
-  }
-
-  if (limit !== undefined) {
-    sql += ` LIMIT ${fmt.placeholder(params.length)}`;
-    params.push(limit);
-  }
-
-  if (offset !== undefined) {
-    sql += ` OFFSET ${fmt.placeholder(params.length)}`;
-    params.push(offset);
-  }
-
-  const rows = await exec.all(sql, params);
-  const result: T[] = [];
-  for (let i = 0; i < rows.length; i++) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- rows are mapped to T via toRow
-    result.push(toRow(model, rows[i]!, select as Select<Record<string, unknown>>));
-  }
-  return result;
-}
-
-export async function update<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where: Where<T>; data: Partial<T> },
-): Promise<T | null> {
-  const { where, data } = args;
-  assertNoPrimaryKeyUpdates(model, data);
-
-  const updateData = toInput(model.fields, data, fmt);
-  const fields = Object.keys(updateData);
-  if (fields.length === 0) return find(exec, table, model, fmt, { where });
-
-  const assignments: string[] = [];
-  const params: unknown[] = [];
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i]!;
-    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(i)}`);
-    params.push(updateData[field]);
-  }
-
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
-  const sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")} WHERE ${built.sql} ${getReturning(fmt, "*")}`;
-  for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-
-  const row = await exec.get(sql, params);
-  if (!row) return find(exec, table, model, fmt, { where });
-  return toRow(model, row);
-}
-
-export async function updateMany<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where?: Where<T>; data: Partial<T> },
-): Promise<number> {
-  const { where, data } = args;
-  assertNoPrimaryKeyUpdates(model, data);
-
-  const updateData = toInput(model.fields, data, fmt);
-  const fields = Object.keys(updateData);
-  if (fields.length === 0) return 0;
-
-  const assignments: string[] = [];
-  const params: unknown[] = [];
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i]!;
-    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(i)}`);
-    params.push(updateData[field]);
-  }
-
-  let sql = `UPDATE ${fmt.quote(table)} SET ${assignments.join(", ")}`;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
-  if (built.sql !== "1=1") {
-    sql += ` WHERE ${built.sql}`;
-    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-  }
-
-  const res = await exec.run(sql, params);
-  return res.changes;
-}
-
-export async function upsert<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: {
-    create: T;
-    update: Partial<T>;
-    where?: Where<T>;
-    select?: Select<T>;
-  },
-): Promise<T> {
-  const { create: cData, update: uData, where, select } = args;
-  assertNoPrimaryKeyUpdates(model, uData);
-
-  const createData = toInput(model.fields, cData, fmt);
-  const createFields = Object.keys(createData);
-  const updateData = toInput(model.fields, uData, fmt);
-  const updateFields = Object.keys(updateData);
-  const pkFields = getPrimaryKeyFields(model);
-
-  const insertColumns: string[] = [];
-  const insertPlaceholders: string[] = [];
-  const params: unknown[] = [];
-  for (let i = 0; i < createFields.length; i++) {
-    const field = createFields[i]!;
-    insertColumns.push(fmt.quote(field));
-    insertPlaceholders.push(fmt.placeholder(i));
-    params.push(createData[field]);
-  }
-
-  const updateColumns: string[] = [];
-  for (let i = 0; i < updateFields.length; i++) {
-    const field = updateFields[i]!;
-    updateColumns.push(field);
-    params.push(updateData[field]);
-  }
-
-  let whereSql = "";
-  if (where) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-    const built = toWhere(fmt, model, where as Where, undefined, undefined, params.length);
-    whereSql = built.sql;
-    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-  }
-
-  const sqlSelect = toSelect(
-    fmt,
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Select<T> is a subtype of string[] because model keys are strings
-    select as Select<Record<string, unknown>>,
-  );
-
-  const assignments: string[] = [];
-  for (let i = 0; i < updateFields.length; i++) {
-    const field = updateFields[i]!;
-    assignments.push(`${fmt.quote(field)} = ${fmt.placeholder(createFields.length + i)}`);
-  }
-
-  const sql = getUpsert(fmt, {
-    table,
-    insert: { columns: insertColumns, placeholders: insertPlaceholders },
-    update: updateFields.length > 0 ? { assignments, where: whereSql || undefined } : undefined,
-    conflict: { columns: pkFields.map((f) => fmt.quote(f)) },
-    returning: getReturning(fmt, sqlSelect),
-  });
-
-  const row = await exec.get(sql, params);
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- row is mapped to T via toRow
-  if (row) return toRow(model, row, select as Select<Record<string, unknown>>);
-
-  const identityValues = getIdentityValues(model, cData);
-  const existing = await find(exec, table, model, fmt, {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field names in identityValues match model fields at runtime
-    where: buildIdentityFilter(model, identityValues) as Where<T>,
-    select,
-  });
-  if (!existing) throw new Error("Failed to refetch upserted record.");
-  return existing;
-}
-
-export async function remove<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where: Where<T> },
-): Promise<void> {
-  const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where);
-  await exec.run(`DELETE FROM ${fmt.quote(table)} WHERE ${built.sql}`, built.params);
-}
-
-export async function removeMany<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where?: Where<T> },
-): Promise<number> {
-  const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where);
-  let sql = `DELETE FROM ${fmt.quote(table)}`;
-  if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
-  const res = await exec.run(sql, built.params);
-  return res.changes;
-}
-
-export async function count<T extends Record<string, unknown>>(
-  exec: QueryExecutor,
-  table: string,
-  model: Model,
-  fmt: SqlFormat,
-  args: { where?: Where<T> },
-): Promise<number> {
-  const { where } = args;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where<T> is compatible with Where for SQL generation
-  const built = toWhere(fmt, model, where as Where);
-  let sql = `SELECT COUNT(*) as count FROM ${fmt.quote(table)}`;
-  if (built.sql !== "1=1") sql += ` WHERE ${built.sql}`;
-  const row = await exec.get(sql, built.params);
-  if (!row) return 0;
-  const val = row["count"];
-  return typeof val === "number" ? val : Number(val ?? 0);
-}
-
 /**
  * FUTURE EXTENSION: GreptimeDB & MySQL
  *
@@ -679,15 +68,12 @@ export async function count<T extends Record<string, unknown>>(
  *    - Mutation responses over Bun.SQL might not populate `count` but provide a `command` string
  *      like "OK 1". Parsed in `postgres.ts`.
  *    - JSON strings can contain Rust-style Unicode escapes (\u{xxxx}) which are invalid JSON.
- *      May need a `mapJsonOutput` hook in `SqlFormat`. Empty JSON strings ("") or "{}"
- *      should be normalized to {}. To avoid driver crashes, JSON columns might need
- *      to be cast to STRING on the wire (e.g. `col::STRING`).
+ *      Empty JSON strings ("") or "{}" should be normalized to {}. To avoid driver crashes,
+ *      JSON columns might need to be cast to STRING on the wire (e.g. `col::STRING`).
  *    - DDL: `TIME INDEX` is mandatory. May also need `PARTITION BY`, `WITH` (e.g. merge_mode),
  *      or `SKIPPING INDEX` for performance optimizations.
  *    - JSON: Specialized functions like `json_get_string` might be required instead of
  *      standard Postgres operators like `->>`.
- *    - Batch inserts: When using a time index as part of uniqueness, adding a slight offset
- *      (e.g. +1ms) per item in a batch avoids timestamp collisions.
  *
  * 2. MySQL / MariaDB:
  *    - Quoting uses backticks (`) instead of double quotes ("). Note that backticks
@@ -698,7 +84,5 @@ export async function count<T extends Record<string, unknown>>(
  *
  * 3. General SQL:
  *    - Some databases don't support parameters in `LIMIT` clauses. May need a `limitAsLiteral` flag.
- *    - May need to override `toInput`/`toRow` logic if per-driver parameter mapping is needed
- *      (e.g. Date to Number/BigInt, or BigInt to Number).
  *    - Indexing: Different types like `BRIN` might not support `ASC`/`DESC` or require `USING` syntax.
  */
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index fd7f9e8..4b13a7b 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -3,70 +3,191 @@ import type { Database as BunDatabase } from "bun:sqlite";
 import type { Database as BetterSqlite3Database } from "better-sqlite3";
 import type { Database as SqliteDatabase } from "sqlite";
 
-import type { Adapter, Field, InferModel, Schema, Select, SortBy, Where, Cursor } from "../types";
+import type {
+  Adapter,
+  Field,
+  InferModel,
+  Schema,
+  Select,
+  SortBy,
+  Where,
+  Cursor,
+  Model,
+} from "../types";
 import {
-  type QueryExecutor,
-  type SqlFormat,
-  isQueryExecutor,
-  migrate,
-  create,
-  find,
-  findMany,
-  update,
-  updateMany,
-  upsert,
-  remove,
-  removeMany,
-  count,
-} from "./sql";
+  assertNoPrimaryKeyUpdates,
+  buildIdentityFilter,
+  getIdentityValues,
+  getPaginationFilter,
+  getPrimaryKeyFields,
+} from "./common";
+import { type QueryExecutor, isQueryExecutor, toRow } from "./sql";
 
 export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
 
-// --- Formatting Hooks ---
-
-const sqlite: SqlFormat = {
-  placeholder: () => "?",
-  quote: (s) => `"${s.replaceAll('"', '""')}"`,
-  mapBoolean: (v) => (v ? 1 : 0),
-  mapFieldType(field: Field): string {
-    switch (field.type) {
-      case "string":
-        return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
-      case "number":
-        return "REAL";
-      case "boolean":
-      case "timestamp":
-        return "INTEGER";
-      case "json":
-      case "json[]":
-        return "TEXT";
-      default:
-        return "TEXT";
-    }
-  },
-  jsonExtract(column: string, path: string[]): string {
-    let jsonPath = "$";
-    for (let i = 0; i < path.length; i++) {
-      const segment = path[i]!;
-      let isIndex = true;
-      for (let j = 0; j < segment.length; j++) {
-        const c = segment.codePointAt(j);
-        if (c === undefined || c < 48 || c > 57) {
-          isIndex = false;
-          break;
-        }
-      }
-      if (isIndex) {
-        jsonPath += `[${segment}]`;
-      } else {
-        jsonPath += `.${segment}`;
+const MAX_CACHE_SIZE = 100;
+
+// --- Internal SQLite Syntax Helpers ---
+
+const quote = (s: string) => `"${s.replaceAll('"', '""')}"`;
+const placeholder = () => "?";
+
+function mapFieldType(field: Field): string {
+  switch (field.type) {
+    case "string":
+      return field.max === undefined ? "TEXT" : `VARCHAR(${field.max})`;
+    case "number":
+      return "REAL";
+    case "boolean":
+    case "timestamp":
+      return "INTEGER";
+    case "json":
+    case "json[]":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+
+function jsonExtract(column: string, path: string[]): string {
+  let jsonPath = "$";
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i]!;
+    let isIndex = true;
+    for (let j = 0; j < segment.length; j++) {
+      const c = segment.codePointAt(j);
+      if (c === undefined || c < 48 || c > 57) {
+        isIndex = false;
+        break;
       }
     }
-    return `json_extract(${column}, '${jsonPath}')`;
-  },
-};
+    if (isIndex) jsonPath += `[${segment}]`;
+    else jsonPath += `.${segment}`;
+  }
+  return `json_extract(${column}, '${jsonPath}')`;
+}
 
-const MAX_CACHE_SIZE = 100;
+function toColumnExpr(model: Model, fieldName: string, path?: string[]): string {
+  if (!path || path.length === 0) return quote(fieldName);
+  const field = model.fields[fieldName];
+  if (field?.type !== "json" && field?.type !== "json[]") {
+    throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
+  }
+  return jsonExtract(quote(fieldName), path);
+}
+
+function toWhereRecursive(model: Model, where: Where): { sql: string; params: unknown[] } {
+  if ("and" in where) {
+    const parts = [];
+    const params = [];
+    for (let i = 0; i < where.and.length; i++) {
+      const built = toWhereRecursive(model, where.and[i]!);
+      parts.push(`(${built.sql})`);
+      params.push(...built.params);
+    }
+    return { sql: parts.join(" AND "), params };
+  }
+
+  if ("or" in where) {
+    const parts = [];
+    const params = [];
+    for (let i = 0; i < where.or.length; i++) {
+      const built = toWhereRecursive(model, where.or[i]!);
+      parts.push(`(${built.sql})`);
+      params.push(...built.params);
+    }
+    return { sql: parts.join(" OR "), params };
+  }
+
+  const expr = toColumnExpr(model, where.field, where.path);
+  const val = where.value;
+  const mappedVal = typeof val === "boolean" ? (val ? 1 : 0) : val;
+
+  switch (where.op) {
+    case "eq":
+      if (val === null) return { sql: `${expr} IS NULL`, params: [] };
+      return { sql: `${expr} = ${placeholder()}`, params: [mappedVal] };
+    case "ne":
+      if (val === null) return { sql: `${expr} IS NOT NULL`, params: [] };
+      return { sql: `${expr} != ${placeholder()}`, params: [mappedVal] };
+    case "gt":
+      return { sql: `${expr} > ${placeholder()}`, params: [mappedVal] };
+    case "gte":
+      return { sql: `${expr} >= ${placeholder()}`, params: [mappedVal] };
+    case "lt":
+      return { sql: `${expr} < ${placeholder()}`, params: [mappedVal] };
+    case "lte":
+      return { sql: `${expr} <= ${placeholder()}`, params: [mappedVal] };
+    case "in": {
+      if (!Array.isArray(val) || val.length === 0) return { sql: "1=0", params: [] };
+      const inParams = val.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
+      return { sql: `${expr} IN (${val.map(() => placeholder()).join(", ")})`, params: inParams };
+    }
+    case "not_in": {
+      if (!Array.isArray(val) || val.length === 0) return { sql: "1=1", params: [] };
+      const inParams = val.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
+      return {
+        sql: `${expr} NOT IN (${val.map(() => placeholder()).join(", ")})`,
+        params: inParams,
+      };
+    }
+    default:
+      throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
+  }
+}
+
+function toWhere(
+  model: Model,
+  where?: Where,
+  cursor?: Cursor,
+  sortBy?: SortBy[],
+): { sql: string; params: unknown[] } {
+  const parts: string[] = [];
+  const params: unknown[] = [];
+
+  if (where) {
+    const built = toWhereRecursive(model, where);
+    parts.push(`(${built.sql})`);
+    params.push(...built.params);
+  }
+
+  if (cursor) {
+    const paginationWhere = getPaginationFilter(cursor, sortBy);
+    if (paginationWhere) {
+      const built = toWhereRecursive(model, paginationWhere);
+      parts.push(`(${built.sql})`);
+      params.push(...built.params);
+    }
+  }
+
+  return { sql: parts.length > 0 ? parts.join(" AND ") : "1=1", params };
+}
+
+function toInput(
+  fields: Record<string, Field>,
+  data: Record<string, unknown>,
+): Record<string, unknown> {
+  const res: Record<string, unknown> = {};
+  const keys = Object.keys(data);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = data[k];
+    const spec = fields[k];
+    if (val === undefined) continue;
+    if (val === null) {
+      res[k] = null;
+      continue;
+    }
+    if (spec?.type === "json" || spec?.type === "json[]") {
+      res[k] = JSON.stringify(val);
+    } else if (spec?.type === "boolean") {
+      res[k] = val === true ? 1 : 0;
+    } else {
+      res[k] = val;
+    }
+  }
+  return res;
+}
 
 // --- Driver detection and executors ---
 
@@ -97,7 +218,6 @@ interface SyncDriver {
 // Uses a simple Map with FIFO eviction at MAX_CACHE_SIZE.
 function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): QueryExecutor {
   const cache = new Map<string, SyncStatement>();
-
   function getStmt(sql: string): SyncStatement {
     let stmt = cache.get(sql);
     if (stmt === undefined) {
@@ -114,12 +234,12 @@ function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): Qu
   return {
     all: (sql, params) => {
       const result = getStmt(sql).all(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows are plain objects matching RowData
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows match Record shape
       return Promise.resolve(result as Record<string, unknown>[]);
     },
     get: (sql, params) => {
       const result = getStmt(sql).get(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row is a plain object or undefined, matching RowData
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row matches Record shape
       return Promise.resolve(result as Record<string, unknown> | undefined);
     },
     run: (sql, params) => {
@@ -165,10 +285,8 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase, inTransaction = false
 }
 
 function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
-  if (isSyncSqlite(driver)) {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally compatible with SyncDriver
-    return createSyncSqliteExecutor(driver as unknown as SyncDriver);
-  }
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked
+  if (isSyncSqlite(driver)) return createSyncSqliteExecutor(driver as unknown as SyncDriver);
   return createAsyncSqliteExecutor(driver as SqliteDatabase);
 }
 
@@ -184,32 +302,97 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     this.executor = isQueryExecutor(driver) ? driver : createSqliteExecutor(driver);
   }
 
-  migrate = () => migrate(this.executor, this.schema, sqlite);
+  async migrate(): Promise<void> {
+    const models = Object.entries(this.schema);
 
-  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    if (this.executor.inTransaction) {
-      // Re-use current adapter if already in a transaction.
-      return fn(this);
+    // Create tables first, then indexes — indexes depend on tables existing.
+    // DDL must be sequential: some drivers don't support concurrent DDL on one connection.
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      const fields = Object.entries(model.fields);
+      const columns = fields.map(
+        ([fname, f]) =>
+          `${quote(fname)} ${mapFieldType(f)}${f.nullable === true ? "" : " NOT NULL"}`,
+      );
+      const pkFields = getPrimaryKeyFields(model);
+      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
+      // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+      await this.executor.run(
+        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
+      );
+    }
+
+    // Now create indexes
+    for (let i = 0; i < models.length; i++) {
+      const [name, model] = models[i]!;
+      if (!model.indexes) continue;
+      for (let j = 0; j < model.indexes.length; j++) {
+        const idx = model.indexes[j]!;
+        const fields = Array.isArray(idx.field) ? idx.field : [idx.field];
+        const formatted = fields.map(
+          (f) => `${quote(f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
+        );
+        // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
+        await this.executor.run(
+          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${quote(name)} (${formatted.join(", ")})`,
+        );
+      }
     }
+  }
+
+  transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
+    if (this.executor.inTransaction) return fn(this);
     return this.executor.transaction((exec) => fn(new SqliteAdapter(this.schema, exec)));
   }
 
-  create = <
+  async create<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    data: T;
-    select?: Select<T>;
-  }) => create(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
+    const { model: modelName, data, select } = args;
+    const model = this.schema[modelName]!;
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    const sqlFields = fields.map((f) => quote(f)).join(", ");
+    const sqlPlaceholders = fields.map(() => placeholder()).join(", ");
+    const sql = `INSERT INTO ${quote(modelName)} (${sqlFields}) VALUES (${sqlPlaceholders}) RETURNING *`;
+    const row = await this.executor.get(
+      sql,
+      fields.map((f) => input[f]),
+    );
+    if (row === undefined || row === null) {
+      // Fallback for drivers that don't support RETURNING (though Bun/Better-Sqlite3 do)
+      const res = await this.find({
+        model: modelName,
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+        where: buildIdentityFilter(model, getIdentityValues(model, data)) as Where<T>,
 
-  find = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where: Where<T>;
-    select?: Select<T>;
-  }) => find(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+        select,
+      });
+      if (!res) throw new Error("Failed to insert record");
+      return res;
+    }
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+  }
 
-  findMany = <
+  async find<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model: modelName, where, select } = args;
+    const model = this.schema[modelName]!;
+    const built = toWhere(model, where as Where);
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+    const sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql} LIMIT 1`;
+    const row = await this.executor.get(sql, built.params);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    if (row === undefined || row === null) return null;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
+    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+  }
+
+  async findMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -220,27 +403,79 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     limit?: number;
     offset?: number;
     cursor?: Cursor<T>;
-  }) => findMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  }): Promise<T[]> {
+    const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where/Cursor/SortBy types match at runtime
+    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[]);
+    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
+    let sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql}`;
 
-  update = <
+    if (sortBy && sortBy.length > 0) {
+      const parts = sortBy.map(
+        (s) => `${toColumnExpr(model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
+      );
+      sql += ` ORDER BY ${parts.join(", ")}`;
+    }
+    if (limit !== undefined) {
+      sql += ` LIMIT ${placeholder()}`;
+      built.params.push(limit);
+    }
+    if (offset !== undefined) {
+      sql += ` OFFSET ${placeholder()}`;
+      built.params.push(offset);
+    }
+    const rows = await this.executor.all(sql, built.params);
+
+    const result: T[] = [];
+    for (let i = 0; i < rows.length; i++) {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+      result.push(toRow<T>(model, rows[i]!, select as Select<Record<string, unknown>>));
+    }
+    return result;
+  }
+
+  async update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where: Where<T>;
-    data: Partial<T>;
-  }) => update(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
+    const { model: modelName, where, data } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, data);
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    if (fields.length === 0) return this.find({ model: modelName, where, select: undefined });
 
-  updateMany = <
+    const assignments = fields.map((f) => `${quote(f)} = ${placeholder()}`);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
+    const row = await this.executor.get(sql, [...fields.map((f) => input[f]), ...built.params]);
+    if (row === undefined || row === null) return this.find({ model: modelName, where });
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    return toRow<T>(model, row);
+  }
+
+  async updateMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-    data: Partial<T>;
-  }) => updateMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
+    const { model: modelName, where, data } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, data);
+    const input = toInput(model.fields, data);
+    const fields = Object.keys(input);
+    if (fields.length === 0) return 0;
 
-  upsert = <
+    const assignments = fields.map((f) => `${quote(f)} = ${placeholder()}`);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql}`;
+    const res = await this.executor.run(sql, [...fields.map((f) => input[f]), ...built.params]);
+    return res.changes;
+  }
+
+  async upsert<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: {
@@ -249,26 +484,97 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     update: Partial<T>;
     where?: Where<T>;
     select?: Select<T>;
-  }) => upsert(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  }): Promise<T> {
+    const { model: modelName, create: cData, update: uData, where, select } = args;
+    const model = this.schema[modelName]!;
+    assertNoPrimaryKeyUpdates(model, uData);
+
+    const cInput = toInput(model.fields, cData);
+    const cFields = Object.keys(cInput);
+    const uInput = toInput(model.fields, uData);
+    const uFields = Object.keys(uInput);
+    const pkFields = getPrimaryKeyFields(model);
+
+    const sqlColumns = cFields.map((f) => quote(f)).join(", ");
+    const sqlPlaceholders = cFields.map(() => placeholder()).join(", ");
+    const sqlConflict = pkFields.map((f) => quote(f)).join(", ");
+
+    let sql = `INSERT INTO ${quote(modelName)} (${sqlColumns}) VALUES (${sqlPlaceholders}) ON CONFLICT (${sqlConflict}) `;
+    const params = cFields.map((f) => cInput[f]);
+
+    if (uFields.length > 0) {
+      const assignments: string[] = [];
+      for (let i = 0; i < uFields.length; i++) {
+        const f = uFields[i]!;
+        assignments.push(`${quote(f)} = ${placeholder()}`);
+        params.push(uInput[f]);
+      }
+      sql += `DO UPDATE SET ${assignments.join(", ")}`;
+      if (where) {
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+        const built = toWhere(model, where as Where);
+        sql += ` WHERE ${built.sql}`;
+        params.push(...built.params);
+      }
+    } else {
+      sql += "DO NOTHING";
+    }
+
+    sql += " RETURNING *";
+    const row = await this.executor.get(sql, params);
+    if (row !== undefined && row !== null) {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
+      return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    }
+
+    const existing = await this.find({
+      model: modelName,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+      where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
+      select,
+    });
+    if (existing === null) throw new Error("Failed to refetch record after upsert");
+    return existing;
+  }
 
-  delete = <
+  async delete<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where: Where<T>;
-  }) => remove(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  >(args: { model: K; where: Where<T> }): Promise<void> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    await this.executor.run(`DELETE FROM ${quote(modelName)} WHERE ${built.sql}`, built.params);
+  }
 
-  deleteMany = <
+  async deleteMany<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: {
-    model: K;
-    where?: Where<T>;
-  }) => removeMany(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const res = await this.executor.run(
+      `DELETE FROM ${quote(modelName)} WHERE ${built.sql}`,
+      built.params,
+    );
+    return res.changes;
+  }
 
-  count = <K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
-    model: K;
-    where?: Where<T>;
-  }) => count(this.executor, args.model, this.schema[args.model]!, sqlite, args);
+  async count<
+    K extends keyof S & string,
+    T extends Record<string, unknown> = InferModel<S[K]>,
+  >(args: { model: K; where?: Where<T> }): Promise<number> {
+    const { model: modelName, where } = args;
+    const model = this.schema[modelName]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
+    const built = toWhere(model, where as Where);
+    const row = await this.executor.get(
+      `SELECT COUNT(*) as count FROM ${quote(modelName)} WHERE ${built.sql}`,
+      built.params,
+    );
+    return row === undefined || row === null ? 0 : Number(row["count"] ?? 0);
+  }
 }

From 2cb4b23320aa6205e10e960f5fc852170ee11f6f Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Thu, 30 Apr 2026 18:29:32 +0800
Subject: [PATCH 23/24] refactor: eliminate the use of unsafe methods

---
 AGENTS.md                          |  23 +-
 README.md                          |  41 +-
 src/adapters/memory.test.ts        |   4 +-
 src/adapters/memory.ts             | 295 ++++++++------
 src/adapters/postgres.ts           | 598 +++++++++++++++++------------
 src/adapters/sql.ts                |  88 -----
 src/adapters/sqlite.test.ts        |  24 ++
 src/adapters/sqlite.ts             | 497 +++++++++++++++---------
 src/adapters/{ => utils}/common.ts |   2 +-
 src/adapters/utils/sql.ts          | 160 ++++++++
 tsconfig.json                      |   2 +-
 11 files changed, 1056 insertions(+), 678 deletions(-)
 delete mode 100644 src/adapters/sql.ts
 rename src/adapters/{ => utils}/common.ts (98%)
 create mode 100644 src/adapters/utils/sql.ts

diff --git a/AGENTS.md b/AGENTS.md
index eaaee41..d21b5a4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,7 +9,7 @@ This file gives coding agents a fast, reliable workflow for contributing to `@8m
 - Runtime: Bun + TypeScript (ESM).
 - Library type: Tiny, schema-first persistence core for TypeScript libraries.
 - Not a query builder, migration framework, or full ORM runtime.
-- Designed to be embedded inside other libraries (e.g. `hebo-gateway`).
+- Designed to be embedded inside other libraries.
 
 ## Technical Design Priorities
 
@@ -33,11 +33,12 @@ src/
   types.ts              Schema, Adapter interface, Where/SortBy/Cursor types
   index.ts              Public entrypoint (re-exports types.ts)
   adapters/
-    common.ts           Shared PK, pagination, and value helpers
     memory.ts           MemoryAdapter (LRU-cache-backed)
-    sql.ts              QueryExecutor interface and toRow helper (shared SQL logic)
     postgres.ts         PostgresAdapter (Autonomous SQL + Execution)
     sqlite.ts           SqliteAdapter (Autonomous SQL + Execution)
+    utils/
+      common.ts         Shared PK, pagination, and value helpers
+      sql.ts            QueryExecutor interface and toRow helper (shared SQL logic)
 ```
 
 Each adapter file is self-contained: SQL building, driver detection, executor factories, and adapter class all live together.
@@ -57,10 +58,11 @@ Each adapter file is self-contained: SQL building, driver detection, executor fa
 
 1. Read the touched feature area first.
 2. Keep edits minimal and localized; avoid broad refactors unless asked.
-3. Retain existing architectural and defensive comments that explain "why" (e.g. sequential DDL, driver detection order, V8 optimizations).
-4. Update related tests when behavior changes.
-5. Run `bun run check` and `bun test` before considering a change done.
-6. If formatting/linting is impacted, run `bun run format` and `bun run lint`.
+3. **No Rearrangement**: Do not move existing classes, methods, or functions to different positions within a file. Maintaining the original order is required to ensure clean git diffs and facilitate efficient code reviews.
+4. Retain existing architectural and defensive comments that explain "why" (e.g. sequential DDL, driver detection order, V8 optimizations).
+5. Update related tests when behavior changes.
+6. Run `bun run check` and `bun test` before considering a change done.
+7. If formatting/linting is impacted, run `bun run format` and `bun run lint`.
 
 - Update this file with new "Lessons Learned" or "Mistakes to Avoid" if a significant architectural shift or subtle bug is encountered.
 
@@ -107,10 +109,6 @@ The memory adapter methods are synchronous. Return `Promise.resolve(value)` inst
 
 Prefer `for (let i = 0; i < arr.length; i++)` over `for...of` in adapter internals. The indexed form avoids iterator protocol overhead.
 
-### Use `Array.toSorted()` over `Array.sort()`
-
-`toSorted` returns a new array without mutating the original. This satisfies the unicorn lint rule and avoids side effects.
-
 ## Architecture Notes
 
 ### Adapter boundary is the one place where `as T` casts are acceptable
@@ -166,8 +164,7 @@ The schema is passed to the adapter constructor. `migrate()` uses `this.schema`
 ## Testing Expectations
 
 - Prefer focused tests close to the changed code.
-- Memory adapter tests go in `src/adapters/memory.test.ts`.
-- SQLite integration tests go in `src/adapters/sqlite.test.ts`.
+- Unit tests go in `src/**/*.test.ts`.
 - Cover: CRUD lifecycle, composite primary keys, select projection, all operators (`eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `not_in`), logical composition (`and`, `or`), null handling, JSON path filters, pagination (offset + cursor), sorting with nulls, upsert (insert/update/predicated), updateMany, deleteMany, count, transactions, LRU eviction, duplicate key rejection.
 - When adding a new adapter, add integration tests exercising the full operation set.
 
diff --git a/README.md b/README.md
index 0c19fe3..018ce8b 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ type User = InferModel<typeof schema.users>;
 import { Database } from "bun:sqlite";
 import { SqliteAdapter } from "@8monkey/no-orm/adapters/sqlite";
 
-const db = new Database(":memory:");
+const db = new Database("data.db");
 const adapter = new SqliteAdapter(schema, db);
 
 await adapter.migrate();
@@ -59,8 +59,6 @@ await adapter.migrate();
 
 ### Postgres
 
-Supports `pg`, `postgres.js`, and `Bun.SQL`.
-
 ```ts
 import postgres from "postgres"; // or import { Pool } from "pg"
 import { PostgresAdapter } from "@8monkey/no-orm/adapters/postgres";
@@ -73,12 +71,12 @@ await adapter.migrate();
 
 ### Memory
 
-Uses [lru-cache](https://github.com/isaacs/node-lru-cache) for bounded storage with LRU eviction.
+In-memory storage for testing or temporary data.
 
 ```ts
 import { MemoryAdapter } from "@8monkey/no-orm/adapters/memory";
 
-const adapter = new MemoryAdapter(schema, { maxSize: 100 });
+const adapter = new MemoryAdapter(schema, { maxItems: 100 });
 await adapter.migrate();
 ```
 
@@ -86,7 +84,7 @@ await adapter.migrate();
 
 ```ts
 // Create
-const created = await adapter.create<"users", User>({
+const created = await adapter.create({
   model: "users",
   data: {
     id: "u1",
@@ -100,13 +98,13 @@ const created = await adapter.create<"users", User>({
 });
 
 // Find one
-const found = await adapter.find<"users", User>({
+const found = await adapter.find({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
 });
 
 // Find many
-const users = await adapter.findMany<"users", User>({
+const users = await adapter.findMany({
   model: "users",
   where: { field: "is_active", op: "eq", value: true },
   sortBy: [{ field: "created_at", direction: "desc" }],
@@ -114,39 +112,39 @@ const users = await adapter.findMany<"users", User>({
 });
 
 // Update one
-const updated = await adapter.update<"users", User>({
+const updated = await adapter.update({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
   data: { age: 31 },
 });
 
 // Update many
-const updatedCount = await adapter.updateMany<"users", User>({
+const updatedCount = await adapter.updateMany({
   model: "users",
   where: { field: "is_active", op: "eq", value: true },
   data: { age: 99 },
 });
 
 // Delete one
-await adapter.delete<"users", User>({
+await adapter.delete({
   model: "users",
   where: { field: "id", op: "eq", value: "u1" },
 });
 
 // Delete many
-const deletedCount = await adapter.deleteMany<"users", User>({
+const deletedCount = await adapter.deleteMany({
   model: "users",
   where: { field: "is_active", op: "eq", value: false },
 });
 
 // Count
-const total = await adapter.count<"users", User>({
+const total = await adapter.count({
   model: "users",
   where: { field: "is_active", op: "eq", value: true },
 });
 
 // Upsert - insert or update by primary key
-const user = await adapter.upsert<"users", User>({
+const user = await adapter.upsert({
   model: "users",
   create: { id: "u1", name: "Alice", age: 30, is_active: true, created_at: Date.now() },
   update: { age: 31 },
@@ -184,7 +182,7 @@ where: {
 Filter nested JSON fields using `path`:
 
 ```ts
-const darkUsers = await adapter.findMany<"users", User>({
+const darkUsers = await adapter.findMany({
   model: "users",
   where: {
     field: "metadata",
@@ -199,7 +197,7 @@ const darkUsers = await adapter.findMany<"users", User>({
 
 ```ts
 // Offset pagination
-const page = await adapter.findMany<"users", User>({
+const page = await adapter.findMany({
   model: "users",
   sortBy: [{ field: "created_at", direction: "desc" }],
   limit: 20,
@@ -207,7 +205,7 @@ const page = await adapter.findMany<"users", User>({
 });
 
 // Cursor pagination (keyset)
-const cursorPage = await adapter.findMany<"users", User>({
+const cursorPage = await adapter.findMany({
   model: "users",
   sortBy: [{ field: "created_at", direction: "desc" }],
   limit: 20,
@@ -236,15 +234,6 @@ await adapter.transaction(async (tx) => {
 
 SQLite and Postgres support nested transactions via savepoints.
 
-## Notes
-
-- `upsert` always conflicts on the Primary Key
-- Optional `where` in `upsert` acts as a predicate -- record is only updated if condition is met
-- Primary-key updates are rejected to keep adapter behavior consistent
-- SQLite stores JSON as text; Postgres stores JSON as `jsonb`
-- `number` and `timestamp` use standard JavaScript `Number`. `bigint` is not supported in v1.
-- Memory adapter uses `lru-cache` (required dependency) with configurable `maxSize` for bounded storage
-
 ## License
 
 MIT
diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 2fcbc25..7aa1fc2 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -648,8 +648,8 @@ describe("MemoryAdapter", () => {
 
   // --- LRU eviction ---
 
-  it("should evict oldest entries when maxSize is exceeded", async () => {
-    const smallAdapter = new MemoryAdapter(schema, { maxSize: 2 });
+  it("should evict oldest entries when maxItems is exceeded", async () => {
+    const smallAdapter = new MemoryAdapter(schema, { maxItems: 2 });
     await smallAdapter.migrate();
 
     await smallAdapter.create({
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 8ef6886..9cf23b8 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -7,39 +7,57 @@ import {
   getNestedValue,
   getPaginationFilter,
   getPrimaryKeyFields,
-} from "./common";
+} from "./utils/common";
 
 type RowData = Record<string, unknown>;
-type ModelCache = LRUCache<string, RowData>;
 
-const DEFAULT_MAX_SIZE = 1000;
+const DEFAULT_MAX_ITEMS = 1000;
 
 export interface MemoryAdapterOptions {
-  maxSize?: number;
+  maxItems?: number;
 }
 
+/**
+ * In-memory adapter with bounded global storage and high-performance indexed scans.
+ *
+ * Technical Design:
+ * - Table Storage: Per-table arrays (Heaps) allow for O(1) indexed scans.
+ * - PK Index: Per-table Maps for O(1) primary key lookups.
+ * - Global Eviction: A single LRUCache tracks all rows across all tables to enforce maxItems.
+ * - O(1) Removals: Uses an index map and swap-and-pop to remove evicted rows without array shifts.
+ */
 export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
-  private storage = new Map<keyof S, ModelCache>();
+  private tables = new Map<keyof S, RowData[]>();
+  private pkIndexes = new Map<keyof S, Map<string, RowData>>();
+  private indexMap = new Map<RowData, number>();
+  private globalLRU: LRUCache<RowData, keyof S & string>;
 
   constructor(
     private schema: S,
     private options?: MemoryAdapterOptions,
-  ) {}
+  ) {
+    this.globalLRU = new LRUCache<RowData, keyof S & string>({
+      max: this.options?.maxItems ?? DEFAULT_MAX_ITEMS,
+      dispose: (model, row, reason) => {
+        if (reason === "evict" || reason === "set") {
+          this.removeFromTable(row, model);
+        }
+      },
+    });
 
-  migrate(): Promise<void> {
     const keys = Object.keys(this.schema) as (keyof S)[];
-    for (const key of keys) {
-      if (!this.storage.has(key)) {
-        this.storage.set(key, new LRUCache({ max: this.options?.maxSize ?? DEFAULT_MAX_SIZE }));
-      }
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]!;
+      this.tables.set(key, []);
+      this.pkIndexes.set(key, new Map());
     }
+  }
+
+  migrate(): Promise<void> {
     return Promise.resolve();
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
-    // MemoryAdapter is synchronous and doesn't support real ACID transactions.
-    // We simply return the current instance to satisfy the interface and
-    // support nesting by reusing the same adapter.
     return fn(this);
   }
 
@@ -49,16 +67,26 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T> {
     const { model, data, select } = args;
-    const cache = this.getModelStorage(model);
-    const pkValue = this.getPrimaryKeyString(model, data);
+    const pkIndex = this.pkIndexes.get(model)!;
+    const pkValue = this.serializePK(model, data);
 
-    if (cache.has(pkValue)) {
+    if (pkIndex.has(pkValue)) {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
     }
 
     const record: RowData = Object.assign({}, data);
-    cache.set(pkValue, record);
-    return Promise.resolve(this.applySelect<T>(record, select));
+    const heap = this.tables.get(model)!;
+
+    // Add to storage
+    const index = heap.length;
+    heap.push(record);
+    pkIndex.set(pkValue, record);
+    this.indexMap.set(record, index);
+
+    // Add to global LRU for eviction tracking
+    this.globalLRU.set(record, model);
+
+    return Promise.resolve(this.applySelect(record, select));
   }
 
   find<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
@@ -67,11 +95,31 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T | null> {
     const { model, where, select } = args;
-    const cache = this.getModelStorage(model);
 
-    for (const [, value] of cache.entries()) {
+    // Fast path: PK lookup
+    const pkFields = getPrimaryKeyFields(this.schema[model]!);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- checking for field-based clause
+    const w = where as { field?: string; op?: string; value?: unknown };
+    if (
+      w.field !== undefined &&
+      pkFields.length === 1 &&
+      w.field === pkFields[0] &&
+      w.op === "eq"
+    ) {
+      const pkValue = String(w.value);
+      const row = this.pkIndexes.get(model)!.get(pkValue);
+      if (row && this.matchesWhere(where, row)) {
+        this.globalLRU.get(row); // Touch for LRU
+        return Promise.resolve(this.applySelect(row, select));
+      }
+    }
+
+    const heap = this.tables.get(model)!;
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
-        return Promise.resolve(this.applySelect<T>(value, select));
+        this.globalLRU.get(value); // Touch for LRU
+        return Promise.resolve(this.applySelect(value, select));
       }
     }
     return Promise.resolve(null);
@@ -87,32 +135,34 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor?: Cursor<T>;
   }): Promise<T[]> {
     const { model, where, select, sortBy, limit, offset, cursor } = args;
-    const cache = this.getModelStorage(model);
+    const heap = this.tables.get(model)!;
 
-    let results: RowData[] = [];
-    for (const [, value] of cache.entries()) {
+    const results: RowData[] = [];
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
         results.push(value);
       }
     }
 
+    let out: RowData[] = results;
     if (cursor !== undefined) {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, which matches the Record key type
-      results = this.applyCursor(results, cursor, sortBy as SortBy[] | undefined);
+      out = this.applyCursor(out, cursor, sortBy);
     }
 
     if (sortBy !== undefined && sortBy.length > 0) {
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SortBy<T>.field is a subtype of string, which matches the Record key type
-      results = this.applySort(results, sortBy as SortBy[]);
+      out = this.applySort(out, sortBy);
     }
 
     const start = offset ?? 0;
-    const end = limit === undefined ? results.length : start + limit;
-    const out: T[] = [];
-    for (let i = start; i < end && i < results.length; i++) {
-      out.push(this.applySelect<T>(results[i]!, select));
+    const end = limit === undefined ? out.length : start + limit;
+    const final: T[] = [];
+    for (let i = start; i < end && i < out.length; i++) {
+      const r = out[i]!;
+      this.globalLRU.get(r); // Touch for LRU
+      final.push(this.applySelect<T>(r, select));
     }
-    return Promise.resolve(out);
+    return Promise.resolve(final);
   }
 
   update<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
@@ -121,13 +171,14 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     data: Partial<T>;
   }): Promise<T | null> {
     const { model, where, data } = args;
-    assertNoPrimaryKeyUpdates(this.getModel(model), data);
-    const cache = this.getModelStorage(model);
+    assertNoPrimaryKeyUpdates(this.schema[model]!, data);
+    const heap = this.tables.get(model)!;
 
-    for (const [key, value] of cache.entries()) {
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
-        const updated: RowData = Object.assign({}, value, data);
-        cache.set(key, updated);
+        const updated: RowData = Object.assign(value, data);
+        this.globalLRU.set(updated, model); // Update in LRU
         return Promise.resolve(this.applySelect<T>(updated));
       }
     }
@@ -139,21 +190,19 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T>; data: Partial<T> }): Promise<number> {
     const { model, where, data } = args;
-    assertNoPrimaryKeyUpdates(this.getModel(model), data);
-    const cache = this.getModelStorage(model);
+    assertNoPrimaryKeyUpdates(this.schema[model]!, data);
+    const heap = this.tables.get(model)!;
 
-    // Collect first, then mutate — avoids mutation during iteration
-    const matches: { key: string; value: RowData }[] = [];
-    for (const [key, value] of cache.entries()) {
+    let count = 0;
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
-        matches.push({ key, value });
+        Object.assign(value, data);
+        this.globalLRU.set(value, model); // Update in LRU
+        count++;
       }
     }
-    for (let i = 0; i < matches.length; i++) {
-      const m = matches[i]!;
-      cache.set(m.key, Object.assign({}, m.value, data));
-    }
-    return Promise.resolve(matches.length);
+    return Promise.resolve(count);
   }
 
   upsert<K extends keyof S & string, T extends Record<string, unknown> = InferModel<S[K]>>(args: {
@@ -164,20 +213,17 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T> {
     const { model, create, update, where, select } = args;
-    const modelSpec = this.getModel(model);
-    assertNoPrimaryKeyUpdates(modelSpec, update);
-
-    const pkValue = this.getPrimaryKeyString(model, create);
-    const cache = this.getModelStorage(model);
-    const existing = cache.get(pkValue);
+    const pkValue = this.serializePK(model, create);
+    const existing = this.pkIndexes.get(model)!.get(pkValue);
 
     if (existing !== undefined) {
       if (this.matchesWhere(where, existing)) {
-        const updated: RowData = Object.assign({}, existing, update);
-        cache.set(pkValue, updated);
-        return Promise.resolve(this.applySelect<T>(updated, select));
+        const updated: RowData = Object.assign(existing, update);
+        this.globalLRU.set(updated, model);
+        return Promise.resolve(this.applySelect(updated, select));
       }
-      return Promise.resolve(this.applySelect<T>(existing, select));
+      this.globalLRU.get(existing);
+      return Promise.resolve(this.applySelect(existing, select));
     }
 
     return this.create({ model, data: create, select });
@@ -188,11 +234,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where: Where<T>;
   }): Promise<void> {
     const { model, where } = args;
-    const cache = this.getModelStorage(model);
+    const heap = this.tables.get(model)!;
 
-    for (const [key, value] of cache.entries()) {
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
-        cache.delete(key);
+        this.globalLRU.delete(value);
+        this.removeFromTable(value, model);
         return Promise.resolve();
       }
     }
@@ -204,16 +252,19 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     T extends Record<string, unknown> = InferModel<S[K]>,
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model, where } = args;
-    const cache = this.getModelStorage(model);
-    const toDelete: string[] = [];
+    const heap = this.tables.get(model)!;
+    const toDelete: RowData[] = [];
 
-    for (const [key, value] of cache.entries()) {
+    for (let i = 0; i < heap.length; i++) {
+      const value = heap[i]!;
       if (this.matchesWhere(where, value)) {
-        toDelete.push(key);
+        toDelete.push(value);
       }
     }
     for (let i = 0; i < toDelete.length; i++) {
-      cache.delete(toDelete[i]!);
+      const row = toDelete[i]!;
+      this.globalLRU.delete(row);
+      this.removeFromTable(row, model);
     }
     return Promise.resolve(toDelete.length);
   }
@@ -223,37 +274,45 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     where?: Where<T>;
   }): Promise<number> {
     const { model, where } = args;
-    const cache = this.getModelStorage(model);
+    const heap = this.tables.get(model)!;
 
-    if (where === undefined) return Promise.resolve(cache.size);
+    if (where === undefined) {
+      return Promise.resolve(heap.length);
+    }
 
     let count = 0;
-    for (const [, value] of cache.entries()) {
-      if (this.matchesWhere(where, value)) count++;
+    for (let i = 0; i < heap.length; i++) {
+      if (this.matchesWhere(where, heap[i]!)) count++;
     }
     return Promise.resolve(count);
   }
 
   // --- Private helpers ---
 
-  private getModelStorage(model: string): ModelCache {
-    const storage = this.storage.get(model);
-    if (storage === undefined) {
-      throw new Error(`Model ${model} not initialized. Call migrate() first.`);
-    }
-    return storage;
-  }
+  private removeFromTable(row: RowData, model: keyof S & string) {
+    const heap = this.tables.get(model);
+    const pkIndex = this.pkIndexes.get(model);
+    if (!heap || !pkIndex) return;
+
+    const idx = this.indexMap.get(row);
+    if (idx === undefined) return;
 
-  private getModel(model: string): S[keyof S & string] {
-    const spec = this.schema[model as keyof S & string];
-    if (spec === undefined) throw new Error(`Model ${model} not found in schema`);
-    return spec;
+    // Swap-and-pop
+    const lastRow = heap.at(-1)!;
+    heap[idx] = lastRow;
+    this.indexMap.set(lastRow, idx);
+    heap.pop();
+
+    // Cleanup indexes
+    this.indexMap.delete(row);
+    const pkValue = this.serializePK(model, row);
+    pkIndex.delete(pkValue);
   }
 
-  private getPrimaryKeyString(modelName: string, data: Record<string, unknown>): string {
-    const model = this.getModel(modelName);
-    const pkValues = getIdentityValues(model, data);
-    const pkFields = getPrimaryKeyFields(model);
+  private serializePK(modelName: string, data: Record<string, unknown>): string {
+    const modelSpec = this.schema[modelName as keyof S & string]!;
+    const pkValues = getIdentityValues(modelSpec, data);
+    const pkFields = getPrimaryKeyFields(modelSpec);
     let res = "";
     for (let i = 0; i < pkFields.length; i++) {
       if (i > 0) res += "|";
@@ -269,26 +328,29 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return res;
   }
 
-  /**
-   * Checks if a record matches a Where filter.
-   * Accepts Where<T> for any T — since RowData is Record<string, unknown>,
-   * all field names are valid string keys. This avoids repeated generic casts.
-   */
-  private matchesWhere(where: Where | undefined, record: RowData): boolean {
+  private matchesWhere<T extends Record<string, unknown>>(
+    where: Where<T> | undefined,
+    record: RowData,
+  ): boolean {
     if (where === undefined) return true;
     return this.evaluateWhere(where, record);
   }
 
-  private evaluateWhere(where: Where, record: RowData): boolean {
+  private evaluateWhere<T extends Record<string, unknown>>(
+    where: Where<T>,
+    record: RowData,
+  ): boolean {
     if ("and" in where) {
-      for (let i = 0; i < where.and.length; i++) {
-        if (!this.evaluateWhere(where.and[i]!, record)) return false;
+      const and = (where as { and: Where<T>[] }).and;
+      for (let i = 0; i < and.length; i++) {
+        if (!this.evaluateWhere(and[i]!, record)) return false;
       }
       return true;
     }
     if ("or" in where) {
-      for (let i = 0; i < where.or.length; i++) {
-        if (this.evaluateWhere(where.or[i]!, record)) return true;
+      const or = (where as { or: Where<T>[] }).or;
+      for (let i = 0; i < or.length; i++) {
+        if (this.evaluateWhere(or[i]!, record)) return true;
       }
       return false;
     }
@@ -316,39 +378,45 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     return false;
   }
 
-  /**
-   * Projects a record to the selected fields, returning a shallow copy.
-   * The `as T` casts are intentional: storage holds RowData but the adapter
-   * interface promises T. This is the single boundary where the cast occurs.
-   */
   private applySelect<T extends Record<string, unknown>>(record: RowData, select?: Select<T>): T {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- record is mapped to T via shallow copy and optional projection
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- record matches shape of T
     if (select === undefined) return Object.assign({}, record) as T;
     const res: RowData = {};
     for (let i = 0; i < select.length; i++) {
       const k = select[i]!;
-      res[k] = record[k] ?? null;
+      res[k as string] = record[k as string] ?? null;
     }
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- record is mapped to T via shallow copy and optional projection
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- projection matches T
     return res as T;
   }
 
-  private applyCursor(results: RowData[], cursor: Cursor, sortBy?: SortBy[]): RowData[] {
-    const paginationWhere = getPaginationFilter(cursor, sortBy);
+  private applyCursor<T extends Record<string, unknown>>(
+    results: RowData[],
+    cursor: Cursor<T>,
+    sortBy?: SortBy<T>[],
+  ): RowData[] {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- cursor and sortBy are structurally compatible with non-generic variants
+    const paginationWhere = getPaginationFilter(cursor as Cursor, sortBy as SortBy[]);
     if (!paginationWhere) return results;
 
     const filtered: RowData[] = [];
     for (let i = 0; i < results.length; i++) {
       const record = results[i]!;
-      if (this.evaluateWhere(paginationWhere, record)) {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- paginationWhere matches the record shape
+      if (this.evaluateWhere(paginationWhere as Where<T>, record)) {
         filtered.push(record);
       }
     }
     return filtered;
   }
 
-  private applySort(results: RowData[], sortBy: SortBy[]): RowData[] {
-    return results.toSorted((a, b) => {
+  private applySort<T extends Record<string, unknown>>(
+    results: RowData[],
+    sortBy: SortBy<T>[],
+  ): RowData[] {
+    const sorted = results.slice();
+    // eslint-disable-next-line unicorn/no-array-sort -- sorting a shallow copy
+    sorted.sort((a, b) => {
       for (let i = 0; i < sortBy.length; i++) {
         const s = sortBy[i]!;
         const valA = getNestedValue(a, s.field, s.path);
@@ -360,13 +428,10 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
       }
       return 0;
     });
+    return sorted;
   }
 }
 
-/**
- * Null-safe comparison of primitive values.
- * Treats null/undefined as the smallest possible values.
- */
 function compareValues(left: unknown, right: unknown): number {
   if (left === right) return 0;
   if (left === undefined || left === null) return -1;
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index 7fc4947..e3aa28c 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -18,20 +18,33 @@ import {
   getIdentityValues,
   getPaginationFilter,
   getPrimaryKeyFields,
-} from "./common";
-import { type QueryExecutor, isQueryExecutor, toRow } from "./sql";
+} from "./utils/common";
+import {
+  type QueryExecutor,
+  isQueryExecutor,
+  toRow,
+  toDbRow,
+  type Fragment,
+  type QuotedSchema,
+  createQuotedSchema,
+  join,
+  wrap,
+} from "./utils/sql";
 
 type PostgresJsSql = postgres.Sql;
 type TransactionSql = postgres.TransactionSql;
 
 export type PostgresDriver = PgClient | PgPool | PgPoolClient | PostgresJsSql | TransactionSql;
 
-const MAX_CACHE_SIZE = 100;
+/**
+ * Limits the number of prepared statement objects kept in memory to prevent leaks
+ * while allowing statement reuse for performance.
+ */
+const MAX_CACHED_STATEMENTS = 100;
 
 // --- Internal PG Syntax Helpers ---
 
 const quote = (s: string) => `"${s.replaceAll('"', '""')}"`;
-const placeholder = (i: number) => `$${i + 1}`;
 
 function mapFieldType(field: Field): string {
   switch (field.type) {
@@ -51,92 +64,99 @@ function mapFieldType(field: Field): string {
   }
 }
 
-function jsonExtract(
-  column: string,
-  path: string[],
-  isNumeric?: boolean,
-  isBoolean?: boolean,
-): string {
-  let segments = "";
-  for (let i = 0; i < path.length; i++) {
-    if (i > 0) segments += ", ";
-    segments += `'${path[i]!.replaceAll("'", "''")}'`;
-  }
-  const base = `jsonb_extract_path_text(${column}, ${segments})`;
-  if (isNumeric === true) return `(${base})::double precision`;
-  if (isBoolean === true) return `(${base})::boolean`;
-  return base;
-}
-
-function toColumnExpr(model: Model, fieldName: string, path?: string[], value?: unknown): string {
-  if (!path || path.length === 0) return quote(fieldName);
+function toColumnExpr(
+  model: Model,
+  fieldName: string,
+  path?: string[],
+  value?: unknown,
+  quoteFn: (s: string) => string = quote,
+): Fragment {
+  const quoted = quoteFn(fieldName);
+  if (!path || path.length === 0) return { strings: [quoted], params: [] };
   const field = model.fields[fieldName];
   if (field?.type !== "json" && field?.type !== "json[]") {
     throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
   }
-  return jsonExtract(quote(fieldName), path, typeof value === "number", typeof value === "boolean");
+
+  const isNumeric = typeof value === "number";
+  const isBoolean = typeof value === "boolean";
+
+  const strings = [
+    `jsonb_extract_path_text(${quoted}, `,
+    // eslint-disable-next-line unicorn/no-new-array -- creating array of specific length for placeholders
+    ...new Array<string>(path.length - 1).fill(", "),
+    ")",
+  ];
+  if (isNumeric) {
+    strings[0] = "(" + strings[0]!;
+    strings[strings.length - 1] += ")::double precision";
+  } else if (isBoolean) {
+    strings[0] = "(" + strings[0]!;
+    strings[strings.length - 1] += ")::boolean";
+  }
+  return { strings, params: path };
 }
 
 function toWhereRecursive(
   model: Model,
   where: Where,
-  startIndex: number,
-): { sql: string; params: unknown[] } {
+  quoteFn: (s: string) => string = quote,
+): Fragment {
   if ("and" in where) {
-    const parts = [];
-    const params = [];
-    let currentIdx = startIndex;
+    const parts: Fragment[] = [];
     for (let i = 0; i < where.and.length; i++) {
-      const built = toWhereRecursive(model, where.and[i]!, currentIdx);
-      parts.push(`(${built.sql})`);
-      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-      currentIdx += built.params.length;
+      parts.push(wrap(toWhereRecursive(model, where.and[i]!, quoteFn), "(", ")"));
     }
-    return { sql: parts.join(" AND "), params };
+    return join(parts, " AND ");
   }
 
   if ("or" in where) {
-    const parts = [];
-    const params = [];
-    let currentIdx = startIndex;
+    const parts: Fragment[] = [];
     for (let i = 0; i < where.or.length; i++) {
-      const built = toWhereRecursive(model, where.or[i]!, currentIdx);
-      parts.push(`(${built.sql})`);
-      for (let j = 0; j < built.params.length; j++) params.push(built.params[j]);
-      currentIdx += built.params.length;
+      parts.push(wrap(toWhereRecursive(model, where.or[i]!, quoteFn), "(", ")"));
     }
-    return { sql: parts.join(" OR "), params };
+    return join(parts, " OR ");
   }
 
-  const expr = toColumnExpr(model, where.field, where.path, where.value);
+  const expr = toColumnExpr(model, where.field, where.path, where.value, quoteFn);
   const val = where.value;
 
   switch (where.op) {
     case "eq":
-      if (val === null) return { sql: `${expr} IS NULL`, params: [] };
-      return { sql: `${expr} = ${placeholder(startIndex)}`, params: [val] };
+      if (val === null) return wrap(expr, "", " IS NULL");
+      return join([expr, { strings: [" = ", ""], params: [val] }], "");
     case "ne":
-      if (val === null) return { sql: `${expr} IS NOT NULL`, params: [] };
-      return { sql: `${expr} != ${placeholder(startIndex)}`, params: [val] };
+      if (val === null) return wrap(expr, "", " IS NOT NULL");
+      return join([expr, { strings: [" != ", ""], params: [val] }], "");
     case "gt":
-      return { sql: `${expr} > ${placeholder(startIndex)}`, params: [val] };
+      return join([expr, { strings: [" > ", ""], params: [val] }], "");
     case "gte":
-      return { sql: `${expr} >= ${placeholder(startIndex)}`, params: [val] };
+      return join([expr, { strings: [" >= ", ""], params: [val] }], "");
     case "lt":
-      return { sql: `${expr} < ${placeholder(startIndex)}`, params: [val] };
+      return join([expr, { strings: [" < ", ""], params: [val] }], "");
     case "lte":
-      return { sql: `${expr} <= ${placeholder(startIndex)}`, params: [val] };
+      return join([expr, { strings: [" <= ", ""], params: [val] }], "");
     case "in": {
-      if (!Array.isArray(val) || val.length === 0) return { sql: "1=0", params: [] };
-      const phs = [];
-      for (let i = 0; i < val.length; i++) phs.push(placeholder(startIndex + i));
-      return { sql: `${expr} IN (${phs.join(", ")})`, params: val };
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- val cast to unknown array for in operator
+      const vArr = val as unknown[];
+      if (!Array.isArray(vArr) || vArr.length === 0) return { strings: ["1=0"], params: [] };
+      const inFrag: Fragment = {
+        // eslint-disable-next-line unicorn/no-new-array -- creating array of specific length for placeholders
+        strings: [" IN (", ...new Array<string>(vArr.length - 1).fill(", "), ")"],
+        params: vArr,
+      };
+      return join([expr, inFrag], "");
     }
     case "not_in": {
-      if (!Array.isArray(val) || val.length === 0) return { sql: "1=1", params: [] };
-      const phs = [];
-      for (let i = 0; i < val.length; i++) phs.push(placeholder(startIndex + i));
-      return { sql: `${expr} NOT IN (${phs.join(", ")})`, params: val };
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- val cast to unknown array for not_in operator
+      const vArr = val as unknown[];
+      if (!Array.isArray(vArr) || vArr.length === 0) return { strings: ["1=1"], params: [] };
+      const inFrag: Fragment = {
+        // eslint-disable-next-line unicorn/no-new-array -- creating array of specific length for placeholders
+        strings: [" NOT IN (", ...new Array<string>(vArr.length - 1).fill(", "), ")"],
+        params: vArr,
+      };
+      return join([expr, inFrag], "");
     }
     default:
       throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
@@ -148,61 +168,25 @@ function toWhere(
   where?: Where,
   cursor?: Cursor,
   sortBy?: SortBy[],
-  startIndex = 0,
-): { sql: string; params: unknown[] } {
-  const parts: string[] = [];
-  const params: unknown[] = [];
-  let nextIndex = startIndex;
+  quoteFn: (s: string) => string = quote,
+): Fragment {
+  const parts: Fragment[] = [];
 
   if (where) {
-    const built = toWhereRecursive(model, where, nextIndex);
-    parts.push(`(${built.sql})`);
-    for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-    nextIndex += built.params.length;
+    parts.push(wrap(toWhereRecursive(model, where, quoteFn), "(", ")"));
   }
 
   if (cursor) {
     const paginationWhere = getPaginationFilter(cursor, sortBy);
     if (paginationWhere) {
-      const built = toWhereRecursive(model, paginationWhere, nextIndex);
-      parts.push(`(${built.sql})`);
-      for (let i = 0; i < built.params.length; i++) params.push(built.params[i]);
-      nextIndex += built.params.length;
+      parts.push(wrap(toWhereRecursive(model, paginationWhere, quoteFn), "(", ")"));
     }
   }
 
-  return { sql: parts.length > 0 ? parts.join(" AND ") : "1=1", params };
-}
-
-function toInput(
-  fields: Record<string, Field>,
-  data: Record<string, unknown>,
-): Record<string, unknown> {
-  const res: Record<string, unknown> = {};
-  const keys = Object.keys(data);
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i]!;
-    const val = data[k];
-    const spec = fields[k];
-    if (val === undefined) continue;
-    if (val === null) {
-      res[k] = null;
-      continue;
-    }
-    if (spec?.type === "json" || spec?.type === "json[]") {
-      res[k] = JSON.stringify(val);
-    } else {
-      res[k] = val;
-    }
-  }
-  return res;
+  return parts.length > 0 ? join(parts, " AND ") : { strings: ["1=1"], params: [] };
 }
 
 // --- Driver detection ---
-// Bun SQL: has `unsafe` + `transaction` (and `begin`).
-// postgres.js: has `unsafe` + `begin`, but NOT `transaction`.
-// pg: has `query`.
-// Order matters: check Bun SQL first (most specific), then postgres.js, then pg.
 
 function isBunSql(driver: PostgresDriver): boolean {
   return "unsafe" in driver && "transaction" in driver;
@@ -218,33 +202,39 @@ function isPg(driver: PostgresDriver): driver is PgClient | PgPool | PgPoolClien
 
 // --- Executor factories ---
 
-// postgres.js: uses `sql.unsafe(query, params, { prepare: true })` for server-side
-// prepared statements. The driver manages statement name caching internally.
-// Works for both Sql (top-level) and TransactionSql (inside begin/savepoint) since
-// both extend ISql which provides `unsafe()`.
 function createPostgresJsExecutor(
   sql: postgres.Sql | postgres.TransactionSql,
   inTransaction = false,
 ): QueryExecutor {
-  const run = (query: string, params?: unknown[]) =>
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js params type is a stricter version of unknown[]
-    sql.unsafe(query, params as postgres.ParameterOrJSON<never>[], { prepare: true });
+  const runQuery = (query: Fragment) => {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- constructing TemplateStringsArray for driver call
+    const strings = query.strings as string[] & { raw: string[] };
+    strings.raw = query.strings;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion, typescript-eslint/no-unsafe-return -- calling driver as tagged template function to avoid .unsafe()
+    const run = sql as (
+      strings: TemplateStringsArray,
+      ...params: unknown[]
+    ) => Promise<Record<string, unknown>[]>;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- TemplateStringsArray is required by the driver's tagged template signature
+    return run(strings as unknown as TemplateStringsArray, ...query.params);
+  };
 
   return {
-    all: async (query, params) => {
-      const rows = await run(query, params);
-      return rows as Record<string, unknown>[];
+    all: (query) => {
+      return runQuery(query);
     },
-    get: async (query, params) => {
-      const rows = await run(query, params);
-      return rows[0] as Record<string, unknown> | undefined;
+    get: async (query) => {
+      const rows = await runQuery(query);
+      return rows[0];
     },
-    run: async (query, params) => {
-      const rows = await run(query, params);
-      return { changes: rows.count ?? 0 };
+    run: async (query) => {
+      // eslint-disable-next-line typescript-eslint/no-unsafe-assignment -- driver returns result with count/affectedRows
+      const rows = await runQuery(query);
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- postgres.js returns result with .count
+      const r = rows as unknown as { count?: number };
+      return { changes: r.count ?? 0 };
     },
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) => {
-      // Top-level Sql uses begin(); TransactionSql uses savepoint() for nesting
       if ("begin" in sql) {
         // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- T matches return type of fn
         return sql.begin((tx) => fn(createPostgresJsExecutor(tx, true))) as Promise<T>;
@@ -256,54 +246,50 @@ function createPostgresJsExecutor(
   };
 }
 
-// Bun SQL: uses `sql.unsafe(query, params)`. No prepare option — the driver
-// manages prepared statements internally.
 function createBunSqlExecutor(
   driver: Record<string, unknown>,
   inTransaction = false,
 ): QueryExecutor {
+  // Bun SQL driver is a callable function that also has a .transaction() method
   // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isBunSql
-  const unsafeFn = driver["unsafe"] as (
-    query: string,
-    params?: unknown[],
-  ) => Promise<
-    Record<string, unknown>[] & { count?: number; affectedRows?: number; command?: string }
-  >;
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isBunSql
-  const transactionFn = driver["transaction"] as (
-    cb: (tx: unknown) => Promise<unknown>,
-  ) => Promise<unknown>;
+  const bunSql = driver as unknown as ((
+    strings: TemplateStringsArray,
+    ...params: unknown[]
+  ) => Promise<Record<string, unknown>[]>) & {
+    transaction: <T>(fn: (tx: Record<string, unknown>) => Promise<T>) => Promise<T>;
+  };
+
+  const runQuery = (query: Fragment) => {
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- constructing TemplateStringsArray for driver call
+    const strings = query.strings as string[] & { raw: string[] };
+    strings.raw = query.strings;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver call expects TemplateStringsArray
+    return bunSql(strings as unknown as TemplateStringsArray, ...query.params);
+  };
 
   return {
-    all: (query, params) => unsafeFn(query, params),
-    get: async (query, params) => {
-      const rows = await unsafeFn(query, params);
+    all: (query) => runQuery(query),
+    get: async (query) => {
+      const rows = await runQuery(query);
       return rows[0];
     },
-    run: async (query, params) => {
-      const rows = await unsafeFn(query, params);
-      let changes = rows.affectedRows ?? rows.count ?? 0;
-
-      // Special treat for GreptimeDB over Postgres wire protocol:
-      // command string might be "OK 1" while count/affectedRows is 0.
-      if (changes === 0 && rows.command !== undefined && rows.command.startsWith("OK ")) {
-        const parsed = parseInt(rows.command.slice(3), 10);
+    run: async (query) => {
+      const rows = await runQuery(query);
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver result has count/affectedRows/command
+      const r = rows as unknown as { affectedRows?: number; count?: number; command?: string };
+      let changes = r.affectedRows ?? r.count ?? 0;
+      if (changes === 0 && r.command !== undefined && r.command.startsWith("OK ")) {
+        const parsed = parseInt(r.command.slice(3), 10);
         if (!isNaN(parsed)) changes = parsed;
       }
       return { changes };
     },
     transaction: <T>(fn: (executor: QueryExecutor) => Promise<T>) =>
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- T matches return type of fn
-      transactionFn((tx) =>
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Bun SQL transaction provides a driver-like object
-        fn(createBunSqlExecutor(tx as Record<string, unknown>, true)),
-      ) as Promise<T>,
+      bunSql.transaction((tx) => fn(createBunSqlExecutor(tx, true))),
     inTransaction,
   };
 }
 
-// pg: uses named queries with a bounded LRU cache for server-side prepared
-// statement reuse. Each unique SQL string gets a stable name (e.g. `q_0`).
 function createPgExecutor(
   driver: PgClient | PgPool | PgPoolClient,
   inTransaction = false,
@@ -311,30 +297,37 @@ function createPgExecutor(
   const cache = new Map<string, string>();
   let statementCount = 0;
 
-  function getQuery(sql: string, values?: unknown[]) {
-    let name = cache.get(sql);
+  function getQuery(query: Fragment) {
+    // pg needs a single string with $1, $2 placeholders
+    const text = query.strings.reduce(
+      (acc, s, i) => acc + s + (i < query.params.length ? "$" + (i + 1) : ""),
+      "",
+    );
+    const values = query.params;
+
+    let name = cache.get(text);
     if (name === undefined) {
-      if (cache.size >= MAX_CACHE_SIZE) {
+      if (cache.size >= MAX_CACHED_STATEMENTS) {
         const first = cache.keys().next();
         if (first.done !== true) cache.delete(first.value);
       }
       name = `q_${statementCount++}`;
-      cache.set(sql, name);
+      cache.set(text, name);
     }
-    return { name, text: sql, values };
+    return { name, text, values };
   }
 
   return {
-    all: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>(getQuery(sql, params));
+    all: async (q) => {
+      const res = await driver.query<Record<string, unknown>>(getQuery(q));
       return res.rows;
     },
-    get: async (sql, params) => {
-      const res = await driver.query<Record<string, unknown>>(getQuery(sql, params));
+    get: async (q) => {
+      const res = await driver.query<Record<string, unknown>>(getQuery(q));
       return res.rows[0];
     },
-    run: async (sql, params) => {
-      const res = await driver.query(getQuery(sql, params));
+    run: async (q) => {
+      const res = await driver.query(getQuery(q));
       return { changes: res.rowCount ?? 0 };
     },
     transaction: async (fn) => {
@@ -378,16 +371,38 @@ function createPostgresExecutor(driver: PostgresDriver): QueryExecutor {
 
 // --- Adapter ---
 
+/**
+ * Postgres Adapter for no-orm.
+ *
+ * Notes:
+ * - Sequential DDL: Create tables first, then indexes.
+ * - SQLite stores JSON as text; Postgres stores JSON as jsonb.
+ * - Driver support: node-postgres (pg), postgres.js, and Bun.SQL.
+ * - upsert always conflicts on the Primary Key.
+ * - Optional where in upsert acts as a predicate -- record is only updated if condition is met.
+ * - Primary-key updates are rejected to keep adapter behavior consistent.
+ * - number and timestamp use standard JavaScript Number. bigint is not supported in v1.
+ */
 export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   private executor: QueryExecutor;
 
   constructor(
     private schema: S,
     driver: PostgresDriver | QueryExecutor,
+    private quoted: QuotedSchema = createQuotedSchema(schema, quote),
   ) {
     this.executor = isQueryExecutor(driver) ? driver : createPostgresExecutor(driver);
   }
 
+  private getQuotedModel(name: keyof S): string {
+    const key = String(name);
+    return this.quoted.models[key] ?? quote(key);
+  }
+
+  private getQuotedField(model: keyof S, field: string): string {
+    return this.quoted.fields[String(model)]?.[field] ?? quote(field);
+  }
+
   async migrate(): Promise<void> {
     const models = Object.entries(this.schema);
 
@@ -396,18 +411,22 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     for (let i = 0; i < models.length; i++) {
       const [name, model] = models[i]!;
       const fields = Object.entries(model.fields);
-      const columns: string[] = [];
+      const columnParts: string[] = [];
       for (let j = 0; j < fields.length; j++) {
         const [fieldName, field] = fields[j]!;
+        const type = mapFieldType(field);
         const nullable = field.nullable === true ? "" : " NOT NULL";
-        columns.push(`${quote(fieldName)} ${mapFieldType(field)}${nullable}`);
+        columnParts.push(`${this.getQuotedField(name as keyof S, fieldName)} ${type}${nullable}`);
       }
       const pkFields = getPrimaryKeyFields(model);
-      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
+      const pk = `PRIMARY KEY (${pkFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
       // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-      await this.executor.run(
-        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
-      );
+      await this.executor.run({
+        strings: [
+          `CREATE TABLE IF NOT EXISTS ${this.getQuotedModel(name as keyof S)} (${columnParts.join(", ")}, ${pk})`,
+        ],
+        params: [],
+      });
     }
 
     // Now create indexes
@@ -418,19 +437,25 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
         const idx = model.indexes[j]!;
         const fields = Array.isArray(idx.field) ? idx.field : [idx.field];
         const formatted = fields.map(
-          (f) => `${quote(f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
+          (f) =>
+            `${this.getQuotedField(name as keyof S, f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
         );
         // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-        await this.executor.run(
-          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${quote(name)} (${formatted.join(", ")})`,
-        );
+        await this.executor.run({
+          strings: [
+            `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${this.getQuotedModel(name as keyof S)} (${formatted.join(", ")})`,
+          ],
+          params: [],
+        });
       }
     }
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
     if (this.executor.inTransaction) return fn(this);
-    return this.executor.transaction((exec) => fn(new PostgresAdapter(this.schema, exec)));
+    return this.executor.transaction((exec) =>
+      fn(new PostgresAdapter(this.schema, exec, this.quoted)),
+    );
   }
 
   async create<
@@ -439,16 +464,19 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
     const { model: modelName, data, select } = args;
     const model = this.schema[modelName]!;
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data);
     const fields = Object.keys(input);
-    const sqlFields = fields.map((f) => quote(f)).join(", ");
-    const sqlValues = fields.map((_, i) => placeholder(i)).join(", ");
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-    const sql = `INSERT INTO ${quote(modelName)} (${sqlFields}) VALUES (${sqlValues}) RETURNING ${sqlSelect}`;
-    const row = await this.executor.get(
-      sql,
-      fields.map((f) => input[f]),
-    );
+    const sqlFields = fields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
+    for (let i = 1; i < fields.length; i++) strings.push(", ");
+    strings.push(`) RETURNING ${sqlSelect}`);
+    const params = fields.map((f) => input[f]);
+
+    const row = await this.executor.get({ strings, params });
     if (row === undefined || row === null) throw new Error("Failed to insert record");
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
     return toRow<T>(model, row, select as Select<Record<string, unknown>>);
@@ -460,10 +488,20 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
     const { model: modelName, where, select } = args;
     const model = this.schema[modelName]!;
-    const built = toWhere(model, where as Where);
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-    const sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql} LIMIT 1`;
-    const row = await this.executor.get(sql, built.params);
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches model fields
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const query = wrap(
+      built,
+      `SELECT ${sqlSelect} FROM ${this.getQuotedModel(modelName)} WHERE `,
+      " LIMIT 1",
+    );
+
+    const row = await this.executor.get(query);
     if (row === undefined || row === null) return null;
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
     return toRow<T>(model, row, select as Select<Record<string, unknown>>);
@@ -483,26 +521,47 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   }): Promise<T[]> {
     const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
     const model = this.schema[modelName]!;
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where/Cursor/SortBy types match at runtime
-    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[]);
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-    let sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql}`;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- input parameters match where/cursor/sortBy shapes
+    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[], quoter);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const query = wrap(
+      built,
+      `SELECT ${sqlSelect} FROM ${this.getQuotedModel(modelName)} WHERE `,
+      "",
+    );
 
     if (sortBy && sortBy.length > 0) {
-      const parts = sortBy.map(
-        (s) => `${toColumnExpr(model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
-      );
-      sql += ` ORDER BY ${parts.join(", ")}`;
+      query.strings[query.strings.length - 1] += " ORDER BY ";
+      for (let i = 0; i < sortBy.length; i++) {
+        const s = sortBy[i]!;
+        const expr = toColumnExpr(model, s.field, s.path, undefined, quoter);
+        const dir = (s.direction ?? "asc").toUpperCase();
+        if (i > 0) query.strings[query.strings.length - 1] += ", ";
+        query.strings[query.strings.length - 1] += expr.strings[0]!;
+        for (let j = 1; j < expr.strings.length; j++) {
+          query.strings.push(expr.strings[j]!);
+        }
+        for (let j = 0; j < expr.params.length; j++) {
+          query.params.push(expr.params[j]);
+        }
+        query.strings[query.strings.length - 1] += ` ${dir}`;
+      }
     }
     if (limit !== undefined) {
-      sql += ` LIMIT ${placeholder(built.params.length)}`;
-      built.params.push(limit);
+      query.strings[query.strings.length - 1] += " LIMIT ";
+      query.strings.push("");
+      query.params.push(limit);
     }
     if (offset !== undefined) {
-      sql += ` OFFSET ${placeholder(built.params.length)}`;
-      built.params.push(offset);
+      query.strings[query.strings.length - 1] += " OFFSET ";
+      query.strings.push("");
+      query.params.push(offset);
     }
-    const rows = await this.executor.all(sql, built.params);
+    const rows = await this.executor.all(query);
 
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
@@ -515,20 +574,36 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   async update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    const { model: modelName, where, data } = args;
+  >(args: { model: K; data: Partial<T>; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model: modelName, data, where } = args;
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, data);
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data);
     const fields = Object.keys(input);
+
     if (fields.length === 0) return this.find({ model: modelName, where, select: undefined });
 
-    const assignments = fields.map((f, i) => `${quote(f)} = ${placeholder(i)}`);
+    const setParts: Fragment[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i]!;
+      setParts.push({
+        strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+        params: [input[f]],
+      });
+    }
+    const setFrag = join(setParts, ", ");
+
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, fields.length);
-    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
-    const row = await this.executor.get(sql, [...fields.map((f) => input[f]), ...built.params]);
-    if (row === undefined || row === null) return null;
+    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = join(
+      [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
+      " WHERE ",
+    );
+    query.strings[query.strings.length - 1] += " RETURNING *";
+
+    const row = await this.executor.get(query);
+    if (row === undefined || row === null) return this.find({ model: modelName, where });
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
     return toRow<T>(model, row);
   }
@@ -540,15 +615,29 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where, data } = args;
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, data);
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data);
     const fields = Object.keys(input);
     if (fields.length === 0) return 0;
 
-    const assignments = fields.map((f, i) => `${quote(f)} = ${placeholder(i)}`);
+    const setParts: Fragment[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i]!;
+      setParts.push({
+        strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+        params: [input[f]],
+      });
+    }
+    const setFrag = join(setParts, ", ");
+
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, fields.length);
-    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql}`;
-    const res = await this.executor.run(sql, [...fields.map((f) => input[f]), ...built.params]);
+    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = join(
+      [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
+      " WHERE ",
+    );
+
+    const res = await this.executor.run(query);
     return res.changes;
   }
 
@@ -566,36 +655,56 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, uData);
 
-    const cInput = toInput(model.fields, cData);
-    const cFields = Object.keys(cInput);
-    const uInput = toInput(model.fields, uData);
-    const uFields = Object.keys(uInput);
+    const insertRow = toDbRow(model, cData);
+    const cFields = Object.keys(insertRow);
+    const updateRow = toDbRow(model, uData);
+    const uFields = Object.keys(updateRow);
     const pkFields = getPrimaryKeyFields(model);
 
-    const sqlColumns = cFields.map((f) => quote(f)).join(", ");
-    const sqlPlaceholders = cFields.map((_, i) => placeholder(i)).join(", ");
-    const sqlConflict = pkFields.map((f) => quote(f)).join(", ");
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-
-    let sql = `INSERT INTO ${quote(modelName)} (${sqlColumns}) VALUES (${sqlPlaceholders}) ON CONFLICT (${sqlConflict}) `;
-    const params = cFields.map((f) => cInput[f]);
+    const sqlFields = cFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlConflict = pkFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+
+    let query: Fragment = {
+      strings: [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`],
+      params: [],
+    };
+    for (let i = 0; i < cFields.length; i++) {
+      if (i > 0) query.strings[query.strings.length - 1] += ", ";
+      query.params.push(insertRow[cFields[i]!]);
+      query.strings.push("");
+    }
+    query.strings[query.strings.length - 1] += `) ON CONFLICT (${sqlConflict}) `;
 
     if (uFields.length > 0) {
-      const assignments = uFields.map((f, i) => `${quote(f)} = ${placeholder(cFields.length + i)}`);
-      params.push(...uFields.map((f) => uInput[f]));
-      sql += `DO UPDATE SET ${assignments.join(", ")}`;
+      const setParts: Fragment[] = [];
+      for (let i = 0; i < uFields.length; i++) {
+        const f = uFields[i]!;
+        setParts.push({
+          strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+          params: [updateRow[f]],
+        });
+      }
+      const setFrag = join(setParts, ", ");
+      query.strings[query.strings.length - 1] += "DO UPDATE SET ";
+      query = join([query, setFrag], "");
+
       if (where) {
+        const quoter = (f: string) => this.getQuotedField(modelName, f);
         // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-        const built = toWhere(model, where as Where, undefined, undefined, params.length);
-        sql += ` WHERE ${built.sql}`;
-        params.push(...built.params);
+        const built = toWhere(model, where as Where, undefined, undefined, quoter);
+        query.strings[query.strings.length - 1] += " WHERE ";
+        query = join([query, built], "");
       }
     } else {
-      sql += "DO NOTHING";
+      query.strings[query.strings.length - 1] += "DO NOTHING";
     }
 
-    sql += ` RETURNING ${sqlSelect}`;
-    const row = await this.executor.get(sql, params);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+    query.strings[query.strings.length - 1] += ` RETURNING ${sqlSelect}`;
+
+    const row = await this.executor.get(query);
     if (row !== undefined && row !== null) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
       return toRow<T>(model, row, select as Select<Record<string, unknown>>);
@@ -603,7 +712,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const existing = await this.find({
       model: modelName,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
       where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
       select,
     });
@@ -617,9 +726,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where: Where<T> }): Promise<void> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    await this.executor.run(`DELETE FROM ${quote(modelName)} WHERE ${built.sql}`, built.params);
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
+    await this.executor.run(query);
   }
 
   async deleteMany<
@@ -628,12 +739,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const res = await this.executor.run(
-      `DELETE FROM ${quote(modelName)} WHERE ${built.sql}`,
-      built.params,
-    );
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
+    const res = await this.executor.run(query);
     return res.changes;
   }
 
@@ -643,12 +753,16 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const row = await this.executor.get(
-      `SELECT COUNT(*) as count FROM ${quote(modelName)} WHERE ${built.sql}`,
-      built.params,
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(
+      built,
+      `SELECT COUNT(*) as count FROM ${this.getQuotedModel(modelName)} WHERE `,
+      "",
     );
-    return row === undefined || row === null ? 0 : Number(row["count"] ?? 0);
+    const row = await this.executor.get(query);
+    const count = row?.["count"];
+    return count === undefined || count === null ? 0 : Number(count);
   }
 }
diff --git a/src/adapters/sql.ts b/src/adapters/sql.ts
deleted file mode 100644
index b02a3e1..0000000
--- a/src/adapters/sql.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import type { Model, Select } from "../types";
-import { mapNumeric } from "./common";
-
-/** Shared contracts for SQL executors */
-
-export interface QueryExecutor {
-  all(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
-  get(sql: string, params?: unknown[]): Promise<Record<string, unknown> | undefined | null>;
-  run(sql: string, params?: unknown[]): Promise<{ changes: number }>;
-  transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
-  readonly inTransaction: boolean;
-}
-
-export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
-  if (typeof obj !== "object" || obj === null) return false;
-  return (
-    "all" in obj &&
-    "run" in obj &&
-    typeof (obj as Record<string, unknown>)["all"] === "function" &&
-    typeof (obj as Record<string, unknown>)["run"] === "function"
-  );
-}
-
-/**
- * Maps a raw database row to the inferred model type T.
- * Handles JSON parsing, boolean conversion, and numeric mapping.
- */
-export function toRow<T extends Record<string, unknown>>(
-  model: Model,
-  row: Record<string, unknown>,
-  select?: Select<Record<string, unknown>>,
-): T {
-  const fields = model.fields;
-  const res: Record<string, unknown> = {};
-  const keys = select ?? Object.keys(row);
-
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i]!;
-    const val = row[k];
-    const spec = fields[k];
-    if (spec === undefined || val === undefined || val === null) {
-      res[k] = val;
-      continue;
-    }
-    if (spec.type === "json" || spec.type === "json[]") {
-      res[k] = typeof val === "string" ? JSON.parse(val) : val;
-    } else if (spec.type === "boolean") {
-      res[k] = val === true || val === 1;
-    } else if (spec.type === "number" || spec.type === "timestamp") {
-      res[k] = mapNumeric(val);
-    } else {
-      res[k] = val;
-    }
-  }
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
-  return res as T;
-}
-
-/**
- * FUTURE EXTENSION: GreptimeDB & MySQL
- *
- * Lessons learned from hebo-gateway and typical SQL quirks:
- *
- * 1. GreptimeDB:
- *    - Supports multiple protocols (Postgres, MySQL). When using Postgres wire protocol
- *      (via `PostgresAdapter`), use double quotes (") for identifiers. When using MySQL
- *      protocol, use backticks (`).
- *    - Mutation responses over Bun.SQL might not populate `count` but provide a `command` string
- *      like "OK 1". Parsed in `postgres.ts`.
- *    - JSON strings can contain Rust-style Unicode escapes (\u{xxxx}) which are invalid JSON.
- *      Empty JSON strings ("") or "{}" should be normalized to {}. To avoid driver crashes,
- *      JSON columns might need to be cast to STRING on the wire (e.g. `col::STRING`).
- *    - DDL: `TIME INDEX` is mandatory. May also need `PARTITION BY`, `WITH` (e.g. merge_mode),
- *      or `SKIPPING INDEX` for performance optimizations.
- *    - JSON: Specialized functions like `json_get_string` might be required instead of
- *      standard Postgres operators like `->>`.
- *
- * 2. MySQL / MariaDB:
- *    - Quoting uses backticks (`) instead of double quotes ("). Note that backticks
- *      within identifiers might need to be escaped by doubling them (``).
- *    - Upsert uses `ON DUPLICATE KEY UPDATE` instead of `ON CONFLICT`.
- *    - Does not support `CREATE INDEX IF NOT EXISTS`. Must be handled via try/catch in `migrate`.
- *    - Does not support `RETURNING`. `create` and `upsert` must fall back to a second `find` call.
- *
- * 3. General SQL:
- *    - Some databases don't support parameters in `LIMIT` clauses. May need a `limitAsLiteral` flag.
- *    - Indexing: Different types like `BRIN` might not support `ASC`/`DESC` or require `USING` syntax.
- */
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index c3c770b..55e798f 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -78,6 +78,30 @@ describe("SqliteAdapter", () => {
       ).toThrow("Primary key updates are not supported.");
     });
 
+    it("should surface unknown write fields as database errors", async () => {
+      try {
+        await adapter.create({
+          model: "users",
+          data: {
+            id: "u1",
+            name: "Alice",
+            age: 30,
+            is_active: true,
+            metadata: null,
+            tags: null,
+            nickname: "Al",
+          } as User & { nickname: string },
+        });
+        expect.unreachable("create should fail for unknown columns");
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+        expect(error.message).toMatch(/nickname/i);
+      }
+    });
+
     it("should delete a record", async () => {
       await adapter.create({
         model: "users",
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index 4b13a7b..febef90 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -20,17 +20,35 @@ import {
   getIdentityValues,
   getPaginationFilter,
   getPrimaryKeyFields,
-} from "./common";
-import { type QueryExecutor, isQueryExecutor, toRow } from "./sql";
+} from "./utils/common";
+import {
+  type QueryExecutor,
+  isQueryExecutor,
+  toRow,
+  toDbRow,
+  type Fragment,
+  type QuotedSchema,
+  createQuotedSchema,
+  join,
+  wrap,
+} from "./utils/sql";
 
 export type SqliteDriver = SqliteDatabase | BunDatabase | BetterSqlite3Database;
 
-const MAX_CACHE_SIZE = 100;
+/**
+ * Limits the number of prepared statement objects kept in memory to prevent leaks
+ * while allowing statement reuse for performance.
+ */
+const MAX_CACHED_STATEMENTS = 100;
 
 // --- Internal SQLite Syntax Helpers ---
 
 const quote = (s: string) => `"${s.replaceAll('"', '""')}"`;
-const placeholder = () => "?";
+
+const mapSqliteValue = (val: unknown, spec: Field) => {
+  if (spec.type === "boolean") return val === true ? 1 : 0;
+  return val;
+};
 
 function mapFieldType(field: Field): string {
   switch (field.type) {
@@ -49,87 +67,105 @@ function mapFieldType(field: Field): string {
   }
 }
 
-function jsonExtract(column: string, path: string[]): string {
+function serializeJsonPath(path: string[]): string {
   let jsonPath = "$";
   for (let i = 0; i < path.length; i++) {
     const segment = path[i]!;
     let isIndex = true;
-    for (let j = 0; j < segment.length; j++) {
-      const c = segment.codePointAt(j);
-      if (c === undefined || c < 48 || c > 57) {
-        isIndex = false;
-        break;
+    if (segment.length === 0) isIndex = false;
+    else {
+      for (let j = 0; j < segment.length; j++) {
+        const c = segment.codePointAt(j);
+        if (c === undefined || c < 48 || c > 57) {
+          isIndex = false;
+          break;
+        }
       }
     }
     if (isIndex) jsonPath += `[${segment}]`;
     else jsonPath += `.${segment}`;
   }
-  return `json_extract(${column}, '${jsonPath}')`;
+  return jsonPath;
 }
 
-function toColumnExpr(model: Model, fieldName: string, path?: string[]): string {
-  if (!path || path.length === 0) return quote(fieldName);
+function toColumnExpr(
+  model: Model,
+  fieldName: string,
+  path?: string[],
+  quoteFn: (s: string) => string = quote,
+): Fragment {
+  const quoted = quoteFn(fieldName);
+  if (!path || path.length === 0) return { strings: [quoted], params: [] };
   const field = model.fields[fieldName];
   if (field?.type !== "json" && field?.type !== "json[]") {
     throw new Error(`Cannot use JSON path on non-JSON field: ${fieldName}`);
   }
-  return jsonExtract(quote(fieldName), path);
+  return { strings: [`json_extract(${quoted}, ?)`], params: [serializeJsonPath(path)] };
 }
 
-function toWhereRecursive(model: Model, where: Where): { sql: string; params: unknown[] } {
+function toWhereRecursive(
+  model: Model,
+  where: Where,
+  quoteFn: (s: string) => string = quote,
+): Fragment {
   if ("and" in where) {
-    const parts = [];
-    const params = [];
+    const parts: Fragment[] = [];
     for (let i = 0; i < where.and.length; i++) {
-      const built = toWhereRecursive(model, where.and[i]!);
-      parts.push(`(${built.sql})`);
-      params.push(...built.params);
+      parts.push(wrap(toWhereRecursive(model, where.and[i]!, quoteFn), "(", ")"));
     }
-    return { sql: parts.join(" AND "), params };
+    return join(parts, " AND ");
   }
 
   if ("or" in where) {
-    const parts = [];
-    const params = [];
+    const parts: Fragment[] = [];
     for (let i = 0; i < where.or.length; i++) {
-      const built = toWhereRecursive(model, where.or[i]!);
-      parts.push(`(${built.sql})`);
-      params.push(...built.params);
+      parts.push(wrap(toWhereRecursive(model, where.or[i]!, quoteFn), "(", ")"));
     }
-    return { sql: parts.join(" OR "), params };
+    return join(parts, " OR ");
   }
 
-  const expr = toColumnExpr(model, where.field, where.path);
+  const expr = toColumnExpr(model, where.field, where.path, quoteFn);
   const val = where.value;
   const mappedVal = typeof val === "boolean" ? (val ? 1 : 0) : val;
 
   switch (where.op) {
     case "eq":
-      if (val === null) return { sql: `${expr} IS NULL`, params: [] };
-      return { sql: `${expr} = ${placeholder()}`, params: [mappedVal] };
+      if (val === null) return wrap(expr, "", " IS NULL");
+      return join([expr, { strings: [" = ", ""], params: [mappedVal] }], "");
     case "ne":
-      if (val === null) return { sql: `${expr} IS NOT NULL`, params: [] };
-      return { sql: `${expr} != ${placeholder()}`, params: [mappedVal] };
+      if (val === null) return wrap(expr, "", " IS NOT NULL");
+      return join([expr, { strings: [" != ", ""], params: [mappedVal] }], "");
     case "gt":
-      return { sql: `${expr} > ${placeholder()}`, params: [mappedVal] };
+      return join([expr, { strings: [" > ", ""], params: [mappedVal] }], "");
     case "gte":
-      return { sql: `${expr} >= ${placeholder()}`, params: [mappedVal] };
+      return join([expr, { strings: [" >= ", ""], params: [mappedVal] }], "");
     case "lt":
-      return { sql: `${expr} < ${placeholder()}`, params: [mappedVal] };
+      return join([expr, { strings: [" < ", ""], params: [mappedVal] }], "");
     case "lte":
-      return { sql: `${expr} <= ${placeholder()}`, params: [mappedVal] };
+      return join([expr, { strings: [" <= ", ""], params: [mappedVal] }], "");
     case "in": {
-      if (!Array.isArray(val) || val.length === 0) return { sql: "1=0", params: [] };
-      const inParams = val.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
-      return { sql: `${expr} IN (${val.map(() => placeholder()).join(", ")})`, params: inParams };
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- val cast to unknown array for in operator
+      const vArr = val as unknown[];
+      if (!Array.isArray(vArr) || vArr.length === 0) return { strings: ["1=0"], params: [] };
+      const inParams = vArr.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
+      const inFrag: Fragment = {
+        // eslint-disable-next-line unicorn/no-new-array -- creating array of specific length for placeholders
+        strings: [" IN (", ...new Array<string>(vArr.length - 1).fill(", "), ")"],
+        params: inParams,
+      };
+      return join([expr, inFrag], "");
     }
     case "not_in": {
-      if (!Array.isArray(val) || val.length === 0) return { sql: "1=1", params: [] };
-      const inParams = val.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
-      return {
-        sql: `${expr} NOT IN (${val.map(() => placeholder()).join(", ")})`,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- val cast to unknown array for not_in operator
+      const vArr = val as unknown[];
+      if (!Array.isArray(vArr) || vArr.length === 0) return { strings: ["1=1"], params: [] };
+      const inParams = vArr.map((v): unknown => (typeof v === "boolean" ? (v ? 1 : 0) : v));
+      const inFrag: Fragment = {
+        // eslint-disable-next-line unicorn/no-new-array -- creating array of specific length for placeholders
+        strings: [" NOT IN (", ...new Array<string>(vArr.length - 1).fill(", "), ")"],
         params: inParams,
       };
+      return join([expr, inFrag], "");
     }
     default:
       throw new Error(`Unsupported operator: ${String((where as Record<string, unknown>)["op"])}`);
@@ -141,69 +177,30 @@ function toWhere(
   where?: Where,
   cursor?: Cursor,
   sortBy?: SortBy[],
-): { sql: string; params: unknown[] } {
-  const parts: string[] = [];
-  const params: unknown[] = [];
+  quoteFn: (s: string) => string = quote,
+): Fragment {
+  const parts: Fragment[] = [];
 
   if (where) {
-    const built = toWhereRecursive(model, where);
-    parts.push(`(${built.sql})`);
-    params.push(...built.params);
+    parts.push(wrap(toWhereRecursive(model, where, quoteFn), "(", ")"));
   }
 
   if (cursor) {
     const paginationWhere = getPaginationFilter(cursor, sortBy);
     if (paginationWhere) {
-      const built = toWhereRecursive(model, paginationWhere);
-      parts.push(`(${built.sql})`);
-      params.push(...built.params);
+      parts.push(wrap(toWhereRecursive(model, paginationWhere, quoteFn), "(", ")"));
     }
   }
 
-  return { sql: parts.length > 0 ? parts.join(" AND ") : "1=1", params };
-}
-
-function toInput(
-  fields: Record<string, Field>,
-  data: Record<string, unknown>,
-): Record<string, unknown> {
-  const res: Record<string, unknown> = {};
-  const keys = Object.keys(data);
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i]!;
-    const val = data[k];
-    const spec = fields[k];
-    if (val === undefined) continue;
-    if (val === null) {
-      res[k] = null;
-      continue;
-    }
-    if (spec?.type === "json" || spec?.type === "json[]") {
-      res[k] = JSON.stringify(val);
-    } else if (spec?.type === "boolean") {
-      res[k] = val === true ? 1 : 0;
-    } else {
-      res[k] = val;
-    }
-  }
-  return res;
+  return parts.length > 0 ? join(parts, " AND ") : { strings: ["1=1"], params: [] };
 }
 
 // --- Driver detection and executors ---
 
-// better-sqlite3 and bun:sqlite are synchronous — they have `prepare` returning a statement
-// with synchronous `.all()`, `.get()`, `.run()` methods.
-// The async `sqlite` package wraps sqlite3 and has async `.all()`, `.get()`, `.run()` directly.
 function isSyncSqlite(driver: SqliteDriver): driver is BunDatabase | BetterSqlite3Database {
   return "prepare" in driver && !("all" in driver);
 }
 
-/**
- * Structural interface for the shared subset of BunDatabase and BetterSqlite3Database
- * `prepare()` APIs. Their full type signatures differ but both satisfy this shape.
- * This allows the adapter to work with both drivers without direct dependencies
- * on their respective type libraries.
- */
 type SyncStatement = {
   all(...params: unknown[]): unknown[];
   get(...params: unknown[]): unknown;
@@ -214,14 +211,13 @@ interface SyncDriver {
   prepare(sql: string): SyncStatement;
 }
 
-// Caches compiled Statement objects per SQL string to avoid re-parsing on every query.
-// Uses a simple Map with FIFO eviction at MAX_CACHE_SIZE.
 function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): QueryExecutor {
   const cache = new Map<string, SyncStatement>();
+
   function getStmt(sql: string): SyncStatement {
     let stmt = cache.get(sql);
     if (stmt === undefined) {
-      if (cache.size >= MAX_CACHE_SIZE) {
+      if (cache.size >= MAX_CACHED_STATEMENTS) {
         const first = cache.keys().next();
         if (first.done !== true) cache.delete(first.value);
       }
@@ -232,19 +228,23 @@ function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): Qu
   }
 
   return {
-    all: (sql, params) => {
-      const result = getStmt(sql).all(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite rows match Record shape
-      return Promise.resolve(result as Record<string, unknown>[]);
+    all: (query) => {
+      const { strings, params } = query;
+      const sql = strings.join("?");
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver result row matches Record shape
+      return Promise.resolve(getStmt(sql).all(...params) as Record<string, unknown>[]);
     },
-    get: (sql, params) => {
-      const result = getStmt(sql).get(...(params ?? []));
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- SQLite row matches Record shape
-      return Promise.resolve(result as Record<string, unknown> | undefined);
+    get: (query) => {
+      const { strings, params } = query;
+      const sql = strings.join("?");
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver returns either a row object or undefined
+      return Promise.resolve(getStmt(sql).get(...params) as Record<string, unknown> | undefined);
     },
-    run: (sql, params) => {
-      const res = getStmt(sql).run(...(params ?? []));
-      return Promise.resolve({ changes: res.changes ?? 0 });
+    run: (query) => {
+      const { strings, params } = query;
+      const sql = strings.join("?");
+      const res = getStmt(sql).run(...params);
+      return Promise.resolve({ changes: res.changes });
     },
     transaction: async (fn) => {
       getStmt("BEGIN").run();
@@ -263,10 +263,12 @@ function createSyncSqliteExecutor(driver: SyncDriver, inTransaction = false): Qu
 
 function createAsyncSqliteExecutor(driver: SqliteDatabase, inTransaction = false): QueryExecutor {
   return {
-    all: (sql, params) => driver.all(sql, params),
-    get: (sql, params) => driver.get(sql, params),
-    run: async (sql, params) => {
-      const res = await driver.run(sql, params);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-return -- async driver returns rows
+    all: (query) => driver.all(query.strings.join("?"), query.params),
+    // eslint-disable-next-line typescript-eslint/no-unsafe-return -- async driver returns row
+    get: (query) => driver.get(query.strings.join("?"), query.params),
+    run: async (query) => {
+      const res = await driver.run(query.strings.join("?"), query.params);
       return { changes: res.changes ?? 0 };
     },
     transaction: async (fn) => {
@@ -285,23 +287,45 @@ function createAsyncSqliteExecutor(driver: SqliteDatabase, inTransaction = false
 }
 
 function createSqliteExecutor(driver: SqliteDriver): QueryExecutor {
-  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked in isSyncSqlite
   if (isSyncSqlite(driver)) return createSyncSqliteExecutor(driver as unknown as SyncDriver);
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- driver is structurally checked
   return createAsyncSqliteExecutor(driver as SqliteDatabase);
 }
 
 // --- Adapter ---
 
+/**
+ * SQLite Adapter for no-orm.
+ *
+ * Notes:
+ * - upsert always conflicts on the Primary Key.
+ * - Optional where in upsert acts as a predicate -- record is only updated if condition is met.
+ * - Primary-key updates are rejected to keep adapter behavior consistent.
+ * - SQLite stores JSON as text; Postgres stores JSON as jsonb.
+ * - number and timestamp use standard JavaScript Number. bigint is not supported in v1.
+ * - DDL must be sequential: some drivers don't support concurrent DDL on one connection.
+ */
 export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   private executor: QueryExecutor;
 
   constructor(
     private schema: S,
     driver: SqliteDriver | QueryExecutor,
+    private quoted: QuotedSchema = createQuotedSchema(schema, quote),
   ) {
     this.executor = isQueryExecutor(driver) ? driver : createSqliteExecutor(driver);
   }
 
+  private getQuotedModel(name: keyof S): string {
+    const key = String(name);
+    return this.quoted.models[key] ?? quote(key);
+  }
+
+  private getQuotedField(model: keyof S, field: string): string {
+    return this.quoted.fields[String(model)]?.[field] ?? quote(field);
+  }
+
   async migrate(): Promise<void> {
     const models = Object.entries(this.schema);
 
@@ -312,14 +336,17 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
       const fields = Object.entries(model.fields);
       const columns = fields.map(
         ([fname, f]) =>
-          `${quote(fname)} ${mapFieldType(f)}${f.nullable === true ? "" : " NOT NULL"}`,
+          `${this.getQuotedField(name as keyof S, fname)} ${mapFieldType(f)}${f.nullable === true ? "" : " NOT NULL"}`,
       );
       const pkFields = getPrimaryKeyFields(model);
-      const pk = `PRIMARY KEY (${pkFields.map((f) => quote(f)).join(", ")})`;
+      const pk = `PRIMARY KEY (${pkFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
       // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-      await this.executor.run(
-        `CREATE TABLE IF NOT EXISTS ${quote(name)} (${columns.join(", ")}, ${pk})`,
-      );
+      await this.executor.run({
+        strings: [
+          `CREATE TABLE IF NOT EXISTS ${this.getQuotedModel(name as keyof S)} (${columns.join(", ")}, ${pk})`,
+        ],
+        params: [],
+      });
     }
 
     // Now create indexes
@@ -330,19 +357,25 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
         const idx = model.indexes[j]!;
         const fields = Array.isArray(idx.field) ? idx.field : [idx.field];
         const formatted = fields.map(
-          (f) => `${quote(f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
+          (f) =>
+            `${this.getQuotedField(name as keyof S, f)}${idx.order ? ` ${idx.order.toUpperCase()}` : ""}`,
         );
         // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
-        await this.executor.run(
-          `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${quote(name)} (${formatted.join(", ")})`,
-        );
+        await this.executor.run({
+          strings: [
+            `CREATE INDEX IF NOT EXISTS ${quote(`idx_${name}_${j}`)} ON ${this.getQuotedModel(name as keyof S)} (${formatted.join(", ")})`,
+          ],
+          params: [],
+        });
       }
     }
   }
 
   transaction<T>(fn: (tx: Adapter<S>) => Promise<T>): Promise<T> {
     if (this.executor.inTransaction) return fn(this);
-    return this.executor.transaction((exec) => fn(new SqliteAdapter(this.schema, exec)));
+    return this.executor.transaction((exec) =>
+      fn(new SqliteAdapter(this.schema, exec, this.quoted)),
+    );
   }
 
   async create<
@@ -351,22 +384,24 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; data: T; select?: Select<T> }): Promise<T> {
     const { model: modelName, data, select } = args;
     const model = this.schema[modelName]!;
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data, mapSqliteValue);
     const fields = Object.keys(input);
-    const sqlFields = fields.map((f) => quote(f)).join(", ");
-    const sqlPlaceholders = fields.map(() => placeholder()).join(", ");
-    const sql = `INSERT INTO ${quote(modelName)} (${sqlFields}) VALUES (${sqlPlaceholders}) RETURNING *`;
-    const row = await this.executor.get(
-      sql,
-      fields.map((f) => input[f]),
-    );
+    const sqlFields = fields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
+    for (let i = 1; i < fields.length; i++) strings.push(", ");
+    strings.push(`) RETURNING ${sqlSelect}`);
+    const params = fields.map((f) => input[f]);
+
+    const row = await this.executor.get({ strings, params });
     if (row === undefined || row === null) {
-      // Fallback for drivers that don't support RETURNING (though Bun/Better-Sqlite3 do)
       const res = await this.find({
         model: modelName,
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
         where: buildIdentityFilter(model, getIdentityValues(model, data)) as Where<T>,
-
         select,
       });
       if (!res) throw new Error("Failed to insert record");
@@ -382,11 +417,20 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where: Where<T>; select?: Select<T> }): Promise<T | null> {
     const { model: modelName, where, select } = args;
     const model = this.schema[modelName]!;
-    const built = toWhere(model, where as Where);
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-    const sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql} LIMIT 1`;
-    const row = await this.executor.get(sql, built.params);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches model fields
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const query = wrap(
+      built,
+      `SELECT ${sqlSelect} FROM ${this.getQuotedModel(modelName)} WHERE `,
+      " LIMIT 1",
+    );
+
+    const row = await this.executor.get(query);
     if (row === undefined || row === null) return null;
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
     return toRow<T>(model, row, select as Select<Record<string, unknown>>);
@@ -406,26 +450,47 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   }): Promise<T[]> {
     const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
     const model = this.schema[modelName]!;
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where/Cursor/SortBy types match at runtime
-    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[]);
-    const sqlSelect = select ? select.map((s) => quote(s)).join(", ") : "*";
-    let sql = `SELECT ${sqlSelect} FROM ${quote(modelName)} WHERE ${built.sql}`;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- input parameters match where/cursor/sortBy shapes
+    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[], quoter);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+
+    const query = wrap(
+      built,
+      `SELECT ${sqlSelect} FROM ${this.getQuotedModel(modelName)} WHERE `,
+      "",
+    );
 
     if (sortBy && sortBy.length > 0) {
-      const parts = sortBy.map(
-        (s) => `${toColumnExpr(model, s.field, s.path)} ${(s.direction ?? "asc").toUpperCase()}`,
-      );
-      sql += ` ORDER BY ${parts.join(", ")}`;
+      query.strings[query.strings.length - 1] += " ORDER BY ";
+      for (let i = 0; i < sortBy.length; i++) {
+        const s = sortBy[i]!;
+        const expr = toColumnExpr(model, s.field, s.path, quoter);
+        const dir = (s.direction ?? "asc").toUpperCase();
+        if (i > 0) query.strings[query.strings.length - 1] += ", ";
+        query.strings[query.strings.length - 1] += expr.strings[0]!;
+        for (let j = 1; j < expr.strings.length; j++) {
+          query.strings.push(expr.strings[j]!);
+        }
+        for (let j = 0; j < expr.params.length; j++) {
+          query.params.push(expr.params[j]);
+        }
+        query.strings[query.strings.length - 1] += ` ${dir}`;
+      }
     }
     if (limit !== undefined) {
-      sql += ` LIMIT ${placeholder()}`;
-      built.params.push(limit);
+      query.strings[query.strings.length - 1] += " LIMIT ";
+      query.strings.push("");
+      query.params.push(limit);
     }
     if (offset !== undefined) {
-      sql += ` OFFSET ${placeholder()}`;
-      built.params.push(offset);
+      query.strings[query.strings.length - 1] += " OFFSET ";
+      query.strings.push("");
+      query.params.push(offset);
     }
-    const rows = await this.executor.all(sql, built.params);
+    const rows = await this.executor.all(query);
 
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
@@ -438,19 +503,35 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   async update<
     K extends keyof S & string,
     T extends Record<string, unknown> = InferModel<S[K]>,
-  >(args: { model: K; where: Where<T>; data: Partial<T> }): Promise<T | null> {
-    const { model: modelName, where, data } = args;
+  >(args: { model: K; data: Partial<T>; where: Where<T>; select?: Select<T> }): Promise<T | null> {
+    const { model: modelName, data, where } = args;
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, data);
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data, mapSqliteValue);
     const fields = Object.keys(input);
+
     if (fields.length === 0) return this.find({ model: modelName, where, select: undefined });
 
-    const assignments = fields.map((f) => `${quote(f)} = ${placeholder()}`);
+    const setParts: Fragment[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i]!;
+      setParts.push({
+        strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+        params: [input[f]],
+      });
+    }
+    const setFrag = join(setParts, ", ");
+
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql} RETURNING *`;
-    const row = await this.executor.get(sql, [...fields.map((f) => input[f]), ...built.params]);
+    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = join(
+      [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
+      " WHERE ",
+    );
+    query.strings[query.strings.length - 1] += " RETURNING *";
+
+    const row = await this.executor.get(query);
     if (row === undefined || row === null) return this.find({ model: modelName, where });
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
     return toRow<T>(model, row);
@@ -463,15 +544,29 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where, data } = args;
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, data);
-    const input = toInput(model.fields, data);
+    const input = toDbRow(model, data, mapSqliteValue);
     const fields = Object.keys(input);
     if (fields.length === 0) return 0;
 
-    const assignments = fields.map((f) => `${quote(f)} = ${placeholder()}`);
+    const setParts: Fragment[] = [];
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i]!;
+      setParts.push({
+        strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+        params: [input[f]],
+      });
+    }
+    const setFrag = join(setParts, ", ");
+
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const sql = `UPDATE ${quote(modelName)} SET ${assignments.join(", ")} WHERE ${built.sql}`;
-    const res = await this.executor.run(sql, [...fields.map((f) => input[f]), ...built.params]);
+    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = join(
+      [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
+      " WHERE ",
+    );
+
+    const res = await this.executor.run(query);
     return res.changes;
   }
 
@@ -489,39 +584,56 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const model = this.schema[modelName]!;
     assertNoPrimaryKeyUpdates(model, uData);
 
-    const cInput = toInput(model.fields, cData);
-    const cFields = Object.keys(cInput);
-    const uInput = toInput(model.fields, uData);
-    const uFields = Object.keys(uInput);
+    const insertRow = toDbRow(model, cData, mapSqliteValue);
+    const cFields = Object.keys(insertRow);
+    const updateRow = toDbRow(model, uData, mapSqliteValue);
+    const uFields = Object.keys(updateRow);
     const pkFields = getPrimaryKeyFields(model);
 
-    const sqlColumns = cFields.map((f) => quote(f)).join(", ");
-    const sqlPlaceholders = cFields.map(() => placeholder()).join(", ");
-    const sqlConflict = pkFields.map((f) => quote(f)).join(", ");
+    const sqlFields = cFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlConflict = pkFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
 
-    let sql = `INSERT INTO ${quote(modelName)} (${sqlColumns}) VALUES (${sqlPlaceholders}) ON CONFLICT (${sqlConflict}) `;
-    const params = cFields.map((f) => cInput[f]);
+    const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
+    const params = [];
+
+    for (let i = 0; i < cFields.length; i++) {
+      if (i > 0) strings.push(", ");
+      params.push(insertRow[cFields[i]!]);
+    }
+    strings.push(`) ON CONFLICT (${sqlConflict}) `);
+
+    let query: Fragment = { strings, params };
 
     if (uFields.length > 0) {
-      const assignments: string[] = [];
+      const setParts: Fragment[] = [];
       for (let i = 0; i < uFields.length; i++) {
         const f = uFields[i]!;
-        assignments.push(`${quote(f)} = ${placeholder()}`);
-        params.push(uInput[f]);
+        setParts.push({
+          strings: [`${this.getQuotedField(modelName, f)} = `, ""],
+          params: [updateRow[f]],
+        });
       }
-      sql += `DO UPDATE SET ${assignments.join(", ")}`;
+      const setFrag = join(setParts, ", ");
+      query.strings[query.strings.length - 1] += "DO UPDATE SET ";
+      query = join([query, setFrag], "");
+
       if (where) {
+        const quoter = (f: string) => this.getQuotedField(modelName, f);
         // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-        const built = toWhere(model, where as Where);
-        sql += ` WHERE ${built.sql}`;
-        params.push(...built.params);
+        const built = toWhere(model, where as Where, undefined, undefined, quoter);
+        query.strings[query.strings.length - 1] += " WHERE ";
+        query = join([query, built], "");
       }
     } else {
-      sql += "DO NOTHING";
+      query.strings[query.strings.length - 1] += "DO NOTHING";
     }
 
-    sql += " RETURNING *";
-    const row = await this.executor.get(sql, params);
+    const sqlSelect = select
+      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      : "*";
+    query.strings[query.strings.length - 1] += ` RETURNING ${sqlSelect}`;
+
+    const row = await this.executor.get(query);
     if (row !== undefined && row !== null) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
       return toRow<T>(model, row, select as Select<Record<string, unknown>>);
@@ -529,7 +641,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     const existing = await this.find({
       model: modelName,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- PK filter matches T
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
       where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
       select,
     });
@@ -543,9 +655,11 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where: Where<T> }): Promise<void> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    await this.executor.run(`DELETE FROM ${quote(modelName)} WHERE ${built.sql}`, built.params);
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
+    await this.executor.run(query);
   }
 
   async deleteMany<
@@ -554,12 +668,11 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const res = await this.executor.run(
-      `DELETE FROM ${quote(modelName)} WHERE ${built.sql}`,
-      built.params,
-    );
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
+    const res = await this.executor.run(query);
     return res.changes;
   }
 
@@ -569,12 +682,16 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
   >(args: { model: K; where?: Where<T> }): Promise<number> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
+    const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where);
-    const row = await this.executor.get(
-      `SELECT COUNT(*) as count FROM ${quote(modelName)} WHERE ${built.sql}`,
-      built.params,
+    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const query = wrap(
+      built,
+      `SELECT COUNT(*) as count FROM ${this.getQuotedModel(modelName)} WHERE `,
+      "",
     );
-    return row === undefined || row === null ? 0 : Number(row["count"] ?? 0);
+    const row = await this.executor.get(query);
+    const count = row?.["count"];
+    return count === undefined || count === null ? 0 : Number(count);
   }
 }
diff --git a/src/adapters/common.ts b/src/adapters/utils/common.ts
similarity index 98%
rename from src/adapters/common.ts
rename to src/adapters/utils/common.ts
index 5d4b674..0f06ca7 100644
--- a/src/adapters/common.ts
+++ b/src/adapters/utils/common.ts
@@ -1,4 +1,4 @@
-import type { Cursor, Model, SortBy, Where } from "../types";
+import type { Cursor, Model, SortBy, Where } from "../../types";
 
 // --- Schema & Logic Helpers ---
 
diff --git a/src/adapters/utils/sql.ts b/src/adapters/utils/sql.ts
new file mode 100644
index 0000000..92b61af
--- /dev/null
+++ b/src/adapters/utils/sql.ts
@@ -0,0 +1,160 @@
+import type { Field, Model, Schema, Select } from "../../types";
+import { mapNumeric } from "./common";
+
+/**
+ * A Fragment keeps SQL logic and dynamic data separate to prevent injection.
+ * It is structured to be compatible with TemplateStringsArray for safe driver calls.
+ */
+export interface Fragment {
+  strings: string[];
+  params: unknown[];
+}
+
+/** Shared contracts for SQL executors */
+export interface QueryExecutor {
+  all(query: Fragment): Promise<Record<string, unknown>[]>;
+  get(query: Fragment): Promise<Record<string, unknown> | undefined | null>;
+  run(query: Fragment): Promise<{ changes: number }>;
+  transaction<T>(fn: (executor: QueryExecutor) => Promise<T>): Promise<T>;
+  readonly inTransaction: boolean;
+}
+
+export type QuotedSchema = {
+  models: Record<string, string>;
+  fields: Record<string, Record<string, string>>;
+};
+
+export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
+  if (typeof obj !== "object" || obj === null) return false;
+  return (
+    "all" in obj &&
+    "run" in obj &&
+    typeof (obj as Record<string, unknown>)["all"] === "function" &&
+    typeof (obj as Record<string, unknown>)["run"] === "function"
+  );
+}
+
+/**
+ * Maps a raw database row to the inferred model type T.
+ * Handles JSON parsing, boolean conversion, and numeric mapping.
+ */
+export function toRow<T extends Record<string, unknown>>(
+  model: Model,
+  row: Record<string, unknown>,
+  select?: Select<Record<string, unknown>>,
+): T {
+  const fields = model.fields;
+  const res: Record<string, unknown> = {};
+  const keys = select ?? Object.keys(row);
+
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = row[k];
+    const spec = fields[k];
+    if (spec === undefined || val === undefined || val === null) {
+      res[k] = val;
+      continue;
+    }
+    if (spec.type === "json" || spec.type === "json[]") {
+      res[k] = typeof val === "string" ? JSON.parse(val) : val;
+    } else if (spec.type === "boolean") {
+      // Postgres returns boolean, SQLite returns 1/0
+      res[k] = val === true || val === 1;
+    } else if (spec.type === "number" || spec.type === "timestamp") {
+      res[k] = mapNumeric(val);
+    } else {
+      res[k] = val;
+    }
+  }
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
+  return res as T;
+}
+
+/**
+ * Prepares a data object for database insertion/update.
+ * Handles JSON stringification and optional adapter-specific mapping.
+ */
+export function toDbRow(
+  model: Model,
+  data: Record<string, unknown>,
+  mapValue?: (val: unknown, field: Field) => unknown,
+): Record<string, unknown> {
+  const fields = model.fields;
+  const res: Record<string, unknown> = {};
+  const keys = Object.keys(data);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i]!;
+    const val = data[k];
+    const spec = fields[k];
+    if (val === undefined) continue;
+
+    if (val === null) {
+      res[k] = null;
+      continue;
+    }
+
+    if (spec === undefined) {
+      res[k] = val;
+      continue;
+    }
+
+    let processed = val;
+    if (spec.type === "json" || spec.type === "json[]") {
+      processed = JSON.stringify(val);
+    }
+
+    res[k] = mapValue ? mapValue(processed, spec) : processed;
+  }
+  return res;
+}
+
+/**
+ * Concatenates multiple fragments with a separator.
+ */
+export function join(fragments: Fragment[], separator: string): Fragment {
+  if (fragments.length === 0) return { strings: [""], params: [] };
+
+  const strings = [...fragments[0]!.strings];
+  const params = [...fragments[0]!.params];
+
+  for (let i = 1; i < fragments.length; i++) {
+    const f = fragments[i]!;
+    strings[strings.length - 1] += separator + f.strings[0];
+    for (let j = 1; j < f.strings.length; j++) {
+      strings.push(f.strings[j]!);
+    }
+    for (let j = 0; j < f.params.length; j++) {
+      params.push(f.params[j]);
+    }
+  }
+
+  return { strings, params };
+}
+
+/**
+ * Wraps a fragment with a prefix and suffix.
+ */
+export function wrap(fragment: Fragment, prefix: string, suffix: string): Fragment {
+  const strings = [...fragment.strings];
+  strings[0] = prefix + strings[0]!;
+  strings[strings.length - 1] += suffix;
+  return { strings, params: [...fragment.params] };
+}
+
+export function createQuotedSchema(schema: Schema, quote: (s: string) => string): QuotedSchema {
+  const quoted: QuotedSchema = { models: {}, fields: {} };
+  const models = Object.keys(schema);
+  for (let i = 0; i < models.length; i++) {
+    const modelName = models[i]!;
+    quoted.models[modelName] = quote(modelName);
+
+    const fields = Object.keys(schema[modelName]!.fields);
+    const quotedFields: Record<string, string> = {};
+    for (let j = 0; j < fields.length; j++) {
+      const fieldName = fields[j]!;
+      quotedFields[fieldName] = quote(fieldName);
+    }
+    quoted.fields[modelName] = quotedFields;
+  }
+  return quoted;
+}
diff --git a/tsconfig.json b/tsconfig.json
index f8d8f4f..97c14f5 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,7 +2,7 @@
   "compilerOptions": {
     // Environment setup & latest features
     "types": ["bun"],
-    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "lib": ["ES2022"],
     "target": "ES2022",
     "module": "Preserve",
     "moduleDetection": "force",

From 77b0005aabaaec595a37732d4b1ecc05b898d2bb Mon Sep 17 00:00:00 2001
From: Bao Anh <buibaoanh90@yahoo.com.vn>
Date: Fri, 1 May 2026 17:19:59 +0800
Subject: [PATCH 24/24] refactor: strengthen type safety and reduce adapter
 casts

---
 src/adapters/memory.test.ts  |  2 +-
 src/adapters/memory.ts       | 30 +++++++--------
 src/adapters/postgres.ts     | 70 ++++++++++++++++-------------------
 src/adapters/sqlite.test.ts  |  2 +-
 src/adapters/sqlite.ts       | 72 ++++++++++++++++--------------------
 src/adapters/utils/common.ts | 61 +++++++++++++++++-------------
 src/adapters/utils/sql.ts    |  5 ++-
 src/types.ts                 |  4 +-
 8 files changed, 118 insertions(+), 128 deletions(-)

diff --git a/src/adapters/memory.test.ts b/src/adapters/memory.test.ts
index 7aa1fc2..105978f 100644
--- a/src/adapters/memory.test.ts
+++ b/src/adapters/memory.test.ts
@@ -566,7 +566,7 @@ describe("MemoryAdapter", () => {
     });
 
     it("should throw error if primary key is missing in 'create' data", () => {
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- deliberate invalid data for error case
       const invalidData = {
         name: "Missing ID",
         age: 20,
diff --git a/src/adapters/memory.ts b/src/adapters/memory.ts
index 9cf23b8..ab96723 100644
--- a/src/adapters/memory.ts
+++ b/src/adapters/memory.ts
@@ -3,10 +3,10 @@ import { LRUCache } from "lru-cache";
 import type { Adapter, Cursor, InferModel, Schema, Select, SortBy, Where } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
-  getIdentityValues,
   getNestedValue,
   getPaginationFilter,
   getPrimaryKeyFields,
+  getPrimaryKeyValues,
 } from "./utils/common";
 
 type RowData = Record<string, unknown>;
@@ -68,7 +68,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
   }): Promise<T> {
     const { model, data, select } = args;
     const pkIndex = this.pkIndexes.get(model)!;
-    const pkValue = this.serializePK(model, data);
+    const pkValue = this.getPrimaryKeyString(model, data);
 
     if (pkIndex.has(pkValue)) {
       throw new Error(`Record with primary key ${pkValue} already exists in ${model}`);
@@ -97,13 +97,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model, where, select } = args;
 
     // Fast path: PK lookup
-    const pkFields = getPrimaryKeyFields(this.schema[model]!);
+    const primaryKeyFields = getPrimaryKeyFields(this.schema[model]!);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- checking for field-based clause
     const w = where as { field?: string; op?: string; value?: unknown };
     if (
       w.field !== undefined &&
-      pkFields.length === 1 &&
-      w.field === pkFields[0] &&
+      primaryKeyFields.length === 1 &&
+      w.field === primaryKeyFields[0] &&
       w.op === "eq"
     ) {
       const pkValue = String(w.value);
@@ -213,7 +213,7 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     select?: Select<T>;
   }): Promise<T> {
     const { model, create, update, where, select } = args;
-    const pkValue = this.serializePK(model, create);
+    const pkValue = this.getPrimaryKeyString(model, create);
     const existing = this.pkIndexes.get(model)!.get(pkValue);
 
     if (existing !== undefined) {
@@ -305,18 +305,18 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
 
     // Cleanup indexes
     this.indexMap.delete(row);
-    const pkValue = this.serializePK(model, row);
+    const pkValue = this.getPrimaryKeyString(model, row);
     pkIndex.delete(pkValue);
   }
 
-  private serializePK(modelName: string, data: Record<string, unknown>): string {
+  private getPrimaryKeyString(modelName: string, data: Record<string, unknown>): string {
     const modelSpec = this.schema[modelName as keyof S & string]!;
-    const pkValues = getIdentityValues(modelSpec, data);
-    const pkFields = getPrimaryKeyFields(modelSpec);
+    const primaryKeyValues = getPrimaryKeyValues(modelSpec, data);
+    const primaryKeyFields = getPrimaryKeyFields(modelSpec);
     let res = "";
-    for (let i = 0; i < pkFields.length; i++) {
+    for (let i = 0; i < primaryKeyFields.length; i++) {
       if (i > 0) res += "|";
-      const val = pkValues[pkFields[i]!];
+      const val = primaryKeyValues[primaryKeyFields[i]!];
       if (val !== null && val !== undefined) {
         if (typeof val === "object") {
           res += JSON.stringify(val);
@@ -395,15 +395,13 @@ export class MemoryAdapter<S extends Schema = Schema> implements Adapter<S> {
     cursor: Cursor<T>,
     sortBy?: SortBy<T>[],
   ): RowData[] {
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- cursor and sortBy are structurally compatible with non-generic variants
-    const paginationWhere = getPaginationFilter(cursor as Cursor, sortBy as SortBy[]);
+    const paginationWhere = getPaginationFilter(cursor, sortBy);
     if (!paginationWhere) return results;
 
     const filtered: RowData[] = [];
     for (let i = 0; i < results.length; i++) {
       const record = results[i]!;
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- paginationWhere matches the record shape
-      if (this.evaluateWhere(paginationWhere as Where<T>, record)) {
+      if (this.evaluateWhere(paginationWhere, record)) {
         filtered.push(record);
       }
     }
diff --git a/src/adapters/postgres.ts b/src/adapters/postgres.ts
index e3aa28c..82bc454 100644
--- a/src/adapters/postgres.ts
+++ b/src/adapters/postgres.ts
@@ -14,10 +14,10 @@ import type {
 } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
-  buildIdentityFilter,
-  getIdentityValues,
+  buildPrimaryKeyFilter,
   getPaginationFilter,
   getPrimaryKeyFields,
+  getPrimaryKeyValues,
 } from "./utils/common";
 import {
   type QueryExecutor,
@@ -97,9 +97,9 @@ function toColumnExpr(
   return { strings, params: path };
 }
 
-function toWhereRecursive(
+function toWhereRecursive<T>(
   model: Model,
-  where: Where,
+  where: Where<T>,
   quoteFn: (s: string) => string = quote,
 ): Fragment {
   if ("and" in where) {
@@ -118,7 +118,7 @@ function toWhereRecursive(
     return join(parts, " OR ");
   }
 
-  const expr = toColumnExpr(model, where.field, where.path, where.value, quoteFn);
+  const expr = toColumnExpr(model, where.field as string, where.path, where.value, quoteFn);
   const val = where.value;
 
   switch (where.op) {
@@ -163,11 +163,11 @@ function toWhereRecursive(
   }
 }
 
-function toWhere(
+function toWhere<T>(
   model: Model,
-  where?: Where,
-  cursor?: Cursor,
-  sortBy?: SortBy[],
+  where?: Where<T>,
+  cursor?: Cursor<T>,
+  sortBy?: SortBy<T>[],
   quoteFn: (s: string) => string = quote,
 ): Fragment {
   const parts: Fragment[] = [];
@@ -415,11 +415,11 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
       for (let j = 0; j < fields.length; j++) {
         const [fieldName, field] = fields[j]!;
         const type = mapFieldType(field);
-        const nullable = field.nullable === true ? "" : " NOT NULL";
+        const         nullable = field.nullable === true ? "" : " NOT NULL";
         columnParts.push(`${this.getQuotedField(name as keyof S, fieldName)} ${type}${nullable}`);
       }
-      const pkFields = getPrimaryKeyFields(model);
-      const pk = `PRIMARY KEY (${pkFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
+      const primaryKeyFields = getPrimaryKeyFields(model);
+      const pk = `PRIMARY KEY (${primaryKeyFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
       // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
       await this.executor.run({
         strings: [
@@ -468,7 +468,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const fields = Object.keys(input);
     const sqlFields = fields.map((f) => this.getQuotedField(modelName, f)).join(", ");
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
@@ -479,7 +479,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const row = await this.executor.get({ strings, params });
     if (row === undefined || row === null) throw new Error("Failed to insert record");
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
-    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    return toRow<T>(model, row, select);
   }
 
   async find<
@@ -490,9 +490,9 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches model fields
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const query = wrap(
@@ -504,7 +504,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const row = await this.executor.get(query);
     if (row === undefined || row === null) return null;
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
-    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    return toRow<T>(model, row, select);
   }
 
   async findMany<
@@ -522,10 +522,9 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- input parameters match where/cursor/sortBy shapes
-    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[], quoter);
+    const built = toWhere(model, where, cursor, sortBy, quoter);
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const query = wrap(
@@ -566,7 +565,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
-      result.push(toRow<T>(model, rows[i]!, select as Select<Record<string, unknown>>));
+      result.push(toRow<T>(model, rows[i]!, select));
     }
     return result;
   }
@@ -594,8 +593,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const setFrag = join(setParts, ", ");
 
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const whereFrag = toWhere(model, where, undefined, undefined, quoter);
     const query = join(
       [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
       " WHERE ",
@@ -630,8 +628,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const setFrag = join(setParts, ", ");
 
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const whereFrag = toWhere(model, where, undefined, undefined, quoter);
     const query = join(
       [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
       " WHERE ",
@@ -659,10 +656,10 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const cFields = Object.keys(insertRow);
     const updateRow = toDbRow(model, uData);
     const uFields = Object.keys(updateRow);
-    const pkFields = getPrimaryKeyFields(model);
+    const primaryKeyFields = getPrimaryKeyFields(model);
 
     const sqlFields = cFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
-    const sqlConflict = pkFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlConflict = primaryKeyFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
 
     let query: Fragment = {
       strings: [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`],
@@ -690,8 +687,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
 
       if (where) {
         const quoter = (f: string) => this.getQuotedField(modelName, f);
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-        const built = toWhere(model, where as Where, undefined, undefined, quoter);
+        const built = toWhere(model, where, undefined, undefined, quoter);
         query.strings[query.strings.length - 1] += " WHERE ";
         query = join([query, built], "");
       }
@@ -700,20 +696,19 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
     query.strings[query.strings.length - 1] += ` RETURNING ${sqlSelect}`;
 
     const row = await this.executor.get(query);
     if (row !== undefined && row !== null) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
-      return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+      return toRow<T>(model, row, select);
     }
 
     const existing = await this.find({
       model: modelName,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
-      where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
+      where: buildPrimaryKeyFilter<T>(model, getPrimaryKeyValues(model, cData)),
       select,
     });
     if (existing === null) throw new Error("Failed to refetch record after upsert");
@@ -727,8 +722,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
     await this.executor.run(query);
   }
@@ -740,8 +734,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
     const res = await this.executor.run(query);
     return res.changes;
@@ -754,8 +747,7 @@ export class PostgresAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(
       built,
       `SELECT COUNT(*) as count FROM ${this.getQuotedModel(modelName)} WHERE `,
diff --git a/src/adapters/sqlite.test.ts b/src/adapters/sqlite.test.ts
index 55e798f..4e0771f 100644
--- a/src/adapters/sqlite.test.ts
+++ b/src/adapters/sqlite.test.ts
@@ -507,7 +507,7 @@ describe("SqliteAdapter", () => {
         where: { field: "is_active", op: "eq", value: true },
       });
       expect(users).toHaveLength(2);
-      // oxlint-disable-next-line unicorn/no-array-sort
+      // oxlint-disable-next-line unicorn/no-array-sort -- sorting IDs for comparison
       expect(users.map((u) => u["id"]).sort()).toEqual(["b1", "b3"]);
     });
 
diff --git a/src/adapters/sqlite.ts b/src/adapters/sqlite.ts
index febef90..cd4035e 100644
--- a/src/adapters/sqlite.ts
+++ b/src/adapters/sqlite.ts
@@ -16,10 +16,10 @@ import type {
 } from "../types";
 import {
   assertNoPrimaryKeyUpdates,
-  buildIdentityFilter,
-  getIdentityValues,
+  buildPrimaryKeyFilter,
   getPaginationFilter,
   getPrimaryKeyFields,
+  getPrimaryKeyValues,
 } from "./utils/common";
 import {
   type QueryExecutor,
@@ -103,9 +103,9 @@ function toColumnExpr(
   return { strings: [`json_extract(${quoted}, ?)`], params: [serializeJsonPath(path)] };
 }
 
-function toWhereRecursive(
+function toWhereRecursive<T>(
   model: Model,
-  where: Where,
+  where: Where<T>,
   quoteFn: (s: string) => string = quote,
 ): Fragment {
   if ("and" in where) {
@@ -124,7 +124,7 @@ function toWhereRecursive(
     return join(parts, " OR ");
   }
 
-  const expr = toColumnExpr(model, where.field, where.path, quoteFn);
+  const expr = toColumnExpr(model, where.field as string, where.path, quoteFn);
   const val = where.value;
   const mappedVal = typeof val === "boolean" ? (val ? 1 : 0) : val;
 
@@ -172,11 +172,11 @@ function toWhereRecursive(
   }
 }
 
-function toWhere(
+function toWhere<T>(
   model: Model,
-  where?: Where,
-  cursor?: Cursor,
-  sortBy?: SortBy[],
+  where?: Where<T>,
+  cursor?: Cursor<T>,
+  sortBy?: SortBy<T>[],
   quoteFn: (s: string) => string = quote,
 ): Fragment {
   const parts: Fragment[] = [];
@@ -338,8 +338,8 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
         ([fname, f]) =>
           `${this.getQuotedField(name as keyof S, fname)} ${mapFieldType(f)}${f.nullable === true ? "" : " NOT NULL"}`,
       );
-      const pkFields = getPrimaryKeyFields(model);
-      const pk = `PRIMARY KEY (${pkFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
+      const primaryKeyFields = getPrimaryKeyFields(model);
+      const pk = `PRIMARY KEY (${primaryKeyFields.map((f) => this.getQuotedField(name as keyof S, f)).join(", ")})`;
       // eslint-disable-next-line no-await-in-loop -- DDL is intentionally sequential
       await this.executor.run({
         strings: [
@@ -388,7 +388,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const fields = Object.keys(input);
     const sqlFields = fields.map((f) => this.getQuotedField(modelName, f)).join(", ");
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
@@ -400,15 +400,14 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     if (row === undefined || row === null) {
       const res = await this.find({
         model: modelName,
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
-        where: buildIdentityFilter(model, getIdentityValues(model, data)) as Where<T>,
+        where: buildPrimaryKeyFilter<T>(model, getPrimaryKeyValues(model, data)),
         select,
       });
       if (!res) throw new Error("Failed to insert record");
       return res;
     }
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
-    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    return toRow<T>(model, row, select);
   }
 
   async find<
@@ -418,10 +417,9 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where, select } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches model fields
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const query = wrap(
@@ -433,7 +431,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const row = await this.executor.get(query);
     if (row === undefined || row === null) return null;
     // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
-    return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+    return toRow<T>(model, row, select);
   }
 
   async findMany<
@@ -451,10 +449,9 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where, select, sortBy, limit, offset, cursor } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- input parameters match where/cursor/sortBy shapes
-    const built = toWhere(model, where as Where, cursor as Cursor, sortBy as SortBy[], quoter);
+    const built = toWhere(model, where, cursor, sortBy, quoter);
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
 
     const query = wrap(
@@ -495,7 +492,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const result: T[] = [];
     for (let i = 0; i < rows.length; i++) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- mapped fields match the shape of T
-      result.push(toRow<T>(model, rows[i]!, select as Select<Record<string, unknown>>));
+      result.push(toRow<T>(model, rows[i]!, select));
     }
     return result;
   }
@@ -523,8 +520,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const setFrag = join(setParts, ", ");
 
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const whereFrag = toWhere(model, where, undefined, undefined, quoter);
     const query = join(
       [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
       " WHERE ",
@@ -559,8 +555,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const setFrag = join(setParts, ", ");
 
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const whereFrag = toWhere(model, where as Where, undefined, undefined, quoter);
+    const whereFrag = toWhere(model, where, undefined, undefined, quoter);
     const query = join(
       [wrap(setFrag, `UPDATE ${this.getQuotedModel(modelName)} SET `, ""), whereFrag],
       " WHERE ",
@@ -588,10 +583,10 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const cFields = Object.keys(insertRow);
     const updateRow = toDbRow(model, uData, mapSqliteValue);
     const uFields = Object.keys(updateRow);
-    const pkFields = getPrimaryKeyFields(model);
+    const primaryKeyFields = getPrimaryKeyFields(model);
 
     const sqlFields = cFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
-    const sqlConflict = pkFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
+    const sqlConflict = primaryKeyFields.map((f) => this.getQuotedField(modelName, f)).join(", ");
 
     const strings = [`INSERT INTO ${this.getQuotedModel(modelName)} (${sqlFields}) VALUES (`];
     const params = [];
@@ -619,8 +614,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
 
       if (where) {
         const quoter = (f: string) => this.getQuotedField(modelName, f);
-        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-        const built = toWhere(model, where as Where, undefined, undefined, quoter);
+        const built = toWhere(model, where, undefined, undefined, quoter);
         query.strings[query.strings.length - 1] += " WHERE ";
         query = join([query, built], "");
       }
@@ -629,20 +623,19 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     }
 
     const sqlSelect = select
-      ? select.map((s) => this.getQuotedField(modelName, s as string)).join(", ")
+      ? select.map((s) => this.getQuotedField(modelName, s)).join(", ")
       : "*";
     query.strings[query.strings.length - 1] += ` RETURNING ${sqlSelect}`;
 
     const row = await this.executor.get(query);
     if (row !== undefined && row !== null) {
       // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select matches model fields at runtime
-      return toRow<T>(model, row, select as Select<Record<string, unknown>>);
+      return toRow<T>(model, row, select);
     }
 
     const existing = await this.find({
       model: modelName,
-      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- identity filter matches T
-      where: buildIdentityFilter(model, getIdentityValues(model, cData)) as Where<T>,
+      where: buildPrimaryKeyFilter<T>(model, getPrimaryKeyValues(model, cData)),
       select,
     });
     if (existing === null) throw new Error("Failed to refetch record after upsert");
@@ -656,8 +649,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
     await this.executor.run(query);
   }
@@ -669,8 +661,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(built, `DELETE FROM ${this.getQuotedModel(modelName)} WHERE `, "");
     const res = await this.executor.run(query);
     return res.changes;
@@ -683,8 +674,7 @@ export class SqliteAdapter<S extends Schema = Schema> implements Adapter<S> {
     const { model: modelName, where } = args;
     const model = this.schema[modelName]!;
     const quoter = (f: string) => this.getQuotedField(modelName, f);
-    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Where matches at runtime
-    const built = toWhere(model, where as Where, undefined, undefined, quoter);
+    const built = toWhere(model, where, undefined, undefined, quoter);
     const query = wrap(
       built,
       `SELECT COUNT(*) as count FROM ${this.getQuotedModel(modelName)} WHERE `,
diff --git a/src/adapters/utils/common.ts b/src/adapters/utils/common.ts
index 0f06ca7..1ad8023 100644
--- a/src/adapters/utils/common.ts
+++ b/src/adapters/utils/common.ts
@@ -1,4 +1,4 @@
-import type { Cursor, Model, SortBy, Where } from "../../types";
+import type { Cursor, FieldName, Model, SortBy, Where } from "../../types";
 
 // --- Schema & Logic Helpers ---
 
@@ -9,14 +9,14 @@ export function getPrimaryKeyFields(model: Model): string[] {
 /**
  * Extracts primary key values from a data object based on the model schema.
  */
-export function getIdentityValues(
+export function getPrimaryKeyValues(
   model: Model,
   data: Record<string, unknown>,
 ): Record<string, unknown> {
-  const pkFields = getPrimaryKeyFields(model);
+  const primaryKeyFields = getPrimaryKeyFields(model);
   const values: Record<string, unknown> = {};
-  for (let i = 0; i < pkFields.length; i++) {
-    const field = pkFields[i]!;
+  for (let i = 0; i < primaryKeyFields.length; i++) {
+    const field = primaryKeyFields[i]!;
     if (!(field in data)) {
       throw new Error(`Missing primary key field: ${field}`);
     }
@@ -27,27 +27,31 @@ export function getIdentityValues(
 
 /**
  * Builds a 'Where' filter targeting the primary key of a specific record.
- * Returns Where<Record<string, unknown>> — callers cast to Where<T> at the boundary.
  */
-export function buildIdentityFilter(model: Model, source: Record<string, unknown>): Where {
-  const pkFields = getPrimaryKeyFields(model);
-  if (pkFields.length === 1) {
-    const field = pkFields[0]!;
-    return { field, op: "eq" as const, value: source[field] };
+export function buildPrimaryKeyFilter<T = Record<string, unknown>>(
+  model: Model,
+  source: Record<string, unknown>,
+): Where<T> {
+  const primaryKeyFields = getPrimaryKeyFields(model);
+  if (primaryKeyFields.length === 1) {
+    const field = primaryKeyFields[0]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field name from schema is guaranteed to be in T
+    return { field: field as FieldName<T>, op: "eq" as const, value: source[field] };
   }
 
-  const clauses: Where[] = [];
-  for (let i = 0; i < pkFields.length; i++) {
-    const field = pkFields[i]!;
-    clauses.push({ field, op: "eq" as const, value: source[field] });
+  const clauses: Where<T>[] = [];
+  for (let i = 0; i < primaryKeyFields.length; i++) {
+    const field = primaryKeyFields[i]!;
+    // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- field name from schema is guaranteed to be in T
+    clauses.push({ field: field as FieldName<T>, op: "eq" as const, value: source[field] });
   }
   return { and: clauses };
 }
 
 export function assertNoPrimaryKeyUpdates(model: Model, data: Record<string, unknown>): void {
-  const pkFields = getPrimaryKeyFields(model);
-  for (let i = 0; i < pkFields.length; i++) {
-    const field = pkFields[i]!;
+  const primaryKeyFields = getPrimaryKeyFields(model);
+  for (let i = 0; i < primaryKeyFields.length; i++) {
+    const field = primaryKeyFields[i]!;
     if (data[field] !== undefined) {
       throw new Error("Primary key updates are not supported.");
     }
@@ -82,19 +86,23 @@ export function getNestedValue(
   return val;
 }
 
-export function getPaginationFilter(cursor: Cursor, sortBy?: SortBy[]): Where | undefined {
+export function getPaginationFilter<T = Record<string, unknown>>(
+  cursor: Cursor<T>,
+  sortBy?: SortBy<T>[],
+): Where<T> | undefined {
   const criteria = getPaginationCriteria(cursor, sortBy);
   if (criteria.length === 0) return undefined;
 
   const cursorValues = cursor.after as Record<string, unknown>;
-  const orClauses: Where[] = [];
+  const orClauses: Where<T>[] = [];
 
   for (let i = 0; i < criteria.length; i++) {
-    const andClauses: Where[] = [];
+    const andClauses: Where<T>[] = [];
     for (let j = 0; j < i; j++) {
       const prev = criteria[j]!;
       andClauses.push({
-        field: prev.field,
+        // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- criteria field is guaranteed to be in T
+        field: prev.field as FieldName<T>,
         path: prev.path,
         op: "eq",
         value: cursorValues[prev.field],
@@ -102,7 +110,8 @@ export function getPaginationFilter(cursor: Cursor, sortBy?: SortBy[]): Where |
     }
     const curr = criteria[i]!;
     andClauses.push({
-      field: curr.field,
+      // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- criteria field is guaranteed to be in T
+      field: curr.field as FieldName<T>,
       path: curr.path,
       op: curr.direction === "desc" ? "lt" : "gt",
       value: cursorValues[curr.field],
@@ -116,9 +125,9 @@ export function getPaginationFilter(cursor: Cursor, sortBy?: SortBy[]): Where |
 /**
  * Normalizes pagination criteria from a cursor and optional sort parameters.
  */
-export function getPaginationCriteria(
-  cursor: Cursor,
-  sortBy?: SortBy[],
+export function getPaginationCriteria<T = Record<string, unknown>>(
+  cursor: Cursor<T>,
+  sortBy?: SortBy<T>[],
 ): { field: string; direction: "asc" | "desc"; path?: string[] }[] {
   const cursorValues = cursor.after as Record<string, unknown>;
   const criteria = [];
diff --git a/src/adapters/utils/sql.ts b/src/adapters/utils/sql.ts
index 92b61af..ed44e6f 100644
--- a/src/adapters/utils/sql.ts
+++ b/src/adapters/utils/sql.ts
@@ -41,11 +41,12 @@ export function isQueryExecutor(obj: unknown): obj is QueryExecutor {
 export function toRow<T extends Record<string, unknown>>(
   model: Model,
   row: Record<string, unknown>,
-  select?: Select<Record<string, unknown>>,
+  select?: Select<T>,
 ): T {
   const fields = model.fields;
   const res: Record<string, unknown> = {};
-  const keys = select ?? Object.keys(row);
+  // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- select fields are strings
+  const keys = (select as readonly string[]) ?? Object.keys(row);
 
   for (let i = 0; i < keys.length; i++) {
     const k = keys[i]!;
diff --git a/src/types.ts b/src/types.ts
index ed6bf37..7a05893 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -36,7 +36,7 @@ export type InferModel<M extends Model> = {
   [K in keyof M["fields"] as M["fields"][K]["nullable"] extends true ? never : K]: ResolveTSValue<
     M["fields"][K]["type"]
   >;
-} & Record<string, unknown>;
+};
 
 type ResolveTSValue<T extends FieldType> = T extends "string"
   ? string
@@ -197,5 +197,5 @@ export interface SortBy<T = Record<string, unknown>> {
 }
 
 export interface Cursor<T = Record<string, unknown>> {
-  after: Partial<Record<FieldName<T>, unknown>>;
+  after: Partial<{ [K in FieldName<T>]: unknown }>;
 }