@tanstack/db 0.0.13 → 0.0.15

package/dist/cjs/query/builder/functions.cjs

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ir = require("../ir.cjs");
+const refProxy = require("./ref-proxy.cjs");
+function eq(left, right) {
+  return new ir.Func(`eq`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function gt(left, right) {
+  return new ir.Func(`gt`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function gte(left, right) {
+  return new ir.Func(`gte`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function lt(left, right) {
+  return new ir.Func(`lt`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function lte(left, right) {
+  return new ir.Func(`lte`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function and(left, right, ...rest) {
+  const allArgs = [left, right, ...rest];
+  return new ir.Func(
+    `and`,
+    allArgs.map((arg) => refProxy.toExpression(arg))
+  );
+}
+function or(left, right, ...rest) {
+  const allArgs = [left, right, ...rest];
+  return new ir.Func(
+    `or`,
+    allArgs.map((arg) => refProxy.toExpression(arg))
+  );
+}
+function not(value) {
+  return new ir.Func(`not`, [refProxy.toExpression(value)]);
+}
+function inArray(value, array) {
+  return new ir.Func(`in`, [refProxy.toExpression(value), refProxy.toExpression(array)]);
+}
+function like(left, right) {
+  return new ir.Func(`like`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function ilike(left, right) {
+  return new ir.Func(`ilike`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function upper(arg) {
+  return new ir.Func(`upper`, [refProxy.toExpression(arg)]);
+}
+function lower(arg) {
+  return new ir.Func(`lower`, [refProxy.toExpression(arg)]);
+}
+function length(arg) {
+  return new ir.Func(`length`, [refProxy.toExpression(arg)]);
+}
+function concat(...args) {
+  return new ir.Func(
+    `concat`,
+    args.map((arg) => refProxy.toExpression(arg))
+  );
+}
+function coalesce(...args) {
+  return new ir.Func(
+    `coalesce`,
+    args.map((arg) => refProxy.toExpression(arg))
+  );
+}
+function add(left, right) {
+  return new ir.Func(`add`, [refProxy.toExpression(left), refProxy.toExpression(right)]);
+}
+function count(arg) {
+  return new ir.Aggregate(`count`, [refProxy.toExpression(arg)]);
+}
+function avg(arg) {
+  return new ir.Aggregate(`avg`, [refProxy.toExpression(arg)]);
+}
+function sum(arg) {
+  return new ir.Aggregate(`sum`, [refProxy.toExpression(arg)]);
+}
+function min(arg) {
+  return new ir.Aggregate(`min`, [refProxy.toExpression(arg)]);
+}
+function max(arg) {
+  return new ir.Aggregate(`max`, [refProxy.toExpression(arg)]);
+}
+exports.add = add;
+exports.and = and;
+exports.avg = avg;
+exports.coalesce = coalesce;
+exports.concat = concat;
+exports.count = count;
+exports.eq = eq;
+exports.gt = gt;
+exports.gte = gte;
+exports.ilike = ilike;
+exports.inArray = inArray;
+exports.length = length;
+exports.like = like;
+exports.lower = lower;
+exports.lt = lt;
+exports.lte = lte;
+exports.max = max;
+exports.min = min;
+exports.not = not;
+exports.or = or;
+exports.sum = sum;
+exports.upper = upper;
+//# sourceMappingURL=functions.cjs.map

package/dist/cjs/query/builder/functions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.cjs","sources":["../../../../src/query/builder/functions.ts"],"sourcesContent":["import { Aggregate, Func } from \"../ir\"\nimport { toExpression } from \"./ref-proxy.js\"\nimport type { BasicExpression } from \"../ir\"\nimport type { RefProxy } from \"./ref-proxy.js\"\n\n// Helper type for any expression-like value\ntype ExpressionLike = BasicExpression | RefProxy<any> | any\n\n// Operators\n\nexport function eq<T>(\n  left: RefProxy<T>,\n  right: T | RefProxy<T> | BasicExpression<T>\n): BasicExpression<boolean>\nexport function eq<T extends string | number | boolean>(\n  left: T | BasicExpression<T>,\n  right: T | BasicExpression<T>\n): BasicExpression<boolean>\nexport function eq<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>\nexport function eq(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`eq`, [toExpression(left), toExpression(right)])\n}\n\nexport function gt<T>(\n  left: RefProxy<T>,\n  right: T | RefProxy<T> | BasicExpression<T>\n): BasicExpression<boolean>\nexport function gt<T extends string | number>(\n  left: T | BasicExpression<T>,\n  right: T | BasicExpression<T>\n): BasicExpression<boolean>\nexport function gt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>\nexport function gt(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`gt`, [toExpression(left), toExpression(right)])\n}\n\nexport function gte<T>(\n  left: RefProxy<T>,\n  right: T | RefProxy<T> | BasicExpression<T>\n): BasicExpression<boolean>\nexport function gte<T extends string | number>(\n  left: T | BasicExpression<T>,\n  right: T | BasicExpression<T>\n): BasicExpression<boolean>\nexport function gte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>\nexport function gte(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`gte`, [toExpression(left), toExpression(right)])\n}\n\nexport function lt<T>(\n  left: RefProxy<T>,\n  right: T | RefProxy<T> | BasicExpression<T>\n): BasicExpression<boolean>\nexport function lt<T extends string | number>(\n  left: T | BasicExpression<T>,\n  right: T | BasicExpression<T>\n): BasicExpression<boolean>\nexport function lt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>\nexport function lt(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`lt`, [toExpression(left), toExpression(right)])\n}\n\nexport function lte<T>(\n  left: RefProxy<T>,\n  right: T | RefProxy<T> | BasicExpression<T>\n): BasicExpression<boolean>\nexport function lte<T extends string | number>(\n  left: T | BasicExpression<T>,\n  right: T | BasicExpression<T>\n): BasicExpression<boolean>\nexport function lte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>\nexport function lte(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`lte`, [toExpression(left), toExpression(right)])\n}\n\n// Overloads for and() - support 2 or more arguments\nexport function and(\n  left: ExpressionLike,\n  right: ExpressionLike\n): BasicExpression<boolean>\nexport function and(\n  left: ExpressionLike,\n  right: ExpressionLike,\n  ...rest: Array<ExpressionLike>\n): BasicExpression<boolean>\nexport function and(\n  left: ExpressionLike,\n  right: ExpressionLike,\n  ...rest: Array<ExpressionLike>\n): BasicExpression<boolean> {\n  const allArgs = [left, right, ...rest]\n  return new Func(\n    `and`,\n    allArgs.map((arg) => toExpression(arg))\n  )\n}\n\n// Overloads for or() - support 2 or more arguments\nexport function or(\n  left: ExpressionLike,\n  right: ExpressionLike\n): BasicExpression<boolean>\nexport function or(\n  left: ExpressionLike,\n  right: ExpressionLike,\n  ...rest: Array<ExpressionLike>\n): BasicExpression<boolean>\nexport function or(\n  left: ExpressionLike,\n  right: ExpressionLike,\n  ...rest: Array<ExpressionLike>\n): BasicExpression<boolean> {\n  const allArgs = [left, right, ...rest]\n  return new Func(\n    `or`,\n    allArgs.map((arg) => toExpression(arg))\n  )\n}\n\nexport function not(value: ExpressionLike): BasicExpression<boolean> {\n  return new Func(`not`, [toExpression(value)])\n}\n\nexport function inArray(\n  value: ExpressionLike,\n  array: ExpressionLike\n): BasicExpression<boolean> {\n  return new Func(`in`, [toExpression(value), toExpression(array)])\n}\n\nexport function like(\n  left:\n    | RefProxy<string>\n    | RefProxy<string | null>\n    | RefProxy<string | undefined>\n    | string\n    | BasicExpression<string>,\n  right: string | RefProxy<string> | BasicExpression<string>\n): BasicExpression<boolean>\nexport function like(left: any, right: any): BasicExpression<boolean> {\n  return new Func(`like`, [toExpression(left), toExpression(right)])\n}\n\nexport function ilike(\n  left:\n    | RefProxy<string>\n    | RefProxy<string | null>\n    | RefProxy<string | undefined>\n    | string\n    | BasicExpression<string>,\n  right: string | RefProxy<string> | BasicExpression<string>\n): BasicExpression<boolean> {\n  return new Func(`ilike`, [toExpression(left), toExpression(right)])\n}\n\n// Functions\n\nexport function upper(\n  arg:\n    | RefProxy<string>\n    | RefProxy<string | undefined>\n    | string\n    | BasicExpression<string>\n): BasicExpression<string> {\n  return new Func(`upper`, [toExpression(arg)])\n}\n\nexport function lower(\n  arg:\n    | RefProxy<string>\n    | RefProxy<string | undefined>\n    | string\n    | BasicExpression<string>\n): BasicExpression<string> {\n  return new Func(`lower`, [toExpression(arg)])\n}\n\nexport function length(\n  arg:\n    | RefProxy<string>\n    | RefProxy<string | undefined>\n    | RefProxy<Array<any>>\n    | RefProxy<Array<any> | undefined>\n    | string\n    | Array<any>\n    | BasicExpression<string>\n    | BasicExpression<Array<any>>\n): BasicExpression<number> {\n  return new Func(`length`, [toExpression(arg)])\n}\n\nexport function concat(\n  ...args: Array<ExpressionLike>\n): BasicExpression<string> {\n  return new Func(\n    `concat`,\n    args.map((arg) => toExpression(arg))\n  )\n}\n\nexport function coalesce(...args: Array<ExpressionLike>): BasicExpression<any> {\n  return new Func(\n    `coalesce`,\n    args.map((arg) => toExpression(arg))\n  )\n}\n\nexport function add(\n  left:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>,\n  right:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>\n): BasicExpression<number> {\n  return new Func(`add`, [toExpression(left), toExpression(right)])\n}\n\n// Aggregates\n\nexport function count(arg: ExpressionLike): Aggregate<number> {\n  return new Aggregate(`count`, [toExpression(arg)])\n}\n\nexport function avg(\n  arg:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>\n): Aggregate<number> {\n  return new Aggregate(`avg`, [toExpression(arg)])\n}\n\nexport function sum(\n  arg:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>\n): Aggregate<number> {\n  return new Aggregate(`sum`, [toExpression(arg)])\n}\n\nexport function min(\n  arg:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>\n): Aggregate<number> {\n  return new Aggregate(`min`, [toExpression(arg)])\n}\n\nexport function max(\n  arg:\n    | RefProxy<number>\n    | RefProxy<number | undefined>\n    | number\n    | BasicExpression<number>\n): Aggregate<number> {\n  return new Aggregate(`max`, [toExpression(arg)])\n}\n"],"names":["Func","toExpression","Aggregate"],"mappings":"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"}

package/dist/cjs/query/builder/functions.d.cts

@@ -0,0 +1,38 @@
+import { Aggregate, BasicExpression } from '../ir.cjs';
+import { RefProxy } from './ref-proxy.js';
+type ExpressionLike = BasicExpression | RefProxy<any> | any;
+export declare function eq<T>(left: RefProxy<T>, right: T | RefProxy<T> | BasicExpression<T>): BasicExpression<boolean>;
+export declare function eq<T extends string | number | boolean>(left: T | BasicExpression<T>, right: T | BasicExpression<T>): BasicExpression<boolean>;
+export declare function eq<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>;
+export declare function gt<T>(left: RefProxy<T>, right: T | RefProxy<T> | BasicExpression<T>): BasicExpression<boolean>;
+export declare function gt<T extends string | number>(left: T | BasicExpression<T>, right: T | BasicExpression<T>): BasicExpression<boolean>;
+export declare function gt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>;
+export declare function gte<T>(left: RefProxy<T>, right: T | RefProxy<T> | BasicExpression<T>): BasicExpression<boolean>;
+export declare function gte<T extends string | number>(left: T | BasicExpression<T>, right: T | BasicExpression<T>): BasicExpression<boolean>;
+export declare function gte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>;
+export declare function lt<T>(left: RefProxy<T>, right: T | RefProxy<T> | BasicExpression<T>): BasicExpression<boolean>;
+export declare function lt<T extends string | number>(left: T | BasicExpression<T>, right: T | BasicExpression<T>): BasicExpression<boolean>;
+export declare function lt<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>;
+export declare function lte<T>(left: RefProxy<T>, right: T | RefProxy<T> | BasicExpression<T>): BasicExpression<boolean>;
+export declare function lte<T extends string | number>(left: T | BasicExpression<T>, right: T | BasicExpression<T>): BasicExpression<boolean>;
+export declare function lte<T>(left: Aggregate<T>, right: any): BasicExpression<boolean>;
+export declare function and(left: ExpressionLike, right: ExpressionLike): BasicExpression<boolean>;
+export declare function and(left: ExpressionLike, right: ExpressionLike, ...rest: Array<ExpressionLike>): BasicExpression<boolean>;
+export declare function or(left: ExpressionLike, right: ExpressionLike): BasicExpression<boolean>;
+export declare function or(left: ExpressionLike, right: ExpressionLike, ...rest: Array<ExpressionLike>): BasicExpression<boolean>;
+export declare function not(value: ExpressionLike): BasicExpression<boolean>;
+export declare function inArray(value: ExpressionLike, array: ExpressionLike): BasicExpression<boolean>;
+export declare function like(left: RefProxy<string> | RefProxy<string | null> | RefProxy<string | undefined> | string | BasicExpression<string>, right: string | RefProxy<string> | BasicExpression<string>): BasicExpression<boolean>;
+export declare function ilike(left: RefProxy<string> | RefProxy<string | null> | RefProxy<string | undefined> | string | BasicExpression<string>, right: string | RefProxy<string> | BasicExpression<string>): BasicExpression<boolean>;
+export declare function upper(arg: RefProxy<string> | RefProxy<string | undefined> | string | BasicExpression<string>): BasicExpression<string>;
+export declare function lower(arg: RefProxy<string> | RefProxy<string | undefined> | string | BasicExpression<string>): BasicExpression<string>;
+export declare function length(arg: RefProxy<string> | RefProxy<string | undefined> | RefProxy<Array<any>> | RefProxy<Array<any> | undefined> | string | Array<any> | BasicExpression<string> | BasicExpression<Array<any>>): BasicExpression<number>;
+export declare function concat(...args: Array<ExpressionLike>): BasicExpression<string>;
+export declare function coalesce(...args: Array<ExpressionLike>): BasicExpression<any>;
+export declare function add(left: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>, right: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>): BasicExpression<number>;
+export declare function count(arg: ExpressionLike): Aggregate<number>;
+export declare function avg(arg: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>): Aggregate<number>;
+export declare function sum(arg: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>): Aggregate<number>;
+export declare function min(arg: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>): Aggregate<number>;
+export declare function max(arg: RefProxy<number> | RefProxy<number | undefined> | number | BasicExpression<number>): Aggregate<number>;
+export {};

package/dist/cjs/query/builder/index.cjs

@@ -0,0 +1,499 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const collection = require("../../collection.cjs");
+const ir = require("../ir.cjs");
+const refProxy = require("./ref-proxy.cjs");
+class BaseQueryBuilder {
+  constructor(query = {}) {
+    this.query = {};
+    this.query = { ...query };
+  }
+  /**
+   * Creates a CollectionRef or QueryRef from a source object
+   * @param source - An object with a single key-value pair
+   * @param context - Context string for error messages (e.g., "from clause", "join clause")
+   * @returns A tuple of [alias, ref] where alias is the source key and ref is the created reference
+   */
+  _createRefForSource(source, context) {
+    if (Object.keys(source).length !== 1) {
+      throw new Error(`Only one source is allowed in the ${context}`);
+    }
+    const alias = Object.keys(source)[0];
+    const sourceValue = source[alias];
+    let ref;
+    if (sourceValue instanceof collection.CollectionImpl) {
+      ref = new ir.CollectionRef(sourceValue, alias);
+    } else if (sourceValue instanceof BaseQueryBuilder) {
+      const subQuery = sourceValue._getQuery();
+      if (!subQuery.from) {
+        throw new Error(
+          `A sub query passed to a ${context} must have a from clause itself`
+        );
+      }
+      ref = new ir.QueryRef(subQuery, alias);
+    } else {
+      throw new Error(`Invalid source`);
+    }
+    return [alias, ref];
+  }
+  /**
+   * Specify the source table or subquery for the query
+   *
+   * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
+   * @returns A QueryBuilder with the specified source
+   *
+   * @example
+   * ```ts
+   * // Query from a collection
+   * query.from({ users: usersCollection })
+   *
+   * // Query from a subquery
+   * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)
+   * query.from({ activeUsers })
+   * ```
+   */
+  from(source) {
+    const [, from] = this._createRefForSource(source, `from clause`);
+    return new BaseQueryBuilder({
+      ...this.query,
+      from
+    });
+  }
+  /**
+   * Join another table or subquery to the current query
+   *
+   * @param source - An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
+   * @param onCallback - A function that receives table references and returns the join condition
+   * @param type - The type of join: 'inner', 'left', 'right', or 'full' (defaults to 'left')
+   * @returns A QueryBuilder with the joined table available
+   *
+   * @example
+   * ```ts
+   * // Left join users with posts
+   * query
+   *   .from({ users: usersCollection })
+   *   .join({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))
+   *
+   * // Inner join with explicit type
+   * query
+   *   .from({ u: usersCollection })
+   *   .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId), 'inner')
+   * ```
+   *
+   * // Join with a subquery
+   * const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)
+   * query
+   *   .from({ activeUsers })
+   *   .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId))
+   */
+  join(source, onCallback, type = `left`) {
+    const [alias, from] = this._createRefForSource(source, `join clause`);
+    const currentAliases = this._getCurrentAliases();
+    const newAliases = [...currentAliases, alias];
+    const refProxy$1 = refProxy.createRefProxy(newAliases);
+    const onExpression = onCallback(refProxy$1);
+    let left;
+    let right;
+    if (onExpression.type === `func` && onExpression.name === `eq` && onExpression.args.length === 2) {
+      left = onExpression.args[0];
+      right = onExpression.args[1];
+    } else {
+      throw new Error(`Join condition must be an equality expression`);
+    }
+    const joinClause = {
+      from,
+      type,
+      left,
+      right
+    };
+    const existingJoins = this.query.join || [];
+    return new BaseQueryBuilder({
+      ...this.query,
+      join: [...existingJoins, joinClause]
+    });
+  }
+  /**
+   * Filter rows based on a condition
+   *
+   * @param callback - A function that receives table references and returns an expression
+   * @returns A QueryBuilder with the where condition applied
+   *
+   * @example
+   * ```ts
+   * // Simple condition
+   * query
+   *   .from({ users: usersCollection })
+   *   .where(({users}) => gt(users.age, 18))
+   *
+   * // Multiple conditions
+   * query
+   *   .from({ users: usersCollection })
+   *   .where(({users}) => and(
+   *     gt(users.age, 18),
+   *     eq(users.active, true)
+   *   ))
+   *
+   * // Multiple where calls are ANDed together
+   * query
+   *   .from({ users: usersCollection })
+   *   .where(({users}) => gt(users.age, 18))
+   *   .where(({users}) => eq(users.active, true))
+   * ```
+   */
+  where(callback) {
+    const aliases = this._getCurrentAliases();
+    const refProxy$1 = refProxy.createRefProxy(aliases);
+    const expression = callback(refProxy$1);
+    const existingWhere = this.query.where || [];
+    return new BaseQueryBuilder({
+      ...this.query,
+      where: [...existingWhere, expression]
+    });
+  }
+  /**
+   * Filter grouped rows based on aggregate conditions
+   *
+   * @param callback - A function that receives table references and returns an expression
+   * @returns A QueryBuilder with the having condition applied
+   *
+   * @example
+   * ```ts
+   * // Filter groups by count
+   * query
+   *   .from({ posts: postsCollection })
+   *   .groupBy(({posts}) => posts.userId)
+   *   .having(({posts}) => gt(count(posts.id), 5))
+   *
+   * // Filter by average
+   * query
+   *   .from({ orders: ordersCollection })
+   *   .groupBy(({orders}) => orders.customerId)
+   *   .having(({orders}) => gt(avg(orders.total), 100))
+   *
+   * // Multiple having calls are ANDed together
+   * query
+   *   .from({ orders: ordersCollection })
+   *   .groupBy(({orders}) => orders.customerId)
+   *   .having(({orders}) => gt(count(orders.id), 5))
+   *   .having(({orders}) => gt(avg(orders.total), 100))
+   * ```
+   */
+  having(callback) {
+    const aliases = this._getCurrentAliases();
+    const refProxy$1 = refProxy.createRefProxy(aliases);
+    const expression = callback(refProxy$1);
+    const existingHaving = this.query.having || [];
+    return new BaseQueryBuilder({
+      ...this.query,
+      having: [...existingHaving, expression]
+    });
+  }
+  /**
+   * Select specific columns or computed values from the query
+   *
+   * @param callback - A function that receives table references and returns an object with selected fields or expressions
+   * @returns A QueryBuilder that returns only the selected fields
+   *
+   * @example
+   * ```ts
+   * // Select specific columns
+   * query
+   *   .from({ users: usersCollection })
+   *   .select(({users}) => ({
+   *     name: users.name,
+   *     email: users.email
+   *   }))
+   *
+   * // Select with computed values
+   * query
+   *   .from({ users: usersCollection })
+   *   .select(({users}) => ({
+   *     fullName: concat(users.firstName, ' ', users.lastName),
+   *     ageInMonths: mul(users.age, 12)
+   *   }))
+   *
+   * // Select with aggregates (requires GROUP BY)
+   * query
+   *   .from({ posts: postsCollection })
+   *   .groupBy(({posts}) => posts.userId)
+   *   .select(({posts, count}) => ({
+   *     userId: posts.userId,
+   *     postCount: count(posts.id)
+   *   }))
+   * ```
+   */
+  select(callback) {
+    const aliases = this._getCurrentAliases();
+    const refProxy$1 = refProxy.createRefProxy(aliases);
+    const selectObject = callback(refProxy$1);
+    const spreadSentinels = refProxy$1.__spreadSentinels;
+    const select = {};
+    for (const spreadAlias of spreadSentinels) {
+      const sentinelKey = `__SPREAD_SENTINEL__${spreadAlias}`;
+      select[sentinelKey] = refProxy.toExpression(spreadAlias);
+    }
+    for (const [key, value] of Object.entries(selectObject)) {
+      if (refProxy.isRefProxy(value)) {
+        select[key] = refProxy.toExpression(value);
+      } else if (typeof value === `object` && `type` in value && (value.type === `agg` || value.type === `func`)) {
+        select[key] = value;
+      } else {
+        select[key] = refProxy.toExpression(value);
+      }
+    }
+    return new BaseQueryBuilder({
+      ...this.query,
+      select,
+      fnSelect: void 0
+      // remove the fnSelect clause if it exists
+    });
+  }
+  /**
+   * Sort the query results by one or more columns
+   *
+   * @param callback - A function that receives table references and returns the field to sort by
+   * @param direction - Sort direction: 'asc' for ascending, 'desc' for descending (defaults to 'asc')
+   * @returns A QueryBuilder with the ordering applied
+   *
+   * @example
+   * ```ts
+   * // Sort by a single column
+   * query
+   *   .from({ users: usersCollection })
+   *   .orderBy(({users}) => users.name)
+   *
+   * // Sort descending
+   * query
+   *   .from({ users: usersCollection })
+   *   .orderBy(({users}) => users.createdAt, 'desc')
+   *
+   * // Multiple sorts (chain orderBy calls)
+   * query
+   *   .from({ users: usersCollection })
+   *   .orderBy(({users}) => users.lastName)
+   *   .orderBy(({users}) => users.firstName)
+   * ```
+   */
+  orderBy(callback, direction = `asc`) {
+    const aliases = this._getCurrentAliases();
+    const refProxy$1 = refProxy.createRefProxy(aliases);
+    const result = callback(refProxy$1);
+    const orderByClause = {
+      expression: refProxy.toExpression(result),
+      direction
+    };
+    const existingOrderBy = this.query.orderBy || [];
+    return new BaseQueryBuilder({
+      ...this.query,
+      orderBy: [...existingOrderBy, orderByClause]
+    });
+  }
+  /**
+   * Group rows by one or more columns for aggregation
+   *
+   * @param callback - A function that receives table references and returns the field(s) to group by
+   * @returns A QueryBuilder with grouping applied (enables aggregate functions in SELECT and HAVING)
+   *
+   * @example
+   * ```ts
+   * // Group by a single column
+   * query
+   *   .from({ posts: postsCollection })
+   *   .groupBy(({posts}) => posts.userId)
+   *   .select(({posts, count}) => ({
+   *     userId: posts.userId,
+   *     postCount: count()
+   *   }))
+   *
+   * // Group by multiple columns
+   * query
+   *   .from({ sales: salesCollection })
+   *   .groupBy(({sales}) => [sales.region, sales.category])
+   *   .select(({sales, sum}) => ({
+   *     region: sales.region,
+   *     category: sales.category,
+   *     totalSales: sum(sales.amount)
+   *   }))
+   * ```
+   */
+  groupBy(callback) {
+    const aliases = this._getCurrentAliases();
+    const refProxy$1 = refProxy.createRefProxy(aliases);
+    const result = callback(refProxy$1);
+    const newExpressions = Array.isArray(result) ? result.map((r) => refProxy.toExpression(r)) : [refProxy.toExpression(result)];
+    return new BaseQueryBuilder({
+      ...this.query,
+      groupBy: newExpressions
+    });
+  }
+  /**
+   * Limit the number of rows returned by the query
+   * `orderBy` is required for `limit`
+   *
+   * @param count - Maximum number of rows to return
+   * @returns A QueryBuilder with the limit applied
+   *
+   * @example
+   * ```ts
+   * // Get top 5 posts by likes
+   * query
+   *   .from({ posts: postsCollection })
+   *   .orderBy(({posts}) => posts.likes, 'desc')
+   *   .limit(5)
+   * ```
+   */
+  limit(count) {
+    return new BaseQueryBuilder({
+      ...this.query,
+      limit: count
+    });
+  }
+  /**
+   * Skip a number of rows before returning results
+   * `orderBy` is required for `offset`
+   *
+   * @param count - Number of rows to skip
+   * @returns A QueryBuilder with the offset applied
+   *
+   * @example
+   * ```ts
+   * // Get second page of results
+   * query
+   *   .from({ posts: postsCollection })
+   *   .orderBy(({posts}) => posts.createdAt, 'desc')
+   *   .offset(page * pageSize)
+   *   .limit(pageSize)
+   * ```
+   */
+  offset(count) {
+    return new BaseQueryBuilder({
+      ...this.query,
+      offset: count
+    });
+  }
+  // Helper methods
+  _getCurrentAliases() {
+    const aliases = [];
+    if (this.query.from) {
+      aliases.push(this.query.from.alias);
+    }
+    if (this.query.join) {
+      for (const join of this.query.join) {
+        aliases.push(join.from.alias);
+      }
+    }
+    return aliases;
+  }
+  /**
+   * Functional variants of the query builder
+   * These are imperative function that are called for ery row.
+   * Warning: that these cannot be optimized by the query compiler, and may prevent
+   * some type of optimizations being possible.
+   * @example
+   * ```ts
+   * q.fn.select((row) => ({
+   *   name: row.user.name.toUpperCase(),
+   *   age: row.user.age + 1,
+   * }))
+   * ```
+   */
+  get fn() {
+    const builder = this;
+    return {
+      /**
+       * Select fields using a function that operates on each row
+       * Warning: This cannot be optimized by the query compiler
+       *
+       * @param callback - A function that receives a row and returns the selected value
+       * @returns A QueryBuilder with functional selection applied
+       *
+       * @example
+       * ```ts
+       * // Functional select (not optimized)
+       * query
+       *   .from({ users: usersCollection })
+       *   .fn.select(row => ({
+       *     name: row.users.name.toUpperCase(),
+       *     age: row.users.age + 1,
+       *   }))
+       * ```
+       */
+      select(callback) {
+        return new BaseQueryBuilder({
+          ...builder.query,
+          select: void 0,
+          // remove the select clause if it exists
+          fnSelect: callback
+        });
+      },
+      /**
+       * Filter rows using a function that operates on each row
+       * Warning: This cannot be optimized by the query compiler
+       *
+       * @param callback - A function that receives a row and returns a boolean
+       * @returns A QueryBuilder with functional filtering applied
+       *
+       * @example
+       * ```ts
+       * // Functional where (not optimized)
+       * query
+       *   .from({ users: usersCollection })
+       *   .fn.where(row => row.users.name.startsWith('A'))
+       * ```
+       */
+      where(callback) {
+        return new BaseQueryBuilder({
+          ...builder.query,
+          fnWhere: [
+            ...builder.query.fnWhere || [],
+            callback
+          ]
+        });
+      },
+      /**
+       * Filter grouped rows using a function that operates on each aggregated row
+       * Warning: This cannot be optimized by the query compiler
+       *
+       * @param callback - A function that receives an aggregated row and returns a boolean
+       * @returns A QueryBuilder with functional having filter applied
+       *
+       * @example
+       * ```ts
+       * // Functional having (not optimized)
+       * query
+       *   .from({ posts: postsCollection })
+       *   .groupBy(({posts}) => posts.userId)
+       *   .fn.having(row => row.count > 5)
+       * ```
+       */
+      having(callback) {
+        return new BaseQueryBuilder({
+          ...builder.query,
+          fnHaving: [
+            ...builder.query.fnHaving || [],
+            callback
+          ]
+        });
+      }
+    };
+  }
+  _getQuery() {
+    if (!this.query.from) {
+      throw new Error(`Query must have a from clause`);
+    }
+    return this.query;
+  }
+}
+function buildQuery(fn) {
+  const result = fn(new BaseQueryBuilder());
+  return getQueryIR(result);
+}
+function getQueryIR(builder) {
+  return builder._getQuery();
+}
+const Query = BaseQueryBuilder;
+exports.BaseQueryBuilder = BaseQueryBuilder;
+exports.Query = Query;
+exports.buildQuery = buildQuery;
+exports.getQueryIR = getQueryIR;
+//# sourceMappingURL=index.cjs.map