pqb 0.23.5 → 0.24.0

package/dist/index.js

@@ -140,13 +140,9 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * ```
    */
   primaryKey() {
-    return orchidCore.setColumnData(
-      this,
-      "isPrimaryKey",
-      true
-    );
+    return orchidCore.setColumnData(this, "isPrimaryKey", true);
   }
-  foreignKey(fnOrTable, column, options = {}) {
+  foreignKey(fnOrTable, column, options = orchidCore.emptyObject) {
     const item = typeof fnOrTable === "string" ? __spreadValues$g({ table: fnOrTable, columns: [column] }, options) : __spreadValues$g({ fn: fnOrTable, columns: [column] }, options);
     return orchidCore.pushColumnData(this, "foreignKeys", item);
   }
@@ -832,7 +828,7 @@ class JSONColumn extends ColumnType {
 JSONColumn.prototype.encodeFn = JSON.stringify;
 class JSONTextColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "json";
     this.operators = Operators.text;
   }
@@ -1107,8 +1103,7 @@ var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
 const processJoinItem = (ctx, table, query, item, quotedAs) => {
   let target;
   let conditions;
-  const { args } = item;
-  const [first] = args;
+  const { first, args } = item;
   if (typeof first === "string") {
     if (first in table.relations) {
       const { query: toQuery, joinQuery } = table.relations[first].relationConfig;
@@ -1129,8 +1124,8 @@ const processJoinItem = (ctx, table, query, item, quotedAs) => {
         and: j.and ? [...j.and] : [],
         or: j.or ? [...j.or] : []
       };
-      if (args[1]) {
-        const arg = args[1](
+      if (args[0]) {
+        const arg = args[0](
           new ctx.queryBuilder.onQueryBuilder(jq, j, table)
         ).q;
         if (arg.and)
@@ -1207,8 +1202,8 @@ const processJoinItem = (ctx, table, query, item, quotedAs) => {
 };
 const processArgs = (args, ctx, table, query, first, joinAs, joinShape, quotedAs) => {
   var _a;
-  if (args.length === 2) {
-    const arg = args[1];
+  if (args.length === 1) {
+    const arg = args[0];
     if (typeof arg === "function") {
       const joinedShapes = __spreadProps$8(__spreadValues$e({}, query.joinedShapes), {
         [table.q.as || table.table]: table.shape
@@ -1269,7 +1264,7 @@ const processArgs = (args, ctx, table, query, first, joinAs, joinShape, quotedAs
         joinShape
       );
     }
-  } else if (args.length >= 3) {
+  } else if (args.length >= 2) {
     return getConditionsFor3Or4LengthItem(
       ctx,
       query,
@@ -1282,7 +1277,7 @@ const processArgs = (args, ctx, table, query, first, joinAs, joinShape, quotedAs
   return void 0;
 };
 const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, joinShape) => {
-  const [, leftColumn, opOrRightColumn, maybeRightColumn] = args;
+  const [leftColumn, opOrRightColumn, maybeRightColumn] = args;
   const op = maybeRightColumn ? opOrRightColumn : "=";
   const rightColumn = maybeRightColumn ? maybeRightColumn : opOrRightColumn;
   return `${rawOrColumnToSql(
@@ -1381,17 +1376,16 @@ var __spreadValues$d = (a, b) => {
   return a;
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-const _join = (q, require2, type, args) => {
+const _join = (q, require2, type, first, args) => {
   var _a;
   let joinKey;
   let shape;
   let parsers;
   let isSubQuery = false;
-  if (typeof args[0] === "function") {
-    args[0] = args[0](q.relations);
-    args[0].joinQueryAfterCallback = args[0].joinQuery;
+  if (typeof first === "function") {
+    first = first(q.relations);
+    first.joinQueryAfterCallback = first.joinQuery;
   }
-  const first = args[0];
   if (typeof first === "object") {
     isSubQuery = getIsJoinSubQuery(first.q, first.baseQuery.q);
     joinKey = first.q.as || first.table;
@@ -1399,8 +1393,8 @@ const _join = (q, require2, type, args) => {
       shape = getShapeFromSelect(first, isSubQuery);
       parsers = first.q.parsers;
       if (isSubQuery) {
-        args[0] = first.clone();
-        args[0].shape = shape;
+        first = first.clone();
+        first.shape = shape;
       }
     }
   } else {
@@ -1430,12 +1424,14 @@ const _join = (q, require2, type, args) => {
   }
   return pushQueryValue(q, "join", {
     type,
+    first,
     args,
     isSubQuery
   });
 };
-const _joinLateral = (q, type, arg, cb, as) => {
+const _joinLateral = (self, type, arg, cb, as) => {
   var _a, _b, _c;
+  const q = self;
   let relation;
   if (typeof arg === "string") {
     relation = q.relations[arg];
@@ -1478,6 +1474,129 @@ const _joinLateral = (q, type, arg, cb, as) => {
   ]);
 };
 
+const dateTimeEncode = (input) => {
+  return typeof input === "number" ? new Date(input) : input;
+};
+const skipDateMethodsFromToCode = { encodeFn: dateTimeEncode };
+class DateBaseColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringNumberDate);
+    this.operators = Operators.date;
+    this.encodeFn = dateTimeEncode;
+    this.asNumber = schema.dateAsNumber;
+    this.asDate = schema.dateAsDate;
+  }
+}
+class DateColumn extends DateBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "date";
+  }
+  toCode(t) {
+    return columnCode(
+      this,
+      t,
+      `date()${orchidCore.dateDataToCode(this.data)}`,
+      this.data,
+      skipDateMethodsFromToCode
+    );
+  }
+}
+class DateTimeBaseClass extends DateBaseColumn {
+  constructor(schema, dateTimePrecision) {
+    super(schema);
+    this.data.dateTimePrecision = dateTimePrecision;
+  }
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`
+    );
+  }
+}
+class DateTimeTzBaseClass extends DateTimeBaseClass {
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.baseDataType,
+      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`,
+      " with time zone"
+    );
+  }
+}
+const timestampToCode = (self, t) => {
+  const { dateTimePrecision: p } = self.data;
+  return columnCode(
+    self,
+    t,
+    `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data)}`,
+    self.data,
+    skipDateMethodsFromToCode
+  );
+};
+class TimestampColumn extends DateTimeBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamp";
+  }
+  toCode(t) {
+    return timestampToCode(this, t);
+  }
+}
+class TimestampTZColumn extends DateTimeTzBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamptz";
+    this.baseDataType = "timestamp";
+  }
+  toCode(t) {
+    return timestampToCode(this, t);
+  }
+}
+class TimeColumn extends ColumnType {
+  constructor(schema, dateTimePrecision) {
+    super(schema, schema.stringSchema);
+    this.dataType = "time";
+    this.operators = Operators.time;
+    this.data.dateTimePrecision = dateTimePrecision;
+  }
+  toCode(t) {
+    const { dateTimePrecision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(this.data)}`,
+      this.data,
+      skipDateMethodsFromToCode
+    );
+  }
+}
+class IntervalColumn extends ColumnType {
+  constructor(schema, fields, precision) {
+    super(schema, schema.timeInterval);
+    this.dataType = "interval";
+    this.operators = Operators.date;
+    this.data.fields = fields;
+    this.data.precision = precision;
+  }
+  toCode(t) {
+    const { fields, precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`,
+      this.data,
+      skipDateMethodsFromToCode
+    );
+  }
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.fields && ` ${this.data.fields}`,
+      this.data.precision !== void 0 && ` (${this.data.precision})`
+    );
+  }
+}
+
 class EnumColumn extends ColumnType {
   constructor(schema, enumName, options, schemaType) {
     super(schema, schemaType);
@@ -1636,7 +1755,25 @@ const defaultSchemaConfig = {
   json() {
     return new JSONColumn(defaultSchemaConfig, void 0);
   },
-  setErrors: orchidCore.noop
+  setErrors: orchidCore.noop,
+  smallint: () => new SmallIntColumn(defaultSchemaConfig),
+  integer: () => new IntegerColumn(defaultSchemaConfig),
+  real: () => new RealColumn(defaultSchemaConfig),
+  smallSerial: () => new SmallSerialColumn(defaultSchemaConfig),
+  serial: () => new SerialColumn(defaultSchemaConfig),
+  bigint: () => new BigIntColumn(defaultSchemaConfig),
+  decimal: (precision, scale) => new DecimalColumn(defaultSchemaConfig, precision, scale),
+  doublePrecision: () => new DoublePrecisionColumn(defaultSchemaConfig),
+  bigSerial: () => new BigSerialColumn(defaultSchemaConfig),
+  money: () => new MoneyColumn(defaultSchemaConfig),
+  varchar: (limit) => new VarCharColumn(defaultSchemaConfig, limit),
+  char: (limit) => new CharColumn(defaultSchemaConfig, limit),
+  text: (min, max) => new TextColumn(defaultSchemaConfig, min, max),
+  string: (limit) => new StringColumn(defaultSchemaConfig, limit),
+  citext: (min, max) => new CitextColumn(defaultSchemaConfig, min, max),
+  date: () => new DateColumn(defaultSchemaConfig),
+  timestampNoTZ: (precision) => new TimestampColumn(defaultSchemaConfig, precision),
+  timestamp: (precision) => new TimestampTZColumn(defaultSchemaConfig, precision)
 };
 
 const addParserForRawExpression = (q, key, raw) => {
@@ -1734,7 +1871,12 @@ const processSelectArg = (q, as, arg, columnAs) => {
         value = value.q.expr;
       }
     }
-    selectAs[key] = addParserForSelectItem(q, as, key, value);
+    selectAs[key] = addParserForSelectItem(
+      q,
+      as,
+      key,
+      value
+    );
   }
   return { selectAs };
 };
@@ -1896,40 +2038,46 @@ class SelectItemExpression extends orchidCore.Expression {
   }
 }
 
-const _get = (q, returnType, arg) => {
+const _get = (query, returnType, arg) => {
   var _a, _b;
-  q.q.returnType = returnType;
+  const q = query.q;
+  q.returnType = returnType;
   let type;
   if (typeof arg === "string") {
-    type = q.q.shape[arg];
+    type = q.shape[arg];
     if (!type) {
       const index = arg.indexOf(".");
       if (index !== -1) {
         const table = arg.slice(0, index);
         const column = arg.slice(index + 1);
-        if (table === (q.q.as || q.table)) {
-          type = q.q.shape[column];
+        if (table === (q.as || query.table)) {
+          type = q.shape[column];
         } else {
-          type = (_b = (_a = q.q.joinedShapes) == null ? void 0 : _a[table]) == null ? void 0 : _b[column];
+          type = (_b = (_a = q.joinedShapes) == null ? void 0 : _a[table]) == null ? void 0 : _b[column];
         }
       }
     }
-    q.q[orchidCore.getValueKey] = type;
-    setParserForSelectedString(q, arg, getQueryAs(q), orchidCore.getValueKey);
-    q.q.expr = new SelectItemExpression(
-      q,
+    q[orchidCore.getValueKey] = type;
+    setParserForSelectedString(
+      query,
+      arg,
+      getQueryAs(query),
+      orchidCore.getValueKey
+    );
+    q.expr = new SelectItemExpression(
+      query,
       arg,
       type || orchidCore.emptyObject
     );
   } else {
     type = arg._type;
-    q.q[orchidCore.getValueKey] = type;
-    addParserForRawExpression(q, orchidCore.getValueKey, arg);
-    q.q.expr = arg;
+    q[orchidCore.getValueKey] = type;
+    addParserForRawExpression(query, orchidCore.getValueKey, arg);
+    q.expr = arg;
   }
-  q.q.select = [q.q.expr];
+  q.select = [q.expr];
   return setQueryOperators(
-    q,
+    query,
     (type == null ? void 0 : type.operators) || Operators.any
   );
 };
@@ -1940,27 +2088,11 @@ function _queryGetOptional(self, arg) {
   return _get(self, "value", arg);
 }
 
-class QueryBase {
-  constructor() {
-    this.q = {};
-  }
-  /**
-   * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
-   *
-   * Used under the hood, and not really needed on the app side.
-   */
-  clone() {
-    const cloned = Object.create(this.baseQuery);
-    cloned.q = getClonedQueryData(this.q);
-    return cloned;
-  }
-}
-
 const _queryAs = (self, as) => {
   self.q.as = as;
   return self;
 };
-class AsMethods extends QueryBase {
+class AsMethods {
   /**
    * Sets table alias:
    *
@@ -1979,30 +2111,30 @@ class AsMethods extends QueryBase {
 }
 
 function queryFrom(self, args) {
-  var _a, _b, _c;
   if (Array.isArray(args[0])) {
     return queryFrom(self, [
       new RawSQL(args)
     ]);
   }
+  const data = self.q;
   if (typeof args[0] === "string") {
-    (_a = self.q).as || (_a.as = args[0]);
+    data.as || (data.as = args[0]);
   } else if (!orchidCore.isExpression(args[0])) {
     const q = args[0];
-    (_b = self.q).as || (_b.as = q.q.as || q.table || "t");
-    self.q.shape = getShapeFromSelect(
+    data.as || (data.as = q.q.as || q.table || "t");
+    data.shape = getShapeFromSelect(
       args[0],
       true
     );
-    self.q.parsers = q.q.parsers;
+    data.parsers = q.q.parsers;
   } else {
-    (_c = self.q).as || (_c.as = "t");
+    data.as || (data.as = "t");
   }
   const options = args[1];
   if (options == null ? void 0 : options.only) {
-    self.q.fromOnly = options.only;
+    data.fromOnly = options.only;
   }
-  self.q.from = args[0];
+  data.from = args[0];
   return self;
 }
 class From {
@@ -2035,19 +2167,22 @@ class From {
    * @param args - query, raw SQL, name of CTE table, or a template string
    */
   from(...args) {
-    return queryFrom(this.clone(), args);
+    return queryFrom(
+      this.clone(),
+      args
+    );
   }
 }
 
 function queryWrap(self, query, as = "t") {
-  return _queryAs(
-    queryFrom(query, [self]),
-    as
-  );
+  return _queryAs(queryFrom(query, [self]), as);
 }
 
 function queryJson(self, coalesce) {
-  const q = queryWrap(self, self.baseQuery.clone());
+  const q = queryWrap(
+    self,
+    self.baseQuery.clone()
+  );
   _queryGetOptional(
     q,
     new RawSQL(
@@ -3242,16 +3377,17 @@ var __spreadValues$a = (a, b) => {
   return a;
 };
 var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-function setQueryOperators(q, operators) {
-  if (q.q.operators) {
-    if (q.q.operators === operators)
-      return q;
-    q.baseQuery = q.q.originalQuery;
+function setQueryOperators(query, operators) {
+  const q = query.q;
+  if (q.operators) {
+    if (q.operators === operators)
+      return query;
+    query.baseQuery = q.originalQuery;
   } else {
-    q.q.originalQuery = q.baseQuery;
+    q.originalQuery = query.baseQuery;
   }
-  q.q.operators = operators;
-  return extendQuery(q, operators);
+  q.operators = operators;
+  return extendQuery(query, operators);
 }
 const make = (_op) => {
   return Object.assign(
@@ -3384,13 +3520,13 @@ class IntegerBaseColumn extends NumberBaseColumn {
 }
 class NumberAsStringBaseColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.operators = Operators.number;
   }
 }
 class DecimalColumn extends ColumnType {
   constructor(schema, numericPrecision, numericScale) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.operators = Operators.number;
     this.dataType = "decimal";
     this.data.numericPrecision = numericPrecision;
@@ -3549,14 +3685,14 @@ var __spreadValues$9 = (a, b) => {
 };
 var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
 class TextBaseColumn extends ColumnType {
-  constructor(schema, schemaType = schema.string) {
+  constructor(schema, schemaType = schema.stringSchema) {
     super(schema, schemaType);
     this.operators = Operators.text;
   }
 }
 class LimitedTextBaseColumn extends TextBaseColumn {
   constructor(schema, limit) {
-    super(schema, limit ? schema.stringMax(limit) : schema.string);
+    super(schema, limit ? schema.stringMax(limit) : schema.stringSchema);
     this.data.maxChars = limit;
   }
   toSQL() {
@@ -3639,7 +3775,7 @@ const textColumnToCode = (column, t) => {
     `${column.dataType}(${args})${orchidCore.stringDataToCode(data)}`
   );
 };
-const minMaxToSchema = (schema, min, max) => min ? max ? schema.stringMinMax(min, max) : schema.stringMin(min) : schema.string;
+const minMaxToSchema = (schema, min, max) => min ? max ? schema.stringMinMax(min, max) : schema.stringMin(min) : schema.stringSchema;
 class TextColumn extends TextBaseColumn {
   constructor(schema, min, max) {
     super(schema, minMaxToSchema(schema, min, max));
@@ -3662,7 +3798,7 @@ class ByteaColumn extends ColumnType {
 }
 class PointColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "point";
     this.operators = Operators.text;
   }
@@ -3672,7 +3808,7 @@ class PointColumn extends ColumnType {
 }
 class LineColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "line";
     this.operators = Operators.text;
   }
@@ -3682,7 +3818,7 @@ class LineColumn extends ColumnType {
 }
 class LsegColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "lseg";
     this.operators = Operators.text;
   }
@@ -3692,7 +3828,7 @@ class LsegColumn extends ColumnType {
 }
 class BoxColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "box";
     this.operators = Operators.text;
   }
@@ -3702,7 +3838,7 @@ class BoxColumn extends ColumnType {
 }
 class PathColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "path";
     this.operators = Operators.text;
   }
@@ -3712,7 +3848,7 @@ class PathColumn extends ColumnType {
 }
 class PolygonColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "polygon";
     this.operators = Operators.text;
   }
@@ -3722,7 +3858,7 @@ class PolygonColumn extends ColumnType {
 }
 class CircleColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "circle";
     this.operators = Operators.text;
   }
@@ -3732,7 +3868,7 @@ class CircleColumn extends ColumnType {
 }
 class MoneyColumn extends NumberBaseColumn {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "money";
     this.parseFn = Object.assign(
       function(input) {
@@ -3749,7 +3885,7 @@ class MoneyColumn extends NumberBaseColumn {
 }
 class CidrColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "cidr";
     this.operators = Operators.text;
   }
@@ -3759,7 +3895,7 @@ class CidrColumn extends ColumnType {
 }
 class InetColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "inet";
     this.operators = Operators.text;
   }
@@ -3769,7 +3905,7 @@ class InetColumn extends ColumnType {
 }
 class MacAddrColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "macaddr";
     this.operators = Operators.text;
   }
@@ -3779,7 +3915,7 @@ class MacAddrColumn extends ColumnType {
 }
 class MacAddr8Column extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "macaddr8";
     this.operators = Operators.text;
   }
@@ -3825,7 +3961,7 @@ class BitVaryingColumn extends ColumnType {
 }
 class TsVectorColumn extends ColumnType {
   constructor(schema, defaultLanguage = orchidCore.getDefaultLanguage()) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.defaultLanguage = defaultLanguage;
     this.dataType = "tsvector";
     this.operators = Operators.text;
@@ -3879,7 +4015,7 @@ class TsVectorColumn extends ColumnType {
 }
 class TsQueryColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "tsquery";
     this.operators = Operators.text;
   }
@@ -3914,7 +4050,7 @@ class UUIDColumn extends ColumnType {
 }
 class XMLColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.string);
+    super(schema, schema.stringSchema);
     this.dataType = "xml";
     this.operators = Operators.text;
   }
@@ -3933,166 +4069,43 @@ class CitextColumn extends TextBaseColumn {
   }
 }
 
-const dateTimeEncode = (input) => {
-  return typeof input === "number" ? new Date(input) : input;
-};
-const skipDateMethodsFromToCode = { encodeFn: dateTimeEncode };
-class DateBaseColumn extends ColumnType {
+class BooleanColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.stringNumberDate);
-    this.operators = Operators.date;
-    this.encodeFn = dateTimeEncode;
-    this.asNumber = schema.dateAsNumber;
-    this.asDate = schema.dateAsDate;
-  }
-}
-class DateColumn extends DateBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "date";
+    super(schema, schema.boolean);
+    this.dataType = "boolean";
+    this.operators = Operators.boolean;
+    this.parseItem = (input) => input[0] === "t";
   }
   toCode(t) {
-    return columnCode(
-      this,
-      t,
-      `date()${orchidCore.dateDataToCode(this.data)}`,
-      this.data,
-      skipDateMethodsFromToCode
-    );
+    return columnCode(this, t, "boolean()");
   }
 }
-class DateTimeBaseClass extends DateBaseColumn {
-  constructor(schema, dateTimePrecision) {
-    super(schema);
-    this.data.dateTimePrecision = dateTimePrecision;
+
+class CustomTypeColumn extends ColumnType {
+  constructor(schema, dataType) {
+    super(schema, schema.unknown, schema.unknown, schema.unknown);
+    this.dataType = dataType;
+    this.operators = Operators.any;
+    this.data.isOfCustomType = true;
   }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`
-    );
+  toCode(t) {
+    return columnCode(this, t, `type(${orchidCore.singleQuote(this.dataType)})`);
   }
-}
-class DateTimeTzBaseClass extends DateTimeBaseClass {
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.baseDataType,
-      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`,
-      " with time zone"
+  as(column) {
+    const c = orchidCore.setColumnData(
+      this,
+      "as",
+      column
     );
+    c.inputSchema = column.inputSchema;
+    c.outputSchema = column.outputSchema;
+    c.querySchema = column.querySchema;
+    return c;
   }
 }
-const timestampToCode = (self, t) => {
-  const { dateTimePrecision: p } = self.data;
-  return columnCode(
-    self,
-    t,
-    `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data)}`,
-    self.data,
-    skipDateMethodsFromToCode
-  );
-};
-class TimestampColumn extends DateTimeBaseClass {
-  constructor() {
-    super(...arguments);
-    this.dataType = "timestamp";
-  }
-  toCode(t) {
-    return timestampToCode(this, t);
-  }
-}
-class TimestampTZColumn extends DateTimeTzBaseClass {
-  constructor() {
-    super(...arguments);
-    this.dataType = "timestamptz";
-    this.baseDataType = "timestamp";
-  }
+class DomainColumn extends CustomTypeColumn {
   toCode(t) {
-    return timestampToCode(this, t);
-  }
-}
-class TimeColumn extends ColumnType {
-  constructor(schema, dateTimePrecision) {
-    super(schema, schema.string);
-    this.dataType = "time";
-    this.operators = Operators.time;
-    this.data.dateTimePrecision = dateTimePrecision;
-  }
-  toCode(t) {
-    const { dateTimePrecision } = this.data;
-    return columnCode(
-      this,
-      t,
-      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(this.data)}`,
-      this.data,
-      skipDateMethodsFromToCode
-    );
-  }
-}
-class IntervalColumn extends ColumnType {
-  constructor(schema, fields, precision) {
-    super(schema, schema.timeInterval);
-    this.dataType = "interval";
-    this.operators = Operators.date;
-    this.data.fields = fields;
-    this.data.precision = precision;
-  }
-  toCode(t) {
-    const { fields, precision } = this.data;
-    return columnCode(
-      this,
-      t,
-      `interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`,
-      this.data,
-      skipDateMethodsFromToCode
-    );
-  }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.fields && ` ${this.data.fields}`,
-      this.data.precision !== void 0 && ` (${this.data.precision})`
-    );
-  }
-}
-
-class BooleanColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.boolean);
-    this.dataType = "boolean";
-    this.operators = Operators.boolean;
-    this.parseItem = (input) => input[0] === "t";
-  }
-  toCode(t) {
-    return columnCode(this, t, "boolean()");
-  }
-}
-
-class CustomTypeColumn extends ColumnType {
-  constructor(schema, dataType) {
-    super(schema, schema.unknown, schema.unknown, schema.unknown);
-    this.dataType = dataType;
-    this.operators = Operators.any;
-    this.data.isOfCustomType = true;
-  }
-  toCode(t) {
-    return columnCode(this, t, `type(${orchidCore.singleQuote(this.dataType)})`);
-  }
-  as(column) {
-    const c = orchidCore.setColumnData(
-      this,
-      "as",
-      column
-    );
-    c.inputSchema = column.inputSchema;
-    c.outputSchema = column.outputSchema;
-    c.querySchema = column.querySchema;
-    return c;
-  }
-}
-class DomainColumn extends CustomTypeColumn {
-  toCode(t) {
-    return columnCode(this, t, `domain(${orchidCore.singleQuote(this.dataType)})`);
+    return columnCode(this, t, `domain(${orchidCore.singleQuote(this.dataType)})`);
   }
 }
 
@@ -4130,19 +4143,6 @@ const getColumnTypes = (types, fn, nowSQL, language, data = newTableData()) => {
   return fn(types);
 };
 const makeColumnTypes = (schema) => {
-  const columnsWithMethods = {};
-  function columnWithMethods(klass, methods, ...args) {
-    if (columnsWithMethods[klass.name]) {
-      return new columnsWithMethods[klass.name](...args);
-    }
-    const withMethods = class extends klass {
-    };
-    Object.assign(withMethods.prototype, methods);
-    return new (columnsWithMethods[klass.name] = withMethods)(...args);
-  }
-  const numberMethods = schema.numberMethods;
-  const stringMethods = schema.stringMethods;
-  const dateMethods = schema.dateMethods;
   return __spreadValues$8({
     schema,
     enum: schema.enum,
@@ -4165,90 +4165,33 @@ const makeColumnTypes = (schema) => {
       }
       return (...args2) => new RawSQL(args2, arg);
     },
-    smallint() {
-      return columnWithMethods(SmallIntColumn, numberMethods, schema);
-    },
-    integer() {
-      return columnWithMethods(IntegerColumn, numberMethods, schema);
-    },
-    bigint() {
-      return columnWithMethods(BigIntColumn, stringMethods, schema);
-    },
-    numeric(precision, scale) {
-      return columnWithMethods(
-        DecimalColumn,
-        stringMethods,
-        schema,
-        precision,
-        scale
-      );
-    },
-    decimal(precision, scale) {
-      return columnWithMethods(
-        DecimalColumn,
-        stringMethods,
-        schema,
-        precision,
-        scale
-      );
-    },
-    real() {
-      return columnWithMethods(RealColumn, numberMethods, schema);
-    },
-    doublePrecision() {
-      return columnWithMethods(DoublePrecisionColumn, stringMethods, schema);
-    },
+    smallint: schema.smallint,
+    integer: schema.integer,
+    bigint: schema.bigint,
+    numeric: schema.decimal,
+    decimal: schema.decimal,
+    real: schema.real,
+    doublePrecision: schema.doublePrecision,
     identity(options) {
-      return columnWithMethods(
-        IntegerColumn,
-        numberMethods,
-        schema
-      ).identity(options);
-    },
-    smallSerial() {
-      return columnWithMethods(SmallSerialColumn, numberMethods, schema);
-    },
-    serial() {
-      return columnWithMethods(SerialColumn, numberMethods, schema);
-    },
-    bigSerial() {
-      return columnWithMethods(BigSerialColumn, stringMethods, schema);
-    },
-    money() {
-      return columnWithMethods(MoneyColumn, stringMethods, schema);
-    },
-    varchar(limit) {
-      return columnWithMethods(VarCharColumn, stringMethods, schema, limit);
-    },
-    char(limit) {
-      return columnWithMethods(CharColumn, stringMethods, schema, limit);
-    },
-    text(min, max) {
-      return columnWithMethods(TextColumn, stringMethods, schema, min, max);
-    },
-    string(limit = 255) {
-      return columnWithMethods(StringColumn, stringMethods, schema, limit);
-    },
-    citext(min, max) {
-      return columnWithMethods(CitextColumn, stringMethods, schema, min, max);
+      return schema.integer().identity(
+        options
+      );
     },
+    smallSerial: schema.smallSerial,
+    serial: schema.serial,
+    bigSerial: schema.bigSerial,
+    money: schema.money,
+    varchar: schema.varchar,
+    char: schema.char,
+    text: schema.text,
+    string: schema.string,
+    citext: schema.citext,
     bytea() {
       return new ByteaColumn(schema);
     },
-    date() {
-      return columnWithMethods(DateColumn, dateMethods, schema);
-    },
-    timestampNoTZ(precision) {
-      return columnWithMethods(TimestampColumn, dateMethods, schema, precision);
-    },
-    timestamp(precision) {
-      return columnWithMethods(
-        TimestampTZColumn,
-        dateMethods,
-        schema,
-        precision
-      );
-    },
+    date: schema.date,
+    timestampNoTZ: schema.timestampNoTZ,
+    timestamp: schema.timestamp,
     time(precision) {
       return new TimeColumn(schema, precision);
     },
@@ -4822,7 +4765,10 @@ class AggregateMethods {
    * ```
    */
   exists() {
-    const q = _queryGetOptional(this.clone(), new RawSQL("true"));
+    const q = _queryGetOptional(
+      this.clone(),
+      new RawSQL("true")
+    );
     q.q.notFoundDefault = false;
     q.q.coalesceValue = new RawSQL("false");
     return q;
@@ -4852,13 +4798,7 @@ class AggregateMethods {
    * @param options - aggregation options
    */
   count(arg = "*", options) {
-    return makeFnExpression(
-      this,
-      int,
-      "count",
-      [arg],
-      options
-    );
+    return makeFnExpression(this, int, "count", [arg], options);
   }
   /**
    * Get the minimum value for the specified numeric column, returns number or `null` if there are no records.
@@ -6076,16 +6016,17 @@ class OnConflictQueryBuilder {
   }
 }
 
-const _queryDelete = (q) => {
-  if (!q.q.select) {
-    if (q.q.returnType === "oneOrThrow" || q.q.returnType === "valueOrThrow") {
-      q.q.throwOnNotFound = true;
+const _queryDelete = (query) => {
+  const q = query.q;
+  if (!q.select) {
+    if (q.returnType === "oneOrThrow" || q.returnType === "valueOrThrow") {
+      q.throwOnNotFound = true;
     }
-    q.q.returnType = "rowCount";
+    q.returnType = "rowCount";
   }
-  throwIfNoWhere(q, "delete");
-  q.q.type = "delete";
-  return q;
+  throwIfNoWhere(query, "delete");
+  q.type = "delete";
+  return query;
 };
 class Delete {
   /**
@@ -6158,8 +6099,8 @@ const forMethods = {
     return q;
   }
 };
-const forQueryBuilder = (q, type, tableNames) => {
-  q = extendQuery(q, forMethods);
+const forQueryBuilder = (arg, type, tableNames) => {
+  const q = extendQuery(arg, forMethods);
   q.q.for = {
     type,
     tableNames
@@ -6338,7 +6279,7 @@ const _queryHookAfterDelete = (q, select, cb) => {
 const _queryHookAfterDeleteCommit = (q, select, cb) => {
   return after(q, "Delete", select, cb, true);
 };
-class QueryHooks extends QueryBase {
+class QueryHooks {
   /**
    * Run the function before any kind of query.
    *
@@ -6375,7 +6316,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterCreate(select, cb) {
-    return _queryHookAfterCreate(this.clone(), select, cb);
+    return _queryHookAfterCreate(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function after transaction for a `create` kind of query will be committed.
@@ -6385,7 +6330,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterCreateCommit(select, cb) {
-    return _queryHookAfterCreateCommit(this.clone(), select, cb);
+    return _queryHookAfterCreateCommit(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function before an `update` kind of query.
@@ -6406,7 +6355,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterUpdate(select, cb) {
-    return _queryHookAfterUpdate(this.clone(), select, cb);
+    return _queryHookAfterUpdate(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function after transaction for an `update` kind of query will be committed.
@@ -6417,7 +6370,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterUpdateCommit(select, cb) {
-    return _queryHookAfterUpdateCommit(this.clone(), select, cb);
+    return _queryHookAfterUpdateCommit(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function before a `create` or an `update` kind of query.
@@ -6438,7 +6395,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterSave(select, cb) {
-    return _queryHookAfterSave(this.clone(), select, cb);
+    return _queryHookAfterSave(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function after transaction for a `create` or an `update` kind of query will be committed.
@@ -6449,7 +6410,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterSaveCommit(select, cb) {
-    return _queryAfterSaveCommit(this.clone(), select, cb);
+    return _queryAfterSaveCommit(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function before a `delete` kind of query.
@@ -6470,7 +6435,11 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterDelete(select, cb) {
-    return _queryHookAfterDelete(this.clone(), select, cb);
+    return _queryHookAfterDelete(
+      this.clone(),
+      select,
+      cb
+    );
   }
   /**
    * Run the function after transaction for a `delete` kind of query will be committed.
@@ -6481,7 +6450,27 @@ class QueryHooks extends QueryBase {
    * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
   afterDeleteCommit(select, cb) {
-    return _queryHookAfterDeleteCommit(this.clone(), select, cb);
+    return _queryHookAfterDeleteCommit(
+      this.clone(),
+      select,
+      cb
+    );
+  }
+}
+
+class QueryBase {
+  constructor() {
+    this.q = {};
+  }
+  /**
+   * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
+   *
+   * Used under the hood, and not really needed on the app side.
+   */
+  clone() {
+    const cloned = Object.create(this.baseQuery);
+    cloned.q = getClonedQueryData(this.q);
+    return cloned;
   }
 }
 
@@ -6493,7 +6482,11 @@ const _queryWhere = (q, args) => {
       new RawSQL(args)
     );
   }
-  return pushQueryArray(q, "and", args);
+  return pushQueryArray(
+    q,
+    "and",
+    args
+  );
 };
 const _queryWhereNot = (q, args) => {
   if (Array.isArray(args[0])) {
@@ -6547,14 +6540,13 @@ const _queryWhereIn = (q, and, arg, values, not) => {
   }
   return q;
 };
-const existsArgs = (args) => {
-  const q = args[0];
+const existsArgs = (q, args) => {
   let isSubQuery;
   if (typeof q === "object") {
     isSubQuery = getIsJoinSubQuery(q.q, q.baseQuery.q);
     if (isSubQuery) {
-      args[0] = q.clone();
-      args[0].shape = getShapeFromSelect(q, true);
+      q = q.clone();
+      q.shape = getShapeFromSelect(q, true);
     }
   } else {
     isSubQuery = false;
@@ -6562,6 +6554,7 @@ const existsArgs = (args) => {
   return [
     {
       EXISTS: {
+        first: q,
         args,
         isSubQuery
       }
@@ -6958,7 +6951,10 @@ class Where {
    * @param args - {@link WhereArgs}
    */
   where(...args) {
-    return _queryWhere(this.clone(), args);
+    return _queryWhere(
+      this.clone(),
+      args
+    );
   }
   /**
    * `whereNot` takes the same argument as `where`,
@@ -6976,7 +6972,10 @@ class Where {
    * @param args - {@link WhereArgs}
    */
   whereNot(...args) {
-    return _queryWhereNot(this.clone(), args);
+    return _queryWhereNot(
+      this.clone(),
+      args
+    );
   }
   /**
    * `orWhere` is accepting the same arguments as {@link where}, joining arguments with `OR`.
@@ -7010,35 +7009,172 @@ class Where {
    * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
    */
   orWhereNot(...args) {
-    return _queryOrNot(this.clone(), args);
+    return _queryOrNot(
+      this.clone(),
+      args
+    );
   }
-  whereIn(arg, values) {
-    return _queryWhereIn(this.clone(), true, arg, values);
+  /**
+   * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
+   *
+   * When used with a single column it works equivalent to the `in` column operator:
+   *
+   * ```ts
+   * db.table.whereIn('column', [1, 2, 3]);
+   * // the same as:
+   * db.table.where({ column: [1, 2, 3] });
+   * ```
+   *
+   * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
+   *
+   * ```ts
+   * db.table.whereIn(
+   *   ['id', 'name'],
+   *   [
+   *     [1, 'Alice'],
+   *     [2, 'Bob'],
+   *   ],
+   * );
+   * ```
+   *
+   * It supports sub query which should return records with columns of the same type:
+   *
+   * ```ts
+   * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
+   * ```
+   *
+   * It supports raw SQL expression:
+   *
+   * ```ts
+   * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+   * ```
+   */
+  whereIn(...args) {
+    return _queryWhereIn(
+      this.clone(),
+      true,
+      args[0],
+      args[1]
+    );
   }
-  orWhereIn(arg, values) {
-    return _queryWhereIn(this.clone(), false, arg, values);
+  /**
+   * Takes the same arguments as {@link whereIn}.
+   * Add a `WHERE IN` condition prefixed with `OR` to the query:
+   *
+   * ```ts
+   * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
+   * ```
+   */
+  orWhereIn(...args) {
+    return _queryWhereIn(
+      this.clone(),
+      false,
+      args[0],
+      args[1]
+    );
   }
-  whereNotIn(arg, values) {
-    return _queryWhereIn(this.clone(), true, arg, values, true);
+  /**
+   * Acts as `whereIn`, but negates the condition with `NOT`:
+   *
+   * ```ts
+   * db.table.whereNotIn('color', ['red', 'green', 'blue']);
+   * ```
+   */
+  whereNotIn(...args) {
+    return _queryWhereIn(
+      this.clone(),
+      true,
+      args[0],
+      args[1],
+      true
+    );
   }
-  orWhereNotIn(arg, values) {
-    return _queryWhereIn(this.clone(), false, arg, values, true);
+  /**
+   * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
+   *
+   * ```ts
+   * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
+   * ```
+   */
+  orWhereNotIn(...args) {
+    return _queryWhereIn(
+      this.clone(),
+      false,
+      args[0],
+      args[1],
+      true
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  whereExists(...args) {
-    return _queryWhere(this.clone(), existsArgs(args));
+  /**
+   * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
+   *
+   * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
+   *
+   * ```ts
+   * // find users who have accounts
+   * // find by a relation name if it's defined
+   * db.user.whereExists('account');
+   *
+   * // find using a table and a join conditions
+   * db.user.whereExists(db.account, 'account.id', 'user.id');
+   *
+   * // find using a query builder in a callback:
+   * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
+   * ```
+   */
+  whereExists(arg, ...args) {
+    return _queryWhere(
+      this.clone(),
+      existsArgs(arg, args)
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  orWhereExists(...args) {
-    return _queryOr(this.clone(), existsArgs(args));
+  /**
+   * Acts as `whereExists`, but prepends the condition with `OR`:
+   *
+   * ```ts
+   * // find users who have an account or a profile,
+   * // imagine that the user has both `account` and `profile` relations defined.
+   * db.user.whereExist('account').orWhereExists('profile');
+   * ```
+   */
+  orWhereExists(arg, ...args) {
+    return _queryOr(
+      this.clone(),
+      existsArgs(arg, args)
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  whereNotExists(...args) {
-    return _queryWhereNot(this.clone(), existsArgs(args));
+  /**
+   * Acts as `whereExists`, but negates the condition with `NOT`:
+   *
+   * ```ts
+   * // find users who don't have an account,
+   * // image that the user `belongsTo` or `hasOne` account.
+   * db.user.whereNotExist('account');
+   * ```
+   *
+   * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+   * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+   */
+  whereNotExists(arg, ...args) {
+    return _queryWhereNot(
+      this.clone(),
+      existsArgs(arg, args)
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  orWhereNotExists(...args) {
-    return _queryOrNot(this.clone(), existsArgs(args));
+  /**
+   * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
+   *
+   * ```ts
+   * // find users who don't have an account OR who don't have a profile
+   * // imagine that the user has both `account` and `profile` relations defined.
+   * db.user.whereNotExists('account').orWhereNotExists('profile');
+   * ```
+   */
+  orWhereNotExists(arg, ...args) {
+    return _queryOrNot(
+      this.clone(),
+      existsArgs(arg, args)
+    );
   }
 }
 class WhereQueryBase extends QueryBase {
@@ -7046,21 +7182,447 @@ class WhereQueryBase extends QueryBase {
 orchidCore.applyMixins(WhereQueryBase, [Where]);
 
 class Join {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  join(...args) {
-    return _join(this.clone(), true, "JOIN", args);
+  /**
+   * ## Select relation
+   *
+   * Before joining a table, consider if selecting a relation is enough for your case:
+   *
+   * ```ts
+   * // select users with profiles
+   * // result type is Array<{ name: string, profile: Profile }>
+   * await db.user.select('name', {
+   *   profile: (q) => q.profile,
+   * });
+   *
+   * // select posts with counts of comments, order by comments count
+   * // result type is Array<Post & { commentsCount: number }>
+   * await db.post
+   *   .select('*', {
+   *     commentsCount: (q) => q.comments.count(),
+   *   })
+   *   .order({
+   *     commentsCount: 'DESC',
+   *   });
+   *
+   * // select authors with array of their book titles
+   * // result type is Array<Author & { books: string[] }>
+   * await db.author.select('*', {
+   *   books: (q) => q.books.pluck('title'),
+   * });
+   * ```
+   *
+   * Internally, such selects will use `LEFT JOIN LATERAL` to join a relation.
+   * If you're loading users with profiles (one-to-one relation), and some users don't have a profile, `profile` property will have `NULL` for such users.
+   * If you want to load only users that have profiles, and filter out the rest, add `.join()` method to the relation without arguments:
+   *
+   * ```ts
+   * // load only users who have a profile
+   * await db.user.select('*', {
+   *   profile: (q) => q.profile.join(),
+   * });
+   *
+   * // load only users who have a specific profile
+   * await db.user.select('*', {
+   *   profile: (q) => q.profile.join().where({ age: { gt: 20 } }),
+   * });
+   * ```
+   *
+   * You can also use this `.join()` method on the one-to-many relations, and records with empty array will be filtered out:
+   *
+   * ```ts
+   * // posts that have no tags won't be loaded
+   * // result type is Array<Post & { tags: Tag[] }>
+   * db.post.select('*', {
+   *   tags: (q) => q.tags.join(),
+   * });
+   * ```
+   *
+   * # Joins
+   *
+   * `join` methods allows to join other tables, relations by name, [with](/guide/advanced-queries#with) statements, sub queries.
+   *
+   * All the `join` methods accept the same arguments, but returning type is different because with `join` it's guaranteed to load joined table, and with `leftJoin` the joined table columns may be `NULL` when no matching record was found.
+   *
+   * For the following examples, imagine we have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
+   *
+   * ```ts
+   * export class UserTable extends BaseTable {
+   *   readonly table = 'user';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     name: t.text(),
+   *   }));
+   *
+   *   relations = {
+   *     messages: this.hasMany(() => MessageTable, {
+   *       primaryKey: 'id',
+   *       foreignKey: 'userId',
+   *     }),
+   *   };
+   * }
+   *
+   * export class MessageTable extends BaseTable {
+   *   readonly table = 'message';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     text: t.text(),
+   *     ...t.timestamps(),
+   *   }));
+   *
+   *   relations = {
+   *     user: this.belongsTo(() => UserTable, {
+   *       primaryKey: 'id',
+   *       foreignKey: 'userId',
+   *     }),
+   *   };
+   * }
+   * ```
+   *
+   * ## join
+   *
+   * `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
+   *
+   * When no matching record is found, it will skip records of the main table.
+   *
+   * ### join relation
+   *
+   * When relations are defined between the tables, you can join them by a relation name.
+   * Joined table can be references from `where` and `select` by a relation name.
+   *
+   * ```ts
+   * const result = await db.user
+   *   .join('messages')
+   *   // after joining a table, we can use it in `where` conditions:
+   *   .where({ 'messages.text': { startsWith: 'Hi' } })
+   *   .select(
+   *     'name', // name is User column, table name may be omitted
+   *     'messages.text', // text is the Message column, and the table name is required
+   *   );
+   *
+   * // result has the following type:
+   * const ok: { name: string; text: string }[] = result;
+   * ```
+   *
+   * The first argument can also be a callback, where instead of relation name as a string we're picking it as a property of `q`.
+   * In such a way, we can alias the relation with `as`, add `where` conditions, use other query methods.
+   *
+   * ```ts
+   * const result = await db.user.join((q) =>
+   *   q.messages.as('m').where({ text: 'some text' }),
+   * );
+   * ```
+   *
+   * Optionally, you can pass a second callback argument, it makes `on` and `orOn` methods available.
+   *
+   * But remember that when joining a relation, the needed `ON` conditions are already handled automatically.
+   *
+   * ```ts
+   * const result = await db.user.join(
+   *   (q) => q.messages.as('m'),
+   *   (q) =>
+   *     q
+   *       .on('text', 'name') // additionally, match message with user name
+   *       .where({ text: 'some text' }), // you can add `where` in a second callback as well.
+   * );
+   * ```
+   *
+   * ### Selecting full joined records
+   *
+   * `select` supports selecting a full record of a previously joined table by passing a table name with `.*` at the end:
+   *
+   * ```ts
+   * const result = await db.book.join('author').select('title', {
+   *   author: 'author.*',
+   * });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   // title of the book
+   *   title: string;
+   *   // a full author record is included:
+   *   author: { id: number; name: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
+   * ```
+   *
+   * It works fine for `1:1` (`belongsTo`, `hasOne`) relations, but it may have an unexpected result for `1:M` or `M:M` (`hasMany`, `hasAndBelongsToMany`) relations.
+   * For any kind of relation, it results in one main table record with data of exactly one joined table record, i.e. when selecting in this way, the records **won't** be collected into arrays.
+   *
+   * ```ts
+   * const result = await db.user
+   *   .join('messages')
+   *   .where({ 'messages.text': { startsWith: 'Hi' } })
+   *   .select('name', { messages: 'messages.*' });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included:
+   *   messages: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
+   * ```
+   *
+   * Because it's a one-to-many relation, one user has many messages, the user data will be duplicated for different messages data:
+   *
+   * | name   | msg                            |
+   * | ------ | ------------------------------ |
+   * | user 1 | `{ id: 1, text: 'message 1' }` |
+   * | user 1 | `{ id: 2, text: 'message 2' }` |
+   * | user 1 | `{ id: 3, text: 'message 3' }` |
+   *
+   * ### join table
+   *
+   * If relation wasn't defined, provide a `db.table` instance and specify columns for the join.
+   * Joined table can be references from `where` and `select` by a table name.
+   *
+   * ```ts
+   * // Join message where userId = id:
+   * db.user
+   *   .join(db.message, 'userId', 'id')
+   *   .where({ 'message.text': { startsWith: 'Hi' } })
+   *   .select('name', 'message.text');
+   * ```
+   *
+   * Columns in the join list may be prefixed with table names for clarity:
+   *
+   * ```ts
+   * db.user.join(db.message, 'message.userId', 'user.id');
+   * ```
+   *
+   * Joined table can have an alias for referencing it further:
+   *
+   * ```ts
+   * db.user
+   *   .join(db.message.as('m'), 'message.userId', 'user.id')
+   *   .where({ 'm.text': { startsWith: 'Hi' } })
+   *   .select('name', 'm.text');
+   * ```
+   *
+   * Joined table can be selected as an object as well as the relation join above:
+   *
+   * ```ts
+   * const result = await db.user
+   *   .join(db.message.as('m'), 'message.userId', 'user.id')
+   *   .where({ 'm.text': { startsWith: 'Hi' } })
+   *   .select('name', { msg: 'm.*' });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included as msg:
+   *   msg: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
+   * ```
+   *
+   * You can provide a custom comparison operator
+   *
+   * ```ts
+   * db.user.join(db.message, 'userId', '!=', 'id');
+   * ```
+   *
+   * Join can accept raw SQL for the `ON` part of join:
+   *
+   * ```ts
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text") = lower("user"."name")`,
+   * );
+   * ```
+   *
+   * Join can accept raw SQL instead of columns:
+   *
+   * ```ts
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text")`,
+   *   db.user.sql`lower("user"."name")`,
+   * );
+   *
+   * // with operator:
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text")`,
+   *   '!=',
+   *   db.user.sql`lower("user"."name")`,
+   * );
+   * ```
+   *
+   * To join based on multiple columns, you can provide an object where keys are joining table columns, and values are main table columns or a raw SQL:
+   *
+   * ```ts
+   * db.user.join(db.message, {
+   *   userId: 'id',
+   *
+   *   // with table names:
+   *   'message.userId': 'user.id',
+   *
+   *   // value can be a raw SQL expression:
+   *   text: db.user.sql`lower("user"."name")`,
+   * });
+   * ```
+   *
+   * Join all records without conditions by providing `true`:
+   *
+   * ```ts
+   * db.user.join(db.message, true);
+   * ```
+   *
+   * Join methods can accept a callback with a special query builder that has `on` and `orOn` methods for handling advanced cases:
+   *
+   * ```ts
+   * db.user.join(
+   *   db.message,
+   *   (q) =>
+   *     q
+   *       // left column is the db.message column, right column is the db.user column
+   *       .on('userId', 'id')
+   *       // table names can be provided:
+   *       .on('message.userId', 'user.id')
+   *       // operator can be specified:
+   *       .on('userId', '!=', 'id')
+   *       // operator can be specified with table names as well:
+   *       .on('message.userId', '!=', 'user.id')
+   *       // `.orOn` takes the same arguments as `.on` and acts like `.or`:
+   *       .on('userId', 'id') // where message.userId = user.id
+   *       .orOn('text', 'name'), // or message.text = user.name
+   * );
+   * ```
+   *
+   * Join query builder supports all `where` methods: `.where`, `.whereIn`, `.whereExists`, and all `.or`, `.not`, and `.orNot` forms.
+   *
+   * Column names in the where conditions are applied for the joined table, but you can specify a table name to add a condition for the main table.
+   *
+   * ```ts
+   * db.user.join(db.message, (q) =>
+   *   q
+   *     .on('userId', 'id')
+   *     .where({
+   *       // not prefixed column name is for joined table:
+   *       text: { startsWith: 'hello' },
+   *       // specify a table name to set condition on the main table:
+   *       'user.name': 'Bob',
+   *     })
+   *     // id is a column of a joined table Message
+   *     .whereIn('id', [1, 2, 3])
+   *     // condition for id of a user
+   *     .whereIn('user.id', [4, 5, 6]),
+   * );
+   * ```
+   *
+   * The query above will generate the following SQL (simplified):
+   *
+   * ```sql
+   * SELECT * FROM "user"
+   * JOIN "message"
+   *   ON "message"."userId" = "user"."id"
+   *  AND "message"."text" ILIKE 'hello%'
+   *  AND "user"."name" = 'Bob'
+   *  AND "message"."id" IN (1, 2, 3)
+   *  AND "user"."id" IN (4, 5, 6)
+   * ```
+   *
+   * The join argument can be a query with `select`, `where`, and other methods. In such case, it will be handled as a sub query:
+   *
+   * ```ts
+   * db.user.join(
+   *   db.message
+   *     .select('id', 'userId', 'text')
+   *     .where({ text: { startsWith: 'Hi' } })
+   *     .as('t'),
+   *   'userId',
+   *   'id',
+   * );
+   * ```
+   *
+   * It will produce such SQL:
+   *
+   * ```sql
+   * SELECT * FROM "user"
+   * JOIN (
+   *   SELECT "t"."id", "t"."userId", "t"."text"
+   *   FROM "message" AS "t"
+   * ) "t" ON "t"."userId" = "user"."id"
+   * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
+   */
+  join(arg, ...args) {
+    return _join(this.clone(), true, "JOIN", arg, args);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  leftJoin(...args) {
-    return _join(this.clone(), false, "LEFT JOIN", args);
+  /**
+   * `leftJoin` is a method for SQL `LEFT JOIN`, which is equivalent to `OUTER JOIN`, `LEFT OUTER JOIN`.
+   *
+   * When no matching record is found, it will fill joined table columns with `NULL` values in the result rows.
+   *
+   * Works just like `join`, except for result type that may have `null`:
+   *
+   * ```ts
+   * const result = await db.user
+   *   .leftJoin('messages')
+   *   .select('name', 'messages.text');
+   *
+   * // the same query, but joining table explicitly
+   * const result2: typeof result = await db.user
+   *   .leftJoin(db.message, 'userId', 'id')
+   *   .select('name', 'message.text');
+   *
+   * // result has the following type:
+   * const ok: { name: string; text: string | null }[] = result;
+   * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
+   */
+  leftJoin(arg, ...args) {
+    return _join(this.clone(), false, "LEFT JOIN", arg, args);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  rightJoin(...args) {
-    return _join(this.clone(), true, "RIGHT JOIN", args);
+  /**
+   * `rightJoin` is a method for SQL `RIGHT JOIN`, which is equivalent to `RIGHT OUTER JOIN`.
+   *
+   * Takes the same arguments as `json`.
+   *
+   * It will load all records from the joining table, and fill the main table columns with `null` when no match is found.
+   *
+   * The columns of the table you're joining to are becoming nullable when using `rightJoin`.
+   *
+   * ```ts
+   * const result = await db.user
+   *   .rightJoin('messages')
+   *   .select('name', 'messages.text');
+   *
+   * // even though name is not a nullable column, it becomes nullable after using rightJoin
+   * const ok: { name: string | null; text: string }[] = result;
+   * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
+   */
+  rightJoin(arg, ...args) {
+    return _join(this.clone(), true, "RIGHT JOIN", arg, args);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  fullJoin(...args) {
-    return _join(this.clone(), false, "FULL JOIN", args);
+  /**
+   * `fullJoin` is a method for SQL `FULL JOIN`, which is equivalent to `FULL OUTER JOIN`.
+   *
+   * Takes the same arguments as `json`.
+   *
+   * It will load all records from the joining table, both sides of the join may result in `null` values when there is no match.
+   *
+   * All columns become nullable after using `fullJoin`.
+   *
+   * ```ts
+   * const result = await db.user
+   *   .rightJoin('messages')
+   *   .select('name', 'messages.text');
+   *
+   * // all columns can be null
+   * const ok: { name: string | null; text: string | null }[] = result;
+   * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
+   */
+  fullJoin(arg, ...args) {
+    return _join(this.clone(), false, "FULL JOIN", arg, args);
   }
   /**
    * `joinLateral` allows joining a table with a sub-query that can reference the main table of current query and the other joined tables.
@@ -7249,7 +7811,7 @@ class OnQueryBuilder extends WhereQueryBase {
   }
 }
 
-class JsonModifiers extends QueryBase {
+class JsonModifiers {
   /**
    * Return a JSON value/object/array where a given value is set at the given path.
    * The path is an array of keys to access the value.
@@ -7452,7 +8014,10 @@ class JsonMethods {
    * @param coalesce
    */
   json(coalesce) {
-    return queryJson(this.clone(), coalesce);
+    return queryJson(
+      this.clone(),
+      coalesce
+    );
   }
 }
 
@@ -8036,12 +8601,7 @@ class With {
       });
     }
     pushQueryValue(q, "with", [args[0], options || orchidCore.emptyObject, query]);
-    return setQueryObjectValue(
-      q,
-      "withShapes",
-      args[0],
-      shape
-    );
+    return setQueryObjectValue(q, "withShapes", args[0], shape);
   }
 }
 
@@ -8154,12 +8714,13 @@ var __spreadValues$3 = (a, b) => {
   return a;
 };
 const _queryChangeCounter = (self, op, data) => {
-  self.q.type = "update";
-  if (!self.q.select) {
-    if (self.q.returnType === "oneOrThrow" || self.q.returnType === "valueOrThrow") {
-      self.q.throwOnNotFound = true;
+  const q = self.q;
+  q.type = "update";
+  if (!q.select) {
+    if (q.returnType === "oneOrThrow" || q.returnType === "valueOrThrow") {
+      q.throwOnNotFound = true;
     }
-    self.q.returnType = "rowCount";
+    q.returnType = "rowCount";
   }
   let map;
   if (typeof data === "object") {
@@ -8173,13 +8734,14 @@ const _queryChangeCounter = (self, op, data) => {
   pushQueryValue(self, "updateData", map);
   return self;
 };
-const update = (q) => {
-  q.q.type = "update";
-  if (!q.q.select) {
-    q.q.returnType = "rowCount";
+const update = (self) => {
+  const q = self.q;
+  q.type = "update";
+  if (!q.select) {
+    q.returnType = "rowCount";
   }
-  throwIfNoWhere(q, "update");
-  return q;
+  throwIfNoWhere(self, "update");
+  return self;
 };
 const _queryUpdate = (query, arg) => {
   const { q } = query;
@@ -8212,8 +8774,16 @@ const _queryUpdate = (query, arg) => {
       if (value !== null && value !== void 0 && !orchidCore.isExpression(value)) {
         if (value instanceof Db) {
           if (value.q.type) {
-            const as = saveSearchAlias(query, "q", "withShapes");
-            pushQueryValue(query, "with", [as, orchidCore.emptyObject, value]);
+            const as = saveSearchAlias(
+              query,
+              "q",
+              "withShapes"
+            );
+            pushQueryValue(query, "with", [
+              as,
+              orchidCore.emptyObject,
+              value
+            ]);
             set[key] = new RawSQL(`(SELECT * FROM "${as}")`);
           }
         } else {
@@ -8419,7 +8989,10 @@ class Update {
    * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
    */
   update(arg) {
-    return _queryUpdate(this.clone(), arg);
+    return _queryUpdate(
+      this.clone(),
+      arg
+    );
   }
   /**
    * `updateRaw` is for updating records with raw expression.
@@ -8475,7 +9048,10 @@ class Update {
    * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
    */
   updateOrThrow(arg) {
-    return _queryUpdateOrThrow(this.clone(), arg);
+    return _queryUpdateOrThrow(
+      this.clone(),
+      arg
+    );
   }
   /**
    * Increments a column by `1`, returns a count of updated records by default.
@@ -8516,7 +9092,11 @@ class Update {
    * @param data - name of the column to increment, or an object with columns and values to add
    */
   increment(data) {
-    return _queryChangeCounter(this.clone(), "+", data);
+    return _queryChangeCounter(
+      this.clone(),
+      "+",
+      data
+    );
   }
   /**
    * Decrements a column by `1`, returns a count of updated records by default.
@@ -8557,7 +9137,11 @@ class Update {
    * @param data - name of the column to decrement, or an object with columns and values to subtract
    */
   decrement(data) {
-    return _queryChangeCounter(this.clone(), "-", data);
+    return _queryChangeCounter(
+      this.clone(),
+      "-",
+      data
+    );
   }
 }
 
@@ -8698,14 +9282,12 @@ class Headline extends orchidCore.Expression {
 }
 AggregateMethods.prototype.headline = function(search, params) {
   var _a;
-  const source = (_a = this.q.sources) == null ? void 0 : _a[search];
+  const q = this;
+  const source = (_a = q.q.sources) == null ? void 0 : _a[search];
   if (!source)
-    throw new OrchidOrmInternalError(
-      this,
-      `Search \`${search}\` is not defined`
-    );
+    throw new OrchidOrmInternalError(q, `Search \`${search}\` is not defined`);
   return new Headline(
-    this.q,
+    q.q,
     source,
     params
   );
@@ -9210,7 +9792,7 @@ class ScopeMethods {
     var _a;
     const q = this.clone();
     if (!((_a = q.q.scopes) == null ? void 0 : _a[scope])) {
-      const s = this.internal.scopes[scope];
+      const s = q.internal.scopes[scope];
       if (s.and)
         pushQueryArray(q, "and", s.and);
       if (s.or)
@@ -9299,7 +9881,9 @@ class SoftDeleteMethods {
    * ```
    */
   hardDelete(..._args) {
-    return _queryDelete(this.clone().unscope("nonDeleted"));
+    return _queryDelete(
+      this.clone().unscope("nonDeleted")
+    );
   }
 }
 
@@ -9467,7 +10051,11 @@ class QueryMethods {
    * @param columns - column names or a raw SQL
    */
   distinct(...columns) {
-    return pushQueryArray(this.clone(), "distinct", columns);
+    return pushQueryArray(
+      this.clone(),
+      "distinct",
+      columns
+    );
   }
   /**
    * The `find` method is available only for tables which has exactly one primary key.
@@ -9536,7 +10124,10 @@ class QueryMethods {
    * @param args - `where` conditions
    */
   findBy(...args) {
-    return _queryFindBy(this.clone(), args);
+    return _queryFindBy(
+      this.clone(),
+      args
+    );
   }
   /**
    * The same as `where(conditions).takeOptional()`, it will filter records and add a `LIMIT 1`.
@@ -9551,7 +10142,10 @@ class QueryMethods {
    * @param args - `where` conditions
    */
   findByOptional(...args) {
-    return _queryFindByOptional(this.clone(), args);
+    return _queryFindByOptional(
+      this.clone(),
+      args
+    );
   }
   /**
    * Specifies the schema to be used as a prefix of a table name.
@@ -9607,7 +10201,11 @@ class QueryMethods {
    * @param columns - column names or a raw SQL
    */
   group(...columns) {
-    return pushQueryArray(this.clone(), "group", columns);
+    return pushQueryArray(
+      this.clone(),
+      "group",
+      columns
+    );
   }
   /**
    * Add a window with `window` and use it later by its name for aggregate or window functions:
@@ -9693,7 +10291,11 @@ class QueryMethods {
         new RawSQL(args)
       );
     }
-    return pushQueryArray(this.clone(), "order", args);
+    return pushQueryArray(
+      this.clone(),
+      "order",
+      args
+    );
   }
   /**
    * Adds a limit clause to the query.