prisma-ts-select 0.0.33 → 0.1.2

package/dist/extend/dialects/index.js

@@ -0,0 +1,186 @@
+// src/dialects/types.ts
+var SUPPORTED_PROVIDERS = ["sqlite", "mysql", "postgresql"];
+
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/sqlite.ts
+var SQLITE_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "REAL", "NUMERIC", "BLOB"]);
+var dateArg = (col, quoteFn) => {
+  if (typeof col !== "string") return col.sql;
+  const ref = quoteFn(col);
+  return `CASE WHEN typeof(${ref}) = 'integer' THEN datetime(${ref}/1000, 'unixepoch') ELSE ${ref} END`;
+};
+var sqliteContextFns = (quoteFn, condFn) => ({
+  avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
+  // SQLite SUM returns INTEGER (→ bigint) for integer columns, REAL (→ number) for float columns
+  sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
+  // Aggregate integer-result fns — SQLite returns INTEGER → bigint
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  // LENGTH returns INTEGER → bigint in SQLite
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  groupConcat: (col, sep) => sqlExpr(`GROUP_CONCAT(${quoteFn(col)}${sep !== void 0 ? `, '${sep.replace(/'/g, "''")}'` : ""})`),
+  total: (col) => sqlExpr(`TOTAL(${quoteFn(col)})`),
+  // SQLite MIN/MAX return bigint for integer columns — override base (number) return types
+  min: (col) => sqlExpr(`MIN(${quoteFn(col)})`),
+  max: (col) => sqlExpr(`MAX(${quoteFn(col)})`),
+  concat: (...args) => {
+    if (args.length === 0) throw new Error("concat: requires at least one argument");
+    return sqlExpr(args.map((a) => resolveArg(a, quoteFn)).join(" || "));
+  },
+  substr: (col, start, len) => sqlExpr(`SUBSTR(${resolveArg(col, quoteFn)}, ${start}${len !== void 0 ? `, ${len}` : ""})`),
+  instr: (col, substr) => sqlExpr(`INSTR(${resolveArg(col, quoteFn)}, '${substr.replace(/'/g, "''")}')`),
+  char: (...codes) => sqlExpr(`CHAR(${codes.join(", ")})`),
+  hex: (col) => sqlExpr(`HEX(${resolveArg(col, quoteFn)})`),
+  unicode: (col) => sqlExpr(`UNICODE(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  // Note: SQLite has no GREATEST()/LEAST() functions — it uses scalar MAX(a,b)/MIN(a,b) instead.
+  // Omitted here because the naming diverges from the MySQL/PG convention.
+  iif: (cond, trueVal, falseVal) => {
+    const condSql = typeof cond === "object" && cond !== null && "sql" in cond ? cond.sql : condFn(cond);
+    return sqlExpr(`IIF(${condSql}, ${trueVal.sql}, ${falseVal.sql})`);
+  },
+  ifNull: (col, fallback) => sqlExpr(`IFNULL(${resolveArg(col, quoteFn)}, ${fallback.sql})`),
+  // DateTime overrides
+  now: () => sqlExpr(`datetime('now')`),
+  curDate: () => sqlExpr(`date('now')`),
+  year: (col) => sqlExpr(`strftime('%Y', ${dateArg(col, quoteFn)})`),
+  month: (col) => sqlExpr(`strftime('%m', ${dateArg(col, quoteFn)})`),
+  day: (col) => sqlExpr(`strftime('%d', ${dateArg(col, quoteFn)})`),
+  hour: (col) => sqlExpr(`strftime('%H', ${dateArg(col, quoteFn)})`),
+  minute: (col) => sqlExpr(`strftime('%M', ${dateArg(col, quoteFn)})`),
+  second: (col) => sqlExpr(`strftime('%S', ${dateArg(col, quoteFn)})`),
+  // SQLite-only DateTime fns
+  /**
+   * SQLite `strftime` returns `NULL` if the date value is `NULL` or cannot be parsed.
+   * Unknown format directives (e.g. `%q`) are passed through literally, not as errors.
+   */
+  strftime: (fmt, col) => sqlExpr(`strftime('${fmt.replace(/'/g, "''")}', ${dateArg(col, quoteFn)})`),
+  julianday: (col) => sqlExpr(`julianday(${dateArg(col, quoteFn)})`),
+  date: (col) => sqlExpr(`date(${dateArg(col, quoteFn)})`),
+  datetime: (col) => sqlExpr(`datetime(${dateArg(col, quoteFn)})`),
+  // ── Math ─────────────────────────────────────────────────────────────────
+  // SQLite returns bigint for integer results (ceil, floor, sign, mod) and number for floats.
+  // All inputs accept SQLExpr<number | bigint> so composed calls (e.g. sqrt(power(...))) type-check.
+  // sqrt/exp always return REAL, so they are typed as number.
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  round: (col, decimals) => sqlExpr(decimals !== void 0 ? `ROUND(${resolveArg(col, quoteFn)}, ${decimals})` : `ROUND(${resolveArg(col, quoteFn)})`),
+  // SQLite's POWER() always returns REAL regardless of input type
+  power: (base, exp) => sqlExpr(`POWER(${resolveArg(base, quoteFn)}, ${typeof exp === "number" ? exp : exp.sql})`),
+  sqrt: (col) => sqlExpr(`SQRT(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`),
+  exp: (col) => sqlExpr(`EXP(${resolveArg(col, quoteFn)})`),
+  // ── Math (SQLite 3.35+) ──────────────────────────────────────────────────
+  // SQLite RANDOM() returns a 64-bit signed integer — always bigint
+  random: () => sqlExpr("RANDOM()"),
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  log2: (x) => sqlExpr(`LOG2(${resolveArg(x, quoteFn)})`),
+  log10: (x) => sqlExpr(`LOG10(${resolveArg(x, quoteFn)})`),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!SQLITE_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var sqliteDialect = {
+  name: "sqlite",
+  needsBooleanCoercion: () => true,
+  quote: (name, _isAlias) => {
+    if (_isAlias) return "`" + name + "`";
+    return name;
+  },
+  quoteTableIdentifier: (name, _isAlias) => {
+    if (_isAlias) return "`" + name + "`";
+    return name;
+  },
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return ref;
+    const [table, col] = ref.split(".", 2);
+    return `${table}.${col}`;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `${table}.${col}`;
+    })() : `${colRef}`;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+// src/dialects/mysql.ts
+var mysqlDialect = {
+  name: "mysql",
+  needsBooleanCoercion: () => true,
+  quote: (id, _isAlias) => `\`${id}\``,
+  quoteTableIdentifier: (name, _isAlias) => `\`${name}\``,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `\`${ref}\``;
+    const [table, col] = ref.split(".", 2);
+    return `\`${table}\`.\`${col}\``;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `\`${table}\`.\`${col}\``;
+    })() : `\`${colRef}\``;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+// src/dialects/postgresql.ts
+var postgresqlDialect = {
+  name: "postgresql",
+  needsBooleanCoercion: () => false,
+  quote: (id, _isAlias) => `"${id}"`,
+  quoteTableIdentifier: (name, _isAlias) => `"${name}"`,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `"${ref}"`;
+    const [table, col] = ref.split(".", 2);
+    return `"${table}"."${col}"`;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `"${table}"."${col}"`;
+    })() : `"${colRef}"`;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+// src/dialects/index.ts
+function getDialect(provider) {
+  switch (provider) {
+    case "sqlite":
+      return sqliteDialect;
+    case "mysql":
+      return mysqlDialect;
+    case "postgresql":
+      return postgresqlDialect;
+    default:
+      return sqliteDialect;
+  }
+}
+
+export { SUPPORTED_PROVIDERS, sqliteDialect as dialect, sqliteContextFns as dialectContextFns, getDialect, mysqlDialect, postgresqlDialect, sqliteDialect };

package/dist/extend/dialects/mysql-v6.d.ts

@@ -0,0 +1,100 @@
+import { IntervalUnit } from './mysql.js';
+export { mysqlDialect } from './mysql.js';
+import { J as JSONValue } from '../types-D84lxYVc.js';
+import * as _prisma_client_runtime_client from '@prisma/client/runtime/client';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import { ColName, FilterCols } from './shared.js';
+import './types.js';
+
+declare const mysqlV6ContextFns: <TColEntries extends [string, unknown] = never, TCriteria extends object = object>(quoteFn: (ref: string) => string, condFn: (criteria: TCriteria) => string) => {
+    countAll: () => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
+    abs: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    mod: (col: FilterCols<TColEntries, number> | SQLExpr<number>, divisor: number) => SQLExpr<bigint | number>;
+    sign: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    avg: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<_prisma_client_runtime_client.Decimal>;
+    sum: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<_prisma_client_runtime_client.Decimal>;
+    groupConcat: (col: ColName<TColEntries>, sep?: string) => SQLExpr<string>;
+    bitAnd: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitOr: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitXor: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddev: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    variance: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    jsonArrayAgg: (col: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    jsonObjectAgg: (key: ColName<TColEntries>, val: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    concat: (args_0: SQLExpr<string> | FilterCols<TColEntries, string>, ...args: (SQLExpr<string> | FilterCols<TColEntries, string>)[]) => SQLExpr<string>;
+    substring: (col: SQLExpr<string> | FilterCols<TColEntries, string>, start: number, len?: number) => SQLExpr<string>;
+    left: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    right: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    repeat: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    reverse: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    lpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    rpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    locate: (substr: string, col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<bigint>;
+    space: (n: number) => SQLExpr<string>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<bigint>;
+    month: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<bigint>;
+    day: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<bigint>;
+    hour: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<bigint>;
+    minute: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    second: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    $if: <T>(cond: SQLExpr<unknown> | TCriteria, trueVal: SQLExpr<T>, falseVal: SQLExpr<T>) => SQLExpr<T>;
+    ifNull: <T>(col: FilterCols<TColEntries, T> | SQLExpr<T>, fallback: SQLExpr<NonNullable<T>>) => SQLExpr<NonNullable<T>>;
+    greatest: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T | null>;
+    least: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T | null>;
+    dateAdd: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>, n: number, unit: IntervalUnit) => SQLExpr<Date>;
+    dateSub: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>, n: number, unit: IntervalUnit) => SQLExpr<Date>;
+    dateFormat: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>, fmt: string) => SQLExpr<string>;
+    dateDiff: (d1: SQLExpr<Date> | FilterCols<TColEntries, Date>, d2: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    quarter: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<bigint>;
+    weekOfYear: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    dayName: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<string>;
+    lastDay: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<Date>;
+    round: (col: SQLExpr<number> | FilterCols<TColEntries, number>, decimals?: number) => SQLExpr<number>;
+    power: (base: SQLExpr<number> | FilterCols<TColEntries, number>, exp: number | SQLExpr<number>) => SQLExpr<number>;
+    sqrt: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    exp: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    pi: () => SQLExpr<number>;
+    ln: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    log: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    log2: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    log10: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    truncate: (x: SQLExpr<number> | FilterCols<TColEntries, number>, n: number) => SQLExpr<number>;
+    rand: (seed?: number) => SQLExpr<number>;
+    cast: <T extends keyof {
+        SIGNED: bigint;
+        UNSIGNED: bigint;
+        DECIMAL: _prisma_client_runtime_client.Decimal;
+        CHAR: string;
+        BINARY: Buffer;
+        DATE: Date;
+        DATETIME: Date;
+        TIME: string;
+        JSON: JSONValue;
+        FLOAT: number;
+        DOUBLE: number;
+    }>(expr: SQLExpr<unknown> | ColName<TColEntries>, type: T) => SQLExpr<{
+        SIGNED: bigint;
+        UNSIGNED: bigint;
+        DECIMAL: _prisma_client_runtime_client.Decimal;
+        CHAR: string;
+        BINARY: Buffer;
+        DATE: Date;
+        DATETIME: Date;
+        TIME: string;
+        JSON: JSONValue;
+        FLOAT: number;
+        DOUBLE: number;
+    }[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, TCriteria extends object = object> = ReturnType<typeof mysqlV6ContextFns<TColEntries, TCriteria>>;
+
+export { type DialectFns, IntervalUnit, mysqlV6ContextFns };

package/dist/extend/dialects/mysql-v6.js

@@ -0,0 +1,152 @@
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/shared.ts
+var esc = (s) => s.replace(/'/g, "''");
+
+// src/dialects/mysql.ts
+var MYSQL_CAST_TYPES = /* @__PURE__ */ new Set(["SIGNED", "UNSIGNED", "DECIMAL", "CHAR", "BINARY", "DATE", "DATETIME", "TIME", "JSON", "FLOAT", "DOUBLE"]);
+var mysqlContextFns = (quoteFn, condFn) => ({
+  avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
+  sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  groupConcat: (col, sep) => sqlExpr(`GROUP_CONCAT(${quoteFn(col)}${sep !== void 0 ? ` SEPARATOR '${esc(sep)}'` : ""})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  bitXor: (col) => sqlExpr(`BIT_XOR(${quoteFn(col)})`),
+  stddev: (col) => sqlExpr(`STDDEV(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  variance: (col) => sqlExpr(`VARIANCE(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  jsonArrayAgg: (col) => sqlExpr(`JSON_ARRAYAGG(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECTAGG(${quoteFn(key)}, ${quoteFn(val)})`),
+  concat: (...args) => {
+    if (args.length === 0) throw new Error("concat: requires at least one argument");
+    return sqlExpr(`CONCAT(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  substring: (col, start, len) => sqlExpr(`SUBSTRING(${resolveArg(col, quoteFn)}, ${start}${len !== void 0 ? `, ${len}` : ""})`),
+  left: (col, n) => sqlExpr(`LEFT(${resolveArg(col, quoteFn)}, ${n})`),
+  right: (col, n) => sqlExpr(`RIGHT(${resolveArg(col, quoteFn)}, ${n})`),
+  repeat: (col, n) => sqlExpr(`REPEAT(${resolveArg(col, quoteFn)}, ${n})`),
+  reverse: (col) => sqlExpr(`REVERSE(${resolveArg(col, quoteFn)})`),
+  lpad: (col, len, pad) => sqlExpr(`LPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  rpad: (col, len, pad) => sqlExpr(`RPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  locate: (substr, col) => sqlExpr(`LOCATE('${esc(substr)}', ${resolveArg(col, quoteFn)})`),
+  space: (n) => sqlExpr(`SPACE(${n})`),
+  // DateTime base fns (MySQL defaults)
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURDATE()"),
+  year: (col) => sqlExpr(`YEAR(${resolveArg(col, quoteFn)})`),
+  month: (col) => sqlExpr(`MONTH(${resolveArg(col, quoteFn)})`),
+  day: (col) => sqlExpr(`DAY(${resolveArg(col, quoteFn)})`),
+  hour: (col) => sqlExpr(`HOUR(${resolveArg(col, quoteFn)})`),
+  minute: (col) => sqlExpr(`MINUTE(${resolveArg(col, quoteFn)})`),
+  second: (col) => sqlExpr(`SECOND(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  $if: (cond, trueVal, falseVal) => {
+    const condSql = typeof cond === "object" && cond !== null && "sql" in cond ? cond.sql : condFn(cond);
+    return sqlExpr(`IF(${condSql}, ${trueVal.sql}, ${falseVal.sql})`);
+  },
+  ifNull: (col, fallback) => sqlExpr(`IFNULL(${resolveArg(col, quoteFn)}, ${fallback.sql})`),
+  // NULL-poisoned: returns NULL if any arg is NULL
+  greatest: (...args) => {
+    if (args.length === 0) throw new Error("greatest: requires at least one argument");
+    return sqlExpr(`GREATEST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // NULL-poisoned: returns NULL if any arg is NULL
+  least: (...args) => {
+    if (args.length === 0) throw new Error("least: requires at least one argument");
+    return sqlExpr(`LEAST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // DateTime fns (MySQL-only)
+  dateAdd: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateAdd: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_ADD(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  dateSub: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateSub: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_SUB(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  /**
+   * MySQL `DATE_FORMAT` returns `NULL` if the date column value is `NULL`.
+   * Unknown format specifiers are passed through literally, not as errors.
+   */
+  dateFormat: (col, fmt) => sqlExpr(`DATE_FORMAT(${resolveArg(col, quoteFn)}, '${esc(fmt)}')`),
+  dateDiff: (d1, d2) => sqlExpr(`DATEDIFF(${resolveArg(d1, quoteFn)}, ${resolveArg(d2, quoteFn)})`),
+  quarter: (col) => sqlExpr(`QUARTER(${resolveArg(col, quoteFn)})`),
+  weekOfYear: (col) => sqlExpr(`WEEKOFYEAR(${resolveArg(col, quoteFn)})`),
+  dayName: (col) => sqlExpr(`DAYNAME(${resolveArg(col, quoteFn)})`),
+  lastDay: (col) => sqlExpr(`LAST_DAY(${resolveArg(col, quoteFn)})`),
+  // ── Math ─────────────────────────────────────────────────────────────────
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  round: (col, decimals) => sqlExpr(decimals !== void 0 ? `ROUND(${resolveArg(col, quoteFn)}, ${decimals})` : `ROUND(${resolveArg(col, quoteFn)})`),
+  power: (base, exp) => sqlExpr(`POWER(${resolveArg(base, quoteFn)}, ${typeof exp === "number" ? exp : exp.sql})`),
+  sqrt: (col) => sqlExpr(`SQRT(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`),
+  exp: (col) => sqlExpr(`EXP(${resolveArg(col, quoteFn)})`),
+  // ── Math (MySQL-specific) ─────────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  /** Natural log (ln(x)). Use `log10(x)` for base-10. Note: PG `log(x)` is base-10 — opposite semantics. */
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  log2: (x) => sqlExpr(`LOG2(${resolveArg(x, quoteFn)})`),
+  log10: (x) => sqlExpr(`LOG10(${resolveArg(x, quoteFn)})`),
+  truncate: (x, n) => sqlExpr(`TRUNCATE(${resolveArg(x, quoteFn)}, ${n})`),
+  rand: (seed) => sqlExpr(seed !== void 0 ? `RAND(${seed})` : "RAND()"),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!MYSQL_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var mysqlDialect = {
+  name: "mysql",
+  needsBooleanCoercion: () => true,
+  quote: (id, _isAlias) => `\`${id}\``,
+  quoteTableIdentifier: (name, _isAlias) => `\`${name}\``,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `\`${ref}\``;
+    const [table, col] = ref.split(".", 2);
+    return `\`${table}\`.\`${col}\``;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `\`${table}\`.\`${col}\``;
+    })() : `\`${colRef}\``;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+// src/dialects/mysql-v6.ts
+var mysqlV6ContextFns = (quoteFn, condFn) => ({
+  ...mysqlContextFns(quoteFn, condFn),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`)
+});
+
+export { mysqlDialect, mysqlV6ContextFns };

package/dist/extend/dialects/mysql-v7.d.ts

@@ -0,0 +1,6 @@
+export { DialectFns, IntervalUnit, mysqlDialect, mysqlContextFns as mysqlV7ContextFns } from './mysql.js';
+import './types.js';
+import '../sql-expr-BaKWzJ-r.js';
+import '../types-D84lxYVc.js';
+import '@prisma/client/runtime/client';
+import './shared.js';

package/dist/extend/dialects/mysql-v7.js

@@ -0,0 +1,138 @@
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/shared.ts
+var esc = (s) => s.replace(/'/g, "''");
+
+// src/dialects/mysql.ts
+var MYSQL_CAST_TYPES = /* @__PURE__ */ new Set(["SIGNED", "UNSIGNED", "DECIMAL", "CHAR", "BINARY", "DATE", "DATETIME", "TIME", "JSON", "FLOAT", "DOUBLE"]);
+var mysqlContextFns = (quoteFn, condFn) => ({
+  avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
+  sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  groupConcat: (col, sep) => sqlExpr(`GROUP_CONCAT(${quoteFn(col)}${sep !== void 0 ? ` SEPARATOR '${esc(sep)}'` : ""})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  bitXor: (col) => sqlExpr(`BIT_XOR(${quoteFn(col)})`),
+  stddev: (col) => sqlExpr(`STDDEV(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  variance: (col) => sqlExpr(`VARIANCE(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  jsonArrayAgg: (col) => sqlExpr(`JSON_ARRAYAGG(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECTAGG(${quoteFn(key)}, ${quoteFn(val)})`),
+  concat: (...args) => {
+    if (args.length === 0) throw new Error("concat: requires at least one argument");
+    return sqlExpr(`CONCAT(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  substring: (col, start, len) => sqlExpr(`SUBSTRING(${resolveArg(col, quoteFn)}, ${start}${len !== void 0 ? `, ${len}` : ""})`),
+  left: (col, n) => sqlExpr(`LEFT(${resolveArg(col, quoteFn)}, ${n})`),
+  right: (col, n) => sqlExpr(`RIGHT(${resolveArg(col, quoteFn)}, ${n})`),
+  repeat: (col, n) => sqlExpr(`REPEAT(${resolveArg(col, quoteFn)}, ${n})`),
+  reverse: (col) => sqlExpr(`REVERSE(${resolveArg(col, quoteFn)})`),
+  lpad: (col, len, pad) => sqlExpr(`LPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  rpad: (col, len, pad) => sqlExpr(`RPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  locate: (substr, col) => sqlExpr(`LOCATE('${esc(substr)}', ${resolveArg(col, quoteFn)})`),
+  space: (n) => sqlExpr(`SPACE(${n})`),
+  // DateTime base fns (MySQL defaults)
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURDATE()"),
+  year: (col) => sqlExpr(`YEAR(${resolveArg(col, quoteFn)})`),
+  month: (col) => sqlExpr(`MONTH(${resolveArg(col, quoteFn)})`),
+  day: (col) => sqlExpr(`DAY(${resolveArg(col, quoteFn)})`),
+  hour: (col) => sqlExpr(`HOUR(${resolveArg(col, quoteFn)})`),
+  minute: (col) => sqlExpr(`MINUTE(${resolveArg(col, quoteFn)})`),
+  second: (col) => sqlExpr(`SECOND(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  $if: (cond, trueVal, falseVal) => {
+    const condSql = typeof cond === "object" && cond !== null && "sql" in cond ? cond.sql : condFn(cond);
+    return sqlExpr(`IF(${condSql}, ${trueVal.sql}, ${falseVal.sql})`);
+  },
+  ifNull: (col, fallback) => sqlExpr(`IFNULL(${resolveArg(col, quoteFn)}, ${fallback.sql})`),
+  // NULL-poisoned: returns NULL if any arg is NULL
+  greatest: (...args) => {
+    if (args.length === 0) throw new Error("greatest: requires at least one argument");
+    return sqlExpr(`GREATEST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // NULL-poisoned: returns NULL if any arg is NULL
+  least: (...args) => {
+    if (args.length === 0) throw new Error("least: requires at least one argument");
+    return sqlExpr(`LEAST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // DateTime fns (MySQL-only)
+  dateAdd: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateAdd: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_ADD(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  dateSub: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateSub: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_SUB(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  /**
+   * MySQL `DATE_FORMAT` returns `NULL` if the date column value is `NULL`.
+   * Unknown format specifiers are passed through literally, not as errors.
+   */
+  dateFormat: (col, fmt) => sqlExpr(`DATE_FORMAT(${resolveArg(col, quoteFn)}, '${esc(fmt)}')`),
+  dateDiff: (d1, d2) => sqlExpr(`DATEDIFF(${resolveArg(d1, quoteFn)}, ${resolveArg(d2, quoteFn)})`),
+  quarter: (col) => sqlExpr(`QUARTER(${resolveArg(col, quoteFn)})`),
+  weekOfYear: (col) => sqlExpr(`WEEKOFYEAR(${resolveArg(col, quoteFn)})`),
+  dayName: (col) => sqlExpr(`DAYNAME(${resolveArg(col, quoteFn)})`),
+  lastDay: (col) => sqlExpr(`LAST_DAY(${resolveArg(col, quoteFn)})`),
+  // ── Math ─────────────────────────────────────────────────────────────────
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  round: (col, decimals) => sqlExpr(decimals !== void 0 ? `ROUND(${resolveArg(col, quoteFn)}, ${decimals})` : `ROUND(${resolveArg(col, quoteFn)})`),
+  power: (base, exp) => sqlExpr(`POWER(${resolveArg(base, quoteFn)}, ${typeof exp === "number" ? exp : exp.sql})`),
+  sqrt: (col) => sqlExpr(`SQRT(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`),
+  exp: (col) => sqlExpr(`EXP(${resolveArg(col, quoteFn)})`),
+  // ── Math (MySQL-specific) ─────────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  /** Natural log (ln(x)). Use `log10(x)` for base-10. Note: PG `log(x)` is base-10 — opposite semantics. */
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  log2: (x) => sqlExpr(`LOG2(${resolveArg(x, quoteFn)})`),
+  log10: (x) => sqlExpr(`LOG10(${resolveArg(x, quoteFn)})`),
+  truncate: (x, n) => sqlExpr(`TRUNCATE(${resolveArg(x, quoteFn)}, ${n})`),
+  rand: (seed) => sqlExpr(seed !== void 0 ? `RAND(${seed})` : "RAND()"),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!MYSQL_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var mysqlDialect = {
+  name: "mysql",
+  needsBooleanCoercion: () => true,
+  quote: (id, _isAlias) => `\`${id}\``,
+  quoteTableIdentifier: (name, _isAlias) => `\`${name}\``,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `\`${ref}\``;
+    const [table, col] = ref.split(".", 2);
+    return `\`${table}\`.\`${col}\``;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `\`${table}\`.\`${col}\``;
+    })() : `\`${colRef}\``;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+export { mysqlDialect, mysqlContextFns as mysqlV7ContextFns };