prisma-ts-select 0.0.34 → 0.1.2

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

@@ -0,0 +1,136 @@
+// 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/postgresql.ts
+var PG_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "BIGINT", "BOOLEAN", "REAL", "NUMERIC", "DATE", "TIMESTAMP", "JSON", "JSONB"]);
+var postgresqlContextFns = (quoteFn) => ({
+  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)})`),
+  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${quoteFn(col)}, '${esc(sep)}')`),
+  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${quoteFn(col)})`),
+  stddevPop: (col) => sqlExpr(`STDDEV_POP(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  varPop: (col) => sqlExpr(`VAR_POP(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  boolAnd: (col) => sqlExpr(`BOOL_AND(${quoteFn(col)})`),
+  boolOr: (col) => sqlExpr(`BOOL_OR(${quoteFn(col)})`),
+  jsonAgg: (col) => sqlExpr(`JSON_AGG(${quoteFn(col)})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECT_AGG(${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)}')`),
+  initcap: (col) => sqlExpr(`INITCAP(${resolveArg(col, quoteFn)})`),
+  strpos: (col, substr) => sqlExpr(`STRPOS(${resolveArg(col, quoteFn)}, '${esc(substr)}')`),
+  splitPart: (col, delimiter, field) => sqlExpr(`SPLIT_PART(${resolveArg(col, quoteFn)}, '${esc(delimiter)}', ${field})`),
+  btrim: (col, chars) => sqlExpr(`BTRIM(${resolveArg(col, quoteFn)}${chars !== void 0 ? `, '${esc(chars)}'` : ""})`),
+  md5: (col) => sqlExpr(`MD5(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  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(", ")})`);
+  },
+  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 overrides
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURRENT_DATE"),
+  year: (col) => sqlExpr(`EXTRACT(YEAR FROM ${resolveArg(col, quoteFn)})::integer`),
+  month: (col) => sqlExpr(`EXTRACT(MONTH FROM ${resolveArg(col, quoteFn)})::integer`),
+  day: (col) => sqlExpr(`EXTRACT(DAY FROM ${resolveArg(col, quoteFn)})::integer`),
+  hour: (col) => sqlExpr(`EXTRACT(HOUR FROM ${resolveArg(col, quoteFn)})::integer`),
+  minute: (col) => sqlExpr(`EXTRACT(MINUTE FROM ${resolveArg(col, quoteFn)})::integer`),
+  second: (col) => sqlExpr(`EXTRACT(SECOND FROM ${resolveArg(col, quoteFn)})::integer`),
+  // PG-only DateTime fns
+  extract: (field, col) => sqlExpr(`EXTRACT(${field} FROM ${resolveArg(col, quoteFn)})`),
+  dateTrunc: (unit, col) => sqlExpr(`DATE_TRUNC('${unit}', ${resolveArg(col, quoteFn)})`),
+  /**
+   * PG `AGE()` returns an `interval`. Typed as `string` since node-postgres serializes
+   * intervals as strings (e.g. `"1 year 2 mons 3 days"`). Arithmetic on the result
+   * must be done in SQL, not JS — use `sqlExpr` to compose further expressions.
+   */
+  age: (ts1, ts2) => sqlExpr(ts2 !== void 0 ? `AGE(${resolveArg(ts1, quoteFn)}, ${resolveArg(ts2, quoteFn)})` : `AGE(${resolveArg(ts1, quoteFn)})`),
+  toDate: (text, fmt) => sqlExpr(`TO_DATE(${resolveArg(text, quoteFn)}, '${esc(fmt)}')`),
+  // ── 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 (PostgreSQL-specific) ────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  logBase: (base, x) => sqlExpr(`LOG(${base}, ${resolveArg(x, quoteFn)})`),
+  trunc: (x, n) => sqlExpr(n !== void 0 ? `TRUNC(${resolveArg(x, quoteFn)}, ${n})` : `TRUNC(${resolveArg(x, quoteFn)})`),
+  div: (x, y) => sqlExpr(`DIV(${resolveArg(x, quoteFn)}, ${y})`),
+  random: () => sqlExpr("RANDOM()"),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!PG_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+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/postgresql-v7.ts
+var postgresqlV7ContextFns = (quoteFn) => ({
+  ...postgresqlContextFns(quoteFn),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`)
+});
+
+export { postgresqlDialect, postgresqlV7ContextFns };

package/dist/extend/dialects/postgresql.d.ts

@@ -0,0 +1,89 @@
+import { Dialect } from './types.js';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import { J as JSONValue } from '../types-D84lxYVc.js';
+import { FilterCols, ColName } from './shared.js';
+import '@prisma/client/runtime/client';
+
+type PgCastTypeMap = {
+    INTEGER: number;
+    TEXT: string;
+    BIGINT: bigint;
+    BOOLEAN: boolean;
+    REAL: number;
+    NUMERIC: number;
+    DATE: Date;
+    TIMESTAMP: Date;
+    JSON: JSONValue;
+    JSONB: JSONValue;
+};
+type PgExtractField = 'YEAR' | 'MONTH' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'DOW' | 'DOY' | 'EPOCH' | 'WEEK' | 'QUARTER';
+type PgDateTruncUnit = 'microseconds' | 'milliseconds' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year' | 'decade' | 'century' | 'millennium';
+declare const postgresqlContextFns: <TColEntries extends [string, unknown] = never>(quoteFn: (ref: string) => string) => {
+    avg: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    sum: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    countAll: () => SQLExpr<number>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<number>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<number>;
+    length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<number>;
+    stringAgg: (col: ColName<TColEntries>, sep: string) => SQLExpr<string>;
+    arrayAgg: (col: ColName<TColEntries>) => SQLExpr<unknown[]>;
+    stddevPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    boolAnd: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    boolOr: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    jsonAgg: (col: ColName<TColEntries>) => SQLExpr<JSONValue[]>;
+    bitAnd: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitOr: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    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: FilterCols<TColEntries, string> | SQLExpr<string>, start: number, len?: number) => SQLExpr<string>;
+    left: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    right: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    repeat: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    reverse: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<string>;
+    lpad: (col: FilterCols<TColEntries, string> | SQLExpr<string>, len: number, pad: string) => SQLExpr<string>;
+    rpad: (col: FilterCols<TColEntries, string> | SQLExpr<string>, len: number, pad: string) => SQLExpr<string>;
+    initcap: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<string>;
+    strpos: (col: FilterCols<TColEntries, string> | SQLExpr<string>, substr: string) => SQLExpr<number>;
+    splitPart: (col: FilterCols<TColEntries, string> | SQLExpr<string>, delimiter: string, field: number) => SQLExpr<string>;
+    btrim: (col: FilterCols<TColEntries, string> | SQLExpr<string>, chars?: string) => SQLExpr<string>;
+    md5: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<string>;
+    greatest: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    least: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    month: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    day: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    hour: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    minute: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    second: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    extract: (field: PgExtractField, col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    dateTrunc: (unit: PgDateTruncUnit, col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<Date>;
+    age: (ts1: FilterCols<TColEntries, Date> | SQLExpr<Date>, ts2?: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    toDate: (text: FilterCols<TColEntries, string> | SQLExpr<string>, fmt: string) => SQLExpr<Date>;
+    abs: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    round: (col: FilterCols<TColEntries, number> | SQLExpr<number>, decimals?: number) => SQLExpr<number>;
+    power: (base: FilterCols<TColEntries, number> | SQLExpr<number>, exp: number | SQLExpr<number>) => SQLExpr<number>;
+    sqrt: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    mod: (col: FilterCols<TColEntries, number> | SQLExpr<number>, divisor: number) => SQLExpr<number>;
+    sign: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    exp: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    pi: () => SQLExpr<number>;
+    ln: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    logBase: (base: number, x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    trunc: (x: FilterCols<TColEntries, number> | SQLExpr<number>, n?: number) => SQLExpr<number>;
+    div: (x: FilterCols<TColEntries, number> | SQLExpr<number>, y: number) => SQLExpr<number>;
+    random: () => SQLExpr<number>;
+    cast: <T extends keyof PgCastTypeMap>(expr: ColName<TColEntries> | SQLExpr<unknown>, type: T) => SQLExpr<PgCastTypeMap[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, _TCriteria extends object = object> = ReturnType<typeof postgresqlContextFns<TColEntries>>;
+declare const supportedJoinMethods: readonly ["join", "joinUnsafeTypeEnforced", "joinUnsafeIgnoreType", "innerJoin", "innerJoinUnsafeTypeEnforced", "innerJoinUnsafeIgnoreType", "leftJoin", "leftJoinUnsafeTypeEnforced", "leftJoinUnsafeIgnoreType", "rightJoin", "rightJoinUnsafeTypeEnforced", "rightJoinUnsafeIgnoreType", "fullJoin", "fullJoinUnsafeTypeEnforced", "fullJoinUnsafeIgnoreType", "crossJoin", "crossJoinUnsafeTypeEnforced", "crossJoinUnsafeIgnoreType", "manyToManyJoin"];
+declare const postgresqlDialect: Dialect;
+
+export { type DialectFns, type PgDateTruncUnit, type PgExtractField, postgresqlContextFns, postgresqlDialect, supportedJoinMethods };

package/dist/extend/dialects/postgresql.js

@@ -0,0 +1,147 @@
+// 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/postgresql.ts
+var PG_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "BIGINT", "BOOLEAN", "REAL", "NUMERIC", "DATE", "TIMESTAMP", "JSON", "JSONB"]);
+var postgresqlContextFns = (quoteFn) => ({
+  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)})`),
+  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${quoteFn(col)}, '${esc(sep)}')`),
+  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${quoteFn(col)})`),
+  stddevPop: (col) => sqlExpr(`STDDEV_POP(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  varPop: (col) => sqlExpr(`VAR_POP(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  boolAnd: (col) => sqlExpr(`BOOL_AND(${quoteFn(col)})`),
+  boolOr: (col) => sqlExpr(`BOOL_OR(${quoteFn(col)})`),
+  jsonAgg: (col) => sqlExpr(`JSON_AGG(${quoteFn(col)})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECT_AGG(${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)}')`),
+  initcap: (col) => sqlExpr(`INITCAP(${resolveArg(col, quoteFn)})`),
+  strpos: (col, substr) => sqlExpr(`STRPOS(${resolveArg(col, quoteFn)}, '${esc(substr)}')`),
+  splitPart: (col, delimiter, field) => sqlExpr(`SPLIT_PART(${resolveArg(col, quoteFn)}, '${esc(delimiter)}', ${field})`),
+  btrim: (col, chars) => sqlExpr(`BTRIM(${resolveArg(col, quoteFn)}${chars !== void 0 ? `, '${esc(chars)}'` : ""})`),
+  md5: (col) => sqlExpr(`MD5(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  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(", ")})`);
+  },
+  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 overrides
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURRENT_DATE"),
+  year: (col) => sqlExpr(`EXTRACT(YEAR FROM ${resolveArg(col, quoteFn)})::integer`),
+  month: (col) => sqlExpr(`EXTRACT(MONTH FROM ${resolveArg(col, quoteFn)})::integer`),
+  day: (col) => sqlExpr(`EXTRACT(DAY FROM ${resolveArg(col, quoteFn)})::integer`),
+  hour: (col) => sqlExpr(`EXTRACT(HOUR FROM ${resolveArg(col, quoteFn)})::integer`),
+  minute: (col) => sqlExpr(`EXTRACT(MINUTE FROM ${resolveArg(col, quoteFn)})::integer`),
+  second: (col) => sqlExpr(`EXTRACT(SECOND FROM ${resolveArg(col, quoteFn)})::integer`),
+  // PG-only DateTime fns
+  extract: (field, col) => sqlExpr(`EXTRACT(${field} FROM ${resolveArg(col, quoteFn)})`),
+  dateTrunc: (unit, col) => sqlExpr(`DATE_TRUNC('${unit}', ${resolveArg(col, quoteFn)})`),
+  /**
+   * PG `AGE()` returns an `interval`. Typed as `string` since node-postgres serializes
+   * intervals as strings (e.g. `"1 year 2 mons 3 days"`). Arithmetic on the result
+   * must be done in SQL, not JS — use `sqlExpr` to compose further expressions.
+   */
+  age: (ts1, ts2) => sqlExpr(ts2 !== void 0 ? `AGE(${resolveArg(ts1, quoteFn)}, ${resolveArg(ts2, quoteFn)})` : `AGE(${resolveArg(ts1, quoteFn)})`),
+  toDate: (text, fmt) => sqlExpr(`TO_DATE(${resolveArg(text, quoteFn)}, '${esc(fmt)}')`),
+  // ── 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 (PostgreSQL-specific) ────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  logBase: (base, x) => sqlExpr(`LOG(${base}, ${resolveArg(x, quoteFn)})`),
+  trunc: (x, n) => sqlExpr(n !== void 0 ? `TRUNC(${resolveArg(x, quoteFn)}, ${n})` : `TRUNC(${resolveArg(x, quoteFn)})`),
+  div: (x, y) => sqlExpr(`DIV(${resolveArg(x, quoteFn)}, ${y})`),
+  random: () => sqlExpr("RANDOM()"),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!PG_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var supportedJoinMethods = [
+  "join",
+  "joinUnsafeTypeEnforced",
+  "joinUnsafeIgnoreType",
+  "innerJoin",
+  "innerJoinUnsafeTypeEnforced",
+  "innerJoinUnsafeIgnoreType",
+  "leftJoin",
+  "leftJoinUnsafeTypeEnforced",
+  "leftJoinUnsafeIgnoreType",
+  "rightJoin",
+  "rightJoinUnsafeTypeEnforced",
+  "rightJoinUnsafeIgnoreType",
+  "fullJoin",
+  "fullJoinUnsafeTypeEnforced",
+  "fullJoinUnsafeIgnoreType",
+  "crossJoin",
+  "crossJoinUnsafeTypeEnforced",
+  "crossJoinUnsafeIgnoreType",
+  "manyToManyJoin"
+];
+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;
+  }
+};
+
+export { postgresqlContextFns, postgresqlDialect, supportedJoinMethods };

package/dist/extend/dialects/shared.d.ts

@@ -0,0 +1,6 @@
+declare const sharedFunctions: {};
+declare const esc: (s: string) => string;
+type FilterCols<TEntries extends [string, unknown], T> = TEntries extends [infer N extends string, infer V] ? NonNullable<V> extends T ? N : never : never;
+type ColName<TEntries extends [string, unknown]> = TEntries extends [infer N extends string, unknown] ? N : never;
+
+export { type ColName, type FilterCols, esc, sharedFunctions };

package/dist/extend/dialects/shared.js

@@ -0,0 +1,5 @@
+// src/dialects/shared.ts
+var sharedFunctions = {};
+var esc = (s) => s.replace(/'/g, "''");
+
+export { esc, sharedFunctions };

package/dist/extend/dialects/sqlite.d.ts

@@ -0,0 +1,63 @@
+import { Dialect } from './types.js';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import { FilterCols, ColName } from './shared.js';
+
+type SqliteMinMaxResult<TColEntries extends [string, unknown], Col extends string> = TColEntries extends [Col, infer V] ? NonNullable<V> extends number ? bigint | null : V | null : never;
+type SqliteCastTypeMap = {
+    INTEGER: bigint;
+    TEXT: string;
+    REAL: number;
+    NUMERIC: number;
+    BLOB: Buffer;
+};
+declare const sqliteContextFns: <TColEntries extends [string, unknown] = never, TCriteria extends object = object>(quoteFn: (ref: string) => string, condFn: (criteria: TCriteria) => string) => {
+    avg: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    sum: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    countAll: () => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
+    groupConcat: (col: ColName<TColEntries>, sep?: string) => SQLExpr<string>;
+    total: (col: ColName<TColEntries>) => SQLExpr<number>;
+    min: <Col extends ColName<TColEntries>>(col: Col) => SQLExpr<SqliteMinMaxResult<TColEntries, Col>>;
+    max: <Col extends ColName<TColEntries>>(col: Col) => SQLExpr<SqliteMinMaxResult<TColEntries, Col>>;
+    concat: (args_0: FilterCols<TColEntries, string> | SQLExpr<string>, ...args: (FilterCols<TColEntries, string> | SQLExpr<string>)[]) => SQLExpr<string>;
+    substr: (col: FilterCols<TColEntries, string> | SQLExpr<string>, start: number, len?: number) => SQLExpr<string>;
+    instr: (col: FilterCols<TColEntries, string> | SQLExpr<string>, substr: string) => SQLExpr<bigint>;
+    char: (...codes: number[]) => SQLExpr<string>;
+    hex: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<string>;
+    unicode: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
+    iif: <T>(cond: TCriteria | SQLExpr<unknown>, trueVal: SQLExpr<T>, falseVal: SQLExpr<T>) => SQLExpr<T>;
+    ifNull: <T>(col: FilterCols<TColEntries, T> | SQLExpr<T>, fallback: SQLExpr<NonNullable<T>>) => SQLExpr<NonNullable<T>>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    month: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    day: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    hour: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    minute: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    second: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    strftime: (fmt: string, col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    julianday: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    date: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    datetime: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    abs: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<bigint | number>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<bigint | number>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<bigint | number>;
+    round: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>, decimals?: number) => SQLExpr<bigint | number>;
+    power: (base: FilterCols<TColEntries, number> | SQLExpr<number | bigint>, exp: number | SQLExpr<number | bigint>) => SQLExpr<number>;
+    sqrt: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<number>;
+    mod: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>, divisor: number) => SQLExpr<bigint | number>;
+    sign: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<bigint | number>;
+    exp: (col: FilterCols<TColEntries, number> | SQLExpr<number | bigint>) => SQLExpr<number>;
+    random: () => SQLExpr<bigint>;
+    log: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log2: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log10: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    cast: <T extends keyof SqliteCastTypeMap>(expr: ColName<TColEntries> | SQLExpr<unknown>, type: T) => SQLExpr<SqliteCastTypeMap[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, TCriteria extends object = object> = ReturnType<typeof sqliteContextFns<TColEntries, TCriteria>>;
+declare const supportedJoinMethods: readonly ["join", "joinUnsafeTypeEnforced", "joinUnsafeIgnoreType", "innerJoin", "innerJoinUnsafeTypeEnforced", "innerJoinUnsafeIgnoreType", "leftJoin", "leftJoinUnsafeTypeEnforced", "leftJoinUnsafeIgnoreType", "crossJoin", "crossJoinUnsafeTypeEnforced", "crossJoinUnsafeIgnoreType", "manyToManyJoin"];
+declare const sqliteDialect: Dialect;
+
+export { type DialectFns, sqliteContextFns, sqliteDialect, supportedJoinMethods };

package/dist/extend/dialects/sqlite.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/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 supportedJoinMethods = [
+  "join",
+  "joinUnsafeTypeEnforced",
+  "joinUnsafeIgnoreType",
+  "innerJoin",
+  "innerJoinUnsafeTypeEnforced",
+  "innerJoinUnsafeIgnoreType",
+  "leftJoin",
+  "leftJoinUnsafeTypeEnforced",
+  "leftJoinUnsafeIgnoreType",
+  "crossJoin",
+  "crossJoinUnsafeTypeEnforced",
+  "crossJoinUnsafeIgnoreType",
+  "manyToManyJoin"
+];
+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;
+  }
+};
+
+export { sqliteContextFns, sqliteDialect, supportedJoinMethods };

package/dist/extend/dialects/types.d.ts

@@ -0,0 +1,12 @@
+type Dialect = {
+    name: "sqlite" | "mysql" | "postgresql";
+    quote: (identifier: string, isAlias?: boolean) => string;
+    needsBooleanCoercion: () => boolean;
+    quoteTableIdentifier: (name: string, isAlias: boolean) => string;
+    quoteQualifiedColumn: (ref: string) => string;
+    quoteOrderByClause: (clause: string) => string;
+};
+declare const SUPPORTED_PROVIDERS: readonly ["sqlite", "mysql", "postgresql"];
+type SupportedProvider = typeof SUPPORTED_PROVIDERS[keyof typeof SUPPORTED_PROVIDERS];
+
+export { type Dialect, SUPPORTED_PROVIDERS, type SupportedProvider };

package/dist/extend/dialects/types.js

@@ -0,0 +1,4 @@
+// src/dialects/types.ts
+var SUPPORTED_PROVIDERS = ["sqlite", "mysql", "postgresql"];
+
+export { SUPPORTED_PROVIDERS };