@tanstack/db 0.0.14 → 0.0.16

package/dist/esm/query/builder/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","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":[],"mappings":"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"}

package/dist/esm/query/builder/index.d.ts

@@ -0,0 +1,324 @@
+import { OrderByDirection, QueryIR } from '../ir.js';
+import { Context, GroupByCallback, JoinOnCallback, MergeContext, MergeContextWithJoinType, OrderByCallback, RefProxyForContext, ResultTypeFromSelect, SchemaFromSource, SelectObject, Source, WhereCallback, WithResult } from './types.js';
+export declare class BaseQueryBuilder<TContext extends Context = Context> {
+    private readonly query;
+    constructor(query?: Partial<QueryIR>);
+    /**
+     * 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
+     */
+    private _createRefForSource;
+    /**
+     * 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<TSource extends Source>(source: TSource): QueryBuilder<{
+        baseSchema: SchemaFromSource<TSource>;
+        schema: SchemaFromSource<TSource>;
+        fromSourceName: keyof TSource & string;
+        hasJoins: false;
+    }>;
+    /**
+     * 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<TSource extends Source, TJoinType extends `inner` | `left` | `right` | `full` = `left`>(source: TSource, onCallback: JoinOnCallback<MergeContext<TContext, SchemaFromSource<TSource>>>, type?: TJoinType): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>;
+    /**
+     * 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: WhereCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * 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: WhereCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * 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<TSelectObject extends SelectObject>(callback: (refs: RefProxyForContext<TContext>) => TSelectObject): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>>;
+    /**
+     * 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: OrderByCallback<TContext>, direction?: OrderByDirection): QueryBuilder<TContext>;
+    /**
+     * 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: GroupByCallback<TContext>): QueryBuilder<TContext>;
+    /**
+     * 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: number): QueryBuilder<TContext>;
+    /**
+     * 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: number): QueryBuilder<TContext>;
+    private _getCurrentAliases;
+    /**
+     * 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(): {
+        /**
+         * 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<TFuncSelectResult>(callback: (row: TContext[`schema`]) => TFuncSelectResult): QueryBuilder<WithResult<TContext, TFuncSelectResult>>;
+        /**
+         * 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: (row: TContext[`schema`]) => any): QueryBuilder<TContext>;
+        /**
+         * 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: (row: TContext[`schema`]) => any): QueryBuilder<TContext>;
+    };
+    _getQuery(): QueryIR;
+}
+export declare function buildQuery<TContext extends Context>(fn: (builder: InitialQueryBuilder) => QueryBuilder<TContext>): QueryIR;
+export declare function getQueryIR(builder: BaseQueryBuilder | QueryBuilder<any> | InitialQueryBuilder): QueryIR;
+export type InitialQueryBuilder = Pick<BaseQueryBuilder<Context>, `from`>;
+export type InitialQueryBuilderConstructor = new () => InitialQueryBuilder;
+export type QueryBuilder<TContext extends Context> = Omit<BaseQueryBuilder<TContext>, `from` | `_getQuery`>;
+export declare const Query: InitialQueryBuilderConstructor;
+export type ExtractContext<T> = T extends BaseQueryBuilder<infer TContext> ? TContext : T extends QueryBuilder<infer TContext> ? TContext : never;
+export type { Context, Source, GetResult } from './types.js';