pqb 0.30.6 → 0.31.0

package/dist/index.js

@@ -2379,25 +2379,14 @@ const subJoinToSql = (ctx, jq, innerAs, outerAs, cloned) => {
   }).text}) ${outerAs || innerAs}`;
 };
 const processArgs = (args, ctx, query, joinAs, joinShape, quotedAs) => {
-  if (args.length === 1) {
-    return getObjectOrRawConditions(
-      ctx,
-      query,
-      args[0],
-      quotedAs,
-      joinAs,
-      joinShape
-    );
-  } else {
-    return getConditionsFor3Or4LengthItem(
-      ctx,
-      query,
-      joinAs,
-      quotedAs,
-      args,
-      joinShape
-    );
-  }
+  return args.length === 1 ? getObjectOrRawConditions(ctx, query, args[0], quotedAs, joinAs, joinShape) : getConditionsFor3Or4LengthItem(
+    ctx,
+    query,
+    joinAs,
+    quotedAs,
+    args,
+    joinShape
+  );
 };
 const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, joinShape) => {
   const [leftColumn, opOrRightColumn, maybeRightColumn] = args;
@@ -2550,7 +2539,9 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
       );
       return { w: first, r, s: joinSubQuery || getIsJoinSubQuery(r) };
     }
-  } else if (typeof args[0] === "function") {
+  }
+  const args0 = args.length ? args[0] : orchidCore.returnArg;
+  if (typeof args0 === "function") {
     const q = first;
     if (q.joinQueryAfterCallback) {
       let base = q.baseQuery;
@@ -2568,7 +2559,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
     const joinedShapes = __spreadProps$4(__spreadValues$c({}, joinTo.q.joinedShapes), {
       [joinTo.q.as || joinTo.table]: joinTo.shape
     });
-    const r = args[0](
+    const r = args0(
       makeJoinQueryBuilder(
         q,
         q.q.joinedShapes ? __spreadValues$c(__spreadValues$c({}, q.q.joinedShapes), joinedShapes) : joinedShapes,
@@ -3685,15 +3676,16 @@ class AsMethods {
 }
 
 function queryFrom(self, arg) {
-  var _a;
+  var _a, _b;
   const data = self.q;
   if (typeof arg === "string") {
     data.as || (data.as = arg);
+    data.shape = (_a = data.withShapes) == null ? void 0 : _a[arg];
   } else if (orchidCore.isExpression(arg)) {
     data.as || (data.as = "t");
   } else if (Array.isArray(arg)) {
     const { shape } = data;
-    const parsers = (_a = data.parsers) != null ? _a : data.parsers = {};
+    const parsers = (_b = data.parsers) != null ? _b : data.parsers = {};
     for (const item of arg) {
       if (typeof item === "string") {
         const withShape = data.withShapes[item];
@@ -3723,7 +3715,7 @@ function queryFromSql(self, args) {
   data.from = sqlQueryArgsToExpression(args);
   return self;
 }
-class From {
+class FromMethods {
   /**
    * Set the `FROM` value, by default the table name is used.
    *
@@ -4080,20 +4072,21 @@ const havingToSql = (ctx, query, quotedAs) => {
   ).join(" AND ");
 };
 
-const pushWithSql = (ctx, withData) => {
-  if (!withData.length)
+const pushWithSql = (ctx, items) => {
+  if (!items.length)
     return;
   ctx.sql.push(
     "WITH",
-    withData.map((withItem) => {
-      const [name, options, query] = withItem;
+    items.map((item) => {
+      var _a;
       let inner;
-      if (orchidCore.isExpression(query)) {
-        inner = query.toSQL(ctx, `"${name}"`);
+      if (item.q) {
+        inner = makeSQL(item.q, ctx).text;
       } else {
-        inner = makeSQL(query, ctx).text;
+        inner = item.s.toSQL(ctx, `"${item.n}"`);
       }
-      return `${options.recursive ? "RECURSIVE " : ""}"${name}"${options.columns ? `(${options.columns.map((x) => `"${x}"`).join(", ")})` : ""} AS ${options.materialized ? "MATERIALIZED " : options.notMaterialized ? "NOT MATERIALIZED " : ""}(${inner})`;
+      const o = (_a = item.o) != null ? _a : orchidCore.emptyObject;
+      return `${o.recursive ? "RECURSIVE " : ""}"${item.n}"${o.columns ? `(${o.columns.map((x) => `"${x}"`).join(", ")})` : ""} AS ${o.materialized ? "MATERIALIZED " : o.notMaterialized ? "NOT MATERIALIZED " : ""}(${inner})`;
     }).join(", ")
   );
 };
@@ -4775,54 +4768,50 @@ const makeSQL = (table, options) => {
     }
   }
   const quotedAs = (query.as || table.table) && `"${query.as || table.table}"`;
-  sql.push("SELECT");
-  if (query.distinct) {
-    pushDistinctSql(ctx, table, query.distinct, quotedAs);
-  }
-  pushSelectSql(ctx, table, query, quotedAs);
-  if (table.table || query.from) {
-    pushFromAndAs(ctx, table, query, quotedAs);
-  }
-  if (query.join) {
-    pushJoinSql(
-      ctx,
-      table,
-      query,
-      quotedAs
-    );
-  }
-  if (query.and || query.or) {
-    pushWhereStatementSql(ctx, table, query, quotedAs);
-  }
-  if (query.group) {
-    const group = query.group.map(
-      (item) => orchidCore.isExpression(item) ? item.toSQL(ctx, quotedAs) : columnToSql(ctx, table.q, table.q.shape, item, quotedAs)
-    );
-    sql.push(`GROUP BY ${group.join(", ")}`);
-  }
-  if (query.having)
-    pushHavingSql(ctx, query, quotedAs);
-  if (query.window) {
-    const window = [];
-    query.window.forEach((item) => {
-      for (const key in item) {
-        window.push(
-          `"${key}" AS ${windowToSql(ctx, query, item[key], quotedAs)}`
-        );
-      }
-    });
-    sql.push(`WINDOW ${window.join(", ")}`);
-  }
   if (query.union) {
-    for (const item of query.union) {
-      let itemSql;
-      if (orchidCore.isExpression(item.arg)) {
-        itemSql = item.arg.toSQL(ctx, quotedAs);
-      } else {
-        const argSql = makeSQL(item.arg, { values });
-        itemSql = argSql.text;
-      }
-      sql.push(`${item.kind} ${item.wrap ? `(${itemSql})` : itemSql}`);
+    sql.push(`(${makeSQL(query.union.b, { values }).text})`);
+    for (const u of query.union.u) {
+      const itemSql = orchidCore.isExpression(u.a) ? u.a.toSQL(ctx, quotedAs) : makeSQL(u.a, { values }).text;
+      sql.push(`${u.k} (${itemSql})`);
+    }
+  } else {
+    sql.push("SELECT");
+    if (query.distinct) {
+      pushDistinctSql(ctx, table, query.distinct, quotedAs);
+    }
+    pushSelectSql(ctx, table, query, quotedAs);
+    if (table.table || query.from) {
+      pushFromAndAs(ctx, table, query, quotedAs);
+    }
+    if (query.join) {
+      pushJoinSql(
+        ctx,
+        table,
+        query,
+        quotedAs
+      );
+    }
+    if (query.and || query.or) {
+      pushWhereStatementSql(ctx, table, query, quotedAs);
+    }
+    if (query.group) {
+      const group = query.group.map(
+        (item) => orchidCore.isExpression(item) ? item.toSQL(ctx, quotedAs) : columnToSql(ctx, table.q, table.q.shape, item, quotedAs)
+      );
+      sql.push(`GROUP BY ${group.join(", ")}`);
+    }
+    if (query.having)
+      pushHavingSql(ctx, query, quotedAs);
+    if (query.window) {
+      const window = [];
+      query.window.forEach((item) => {
+        for (const key in item) {
+          window.push(
+            `"${key}" AS ${windowToSql(ctx, query, item[key], quotedAs)}`
+          );
+        }
+      });
+      sql.push(`WINDOW ${window.join(", ")}`);
     }
   }
   if (query.order) {
@@ -4906,7 +4895,7 @@ const cloneQuery = (q) => {
     if (q.window)
       q.window = q.window.slice(0);
     if (q.union)
-      q.union = q.union.slice(0);
+      q.union = { b: q.union.b, u: q.union.u.slice(0) };
     if (q.order)
       q.order = q.order.slice(0);
   } else if (q.type === "insert") {
@@ -6366,7 +6355,7 @@ class Create {
    *
    * await db.table.create({
    *   // raw SQL
-   *   column1: sql`'John' || ' ' || 'Doe'`,
+   *   column1: (q) => q.sql`'John' || ' ' || 'Doe'`,
    *
    *   // query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -8304,6 +8293,11 @@ class MergeQueryMethods {
             a[key] = a[key] ? [...a[key], ...value] : value;
           } else if (mergableObjects[key]) {
             a[key] = a[key] ? __spreadValues$5(__spreadValues$5({}, a[key]), value) : value;
+          } else if (key === "union") {
+            a[key] = a[key] ? {
+              b: a[key].b,
+              u: [...a[key].u, ...value.u]
+            } : value;
           } else {
             a[key] = value;
           }
@@ -8317,196 +8311,225 @@ class MergeQueryMethods {
   }
 }
 
-var __defProp$4 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
-var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
-var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$4 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$4.call(b, prop))
-      __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(b)) {
-      if (__propIsEnum$4.call(b, prop))
-        __defNormalProp$4(a, prop, b[prop]);
-    }
-  return a;
+const _queryUnion = (base, args, k) => {
+  const q = base.baseQuery.clone();
+  const u = args.map(
+    (a) => ({
+      a: typeof a === "function" ? a(q) : a,
+      k
+    })
+  );
+  const union = q.q.union = base.q.union;
+  if (union) {
+    union.u.push(...u);
+  } else {
+    q.q.union = {
+      b: base,
+      u
+    };
+  }
+  return q;
 };
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-class With {
+class Union {
   /**
-   * Add Common Table Expression (CTE) to the query.
+   * Creates a union query, takes one or more queries or SQL expressions.
    *
    * ```ts
-   * import { columnTypes } from 'orchid-orm';
-   * import { NumberColumn } from './number';
-   *
-   * // .with optionally accepts such options:
-   * type WithOptions = {
-   *   // list of columns returned by this WITH statement
-   *   // by default all columns from provided column shape will be included
-   *   // true is for default behavior
-   *   columns?: string[] | boolean;
-   *
-   *   // Adds RECURSIVE keyword:
-   *   recursive?: true;
-   *
-   *   // Adds MATERIALIZED keyword:
-   *   materialized?: true;
-   *
-   *   // Adds NOT MATERIALIZED keyword:
-   *   notMaterialized?: true;
-   * };
-   *
-   * // accepts columns shape and a raw expression:
-   * db.table.with(
-   *   'alias',
-   *   {
-   *     id: columnTypes.integer(),
-   *     name: columnTypes.text(3, 100),
-   *   },
-   *   sql`SELECT id, name FROM "someTable"`,
-   * );
-   *
-   * // accepts query:
-   * db.table.with('alias', db.table.all());
-   *
-   * // accepts a callback for a query builder:
-   * db.table.with('alias', (qb) =>
-   *   qb.select({ one: sql`1`.type((t) => t.integer()) }),
-   * );
-   *
-   * // All mentioned forms can accept options as a second argument:
-   * db.table.with(
-   *   'alias',
-   *   {
-   *     recursive: true,
-   *     materialized: true,
-   *   },
-   *   rawOrQueryOrCallback,
-   * );
+   * // The first query of the union
+   * db.one
+   *   .select('id', 'name')
+   *   // add two more queries to the union
+   *   .union(
+   *     db.two.select('id', 'name'),
+   *     (q = q.sql`SELECT id, name FROM "thirdTable"`),
+   *   )
+   *   // sub-sequent `union` is equivalent to passing multiple queries into a single `union`
+   *   .union(db.three.select('id', 'name'));
    * ```
    *
-   * Defined `WITH` table can be used in `.from` or `.join` with all the type safeness:
+   * `order`, `limit`, `offset` are special, it matters if you place them **before** or **after** the `union`, it also have a meaning to place them before and after.
    *
    * ```ts
-   * db.table.with('alias', db.table.all()).from('alias').select('alias.id');
-   *
-   * db.table
-   *   .with('alias', db.table.all())
-   *   .join('alias', 'alias.id', 'user.id')
-   *   .select('alias.id');
+   * // order, limit, offset are applied ONLY to 'one'
+   * db.one
+   *   .order('x')
+   *   .limit(1)
+   *   .offset(1)
+   *   // 'two' also has order, limit, and offset
+   *   .unionAll(db.two.order('y').limit(2).offset(2))
+   *   // sets order, limit, offset for all records
+   *   .order('z')
+   *   .limit(3)
+   *   .offset(3);
    * ```
    *
-   * @param args - first argument is an alias for this CTE, other arguments can be column shape, query object, or raw SQL.
-   */
-  with(...args) {
-    const q = this.clone();
-    let options = args.length === 3 && !orchidCore.isExpression(args[2]) || args.length === 4 ? args[1] : void 0;
-    const last = args[args.length - 1];
-    const query = typeof last === "function" ? last(q.queryBuilder) : last;
-    const shape = args.length === 4 ? args[2] : orchidCore.isExpression(query) ? args[1] : query.q.shape;
-    if ((options == null ? void 0 : options.columns) === true) {
-      options = __spreadProps$1(__spreadValues$4({}, options), {
-        columns: Object.keys(shape)
-      });
-    }
-    pushQueryValue(q, "with", [args[0], options || orchidCore.emptyObject, query]);
-    return setQueryObjectValue(q, "withShapes", args[0], shape);
-  }
-}
-
-class Union {
-  /**
-   * Creates a union query, taking an array or a list of callbacks, builders, or raw statements to build the union statement, with optional boolean `wrap`.
-   * If the `wrap` parameter is true, the queries will be individually wrapped in parentheses.
+   * Equivalent SQL:
    *
-   * ```ts
-   * SomeTable.select('id', 'name').union(
-   *   [
-   *     OtherTable.select('id', 'name'),
-   *     sql`SELECT id, name FROM "thirdTable"`,
-   *   ],
-   *   true, // optional wrap parameter
-   * );
+   * ```sql
+   * -- both union parts have their own order, limit, offset
+   * ( SELECT * FROM one ORDER x ASC LIMIT 1 OFFSET 1 )
+   * UNION ALL
+   * ( SELECT * FROM two ORDER y ASC LIMIT 2 OFFSET 2 )
+   * -- order, limit, offset of the whole query
+   * ORDER BY z ASC LIMIT 3 OFFSET 3
    * ```
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * All the listed methods have the same signature, they are only different by SQL keyword:
+   *
+   * - `union` - union of all queries, performs deduplication
+   * - `unionAll` - `union` that allows duplicated rows
+   * - `intersect` - get only rows that are present in all queries
+   * - `intersectAll` - `intersect` that allows duplicated rows
+   * - `except` - get only rows that are in the first query but not in the second
+   * - `exceptAll` - `except` that allows duplicated rows
+   *
+   * @param args - array of queries or SQL expressions
    */
-  union(args, wrap) {
-    return pushQueryArray(
+  union(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "UNION", wrap }))
+      args,
+      "UNION"
     );
   }
   /**
-   * Same as `union`, but allows duplicated rows.
+   * Same as {@link union}, but allows duplicated rows.
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * @param args - array of queries or SQL expressions
    */
-  unionAll(args, wrap) {
-    return pushQueryArray(
+  unionAll(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "UNION ALL", wrap }))
+      args,
+      "UNION ALL"
     );
   }
   /**
-   * Same as `union`, but uses a `INTERSECT` SQL keyword instead
+   * Same as {@link union}, but uses a `INTERSECT` SQL keyword instead
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * @param args - array of queries or SQL expressions
    */
-  intersect(args, wrap) {
-    return pushQueryArray(
+  intersect(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "INTERSECT", wrap }))
+      args,
+      "INTERSECT"
     );
   }
   /**
-   * Same as `intersect`, but allows duplicated rows.
+   * Same as {@link intersect}, but allows duplicated rows.
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * @param args - array of queries or SQL expressions
    */
-  intersectAll(args, wrap) {
-    return pushQueryArray(
+  intersectAll(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "INTERSECT ALL", wrap }))
+      args,
+      "INTERSECT ALL"
     );
   }
   /**
-   * Same as `union`, but uses an `EXCEPT` SQL keyword instead
+   * Same as {@link union}, but uses an `EXCEPT` SQL keyword instead
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * @param args - array of queries or SQL expressions
    */
-  except(args, wrap) {
-    return pushQueryArray(
+  except(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "EXCEPT", wrap }))
+      args,
+      "EXCEPT"
     );
   }
   /**
-   * Same as `except`, but allows duplicated rows.
+   * Same as {@link except}, but allows duplicated rows.
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * @param args - array of queries or SQL expressions
    */
-  exceptAll(args, wrap) {
-    return pushQueryArray(
+  exceptAll(...args) {
+    return _queryUnion(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "EXCEPT ALL", wrap }))
+      args,
+      "EXCEPT ALL"
+    );
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+class WithMethods {
+  with(name, second, third) {
+    const q = this.clone();
+    let [options, queryArg] = third ? [second, third] : [void 0, second];
+    let query;
+    if (typeof queryArg === "function") {
+      const arg = q.queryBuilder.clone();
+      arg.q.withShapes = q.q.withShapes;
+      query = queryArg(arg);
+    } else {
+      query = queryArg;
+    }
+    if ((options == null ? void 0 : options.columns) === true) {
+      options = __spreadProps$1(__spreadValues$4({}, options), {
+        columns: Object.keys(query.shape)
+      });
+    }
+    pushQueryValue(q, "with", { n: name, o: options, q: query });
+    const shape = getShapeFromSelect(query, true);
+    return setQueryObjectValue(q, "withShapes", name, shape);
+  }
+  withRecursive(name, ...args) {
+    var _a, _b, _c;
+    const q = this.clone();
+    let [options, baseFn, recursiveFn] = args.length === 2 ? [{}, args[0], args[1]] : args;
+    const arg = q.queryBuilder.clone();
+    arg.q.withShapes = q.q.withShapes;
+    let query = typeof baseFn === "function" ? baseFn(arg) : baseFn;
+    const shape = ((_b = (_a = arg.q).withShapes) != null ? _b : _a.withShapes = {})[name] = getShapeFromSelect(
+      query,
+      true
+    );
+    const recursive = recursiveFn(arg);
+    query = _queryUnion(query, [recursive], (_c = options.union) != null ? _c : "UNION ALL");
+    options.recursive = true;
+    if (options.columns === true) {
+      options = __spreadProps$1(__spreadValues$4({}, options), {
+        columns: Object.keys(shape)
+      });
+    }
+    pushQueryValue(q, "with", { n: name, o: options, q: query });
+    return setQueryObjectValue(q, "withShapes", name, shape);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  withSql(name, ...args) {
+    const q = this.clone();
+    const [options, shape, sql] = args.length === 2 ? [void 0, args[0], args[1]] : args;
+    pushQueryValue(q, "with", {
+      n: name,
+      o: options,
+      s: sql(q)
+    });
+    return setQueryObjectValue(
+      q,
+      "withShapes",
+      name,
+      shape(this.columnTypes)
     );
   }
 }
@@ -9340,11 +9363,10 @@ const _queryUpdate = (query, arg) => {
               "q",
               "withShapes"
             );
-            pushQueryValue(query, "with", [
-              as,
-              orchidCore.emptyObject,
-              value
-            ]);
+            pushQueryValue(query, "with", {
+              n: as,
+              q: value
+            });
             set[key] = new RawSQL(`(SELECT * FROM "${as}")`);
           }
         } else {
@@ -9442,7 +9464,7 @@ class Update {
    *   column1: 123,
    *
    *   // use raw SQL to update the column
-   *   column2: sql`2 + 2`,
+   *   column2: (q) => q.sql`2 + 2`,
    *
    *   // use query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -9556,7 +9578,7 @@ class Update {
     );
   }
   /**
-   * `updateRaw` is for updating records with raw expression.
+   * `updateSql` is for updating records with raw expression.
    *
    * The behavior is the same as a regular `update` method has:
    * `find` or `where` must precede calling this method,
@@ -9567,14 +9589,14 @@ class Update {
    * const value = 'new name';
    *
    * // update with SQL template string
-   * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+   * const updatedCount = await db.table.find(1).updateSql`name = ${value}`;
    *
    * // or update with `sql` function:
-   * await db.table.find(1).updateRaw(sql`name = ${value}`);
+   * await db.table.find(1).updateSql(sql`name = ${value}`);
    * ```
    * @param args - raw SQL via a template string or by using a `sql` method
    */
-  updateRaw(...args) {
+  updateSql(...args) {
     return _queryUpdateRaw(
       this.clone(),
       sqlQueryArgsToExpression(args)
@@ -11149,10 +11171,7 @@ class QueryMethods {
    *   pets: (q) => q.pets.join().none(),
    * });
    *
-   * await db.user.join(
-   *   (q) => q.pets.none(),
-   *   (q) => q,
-   * );
+   * await db.user.join((q) => q.pets.none());
    *
    * await db.user.join('pets', (q) => q.none());
    * ```
@@ -11308,10 +11327,10 @@ orchidCore.applyMixins(QueryMethods, [
   AsMethods,
   AggregateMethods,
   Select,
-  From,
+  FromMethods,
   Join,
   OnMethods,
-  With,
+  WithMethods,
   Union,
   JsonModifiers,
   JsonMethods,
@@ -11945,7 +11964,7 @@ exports.EnumColumn = EnumColumn;
 exports.ExpressionMethods = ExpressionMethods;
 exports.FnExpression = FnExpression;
 exports.For = For;
-exports.From = From;
+exports.FromMethods = FromMethods;
 exports.Having = Having;
 exports.InetColumn = InetColumn;
 exports.IntegerBaseColumn = IntegerBaseColumn;
@@ -12012,7 +12031,7 @@ exports.Update = Update;
 exports.VarCharColumn = VarCharColumn;
 exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
-exports.With = With;
+exports.WithMethods = WithMethods;
 exports.XMLColumn = XMLColumn;
 exports._initQueryBuilder = _initQueryBuilder;
 exports._queryAfterSaveCommit = _queryAfterSaveCommit;
@@ -12060,6 +12079,7 @@ exports._queryRows = _queryRows;
 exports._querySelect = _querySelect;
 exports._queryTake = _queryTake;
 exports._queryTakeOptional = _queryTakeOptional;
+exports._queryUnion = _queryUnion;
 exports._queryUpdate = _queryUpdate;
 exports._queryUpdateOrThrow = _queryUpdateOrThrow;
 exports._queryUpdateRaw = _queryUpdateRaw;