prisma-ts-select 0.0.34 → 0.1.3

package/dist/extend/extend.js

@@ -1,8 +1,290 @@
 import { Prisma } from '@prisma/client/extension';
-import { match, P } from 'ts-pattern';
+import { dialectContextFns, dialect } from './dialects/index.js';
 
-const DB = {};
-class DbSelect {
+// src/extend.ts
+
+// ../../node_modules/.pnpm/ts-pattern@5.3.1/node_modules/ts-pattern/dist/index.js
+var t = Symbol.for("@ts-pattern/matcher");
+var e = Symbol.for("@ts-pattern/isVariadic");
+var n = "@ts-pattern/anonymous-select-key";
+var r = (t2) => Boolean(t2 && "object" == typeof t2);
+var i = (e2) => e2 && !!e2[t];
+var s = (n2, o2, c2) => {
+  if (i(n2)) {
+    const e2 = n2[t](), { matched: r2, selections: i2 } = e2.match(o2);
+    return r2 && i2 && Object.keys(i2).forEach((t2) => c2(t2, i2[t2])), r2;
+  }
+  if (r(n2)) {
+    if (!r(o2)) return false;
+    if (Array.isArray(n2)) {
+      if (!Array.isArray(o2)) return false;
+      let t2 = [], r2 = [], a2 = [];
+      for (const s2 of n2.keys()) {
+        const o3 = n2[s2];
+        i(o3) && o3[e] ? a2.push(o3) : a2.length ? r2.push(o3) : t2.push(o3);
+      }
+      if (a2.length) {
+        if (a2.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+        if (o2.length < t2.length + r2.length) return false;
+        const e2 = o2.slice(0, t2.length), n3 = 0 === r2.length ? [] : o2.slice(-r2.length), i2 = o2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
+        return t2.every((t3, n4) => s(t3, e2[n4], c2)) && r2.every((t3, e3) => s(t3, n3[e3], c2)) && (0 === a2.length || s(a2[0], i2, c2));
+      }
+      return n2.length === o2.length && n2.every((t3, e2) => s(t3, o2[e2], c2));
+    }
+    return Reflect.ownKeys(n2).every((e2) => {
+      const r2 = n2[e2];
+      return (e2 in o2 || i(a2 = r2) && "optional" === a2[t]().matcherType) && s(r2, o2[e2], c2);
+      var a2;
+    });
+  }
+  return Object.is(o2, n2);
+};
+var o = (e2) => {
+  var n2, s2, a2;
+  return r(e2) ? i(e2) ? null != (n2 = null == (s2 = (a2 = e2[t]()).getSelectionKeys) ? void 0 : s2.call(a2)) ? n2 : [] : Array.isArray(e2) ? c(e2, o) : c(Object.values(e2), o) : [];
+};
+var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
+function a(...t2) {
+  if (1 === t2.length) {
+    const [e2] = t2;
+    return (t3) => s(e2, t3, () => {
+    });
+  }
+  if (2 === t2.length) {
+    const [e2, n2] = t2;
+    return s(e2, n2, () => {
+    });
+  }
+  throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t2.length}.`);
+}
+function u(t2) {
+  return Object.assign(t2, { optional: () => h(t2), and: (e2) => m(t2, e2), or: (e2) => d(t2, e2), select: (e2) => void 0 === e2 ? y(t2) : y(e2, t2) });
+}
+function l(t2) {
+  return Object.assign(((t3) => Object.assign(t3, { [Symbol.iterator]() {
+    let n2 = 0;
+    const r2 = [{ value: Object.assign(t3, { [e]: true }), done: false }, { done: true, value: void 0 }];
+    return { next: () => {
+      var t4;
+      return null != (t4 = r2[n2++]) ? t4 : r2.at(-1);
+    } };
+  } }))(t2), { optional: () => l(h(t2)), select: (e2) => l(void 0 === e2 ? y(t2) : y(e2, t2)) });
+}
+function h(e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return void 0 === t2 ? (o(e2).forEach((t3) => r2(t3, void 0)), { matched: true, selections: n2 }) : { matched: s(e2, t2, r2), selections: n2 };
+  }, getSelectionKeys: () => o(e2), matcherType: "optional" }) });
+}
+var f = (t2, e2) => {
+  for (const n2 of t2) if (!e2(n2)) return false;
+  return true;
+};
+var g = (t2, e2) => {
+  for (const [n2, r2] of t2.entries()) if (!e2(r2, n2)) return false;
+  return true;
+};
+function m(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return { matched: e2.every((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "and" }) });
+}
+function d(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return c(e2, o).forEach((t3) => r2(t3, void 0)), { matched: e2.some((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "or" }) });
+}
+function p(e2) {
+  return { [t]: () => ({ match: (t2) => ({ matched: Boolean(e2(t2)) }) }) };
+}
+function y(...e2) {
+  const r2 = "string" == typeof e2[0] ? e2[0] : void 0, i2 = 2 === e2.length ? e2[1] : "string" == typeof e2[0] ? void 0 : e2[0];
+  return u({ [t]: () => ({ match: (t2) => {
+    let e3 = { [null != r2 ? r2 : n]: t2 };
+    return { matched: void 0 === i2 || s(i2, t2, (t3, n2) => {
+      e3[t3] = n2;
+    }), selections: e3 };
+  }, getSelectionKeys: () => [null != r2 ? r2 : n].concat(void 0 === i2 ? [] : o(i2)) }) });
+}
+function v(t2) {
+  return "number" == typeof t2;
+}
+function b(t2) {
+  return "string" == typeof t2;
+}
+function w(t2) {
+  return "bigint" == typeof t2;
+}
+var S = u(p(function(t2) {
+  return true;
+}));
+var O = S;
+var j = (t2) => Object.assign(u(t2), { startsWith: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.startsWith(n2)))));
+  var n2;
+}, endsWith: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.endsWith(n2)))));
+  var n2;
+}, minLength: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length >= t3))(e2))), length: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length === t3))(e2))), maxLength: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length <= t3))(e2))), includes: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.includes(n2)))));
+  var n2;
+}, regex: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && Boolean(t3.match(n2))))));
+  var n2;
+} });
+var K = j(p(b));
+var x = (t2) => Object.assign(u(t2), { between: (e2, n2) => x(m(t2, ((t3, e3) => p((n3) => v(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 < t3))(e2))), gt: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 > t3))(e2))), lte: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 <= t3))(e2))), gte: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 >= t3))(e2))), int: () => x(m(t2, p((t3) => v(t3) && Number.isInteger(t3)))), finite: () => x(m(t2, p((t3) => v(t3) && Number.isFinite(t3)))), positive: () => x(m(t2, p((t3) => v(t3) && t3 > 0))), negative: () => x(m(t2, p((t3) => v(t3) && t3 < 0))) });
+var E = x(p(v));
+var A = (t2) => Object.assign(u(t2), { between: (e2, n2) => A(m(t2, ((t3, e3) => p((n3) => w(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 < t3))(e2))), gt: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 > t3))(e2))), lte: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 <= t3))(e2))), gte: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 >= t3))(e2))), positive: () => A(m(t2, p((t3) => w(t3) && t3 > 0))), negative: () => A(m(t2, p((t3) => w(t3) && t3 < 0))) });
+var P = A(p(w));
+var T = u(p(function(t2) {
+  return "boolean" == typeof t2;
+}));
+var B = u(p(function(t2) {
+  return "symbol" == typeof t2;
+}));
+var _ = u(p(function(t2) {
+  return null == t2;
+}));
+var k = u(p(function(t2) {
+  return null != t2;
+}));
+var N = { __proto__: null, matcher: t, optional: h, array: function(...e2) {
+  return l({ [t]: () => ({ match: (t2) => {
+    if (!Array.isArray(t2)) return { matched: false };
+    if (0 === e2.length) return { matched: true };
+    const n2 = e2[0];
+    let r2 = {};
+    if (0 === t2.length) return o(n2).forEach((t3) => {
+      r2[t3] = [];
+    }), { matched: true, selections: r2 };
+    const i2 = (t3, e3) => {
+      r2[t3] = (r2[t3] || []).concat([e3]);
+    };
+    return { matched: t2.every((t3) => s(n2, t3, i2)), selections: r2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : o(e2[0]) }) });
+}, set: function(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    if (!(t2 instanceof Set)) return { matched: false };
+    let n2 = {};
+    if (0 === t2.size) return { matched: true, selections: n2 };
+    if (0 === e2.length) return { matched: true };
+    const r2 = (t3, e3) => {
+      n2[t3] = (n2[t3] || []).concat([e3]);
+    }, i2 = e2[0];
+    return { matched: f(t2, (t3) => s(i2, t3, r2)), selections: n2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : o(e2[0]) }) });
+}, map: function(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    if (!(t2 instanceof Map)) return { matched: false };
+    let n2 = {};
+    if (0 === t2.size) return { matched: true, selections: n2 };
+    const r2 = (t3, e3) => {
+      n2[t3] = (n2[t3] || []).concat([e3]);
+    };
+    if (0 === e2.length) return { matched: true };
+    var i2;
+    if (1 === e2.length) throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i2 = e2[0]) ? void 0 : i2.toString()}`);
+    const [o2, c2] = e2;
+    return { matched: g(t2, (t3, e3) => {
+      const n3 = s(o2, e3, r2), i3 = s(c2, t3, r2);
+      return n3 && i3;
+    }), selections: n2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : [...o(e2[0]), ...o(e2[1])] }) });
+}, intersection: m, union: d, not: function(e2) {
+  return u({ [t]: () => ({ match: (t2) => ({ matched: !s(e2, t2, () => {
+  }) }), getSelectionKeys: () => [], matcherType: "not" }) });
+}, when: p, select: y, any: S, _: O, string: K, number: E, bigint: P, boolean: T, symbol: B, nullish: _, nonNullable: k, instanceOf: function(t2) {
+  return u(p(/* @__PURE__ */ function(t3) {
+    return (e2) => e2 instanceof t3;
+  }(t2)));
+}, shape: function(t2) {
+  return u(p(a(t2)));
+} };
+var W = class extends Error {
+  constructor(t2) {
+    let e2;
+    try {
+      e2 = JSON.stringify(t2);
+    } catch (n2) {
+      e2 = t2;
+    }
+    super(`Pattern matching error: no pattern matches value ${e2}`), this.input = void 0, this.input = t2;
+  }
+};
+var $ = { matched: false, value: void 0 };
+function z(t2) {
+  return new I(t2, $);
+}
+var I = class _I {
+  constructor(t2, e2) {
+    this.input = void 0, this.state = void 0, this.input = t2, this.state = e2;
+  }
+  with(...t2) {
+    if (this.state.matched) return this;
+    const e2 = t2[t2.length - 1], r2 = [t2[0]];
+    let i2;
+    3 === t2.length && "function" == typeof t2[1] ? i2 = t2[1] : t2.length > 2 && r2.push(...t2.slice(1, t2.length - 1));
+    let o2 = false, c2 = {};
+    const a2 = (t3, e3) => {
+      o2 = true, c2[t3] = e3;
+    }, u2 = !r2.some((t3) => s(t3, this.input, a2)) || i2 && !Boolean(i2(this.input)) ? $ : { matched: true, value: e2(o2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
+    return new _I(this.input, u2);
+  }
+  when(t2, e2) {
+    if (this.state.matched) return this;
+    const n2 = Boolean(t2(this.input));
+    return new _I(this.input, n2 ? { matched: true, value: e2(this.input, this.input) } : $);
+  }
+  otherwise(t2) {
+    return this.state.matched ? this.state.value : t2(this.input);
+  }
+  exhaustive() {
+    if (this.state.matched) return this.state.value;
+    throw new W(this.input);
+  }
+  run() {
+    return this.exhaustive();
+  }
+  returnType() {
+    return this;
+  }
+};
+
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function lit(value) {
+  if (value === null) return sqlExpr("NULL");
+  if (typeof value === "boolean") return sqlExpr(value ? "1" : "0");
+  if (typeof value === "string") return sqlExpr(`'${value.replace(/'/g, "''")}'`);
+  return sqlExpr(String(value));
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/shared.ts
+var esc = (s2) => s2.replace(/'/g, "''");
+
+// src/extend.ts
+var DB = {};
+var DbSelect = class {
   constructor(db) {
     this.db = db;
   }
@@ -15,18 +297,148 @@ class DbSelect {
       selects: []
     });
   }
+};
+function applyCondition(quotedField, value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value) && "op" in value) {
+    const opObj = value;
+    switch (opObj.op) {
+      case "IN":
+      case "NOT IN": {
+        const valuesList = opObj.values.map((v2) => typeof v2 === "string" ? `'${esc(v2)}'` : v2).join(", ");
+        return `${quotedField} ${opObj.op} (${valuesList})`;
+      }
+      case "BETWEEN": {
+        const [start, end] = opObj.values;
+        return `${quotedField} BETWEEN ${typeof start === "string" ? `'${esc(start)}'` : start} AND ${typeof end === "string" ? `'${esc(end)}'` : end}`;
+      }
+      case "LIKE":
+      case "NOT LIKE":
+        return `${quotedField} ${opObj.op} '${esc(opObj.value)}'`;
+      case "IS NULL":
+      case "IS NOT NULL":
+        return `${quotedField} ${opObj.op}`;
+      case ">":
+      case ">=":
+      case "<":
+      case "<=":
+      case "!=":
+      case "=":
+        return `${quotedField} ${opObj.op} ${typeof opObj.value === "string" ? `'${esc(opObj.value)}'` : opObj.value}`;
+      default:
+        throw new Error(`Unsupported operation: ${opObj.op}`);
+    }
+  } else if (value === null) {
+    return `${quotedField} IS NULL`;
+  } else if (Array.isArray(value)) {
+    if (value.length === 0) throw new Error(`empty array is not allowed for field "${quotedField}"`);
+    if (typeof value[0] === "object" && value[0] !== null && "op" in value[0]) {
+      const parts = value.map((opObj) => applyCondition(quotedField, opObj));
+      return parts.length === 1 ? parts[0] : "(" + parts.join(" OR ") + ")";
+    }
+    const valuesList = value.map((v2) => typeof v2 === "string" ? `'${esc(v2)}'` : v2).join(", ");
+    return `${quotedField} IN (${valuesList})`;
+  } else {
+    return `${quotedField} = ${typeof value === "string" ? `'${esc(value)}'` : value}`;
+  }
+}
+function processConditions(condition, formatted = false) {
+  const r2 = Object.keys(condition).map((field) => {
+    const value = condition[field];
+    const quotedField = dialect.quoteQualifiedColumn(String(field));
+    return applyCondition(quotedField, value);
+  });
+  return r2.length === 1 ? r2[0].trim() : "(" + r2.join(" AND " + (formatted ? "\n" : "")).trim() + ")";
+}
+function processCriteria(main, joinType = "AND", formatted = false) {
+  const results = [];
+  for (const criteria of main) {
+    if (typeof criteria === "string") {
+      results.push(criteria);
+      continue;
+    }
+    let toProcess = {};
+    const processPending = () => {
+      if (Object.keys(toProcess).length > 0) {
+        results.push(processConditions(toProcess, formatted));
+        toProcess = {};
+      }
+    };
+    for (const criterion in criteria) {
+      const r2 = z(criterion).returnType().with("$AND", (criterion2) => {
+        processPending();
+        return "(" + //@ts-expect-error criterion
+        processCriteria(criteria[criterion2], "AND", formatted) + ")";
+      }).with("$OR", (criterion2) => {
+        processPending();
+        return "(" + //@ts-expect-error criterion
+        processCriteria(criteria[criterion2], "OR", formatted) + ")";
+      }).with("$NOT", (criterion2) => {
+        processPending();
+        return "(NOT(" + //@ts-expect-error criterion
+        processCriteria(criteria[criterion2], "AND", formatted) + "))";
+      }).with("$NOR", (criterion2) => {
+        processPending();
+        return "(NOT(" + //@ts-expect-error criterion
+        processCriteria(criteria[criterion2], "OR", formatted) + "))";
+      }).with(N.string, (key) => {
+        toProcess[key] = criteria[key];
+        return "";
+      }).exhaustive();
+      if (r2) results.push(r2);
+    }
+    processPending();
+  }
+  return results.join((formatted ? "\n" : " ") + joinType + (formatted ? "\n" : " ")).trim();
 }
-class _fRun {
+function processExprPairs(pairs) {
+  const parts = pairs.map(([expr, value]) => applyCondition(expr.sql, value));
+  return parts.length === 1 ? parts[0] : parts.join(" AND ");
+}
+var _fRun = class {
   constructor(db, values) {
     this.db = db;
     this.values = values;
     this.values.limit = typeof this.values.limit === "number" ? this.values.limit : void 0;
     this.values.offset = typeof this.values.offset === "number" ? this.values.offset : void 0;
   }
-  run() {
-    return this.db.$queryRawUnsafe(
+  async run() {
+    const results = await this.db.$queryRawUnsafe(
       this.getSQL()
     );
+    if (dialect.needsBooleanCoercion()) {
+      return results.map((row) => {
+        const coerced = { ...row };
+        for (const key in coerced) {
+          const value = coerced[key];
+          if (typeof value !== "number" || value !== 0 && value !== 1) continue;
+          const parts = key.split(".");
+          let table;
+          let column;
+          if (parts.length === 2 && parts[0] && parts[1]) {
+            table = parts[0];
+            column = parts[1];
+          } else {
+            column = key;
+            let foundTable;
+            for (const tableObj of this.values.tables) {
+              const tableName = tableObj.table;
+              if (DB[tableName]?.fields[column]) {
+                foundTable = tableName;
+                break;
+              }
+            }
+            if (!foundTable) continue;
+            table = foundTable;
+          }
+          const fieldType = DB[table]?.fields[column];
+          if (fieldType && fieldType.replace("?", "") === "Boolean") {
+            coerced[key] = value === 1;
+          }
+        }
+        return coerced;
+      });
+    }
+    return results;
   }
   getTables() {
     return {};
@@ -38,137 +450,109 @@ class _fRun {
     return {};
   }
   getSQL(formatted = false) {
-    function processCondition(condition, formatted2) {
-      return "(" + Object.keys(condition).map((field) => {
-        const value = condition[field];
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && "op" in value) {
-          switch (value.op) {
-            case "IN":
-            case "NOT IN":
-              const valuesList = value.values.map((v) => typeof v === "string" ? `'${v}'` : v).join(", ");
-              return `${String(field)} ${value.op} (${valuesList})`;
-            case "BETWEEN":
-              if (value.values.length > 2) throw new Error("Too many items supplied to op BETWEEN");
-              const [start, end] = value.values;
-              return `${String(field)} BETWEEN ${typeof start === "string" ? `'${start}'` : start} AND ${typeof end === "string" ? `'${end}'` : end}`;
-            case "LIKE":
-            case "NOT LIKE":
-              return `${String(field)} ${value.op} '${value.value}'`;
-            case "IS NULL":
-            case "IS NOT NULL":
-              return `${String(field)} ${value.op}`;
-            case ">":
-            case ">=":
-            case "<":
-            case "<=":
-            case "!=":
-              return `${String(field)} ${value.op} ${typeof value.value === "string" ? `'${value.value}'` : value.value}`;
-            default:
-              throw new Error(`Unsupported operation: ${value.op}`);
-          }
-        } else if (Array.isArray(value)) {
-          const valuesList = value.map((v) => typeof v === "string" ? `'${v}'` : v).join(", ");
-          return `${String(field)} IN (${valuesList})`;
-        } else if (value === null) {
-          return `${String(field)} IS NULL`;
-        } else {
-          return `${String(field)} = ${typeof value === "string" ? `'${value}'` : value}`;
-        }
-      }).join(" AND " + (" ")) + " )";
-    }
-    function processCriteria(main, joinType = "AND", formatted2 = false) {
-      const results = [];
-      for (const criteria of main) {
-        if (typeof criteria === "string") {
-          results.push(criteria);
-          continue;
-        }
-        for (const criterion in criteria) {
-          results.push(match(criterion).returnType().with("$AND", (criterion2) => {
-            return "(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "AND", formatted2) + ")";
-          }).with("$OR", (criterion2) => {
-            return "(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "OR", formatted2) + ")";
-          }).with("$NOT", (criterion2) => {
-            return "(NOT(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "AND", formatted2) + "))";
-          }).with("$NOR", (criterion2) => {
-            return "(NOT(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "OR", formatted2) + "))";
-          }).with(P.string, () => {
-            return processCondition(criteria);
-          }).exhaustive());
-        }
-      }
-      return results.join((formatted2 ? "\n" : " ") + joinType + (formatted2 ? "\n" : " "));
-    }
+    const withClause = this.values.withs?.length ? `WITH ${this.values.withs.map(
+      (w2) => `${dialect.quoteTableIdentifier(w2.name, false)} AS (${w2.sql})`
+    ).join(", ")}` : "";
     const whereClause = this.values.where !== void 0 ? processCriteria(this.values.where, "AND", formatted) : void 0;
     const havingClause = this.values.having !== void 0 ? processCriteria(this.values.having, "AND", formatted) : void 0;
     const [base, ...joins] = this.values.tables;
-    const baseTable = base.alias ? `${base.table} AS \`${base.alias}\`` : base.table;
+    const quotedTable = dialect.quoteTableIdentifier(base.table, false);
+    const baseTable = base.alias ? `${quotedTable} AS ${dialect.quoteTableIdentifier(base.alias, true)}` : quotedTable;
     return [
+      withClause,
       this.values.selects.length === 0 ? "" : "SELECT " + (this.values.selectDistinct === true ? "DISTINCT " : "") + this.values.selects.join(", "),
       `FROM ${baseTable}`,
       joins.map(({
         table,
         local,
         remote,
-        alias
+        alias,
+        joinWhere,
+        joinType
       }) => {
+        const quotedTable2 = dialect.quoteTableIdentifier(table, false);
+        const tableStr = alias ? `${quotedTable2} AS ${dialect.quoteTableIdentifier(alias, true)}` : quotedTable2;
+        const typePrefix = joinType ? `${joinType} ` : "";
+        if (joinType === "CROSS") {
+          return `${typePrefix}JOIN ${tableStr}`;
+        }
         const tLocal = (alias || table) + "." + local;
-        return `JOIN ${!!alias ? table + " AS `" + alias + "`" : table} ON ${tLocal} = ${remote}`;
+        const quotedLocal = dialect.quoteQualifiedColumn(tLocal);
+        const quotedRemote = dialect.quoteQualifiedColumn(remote);
+        const onClause = `${quotedLocal} = ${quotedRemote}`;
+        const joinWhereStr = joinWhere ? ` AND ${processCriteria(joinWhere, "AND", formatted)}` : "";
+        return `${typePrefix}JOIN ${tableStr} ON ${onClause}${joinWhereStr}`;
       }).join(formatted ? "\n" : " ") ?? "",
       !whereClause ? "" : `WHERE ${whereClause}`,
-      !this.values.groupBy?.length ? "" : `GROUP BY ${this.values.groupBy.join(", ")}`,
+      !this.values.groupBy?.length ? "" : `GROUP BY ${this.values.groupBy.map((g2) => dialect.quoteQualifiedColumn(g2)).join(", ")}`,
       !havingClause ? "" : `HAVING ${havingClause}`,
-      !(this.values.orderBy && this.values.orderBy.length > 0) ? "" : "ORDER BY " + this.values.orderBy.join(", "),
+      !(this.values.orderBy && this.values.orderBy.length > 0) ? "" : "ORDER BY " + this.values.orderBy.map((o2) => dialect.quoteOrderByClause(o2)).join(", "),
       !this.values.limit ? "" : `LIMIT ${this.values.limit}`,
       !this.values.offset ? "" : `OFFSET ${this.values.offset}`
     ].filter(Boolean).join(formatted ? "\n" : " ").trim() + ";";
   }
-}
-class _fOffset extends _fRun {
+};
+var _fOffset = class extends _fRun {
   offset(offset) {
     return new _fRun(this.db, { ...this.values, offset });
   }
-}
-class _fLimit extends _fRun {
+};
+var _fLimit = class extends _fRun {
   limit(limit) {
     return new _fOffset(this.db, { ...this.values, limit });
   }
-}
-class _fOrderBy extends _fLimit {
+};
+var _fOrderBy = class extends _fLimit {
   orderBy(orderBy) {
     return new _fLimit(this.db, { ...this.values, orderBy });
   }
-}
-class _fSelect extends _fOrderBy {
+};
+var _fSelect = class __fSelect extends _fOrderBy {
+  // Implementation (not visible to callers)
   select(select, alias) {
+    if (typeof select === "function") {
+      const ctx = buildContext(dialect);
+      const expr = select(ctx);
+      const aliasArg = alias;
+      const sqlStr = aliasArg !== void 0 ? `${expr.sql} AS ${dialect.quote(aliasArg, true)}` : expr.sql;
+      return new __fSelect(this.db, {
+        ...this.values,
+        selects: [...this.values.selects, sqlStr]
+      });
+    }
     const tableColMatch = select.match(/^(\w+)\.(.*?)$/);
     if (tableColMatch) {
       const [, tableName, colName] = tableColMatch;
-      const tableObject = this.values.tables.find((t) => (t.alias || t.table) === tableName);
+      const tableObject = this.values.tables.find((t2) => (t2.alias || t2.table) === tableName);
       if (!tableObject) throw new Error(`Table "${tableName}" not found in query`);
       const tableFields = DB[tableObject.table];
       if (!tableFields) {
-        throw new Error(`Table "${tableName}" not found in database schema`);
+        if (colName === "*") {
+          throw new Error(`Cannot expand "${tableName}.*" \u2014 CTE columns must be selected explicitly`);
+        }
+        return new __fSelect(this.db, {
+          ...this.values,
+          selects: [...this.values.selects, `${dialect.quoteQualifiedColumn(select)} AS ${dialect.quote(select, true)}`]
+        });
       }
       if (colName === "*") {
         const hasMultipleTables = this.values.tables && this.values.tables.length > 1 || false;
         const expandedSelects = Object.keys(tableFields.fields).map((field) => {
           if (hasMultipleTables) {
-            return `${tableName}.${field} AS \`${tableName}.${field}\``;
+            const tableIdentifier = tableObject.alias || tableName;
+            const qualifiedCol = `${tableIdentifier}.${field}`;
+            return `${dialect.quoteQualifiedColumn(qualifiedCol)} AS ${dialect.quote(`${tableName}.${field}`, true)}`;
           }
-          return `${field}`;
+          return field === "*" ? "*" : dialect.quote(field, false);
         });
-        return new _fSelect(this.db, {
+        return new __fSelect(this.db, {
           ...this.values,
           selects: [...this.values.selects, ...expandedSelects]
         });
       } else if (!alias && !!colName) {
         const currentTablesWithFields = this.values.tables.reduce((acc, table) => {
           const { table: real } = table;
+          if (!DB[real]) return acc;
           for (const col in DB[real].fields) {
             acc[col] = acc[col] ? acc[col] + 1 : 1;
           }
@@ -178,178 +562,401 @@ class _fSelect extends _fOrderBy {
           throw new Error(`Column "${colName}" not found in database schema`);
         }
         if (currentTablesWithFields[colName] > 1) {
-          return new _fSelect(this.db, {
+          return new __fSelect(this.db, {
             ...this.values,
-            selects: [...this.values.selects, `${select} AS \`${select}\``]
+            selects: [...this.values.selects, `${dialect.quoteQualifiedColumn(select)} AS ${dialect.quote(select, true)}`]
           });
         } else {
-          return new _fSelect(this.db, {
+          return new __fSelect(this.db, {
             ...this.values,
-            selects: [...this.values.selects, `${colName}`]
+            selects: [...this.values.selects, dialect.quote(colName, false)]
           });
         }
       }
     }
     if (alias !== void 0) {
-      return new _fSelect(this.db, {
+      if (select === "*" && this.values.tables.length > 1) {
+        throw new Error(`select("*", alias) is not supported on multi-table queries \u2014 use explicit column names or select("*") without alias`);
+      }
+      const quotedSelect2 = select === "*" ? "*" : select.includes(".") ? dialect.quoteQualifiedColumn(select) : dialect.quote(select, false);
+      return new __fSelect(this.db, {
         ...this.values,
-        selects: [...this.values.selects, `${select} AS \`${alias}\``]
+        selects: [...this.values.selects, `${quotedSelect2} AS ${dialect.quote(alias, true)}`]
       });
     }
-    return new _fSelect(this.db, {
+    if (select === "*" && this.values.tables.length > 1) {
+      const expandedSelects = this.values.tables.flatMap(
+        (tableObj) => expandToQualifiedSelects(tableObj, this.values.withs)
+      );
+      return new __fSelect(this.db, { ...this.values, selects: [...this.values.selects, ...expandedSelects] });
+    }
+    const quotedSelect = select === "*" ? "*" : select.includes(".") ? dialect.quoteQualifiedColumn(select) : dialect.quote(select, false);
+    return new __fSelect(this.db, {
       ...this.values,
-      selects: [...this.values.selects, select]
+      selects: [...this.values.selects, quotedSelect]
     });
   }
-}
-class _fSelectDistinct extends _fSelect {
+};
+var _fSelectDistinct = class extends _fSelect {
   selectDistinct() {
     return new _fSelect(this.db, { ...this.values, selectDistinct: true });
   }
   selectAll() {
     const selects = function(values) {
       if (values.tables && values.tables.length > 1) {
-        return [
-          /*values.baseTable,*/
-          ...values.tables.map((t) => t.table)
-        ].reduce((acc, table) => {
-          return acc.concat(Object.keys(DB[table].fields).map((field) => `${table}.${field} AS \`${table}.${field}\``));
+        return values.tables.reduce((acc, tableObj) => {
+          return acc.concat(expandToQualifiedSelects(tableObj, values.withs));
         }, []);
       }
-      return Object.keys(DB[values.tables[0].table].fields);
+      const t2 = values.tables[0];
+      if (!DB[t2.table]) throw new Error(`selectAll() is not supported when the base table is a CTE ("${t2.table}"). Use select() with explicit column references.`);
+      return Object.keys(DB[t2.table].fields).map((field) => dialect.quote(field, false));
     }(this.values);
     return new _fOrderBy(this.db, {
       ...this.values,
       selects
     });
   }
-  //TODO
-  // selectAllOmit() {
-  //     throw new Error("Not implemented yet")
-  // }
-}
-class _fHaving extends _fSelectDistinct {
-  // TODO Allowed Fields
-  //  - specified in groupBy
-  having(criteria) {
-    return new _fSelectDistinct(this.db, {
+  selectAllOmit(omit) {
+    const omitSet = new Set(omit);
+    const selects = function(values) {
+      if (values.tables.length === 1) {
+        const t2 = values.tables[0];
+        const tableIdentifier = t2.alias || t2.table;
+        return Object.keys(DB[t2.table].fields).filter((f2) => !omitSet.has(f2) && !omitSet.has(`${tableIdentifier}.${f2}`)).map((f2) => dialect.quote(f2, false));
+      }
+      return values.tables.reduce((acc, tableObj) => {
+        const tableIdentifier = tableObj.alias || tableObj.table;
+        if (!DB[tableObj.table]) return acc;
+        return acc.concat(
+          Object.keys(DB[tableObj.table].fields).filter((f2) => !omitSet.has(f2) && !omitSet.has(`${tableIdentifier}.${f2}`)).map((f2) => {
+            const q = `${tableIdentifier}.${f2}`;
+            return `${dialect.quoteQualifiedColumn(q)} AS ${dialect.quote(q, true)}`;
+          })
+        );
+      }, []);
+    }(this.values);
+    return new _fOrderBy(this.db, {
       ...this.values,
-      having: [criteria]
+      selects
     });
   }
-}
-class _fGroupBy extends _fHaving {
+};
+var _fHaving = class __fHaving extends _fSelect {
+  // Keep selectDistinct() available after groupBy(), but not selectAll()
+  selectDistinct() {
+    return new _fSelect(this.db, { ...this.values, selectDistinct: true });
+  }
+  having(criteriaOrFn) {
+    const existing = this.values.having ?? [];
+    if (typeof criteriaOrFn === "function") {
+      const ctx = buildContext(dialect);
+      const sql = processExprPairs(criteriaOrFn(ctx));
+      return new __fHaving(this.db, { ...this.values, having: [...existing, sql] });
+    }
+    return new __fHaving(this.db, { ...this.values, having: [...existing, criteriaOrFn] });
+  }
+};
+var _fGroupBy = class extends _fSelectDistinct {
+  having(criteriaOrFn) {
+    const existing = this.values.having ?? [];
+    if (typeof criteriaOrFn === "function") {
+      const ctx = buildContext(dialect);
+      const sql = processExprPairs(criteriaOrFn(ctx));
+      return new _fSelectDistinct(this.db, { ...this.values, having: [...existing, sql] });
+    }
+    return new _fSelectDistinct(this.db, { ...this.values, having: [...existing, criteriaOrFn] });
+  }
   //TODO this should only accept columns for tables in play
   groupBy(groupBy) {
     return new _fHaving(this.db, { ...this.values, groupBy });
   }
-}
-class _fWhere extends _fGroupBy {
+};
+var _fWhere = class __fWhere extends _fGroupBy {
   whereNotNull(col) {
-    return new _fWhere(this.db, {
+    return new __fWhere(this.db, {
       ...this.values,
       where: [
         ...this.values.where || [],
         {
-          $AND: (
-            //@ts-expect-error todo comeback to, col is a string or never
-            [{ [col]: { op: "IS NOT NULL" } }]
-          )
+          $AND: [{ [col]: { op: "IS NOT NULL" } }]
         }
       ]
     });
   }
   whereIsNull(col) {
-    return new _fWhere(this.db, {
+    return new __fWhere(this.db, {
       ...this.values,
       where: [
         ...this.values.where || [],
         {
-          $AND: (
-            //@ts-expect-error todo comeback to, col is a string or never
-            [{ [col]: { op: "IS NULL" } }]
-          )
+          $AND: [{ [col]: { op: "IS NULL" } }]
         }
       ]
     });
   }
-  where(criteria) {
+  where(criteriaOrFn) {
+    if (typeof criteriaOrFn === "function") {
+      const ctx = buildContext(dialect);
+      const sql = processExprPairs(criteriaOrFn(ctx));
+      return new _fGroupBy(this.db, {
+        ...this.values,
+        where: [...this.values.where || [], sql]
+      });
+    }
     return new _fGroupBy(this.db, {
       ...this.values,
-      where: [...this.values.where || [], criteria]
+      where: [...this.values.where || [], criteriaOrFn]
     });
   }
+  /**
+   * @security NEVER pass user-supplied input. Inserts SQL verbatim into $queryRawUnsafe without parameterization.
+   */
   whereRaw(where) {
     return new _fGroupBy(this.db, {
       ...this.values,
       where: [...this.values.where || [], where.replace(/^\s*where\s*/i, "").trim()]
     });
   }
+};
+function buildContext(d2) {
+  const quoteFn = (col) => d2.quoteQualifiedColumn(col);
+  return {
+    lit,
+    min: (col) => sqlExpr(`MIN(${resolveArg(col, quoteFn)})`),
+    max: (col) => sqlExpr(`MAX(${resolveArg(col, quoteFn)})`),
+    replace: (col, from, to) => sqlExpr(`REPLACE(${resolveArg(col, quoteFn)}, '${from.replace(/'/g, "''")}', '${to.replace(/'/g, "''")}')`),
+    upper: (col) => sqlExpr(`UPPER(${resolveArg(col, quoteFn)})`),
+    lower: (col) => sqlExpr(`LOWER(${resolveArg(col, quoteFn)})`),
+    trim: (col) => sqlExpr(`TRIM(${resolveArg(col, quoteFn)})`),
+    ltrim: (col) => sqlExpr(`LTRIM(${resolveArg(col, quoteFn)})`),
+    rtrim: (col) => sqlExpr(`RTRIM(${resolveArg(col, quoteFn)})`),
+    cond: (criteria) => sqlExpr(processCriteria([criteria])),
+    coalesce: (...args) => {
+      if (args.length === 0) throw new Error("coalesce: requires at least one argument");
+      return sqlExpr(`COALESCE(${args.map((a2) => resolveArg(a2, quoteFn)).join(", ")})`);
+    },
+    nullif: (expr1, expr2) => sqlExpr(`NULLIF(${expr1.sql}, ${expr2.sql})`),
+    caseWhen: (cases, elseVal) => {
+      if (cases.length === 0) throw new Error("caseWhen: requires at least one WHEN clause");
+      const parts = cases.map((c2) => `WHEN ${processCriteria([c2.when])} THEN ${c2.then.sql}`).join(" ");
+      return sqlExpr(`CASE ${parts}${elseVal ? ` ELSE ${elseVal.sql}` : ""} END`);
+    },
+    // Partial<> cast: SelectFnContext is a stub here; generator injects DialectFns at codegen time.
+    ...dialectContextFns(quoteFn, (c2) => processCriteria([c2]))
+  };
 }
-class _fJoin extends _fWhere {
+var _fJoin = class __fJoin extends _fWhere {
   // Implementation
-  join(tableOrOptions, field, reference) {
+  join(tableOrOptions, field, reference, _opts) {
+    return this._joinImpl(void 0, tableOrOptions, field, reference, _opts);
+  }
+  _joinImpl(joinType, tableOrOptions, field, reference, _opts) {
     let table;
     let local;
     let remote;
     let tableAlias;
+    let joinWhere;
     if (typeof tableOrOptions === "object" && "table" in tableOrOptions) {
       table = tableOrOptions.table.trim();
       local = tableOrOptions.src;
       remote = tableOrOptions.on;
       tableAlias = tableOrOptions.alias?.trim();
+      joinWhere = tableOrOptions.where ? [tableOrOptions.where] : void 0;
+      joinType = tableOrOptions.joinType ?? joinType;
     } else {
       const parts = tableOrOptions.split(" ");
       table = parts[0];
       tableAlias = parts[1]?.trim();
-      local = field;
-      remote = reference;
+      local = field ?? "";
+      remote = reference ?? "";
+      joinWhere = _opts?.where ? [_opts.where] : void 0;
+      joinType = _opts?.joinType ?? joinType;
     }
-    return new _fJoin(this.db, {
+    return new __fJoin(this.db, {
       ...this.values,
       tables: [...this.values.tables || [], {
         table,
         local,
         remote,
-        alias: tableAlias
+        alias: tableAlias,
+        ...joinWhere ? { joinWhere } : {},
+        ...joinType ? { joinType } : {}
       }]
     });
   }
   // Implementation
-  joinUnsafeTypeEnforced(tableOrOptions, field, reference) {
-    return this.join(tableOrOptions, field, reference);
+  joinUnsafeTypeEnforced(tableOrOptions, field, reference, _opts) {
+    return this.join(tableOrOptions, field, reference, _opts);
   }
   // Implementation
-  joinUnsafeIgnoreType(tableOrOptions, field, reference) {
-    return this.join(tableOrOptions, field, reference);
-  }
-  // innerJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // leftJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // rightJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // fullJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // crossJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // outerJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
+  joinUnsafeIgnoreType(tableOrOptions, field, reference, _opts) {
+    return this.join(tableOrOptions, field, reference, _opts);
+  }
+  manyToManyJoin(targetTable, options) {
+    const opts = options;
+    const refName = opts?.refName;
+    const [tbl, alias] = targetTable.split(" ");
+    let sourceTableName;
+    let sourceAlias;
+    let srcLocalCol;
+    if (opts?.source) {
+      const [srcAliasOrTable, col] = opts.source.split(".");
+      const entry = this.values.tables.find((t2) => (t2.alias || t2.table) === srcAliasOrTable);
+      sourceTableName = entry?.table ?? srcAliasOrTable;
+      sourceAlias = srcAliasOrTable;
+      srcLocalCol = col;
+    } else {
+      const candidates = this.values.tables.filter((entry) => {
+        const relations = DB[entry.table]?.relations;
+        return relations && Object.keys(relations).some(
+          (k2) => k2.startsWith("_") && DB[k2]?.relations?.[tbl] !== void 0
+        );
+      });
+      if (candidates.length === 0) throw new Error(
+        `manyToManyJoin: no source with junction to "${tbl}" among joined tables`
+      );
+      if (candidates.length > 1) {
+        const names = candidates.map((c2) => c2.alias ?? c2.table).join(", ");
+        throw new Error(`manyToManyJoin: ambiguous source for "${tbl}" (${names}). Pass { source: "alias.col" }.`);
+      }
+      const found = candidates[0];
+      sourceTableName = found.table;
+      sourceAlias = found.alias || found.table;
+      const srcRelations2 = DB[sourceTableName]?.relations;
+      const junctionKey = refName ? `_${refName}` : Object.keys(srcRelations2 ?? {}).find(
+        (k2) => k2.startsWith("_") && DB[k2]?.relations?.[tbl] !== void 0
+      );
+      const junctionRelEntry = junctionKey ? srcRelations2[junctionKey] : void 0;
+      srcLocalCol = junctionRelEntry ? Object.keys(junctionRelEntry)[0] : "id";
+    }
+    const srcEntry = DB[sourceTableName];
+    if (!srcEntry) throw new Error(`manyToManyJoin: unknown source table "${sourceTableName}"`);
+    const srcRelations = srcEntry.relations;
+    const junctionTable = refName ? `_${refName}` : Object.keys(srcRelations).find(
+      (k2) => k2.startsWith("_") && DB[k2]?.relations?.[tbl] !== void 0
+    );
+    if (!junctionTable) throw new Error(
+      `manyToManyJoin: no junction between "${sourceTableName}" and "${tbl}"`
+    );
+    const srcJunctionCol = srcRelations[junctionTable]?.[srcLocalCol]?.[0] ?? "A";
+    const tgtRelEntry = DB[junctionTable]?.relations?.[tbl];
+    const tgtJunctionCol = tgtRelEntry ? Object.keys(tgtRelEntry)[0] : "B";
+    const tgtLocalCol = tgtRelEntry?.[tgtJunctionCol]?.[0] ?? "id";
+    const remoteRef = `${sourceAlias}.${srcLocalCol}`;
+    return this.joinUnsafeIgnoreType(junctionTable, srcJunctionCol, remoteRef).joinUnsafeIgnoreType(alias ? `${tbl} ${alias}` : tbl, tgtLocalCol, `${junctionTable}.${tgtJunctionCol}`);
+  }
+  innerJoin(tableOrOptions, field, reference) {
+    return this._joinImpl("INNER", tableOrOptions, field, reference);
+  }
+  leftJoin(tableOrOptions, field, reference) {
+    return this._joinImpl("LEFT", tableOrOptions, field, reference);
+  }
+  rightJoin(tableOrOptions, field, reference) {
+    return this._joinImpl("RIGHT", tableOrOptions, field, reference);
+  }
+  fullJoin(tableOrOptions, field, reference) {
+    return this._joinImpl("FULL", tableOrOptions, field, reference);
+  }
+  // crossJoin: no ON clause — table only (with optional inline alias)
+  crossJoin(table) {
+    return this._joinImpl("CROSS", table);
+  }
+  innerJoinUnsafeTypeEnforced(tableOrOptions, field, reference) {
+    return this._joinImpl("INNER", tableOrOptions, field, reference);
+  }
+  innerJoinUnsafeIgnoreType(tableOrOptions, field, reference) {
+    return this._joinImpl("INNER", tableOrOptions, field, reference);
+  }
+  leftJoinUnsafeTypeEnforced(tableOrOptions, field, reference) {
+    return this._joinImpl("LEFT", tableOrOptions, field, reference);
+  }
+  leftJoinUnsafeIgnoreType(tableOrOptions, field, reference) {
+    return this._joinImpl("LEFT", tableOrOptions, field, reference);
+  }
+  rightJoinUnsafeTypeEnforced(tableOrOptions, field, reference) {
+    return this._joinImpl("RIGHT", tableOrOptions, field, reference);
+  }
+  rightJoinUnsafeIgnoreType(tableOrOptions, field, reference) {
+    return this._joinImpl("RIGHT", tableOrOptions, field, reference);
+  }
+  fullJoinUnsafeTypeEnforced(tableOrOptions, field, reference) {
+    return this._joinImpl("FULL", tableOrOptions, field, reference);
+  }
+  fullJoinUnsafeIgnoreType(tableOrOptions, field, reference) {
+    return this._joinImpl("FULL", tableOrOptions, field, reference);
+  }
+  // crossJoinUnsafeTypeEnforced — CROSS semantics, type-enforced columns
+  crossJoinUnsafeTypeEnforced(table) {
+    return this._joinImpl("CROSS", table);
+  }
+  // crossJoinUnsafeIgnoreType — CROSS semantics, any columns
+  crossJoinUnsafeIgnoreType(table) {
+    return this._joinImpl("CROSS", table);
+  }
+};
+function expandToQualifiedSelects(tableObj, withs) {
+  const tId = tableObj.alias || tableObj.table;
+  if (DB[tableObj.table]) {
+    return Object.keys(DB[tableObj.table].fields).map((field) => {
+      const q = `${tId}.${field}`;
+      return `${dialect.quoteQualifiedColumn(q)} AS ${dialect.quote(q, true)}`;
+    });
+  }
+  const cte = withs?.find((w2) => w2.name === tableObj.table);
+  if (!cte?.columns?.length) throw new Error(`Cannot expand * for CTE "${tableObj.table}" \u2014 select columns explicitly`);
+  return cte.columns.map((col) => {
+    const q = `${tId}.${col}`;
+    return `${dialect.quoteQualifiedColumn(q)} AS ${dialect.quote(q, true)}`;
+  });
+}
+function extractSelectAlias(expr) {
+  const aliased = / AS ["'`](.+?)["'`]\s*$/i.exec(expr);
+  if (aliased) return aliased[1];
+  const quoted = /^["'`](.+?)["'`]$/.exec(expr);
+  if (quoted) return quoted[1];
+  if (/^\w+$/.test(expr)) return expr;
+  return null;
 }
-var extend_default = {
+function extractCTEColumns(query) {
+  return query.values.selects.map(extractSelectAlias).filter((c2) => c2 !== null);
+}
+var DbWith = class _DbWith {
+  constructor(db, _withs) {
+    this.db = db;
+    this._withs = _withs;
+  }
+  with(name, query) {
+    const columns = extractCTEColumns(query);
+    return new _DbWith(this.db, [
+      ...this._withs,
+      { name, sql: query.getSQL().replace(/;$/, ""), columns }
+    ]);
+  }
+  from(baseTableOrCTE, alias) {
+    return new _fJoin(this.db, {
+      tables: [{ table: baseTableOrCTE, alias }],
+      selects: [],
+      withs: this._withs
+    });
+  }
+};
+var extendedPrismaClient = {
+  name: "prisma-ts-select",
   client: {
     $from(table) {
       const client = Prisma.getExtensionContext(this);
       const [base, ...aliases] = table.split(" ");
       return new DbSelect(client).from(base.trim(), aliases.join().trim() || void 0);
+    },
+    /** @note `query` must be produced by the same prisma-ts-select builder instance. */
+    $with(name, query) {
+      const client = Prisma.getExtensionContext(this);
+      const columns = extractCTEColumns(query);
+      return new DbWith(client, [{ name, sql: query.getSQL().replace(/;$/, ""), columns }]);
     }
   }
 };
+var extend_default = extendedPrismaClient;
 
 export { extend_default as default };