@metaobjectsdev/runtime-ts 1.0.9 → 1.0.10

package/src/drivers/kysely-driver.ts

@@ -4,6 +4,7 @@ import type {
   UpdateSpec, UpdateManySpec, DeleteSpec, DeleteManySpec, WhereClause, Row,
 } from "../persistence-driver.js";
 import { ConstraintViolationError } from "../errors.js";
+import { arraysAsJsonText, insertedKey, mysqlConstraintKind } from "./mysql-support.js";
 
 // Kysely's fluent builder is heavily generic on the database schema, but this driver
 // is metadata-driven and accepts any table name at runtime. Confine the schema-agnostic
@@ -17,7 +18,9 @@ type AnyQuery = SelectQueryBuilder<any, any, any>;
 
 export interface KyselyDriverOptions {
   db: Kysely<Record<string, Row>>;
-  dialect: "sqlite" | "postgres";
+  /** `mysql`: build the Kysely instance with `MysqlDialect` over a mysql2 pool created with
+   *  `timezone: "Z"` (DATETIME then holds the UTC wall clock). */
+  dialect: "sqlite" | "postgres" | "mysql";
 }
 
 export interface KyselyDriverPublic extends PersistenceDriver {
@@ -31,8 +34,24 @@ export function kyselyDriver(opts: KyselyDriverOptions): KyselyDriverPublic {
 
 function makeKyselyDriver(
   db: Kysely<Record<string, Row>>,
-  dialect: "sqlite" | "postgres",
+  dialect: "sqlite" | "postgres" | "mysql",
 ): KyselyDriverPublic {
+  // Neither SQLite nor MySQL has an array type: a scalar array is bound as JSON text.
+  const bindable = (values: Row): Row => (dialect === "postgres" ? values : arraysAsJsonText(values));
+
+  // MySQL has no RETURNING: insert, then read the row back by its key.
+  async function insertAndReadBack(table: string, values: Row, returning: string[], key: string[] | undefined): Promise<Row> {
+    const result = await (db as RawKysely).insertInto(table).values(bindable(values)).executeTakeFirst() as
+      { insertId?: bigint | number } | undefined;
+    const keyValues = key !== undefined && key.length > 0 ? insertedKey(key, values, result?.insertId) : undefined;
+    if (keyValues === undefined) {
+      throw new Error(`kyselyDriver.insert: cannot read back the row inserted into '${table}' (no primary-key value)`);
+    }
+    let q = (db as RawKysely).selectFrom(table).select(returning);
+    for (const [col, v] of Object.entries(keyValues)) q = q.where(col, "=", v);
+    return (await q.executeTakeFirstOrThrow()) as Row;
+  }
+
   return {
     db,
     dialect,
@@ -62,9 +81,10 @@ function makeKyselyDriver(
 
     async insert(spec: InsertSpec): Promise<Row> {
       try {
+        if (dialect === "mysql") return await insertAndReadBack(spec.table, spec.values, spec.returning, spec.key);
         const result = await (db as RawKysely)
           .insertInto(spec.table)
-          .values(spec.values)
+          .values(bindable(spec.values))
           .returning(spec.returning)
           .executeTakeFirstOrThrow();
         return result as Row;
@@ -75,9 +95,14 @@ function makeKyselyDriver(
 
     async insertMany(spec: InsertManySpec): Promise<Row[]> {
       try {
+        if (dialect === "mysql") {
+          const out: Row[] = [];
+          for (const row of spec.rows) out.push(await insertAndReadBack(spec.table, row, spec.returning, spec.key));
+          return out;
+        }
         const rows = await (db as RawKysely)
           .insertInto(spec.table)
-          .values(spec.rows)
+          .values(spec.rows.map(bindable))
           .returning(spec.returning)
           .execute();
         return rows as Row[];
@@ -88,8 +113,14 @@ function makeKyselyDriver(
 
     async update(spec: UpdateSpec): Promise<Row | null> {
       try {
-        let q = (db as RawKysely).updateTable(spec.table).set(spec.values);
+        let q = (db as RawKysely).updateTable(spec.table).set(bindable(spec.values));
         q = applyWhere(q, spec.where);
+        if (dialect === "mysql") {
+          await q.execute();
+          let s = (db as RawKysely).selectFrom(spec.table).select(spec.returning);
+          s = applyWhere(s, spec.where);
+          return ((await s.executeTakeFirst()) as Row | undefined) ?? null;
+        }
         const rows = await q.returning(spec.returning).execute();
         return ((rows as Row[])[0]) ?? null;
       } catch (err) {
@@ -99,7 +130,7 @@ function makeKyselyDriver(
 
     async updateMany(spec: UpdateManySpec): Promise<number> {
       try {
-        let q = (db as RawKysely).updateTable(spec.table).set(spec.values);
+        let q = (db as RawKysely).updateTable(spec.table).set(bindable(spec.values));
         q = applyWhere(q, spec.where);
         const result = await q.executeTakeFirst() as { numUpdatedRows?: bigint | number } | undefined;
         return Number(result?.numUpdatedRows ?? 0);
@@ -185,11 +216,16 @@ function applyOrderLimit(
   return out;
 }
 
-function mapDriverError(err: unknown, table: string, dialect: "sqlite" | "postgres"): unknown {
+function mapDriverError(err: unknown, table: string, dialect: "sqlite" | "postgres" | "mysql"): unknown {
   if (!(err instanceof Error)) return err;
   const msg = err.message;
   const code = (err as { code?: string }).code;
 
+  if (dialect === "mysql") {
+    const kind = mysqlConstraintKind(err);
+    return kind === null ? err : new ConstraintViolationError(msg, { kind, table, cause: err });
+  }
+
   if (dialect === "sqlite") {
     const kind = sqliteConstraintKind(code, msg);
     if (kind !== null) {

package/src/drivers/mysql-support.ts

@@ -0,0 +1,77 @@
+// MySQL support shared by the Kysely and Drizzle ObjectManager drivers.
+//
+// MySQL has no RETURNING, so a driver writes and then reads the row back:
+//   - insert: the key is the written key columns, plus the AUTO_INCREMENT id the server
+//     reports when the table has one and the caller did not supply it;
+//   - update: the row is re-selected with the same WHERE (absent → null).
+// Constraint errors are recognised by mysql2's error `code`, walked through any wrapper's
+// `cause` chain (Drizzle wraps driver errors).
+import type { Row } from "../persistence-driver.js";
+
+export type ConstraintKindName = "unique" | "foreign_key" | "not_null" | "check";
+
+const MYSQL_CODES: Record<string, ConstraintKindName> = {
+  ER_DUP_ENTRY: "unique",
+  ER_NO_REFERENCED_ROW_2: "foreign_key",
+  ER_ROW_IS_REFERENCED_2: "foreign_key",
+  ER_NO_REFERENCED_ROW: "foreign_key",
+  ER_ROW_IS_REFERENCED: "foreign_key",
+  ER_BAD_NULL_ERROR: "not_null",
+  ER_CHECK_CONSTRAINT_VIOLATED: "check",
+};
+
+/** The constraint kind a mysql2 error (or a wrapper around one) reports, else null. */
+export function mysqlConstraintKind(err: unknown): ConstraintKindName | null {
+  let cur: unknown = err;
+  for (let depth = 0; depth < 8 && typeof cur === "object" && cur !== null; depth++) {
+    const code = (cur as { code?: unknown }).code;
+    if (typeof code === "string" && code in MYSQL_CODES) return MYSQL_CODES[code]!;
+    const next = (cur as { cause?: unknown }).cause;
+    if (next === cur) break;
+    cur = next;
+  }
+  return null;
+}
+
+/**
+ * The key-column values of a row just inserted: every key column the caller wrote, and the
+ * server-generated AUTO_INCREMENT id for the one it did not. `undefined` when a key column
+ * has neither (the insert cannot be read back).
+ */
+export function insertedKey(
+  key: readonly string[],
+  values: Row,
+  insertId: number | bigint | undefined,
+): Row | undefined {
+  const out: Row = {};
+  let usedInsertId = false;
+  for (const col of key) {
+    const v = values[col];
+    if (v !== undefined && v !== null) {
+      out[col] = v;
+    } else if (!usedInsertId && insertId !== undefined && Number(insertId) !== 0) {
+      out[col] = typeof insertId === "bigint" ? Number(insertId) : insertId;
+      usedInsertId = true;
+    } else {
+      return undefined;
+    }
+  }
+  return out;
+}
+
+/**
+ * A row a SQL driver without an array type can bind (SQLite, MySQL). mysql2 expands a JS
+ * array into a value LIST (`'x', 'y'`), breaking the column count, and libsql cannot bind one
+ * at all; a scalar array lives in a JSON (MySQL) or JSON-in-TEXT (SQLite) column, so it is sent
+ * as JSON text. Objects already arrive as JSON text from the type coercer. Drizzle's JSON
+ * column modes encode for themselves, so only the Kysely driver calls this.
+ */
+export function arraysAsJsonText(values: Row): Row {
+  let out: Row | null = null;
+  for (const [k, v] of Object.entries(values)) {
+    if (!Array.isArray(v)) continue;
+    out ??= { ...values };
+    out[k] = JSON.stringify(v);
+  }
+  return out ?? values;
+}

package/src/drizzle-fastify/filter-parser.ts

@@ -3,6 +3,7 @@ import {
   eq, ne, gt, gte, lt, lte, inArray, like, ilike, isNull, not, and, or, asc, desc, sql,
   type SQL, type SQLWrapper,
 } from "drizzle-orm";
+import type { SqlDialect } from "../sql-dialect.js";
 import type { FilterAllowlist, FilterOp, FilterFieldRule, SortAllowlist } from "./filter-allowlist.js";
 import { sortOrderSpec } from "./filter-allowlist.js";
 import { FilterParseError, parsePageBound, SORT_EXPECTED } from "./list-params.js";
@@ -24,7 +25,7 @@ export interface ParseFilterOpts {
   table: AnyTable;
   allowlist: FilterAllowlist;
   sortAllowlist: SortAllowlist;
-  dialect: "sqlite" | "postgres";
+  dialect: SqlDialect;
   maxNesting?: number;
   maxInListSize?: number;
 }
@@ -132,9 +133,13 @@ export function parseFilterParams(opts: ParseFilterOpts): ParseFilterResult {
       // deliberately case-INSENSITIVE — it is a human search box, not the
       // contract's `like` operator (which is case-sensitive SQL LIKE, ADR-0049).
       // Postgres uses ILIKE; SQLite's native LIKE folds ASCII case by default,
-      // which is the intended behavior here.
-      const matcher = opts.dialect === "postgres" ? ilike : like;
-      const parts = stringCols.map((col) => matcher(col, term));
+      // which is the intended behavior here. MySQL's LIKE follows the column's
+      // collation, which is case-insensitive by default and case-sensitive on a
+      // `_bin` column, so it folds both sides explicitly.
+      const parts = stringCols.map((col) =>
+        opts.dialect === "postgres" ? ilike(col, term)
+        : opts.dialect === "mysql" ? sql`LOWER(${col}) LIKE LOWER(${term})`
+        : like(col, term));
       // or() is defined as returning SQL | undefined but will always return
       // SQL when given a non-empty array. parts[0] is always defined here
       // because stringCols.length > 0 guarantees at least one element.
@@ -150,7 +155,7 @@ function parseNode(
   node: Record<string, unknown>,
   table: AnyTable,
   allowlist: FilterAllowlist,
-  dialect: "sqlite" | "postgres",
+  dialect: SqlDialect,
   maxNesting: number,
   maxInList: number,
   depth: number,
@@ -203,7 +208,7 @@ function compileOp(
   field: string,
   op: string,
   value: unknown,
-  dialect: "sqlite" | "postgres",
+  dialect: SqlDialect,
   maxInList: number,
 ): SQL | undefined {
   if (!rule.ops.includes(op as FilterOp)) {
@@ -234,9 +239,13 @@ function compileOp(
       // default (and `PRAGMA case_sensitive_like` is connection-global on a
       // consumer-owned connection), so the sqlite branch lowers to GLOB with
       // an exactly-translated pattern instead.
+      // MySQL's LIKE follows the column's collation, which is case-INSENSITIVE by
+      // default, so the pattern carries an explicit binary collation.
       return dialect === "postgres"
         ? like(col as any, s)
-        : sql`${col} GLOB ${likePatternToGlob(s)}`;
+        : dialect === "mysql"
+          ? sql`${col} LIKE ${s} COLLATE utf8mb4_bin`
+          : sql`${col} GLOB ${likePatternToGlob(s)}`;
     }
     case "isNull": {
       // isNull's value is always coerced as boolean (true/false), regardless of the

package/src/drizzle-fastify/index.ts

@@ -27,8 +27,9 @@ import qs from "qs";
 import type { FilterAllowlist, SortAllowlist } from "./filter-allowlist.js";
 export type { FilterAllowlist, SortAllowlist } from "./filter-allowlist.js";
 import { parseFilterParams, parsePageBound, FilterParseError } from "./filter-parser.js";
-import { isTruthyFlag, contractErrorCode, coerceIdForColumn, firstRow } from "./util.js";
+import { isTruthyFlag, contractErrorCode, coerceIdForColumn, firstRow, extractRowCount } from "./util.js";
 import { timestampWire } from "../timestamp-wire.js";
+import { supportsReturning, type SqlDialect } from "../sql-dialect.js";
 import { withContractErrorHandler } from "./route-error-handler.js";
 import { validationErrorBody } from "../route-errors.js";
 export { isTruthyFlag, contractErrorCode, parseId, coerceIdForColumn } from "./util.js";
@@ -84,7 +85,7 @@ export interface CrudRoutesOptions {
   filterAllowlist?: FilterAllowlist;
   sortAllowlist?:   SortAllowlist;
   /** Dialect — required if filterAllowlist or sortAllowlist is set (for dialect-specific `like` lowering: SQLite lowers to GLOB to stay case-sensitive; ADR-0049). */
-  dialect?: "sqlite" | "postgres";
+  dialect?: SqlDialect;
   /**
    * FR-017 TPH — scope this route set to a single subtype of a single-table-
    * inheritance base. When set:
@@ -280,15 +281,23 @@ export function mountCreateRoute(opts: VerbOptions): void {
       : parsed.data;
     // A constraint the DB enforces (a foreign key from identity.reference, a unique
     // index) must not surface as a 500 echoing the SQL and its bound parameters.
-    let result: unknown;
+    let row: unknown;
     try {
-      result = await opts.db.insert(opts.table).values(values).returning();
+      if (supportsReturning(opts.dialect)) {
+        row = ((await opts.db.insert(opts.table).values(values).returning()) as unknown[])[0];
+      } else {
+        // MySQL has no RETURNING: take the key from the body (an assigned key) or from
+        // `$returningId()` (AUTO_INCREMENT / `$defaultFn`), then read the row back.
+        const [inserted] = (await opts.db.insert(opts.table).values(values).$returningId()) as
+          Array<Record<string, unknown> | undefined>;
+        const key = (values as Record<string, unknown>).id ?? inserted?.id;
+        row = key === undefined ? undefined : await firstRow(opts.db, opts.table, eq(opts.table.id, key));
+      }
     } catch (e) {
       const f = classifyConstraintError(e);
       if (f === undefined) { logAndRedact(e); throw new RedactedDatabaseError(); }
       return reply.code(f.status).send(f.body);
     }
-    const row = (result as unknown[])[0];
     // #214 — read-your-writes: re-read through the replica view so the response
     // carries derived (origin.passthrough) columns the base table excludes.
     return reply.code(201).send(toWire(await reReadThroughView(opts, row)));
@@ -341,19 +350,21 @@ export function mountUpdateRoute(opts: VerbOptions): void {
       return reply.code(400).send({ error: "invalid_id" });
     }
     const idCond = eq(opts.table.id, idValue);
-    let result: unknown;
+    const cond = discCond ? and(idCond, discCond) : idCond;
+    let row: unknown;
     try {
-      result = await opts.db
-        .update(opts.table)
-        .set(data)
-        .where(discCond ? and(idCond, discCond) : idCond)
-        .returning();
+      if (supportsReturning(opts.dialect)) {
+        row = ((await opts.db.update(opts.table).set(data).where(cond).returning()) as unknown[])[0];
+      } else {
+        // MySQL has no RETURNING: update, then read the row back (absent → 404).
+        await opts.db.update(opts.table).set(data).where(cond);
+        row = await firstRow(opts.db, opts.table, cond);
+      }
     } catch (e) {
       const f = classifyConstraintError(e);
       if (f === undefined) { logAndRedact(e); throw new RedactedDatabaseError(); }
       return reply.code(f.status).send(f.body);
     }
-    const row = (result as unknown[])[0];
     if (row == null) return reply.code(404).send({ error: "not_found" });
     // #214 — re-read through the replica view so the response carries derived columns.
     return toWire(await reReadThroughView(opts, row));
@@ -408,19 +419,5 @@ export function mountDeleteRoute(opts: VerbOptions): void {
   });
 }
 
-function extractRowCount(result: unknown): number {
-  if (typeof result === "number") return result;
-  if (Array.isArray(result)) return result.length;
-  if (result && typeof result === "object") {
-    const obj = result as { rowsAffected?: number | bigint; rowCount?: number; changes?: number };
-    if (typeof obj.rowsAffected === "number") return obj.rowsAffected;
-    if (typeof obj.rowsAffected === "bigint") return Number(obj.rowsAffected);
-    if (typeof obj.rowCount === "number") return obj.rowCount;
-    // bun:sqlite / better-sqlite3 run() result shape.
-    if (typeof obj.changes === "number") return obj.changes;
-  }
-  return 0;
-}
-
 export { mountReadOnlyCrudRoutes, type MountReadOnlyOptions } from "./mount-read-only.js";
 export { mountM2mRoute, type M2mRouteOptions } from "./mount-m2m.js";

package/src/drizzle-fastify/mount-read-only.ts

@@ -1,4 +1,5 @@
 import type { FastifyInstance, RouteShorthandOptions } from "fastify";
+import { quoteIdent, type SqlDialect } from "../sql-dialect.js";
 import { sql, eq, and, count } from "drizzle-orm";
 import qs from "qs";
 import { parseFilterParams, parsePageBound, RAW_VIEW_MAX_LIMIT, FilterParseError } from "./filter-parser.js";
@@ -18,7 +19,7 @@ export interface MountReadOnlyOptions {
   readonly view: AnyView;
   readonly filterAllowlist: FilterAllowlist;
   readonly sortAllowlist: SortAllowlist;
-  readonly dialect: "postgres" | "sqlite";
+  readonly dialect: SqlDialect;
   /** Override default ID column name (defaults to "id"). */
   readonly idColumn?: string;
   /**
@@ -113,6 +114,11 @@ async function rawRows(db: any, dialect: string | undefined, query: unknown): Pr
     if (Array.isArray(res)) return res as Record<string, unknown>[];
     return (res as { rows?: Record<string, unknown>[] } | null)?.rows ?? [];
   }
+  if (dialect === "mysql") {
+    // mysql2 answers `[rows, fields]`.
+    const [rows] = (await db.execute(query)) as [Record<string, unknown>[], unknown];
+    return rows;
+  }
   return (await db.all(query)) as Record<string, unknown>[];
 }
 
@@ -145,11 +151,11 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
         const offsetVal = parsePageBound(parsed, "offset") ?? 0;
         const withCount = isTruthyFlag(parsed["withCount"]);
         // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-        const rows = await rawRows(db, dialect, sql.raw(`SELECT * FROM "${viewName}" LIMIT ${limitVal} OFFSET ${offsetVal}`)) as any[];
+        const rows = await rawRows(db, dialect, sql.raw(`SELECT * FROM ${quoteIdent(dialect, viewName)} LIMIT ${limitVal} OFFSET ${offsetVal}`)) as any[];
         const camelRows = rows.map((r: Record<string, unknown>) => camelizeRow(r));
         if (!withCount) return camelRows;
         // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-        const countRows = await rawRows(db, dialect, sql.raw(`SELECT COUNT(*) AS c FROM "${viewName}"`)) as any[];
+        const countRows = await rawRows(db, dialect, sql.raw(`SELECT COUNT(*) AS c FROM ${quoteIdent(dialect, viewName)}`)) as any[];
         const total: number = Number(countRows[0]?.c ?? 0);
         return { rows: camelRows, total };
       }
@@ -204,7 +210,7 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
     const { id } = req.params as { id: string };
     if (useRawSql) {
       // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-      const rows = await rawRows(db, dialect, sql.raw(`SELECT * FROM "${viewName}" WHERE "${idCol}" = ${rawIdLiteral(id)} LIMIT 1`)) as any[];
+      const rows = await rawRows(db, dialect, sql.raw(`SELECT * FROM ${quoteIdent(dialect, viewName)} WHERE ${quoteIdent(dialect, idCol)} = ${rawIdLiteral(id)} LIMIT 1`)) as any[];
       const row = rows[0] ? camelizeRow(rows[0]) : undefined;
       return row ?? reply.code(404).send({ error: "not_found" });
     }

package/src/drizzle-fastify/util.ts

@@ -114,3 +114,26 @@ export async function firstRow(db: unknown, src: unknown, cond: unknown): Promis
   const rows: unknown = await (db as any).select().from(src).where(cond).limit(1);
   return (rows as unknown[])[0];
 }
+
+/**
+ * Rows a DELETE/UPDATE affected, across the driver result shapes: libsql `rowsAffected`,
+ * node-postgres `rowCount`, bun:sqlite / better-sqlite3 `changes`, and mysql2's
+ * `[ResultSetHeader, fields]` tuple.
+ */
+export function extractRowCount(result: unknown): number {
+  if (typeof result === "number") return result;
+  // mysql2: `[ResultSetHeader, fields]`, the count on the header.
+  if (Array.isArray(result) && typeof (result[0] as { affectedRows?: unknown } | undefined)?.affectedRows === "number") {
+    return (result[0] as { affectedRows: number }).affectedRows;
+  }
+  if (Array.isArray(result)) return result.length;
+  if (result && typeof result === "object") {
+    const obj = result as { rowsAffected?: number | bigint; rowCount?: number; changes?: number };
+    if (typeof obj.rowsAffected === "number") return obj.rowsAffected;
+    if (typeof obj.rowsAffected === "bigint") return Number(obj.rowsAffected);
+    if (typeof obj.rowCount === "number") return obj.rowCount;
+    // bun:sqlite / better-sqlite3 run() result shape.
+    if (typeof obj.changes === "number") return obj.changes;
+  }
+  return 0;
+}

package/src/extract-object.ts

@@ -54,6 +54,7 @@ import {
   FIELD_ATTR_OBJECT_REF,
   FIELD_ATTR_XML_TEXT,
   VALIDATOR_SUBTYPE_NUMERIC,
+  VALIDATOR_SUBTYPE_ARRAY,
   NORMALIZE_DEFAULT,
   type NormalizeMode,
 } from "@metaobjectsdev/metadata";
@@ -64,6 +65,7 @@ import {
   scalar,
   range,
   textContentField,
+  withItemBounds,
   enumField,
   enumArray,
   object,
@@ -143,6 +145,22 @@ function fieldSpecFor(
   format: Format,
   visited: Set<MetaObject>,
   depth: number,
+): FieldSpec {
+  const spec = fieldShapeFor(field, owner, format, visited, depth);
+  if (!field.resolvedIsArray()) return spec;
+  // Element-count bounds: the field's array validator (@min/@max) is the single source of
+  // truth, as the numeric validator is for a scalar's range.
+  const bounds = field.validators().find((v) => v.subType === VALIDATOR_SUBTYPE_ARRAY);
+  if (bounds === undefined) return spec;
+  return withItemBounds(spec, bounds.min ?? null, bounds.max ?? null);
+}
+
+function fieldShapeFor(
+  field: MetaField,
+  owner: MetaObject,
+  format: Format,
+  visited: Set<MetaObject>,
+  depth: number,
 ): FieldSpec {
   const name = field.name;
   const required = isRequired(field);

package/src/hono/index.ts

@@ -42,7 +42,8 @@ export type {
   FilterAllowlist,
   SortAllowlist,
 } from "../drizzle-fastify/filter-allowlist.js";
-import { isTruthyFlag, coerceIdForColumn, firstRow } from "../drizzle-fastify/util.js";
+import { isTruthyFlag, coerceIdForColumn, firstRow, extractRowCount } from "../drizzle-fastify/util.js";
+import { supportsReturning, type SqlDialect } from "../sql-dialect.js";
 import { timestampWire } from "../timestamp-wire.js";
 // Every handler below is wrapped in guardRoute (an unexpected error answers
 // `500 { error: "internal" }`, logged server-side) and reads its body through
@@ -104,7 +105,7 @@ export interface CrudRoutesOptions {
   filterAllowlist?: FilterAllowlist;
   sortAllowlist?:   SortAllowlist;
   /** Dialect — required if filterAllowlist or sortAllowlist is set (for dialect-specific `like` lowering: SQLite lowers to GLOB to stay case-sensitive; ADR-0049). */
-  dialect?: "sqlite" | "postgres";
+  dialect?: SqlDialect;
 }
 
 const ALL_VERBS: readonly CrudVerb[] = ["list", "get", "create", "update", "delete"];
@@ -266,15 +267,23 @@ export function mountCreateRoute(opts: VerbOptions): void {
     // Same redaction contract as the Fastify mount: a constraint the DB enforces must not
     // come back as a 500 carrying the SQL and its bound parameters. Both mounts are
     // required to emit byte-identical responses (docs/features/api-contract.md).
-    let result: unknown;
+    let row: unknown;
     try {
-      result = await opts.db.insert(opts.table).values(parsed.data).returning();
+      if (supportsReturning(opts.dialect)) {
+        row = ((await opts.db.insert(opts.table).values(parsed.data).returning()) as unknown[])[0];
+      } else {
+        // MySQL has no RETURNING — the Fastify mount's rule; see drizzle-fastify/index.ts.
+        const values = parsed.data as Record<string, unknown>;
+        const [inserted] = (await opts.db.insert(opts.table).values(values).$returningId()) as
+          Array<Record<string, unknown> | undefined>;
+        const key = values.id ?? inserted?.id;
+        row = key === undefined ? undefined : await firstRow(opts.db, opts.table, eq(opts.table.id, key));
+      }
     } catch (err) {
       const f = classifyConstraintError(err);
       if (f === undefined) { logAndRedact(err); throw new RedactedDatabaseError(); }
       return c.json(f.body, f.status as 400 | 409);
     }
-    const row = (result as unknown[])[0];
     // Echo the row through the replica view so derived columns are present (#214).
     return c.json(toWire(await reReadThroughView(opts, row)), 201);
   }));
@@ -303,19 +312,19 @@ export function mountUpdateRoute(opts: VerbOptions): void {
     // LOOKING id on a TEXT pk would otherwise UPDATE the wrong row.
     const idValue = coerceIdForColumn(opts.table.id, id);
     if (idValue === undefined) return c.json({ error: "invalid_id" }, 400);
-    let result: unknown;
+    let row: unknown;
     try {
-      result = await opts.db
-        .update(opts.table)
-        .set(parsed.data)
-        .where(eq(opts.table.id, idValue))
-        .returning();
+      if (supportsReturning(opts.dialect)) {
+        row = ((await opts.db.update(opts.table).set(parsed.data).where(eq(opts.table.id, idValue)).returning()) as unknown[])[0];
+      } else {
+        await opts.db.update(opts.table).set(parsed.data).where(eq(opts.table.id, idValue));
+        row = await firstRow(opts.db, opts.table, eq(opts.table.id, idValue));
+      }
     } catch (err) {
       const f = classifyConstraintError(err);
       if (f === undefined) { logAndRedact(err); throw new RedactedDatabaseError(); }
       return c.json(f.body, f.status as 400 | 409);
     }
-    const row = (result as unknown[])[0];
     return row ? c.json(toWire(await reReadThroughView(opts, row))) : c.json({ error: "not_found" }, 404);
   });
   const path = `${opts.path}/:id`;
@@ -358,20 +367,6 @@ export function mountDeleteRoute(opts: VerbOptions): void {
   }));
 }
 
-function extractRowCount(result: unknown): number {
-  if (typeof result === "number") return result;
-  if (Array.isArray(result)) return result.length;
-  if (result && typeof result === "object") {
-    const obj = result as { rowsAffected?: number | bigint; rowCount?: number; changes?: number };
-    if (typeof obj.rowsAffected === "number") return obj.rowsAffected;
-    if (typeof obj.rowsAffected === "bigint") return Number(obj.rowsAffected);
-    if (typeof obj.rowCount === "number") return obj.rowCount;
-    // bun:sqlite / better-sqlite3 run() result shape.
-    if (typeof obj.changes === "number") return obj.changes;
-  }
-  return 0;
-}
-
 export { mountReadOnlyCrudRoutes, type MountReadOnlyOptions } from "./mount-read-only.js";
 
 // ---------------------------------------------------------------------------

package/src/hono/mount-read-only.ts

@@ -2,6 +2,7 @@
 // GET :id only. POST/PATCH/PUT/DELETE return 405. Mirrors the drizzle-fastify
 // equivalent so the cross-port API contract holds for projection endpoints.
 
+import { quoteIdent, type SqlDialect } from "../sql-dialect.js";
 import type { Hono } from "hono";
 import { sql, eq, and, count } from "drizzle-orm";
 import qs from "qs";
@@ -28,7 +29,7 @@ export interface MountReadOnlyOptions {
   readonly view: AnyView;
   readonly filterAllowlist: FilterAllowlist;
   readonly sortAllowlist: SortAllowlist;
-  readonly dialect: "postgres" | "sqlite";
+  readonly dialect: SqlDialect;
   /** Override default ID column name (defaults to "id"). */
   readonly idColumn?: string;
 }
@@ -96,6 +97,11 @@ async function rawRows(db: any, dialect: string | undefined, query: unknown): Pr
     if (Array.isArray(res)) return res as Record<string, unknown>[];
     return (res as { rows?: Record<string, unknown>[] } | null)?.rows ?? [];
   }
+  if (dialect === "mysql") {
+    // mysql2 answers `[rows, fields]`.
+    const [rows] = (await db.execute(query)) as [Record<string, unknown>[], unknown];
+    return rows;
+  }
   return (await db.all(query)) as Record<string, unknown>[];
 }
 
@@ -121,11 +127,11 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
         const offsetVal = parsePageBound(parsed, "offset") ?? 0;
         const withCount = isTruthyFlag(parsed["withCount"]);
         // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-        const rows = (await rawRows(db, dialect, sql.raw(`SELECT * FROM "${viewName}" LIMIT ${limitVal} OFFSET ${offsetVal}`))) as any[];
+        const rows = (await rawRows(db, dialect, sql.raw(`SELECT * FROM ${quoteIdent(dialect, viewName)} LIMIT ${limitVal} OFFSET ${offsetVal}`))) as any[];
         const camelRows = rows.map((r: Record<string, unknown>) => camelizeRow(r));
         if (!withCount) return c.json(camelRows);
         // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-        const countRows = (await rawRows(db, dialect, sql.raw(`SELECT COUNT(*) AS c FROM "${viewName}"`))) as any[];
+        const countRows = (await rawRows(db, dialect, sql.raw(`SELECT COUNT(*) AS c FROM ${quoteIdent(dialect, viewName)}`))) as any[];
         const total: number = Number(countRows[0]?.c ?? 0);
         return c.json({ rows: camelRows, total });
       }
@@ -179,7 +185,7 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
     const id = c.req.param("id") ?? "";
     if (useRawSql) {
       // biome-ignore lint/suspicious/noExplicitAny: dynamic raw result
-      const rows = (await rawRows(db, dialect, sql.raw(`SELECT * FROM "${viewName}" WHERE "${idCol}" = ${rawIdLiteral(id)} LIMIT 1`))) as any[];
+      const rows = (await rawRows(db, dialect, sql.raw(`SELECT * FROM ${quoteIdent(dialect, viewName)} WHERE ${quoteIdent(dialect, idCol)} = ${rawIdLiteral(id)} LIMIT 1`))) as any[];
       const row = rows[0] ? camelizeRow(rows[0]) : undefined;
       return row ? c.json(row) : c.json({ error: "not_found" }, 404);
     }

package/src/object-manager.ts

@@ -10,7 +10,7 @@ import type {
 } from "./persistence-driver.js";
 import {
   buildSelectSpec, buildCountSpec, buildInsertSpec, buildUpdateSpec, buildDeleteSpec,
-  resolvePkFields, compileFilter,
+  resolvePkFields, compileFilter, primaryKeyColumns,
   type Filter, type QueryOpts, type DiscriminatorScope,
 } from "./query-builder.js";
 import { tphSubtypeOf, type TphSubtype } from "./tph.js";
@@ -263,6 +263,7 @@ export class ObjectManager {
       table: resolveTableName(entity),
       rows: validatedRows.map((r) => this.toDbRow(entity, coerceRowOnWrite(entity, r, driver.dialect))),
       returning: this.allDbColumns(entity),
+      key: primaryKeyColumns(entity, this.columnNamingStrategy),
     };
     // Wrap the batch in a transaction so a driver-level constraint failure on row N
     // rolls back rows 1..N-1. Caller-supplied opts.tx already provides this.

package/src/persistence-driver.ts

@@ -2,7 +2,7 @@
 // The driver IS the unit of transaction — transaction(fn) yields a tx-scoped sub-driver.
 // Java analog: ObjectConnection.
 
-export type Dialect = "sqlite" | "postgres" | "memory";
+export type Dialect = "sqlite" | "postgres" | "mysql" | "memory";
 
 export type PrimitiveValue = string | number | boolean;
 
@@ -42,12 +42,19 @@ export interface InsertSpec {
   values: Row;
   /** Columns to return — driver handles RETURNING / lastInsertId per dialect. */
   returning: string[];
+  /**
+   * The primary-key columns. A dialect without RETURNING (MySQL) reads the inserted row
+   * back by them; the others ignore it.
+   */
+  key?: string[];
 }
 
 export interface InsertManySpec {
   table: string;
   rows: Row[];
   returning: string[];
+  /** As {@link InsertSpec.key}. */
+  key?: string[];
 }
 
 export interface UpdateSpec {