@hypequery/clickhouse 0.2.1 → 0.2.3

package/dist/core/cross-filter.d.ts

@@ -0,0 +1,85 @@
+import { ColumnType, FilterOperator, InferColumnType, OperatorValueMap, FilterConditionInput } from '../types';
+export interface FilterGroup<Schema extends Record<string, Record<string, any>> = any, OriginalT extends Record<string, any> = any> {
+    operator: 'AND' | 'OR';
+    conditions: Array<FilterConditionInput<any, Schema, OriginalT> | FilterGroup<Schema, OriginalT>>;
+    limit?: number;
+    orderBy?: {
+        column: keyof OriginalT;
+        direction: 'ASC' | 'DESC';
+    };
+}
+export declare const DateRange: {
+    readonly TODAY: "today";
+    readonly YESTERDAY: "yesterday";
+    readonly LAST_7_DAYS: "last_7_days";
+    readonly LAST_30_DAYS: "last_30_days";
+    readonly THIS_MONTH: "this_month";
+    readonly LAST_MONTH: "last_month";
+    readonly THIS_QUARTER: "this_quarter";
+    readonly YEAR_TO_DATE: "year_to_date";
+};
+export type DateRangeType = typeof DateRange[keyof typeof DateRange];
+/**
+ * A type-safe filter builder supporting both simple conditions and complex nested groups.
+ * @template Schema - The full database schema type
+ * @template TableName - The specific table being filtered
+ */
+export declare class CrossFilter<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+} = any, TableName extends keyof Schema = Extract<keyof Schema, string>> {
+    private schema?;
+    private rootGroup;
+    constructor(schema?: Schema | undefined);
+    /**
+     * Adds a single filter condition to the root group with an implicit AND conjunction.
+     * Performs type-safe validation if a schema is provided.
+     */
+    add<ColumnName extends Extract<keyof Schema[TableName], string>, Op extends FilterOperator>(condition: FilterConditionInput<OperatorValueMap<InferColumnType<Schema[TableName][ColumnName]>>[Op], Schema, Schema[TableName]>): this;
+    /**
+     * Adds multiple filter conditions to the root group.
+     */
+    addMultiple(conditions: Array<FilterConditionInput<any, Schema, Schema[TableName]>>): this;
+    /**
+     * Adds a nested group of filter conditions to the root group using the specified logical operator.
+     * @param groupConditions - Array of filter conditions or nested groups to be grouped together.
+     * @param operator - Logical operator ('AND' or 'OR') to combine the conditions in the group.
+     */
+    addGroup(groupConditions: Array<FilterConditionInput<any, Schema, Schema[TableName]> | FilterGroup<Schema, Schema[TableName]>>, operator: 'AND' | 'OR'): this;
+    /**
+     * Returns the current filter tree representing all conditions and groups.
+     */
+    getConditions(): FilterGroup<Schema, Schema[TableName]>;
+    /**
+     * Looks up a column's type from the schema.
+     * Defaults to 'String' if no schema is provided.
+     * @param column - The column name as a string.
+     */
+    private getColumnType;
+    /**
+     * Validates the value of a filter condition against its expected column type.
+     */
+    private validateValueType;
+    /**
+     * Recursively validates an array of filter conditions and nested groups.
+     */
+    private validateGroup;
+    /**
+     * Type guard to check if an item is a FilterGroup.
+     */
+    private isGroup;
+    private addDateCondition;
+    addDateRange<K extends keyof Schema[TableName]>(column: K extends keyof Schema[TableName] ? Schema[TableName][K] extends 'Date' | 'DateTime' ? K : never : never, range: DateRangeType): this;
+    lastNDays<K extends keyof Schema[TableName]>(column: K extends keyof Schema[TableName] ? Schema[TableName][K] extends 'Date' | 'DateTime' ? K : never : never, days: number): this;
+    addComparisonPeriod<K extends keyof Schema[TableName]>(column: K extends keyof Schema[TableName] ? Schema[TableName][K] extends 'Date' | 'DateTime' ? K : never : never, currentRange: [Date, Date]): this;
+    addYearOverYear<K extends keyof Schema[TableName]>(column: K extends keyof Schema[TableName] ? Schema[TableName][K] extends 'Date' | 'DateTime' ? K : never : never, currentRange: [Date, Date]): this;
+    /**
+     * Creates a filter for top N records by a value column
+     * @param valueColumn - The column to filter and order by
+     * @param n - Number of records to return
+     * @param orderBy - Sort direction, defaults to 'desc'
+     */
+    topN<K extends keyof Schema[TableName]>(valueColumn: K, n: number, orderBy?: 'desc' | 'asc'): this;
+}
+//# sourceMappingURL=cross-filter.d.ts.map

package/dist/core/features/aggregations.d.ts

@@ -0,0 +1,102 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType } from '../../types';
+export declare class AggregationFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    private createAggregation;
+    sum<Column extends keyof OriginalT, Alias extends string = `${Column & string}_sum`>(column: Column, alias?: Alias): {
+        select: string[];
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    count<Column extends keyof OriginalT, Alias extends string = `${Column & string}_count`>(column: Column, alias?: Alias): {
+        select: string[];
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    avg<Column extends keyof OriginalT, Alias extends string = `${Column & string}_avg`>(column: Column, alias?: Alias): {
+        select: string[];
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    min<Column extends keyof OriginalT, Alias extends string = `${Column & string}_min`>(column: Column, alias?: Alias): {
+        select: string[];
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    max<Column extends keyof OriginalT, Alias extends string = `${Column & string}_max`>(column: Column, alias?: Alias): {
+        select: string[];
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=aggregations.d.ts.map

package/dist/core/features/analytics.d.ts

@@ -0,0 +1,66 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType, TableColumn } from '../../types';
+import { ClickHouseSettings } from '@clickhouse/client-web';
+export declare class AnalyticsFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    addCTE(alias: string, subquery: QueryBuilder<any, any> | string): {
+        ctes: string[];
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addTimeInterval(column: keyof T | TableColumn<Schema>, interval: string, method: 'toStartOfInterval' | 'toStartOfMinute' | 'toStartOfHour' | 'toStartOfDay' | 'toStartOfWeek' | 'toStartOfMonth' | 'toStartOfQuarter' | 'toStartOfYear'): {
+        groupBy: string[];
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addSettings(opts: ClickHouseSettings): {
+        settings: string;
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+    };
+}
+//# sourceMappingURL=analytics.d.ts.map

package/dist/core/features/cross-filtering.d.ts

@@ -0,0 +1,31 @@
+import { QueryBuilder } from '../query-builder';
+import { CrossFilter } from '../cross-filter';
+import { ColumnType } from '../../types';
+/**
+ * Feature for handling cross-filter operations on queries
+ */
+export declare class CrossFilteringFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    /**
+     * Applies a set of cross filters to the query
+     * @param crossFilter - An instance of CrossFilter containing shared filter conditions
+     * @returns Updated query config
+     */
+    applyCrossFilters(crossFilter: CrossFilter<Schema, keyof Schema>): import("../../types").QueryConfig<T, Schema>;
+    /**
+     * Apply AND conditions - each condition is applied with WHERE
+     */
+    private applyAndConditions;
+    /**
+     * Apply direct OR conditions without adding extra conjunctions
+     * @param conditions The conditions to apply
+     * @param builder The builder to apply conditions to, defaults to this.builder
+     */
+    private applyOrConditions;
+}
+//# sourceMappingURL=cross-filtering.d.ts.map

package/dist/core/features/cross-filtering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/cross-filtering.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAe,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAwB,UAAU,EAAe,MAAM,aAAa,CAAC;AAgB5E;;GAEG;AACH,qBAAa,qBAAqB,CAChC,MAAM,SAAS;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAA;CAAE,EAC5E,CAAC,EACD,SAAS,SAAS,OAAO,GAAG,KAAK,EACjC,YAAY,GAAG,EAAE,EACjB,SAAS,GAAG,CAAC;IAED,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC;IAExF;;;;OAIG;IACH,iBAAiB,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;IAsBhE;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CAqD1B"}

package/dist/core/features/cross-filtering.js

@@ -0,0 +1,123 @@
+//@ts-
+/**
+ * Type guard to check if an object is a FilterConditionInput
+ */
+function isFilterCondition(obj) {
+    return obj && 'column' in obj && 'operator' in obj && 'value' in obj;
+}
+/**
+ * Type guard to check if an object is a FilterGroup
+ */
+function isFilterGroup(obj) {
+    return obj && 'conditions' in obj && 'operator' in obj;
+}
+/**
+ * Feature for handling cross-filter operations on queries
+ */
+export class CrossFilteringFeature {
+    constructor(builder) {
+        this.builder = builder;
+    }
+    /**
+     * Applies a set of cross filters to the query
+     * @param crossFilter - An instance of CrossFilter containing shared filter conditions
+     * @returns Updated query config
+     */
+    applyCrossFilters(crossFilter) {
+        const filterGroup = crossFilter.getConditions();
+        if (filterGroup.conditions.length === 0) {
+            return this.builder.getConfig();
+        }
+        // Apply conditions based on filter group operator
+        if (filterGroup.operator === 'AND') {
+            // For AND groups, apply each condition directly
+            this.applyAndConditions(filterGroup.conditions);
+        }
+        else {
+            // For OR groups, special handling to ensure proper parentheses
+            // We use whereGroup instead of orWhereGroup here since this is a top-level group
+            this.builder.whereGroup(builder => {
+                this.applyOrConditions(filterGroup.conditions, builder);
+            });
+        }
+        return this.builder.getConfig();
+    }
+    /**
+     * Apply AND conditions - each condition is applied with WHERE
+     */
+    applyAndConditions(conditions) {
+        conditions.forEach(condition => {
+            if (isFilterCondition(condition)) {
+                // Simple condition - apply with WHERE
+                this.builder.where(condition.column, condition.operator, condition.value);
+            }
+            else if (isFilterGroup(condition)) {
+                // Nested group
+                if (condition.operator === 'AND') {
+                    // AND subgroup - apply all conditions
+                    this.builder.whereGroup(builder => {
+                        const feature = new CrossFilteringFeature(builder);
+                        feature.applyAndConditions(condition.conditions);
+                    });
+                }
+                else {
+                    // OR subgroup within AND - needs special parentheses handling
+                    this.builder.whereGroup(builder => {
+                        const feature = new CrossFilteringFeature(builder);
+                        feature.applyOrConditions(condition.conditions, builder);
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Apply direct OR conditions without adding extra conjunctions
+     * @param conditions The conditions to apply
+     * @param builder The builder to apply conditions to, defaults to this.builder
+     */
+    applyOrConditions(conditions, builder = this.builder) {
+        if (conditions.length === 0)
+            return;
+        // Handle first condition
+        const firstCondition = conditions[0];
+        if (isFilterCondition(firstCondition)) {
+            builder.where(firstCondition.column, firstCondition.operator, firstCondition.value);
+        }
+        else if (isFilterGroup(firstCondition)) {
+            // Handle nested group
+            if (firstCondition.operator === 'AND') {
+                builder.whereGroup(innerBuilder => {
+                    const feature = new CrossFilteringFeature(innerBuilder);
+                    feature.applyAndConditions(firstCondition.conditions);
+                });
+            }
+            else {
+                builder.whereGroup(innerBuilder => {
+                    const feature = new CrossFilteringFeature(innerBuilder);
+                    feature.applyOrConditions(firstCondition.conditions, innerBuilder);
+                });
+            }
+        }
+        // Handle remaining conditions
+        for (let i = 1; i < conditions.length; i++) {
+            const condition = conditions[i];
+            if (isFilterCondition(condition)) {
+                builder.orWhere(condition.column, condition.operator, condition.value);
+            }
+            else if (isFilterGroup(condition)) {
+                if (condition.operator === 'AND') {
+                    builder.orWhereGroup(innerBuilder => {
+                        const feature = new CrossFilteringFeature(innerBuilder);
+                        feature.applyAndConditions(condition.conditions);
+                    });
+                }
+                else {
+                    builder.orWhereGroup(innerBuilder => {
+                        const feature = new CrossFilteringFeature(innerBuilder);
+                        feature.applyOrConditions(condition.conditions, innerBuilder);
+                    });
+                }
+            }
+        }
+    }
+}

package/dist/core/features/executor.d.ts

@@ -0,0 +1,19 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType } from '../../types';
+export declare class ExecutorFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    toSQLWithParams(): {
+        sql: string;
+        parameters: any[];
+    };
+    toSQL(): string;
+    execute(): Promise<T[]>;
+    stream(): Promise<ReadableStream<T[]>>;
+    private toSQLWithoutParameters;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/core/features/filtering.d.ts

@@ -0,0 +1,95 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType, FilterOperator, TableColumn } from '../../types';
+export declare class FilteringFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    addCondition<K extends keyof OriginalT | TableColumn<Schema>>(conjunction: 'AND' | 'OR', column: K, operator: FilterOperator, value: any): {
+        where: import("../../types").WhereCondition[];
+        parameters: any[];
+        select?: (string | keyof T)[] | undefined;
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    /**
+     * Adds a group-start marker to start a parenthesized group of conditions with AND conjunction
+     * @returns The updated query config
+     */
+    startWhereGroup(): {
+        where: import("../../types").WhereCondition[];
+        select?: (string | keyof T)[] | undefined;
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    /**
+     * Adds a group-start marker to start a parenthesized group of conditions with OR conjunction
+     * @returns The updated query config
+     */
+    startOrWhereGroup(): {
+        where: import("../../types").WhereCondition[];
+        select?: (string | keyof T)[] | undefined;
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    /**
+     * Adds a group-end marker to end a parenthesized group of conditions
+     * @returns The updated query config
+     */
+    endWhereGroup(): {
+        where: import("../../types").WhereCondition[];
+        select?: (string | keyof T)[] | undefined;
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=filtering.d.ts.map

package/dist/core/features/filtering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/filtering.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEtE,qBAAa,gBAAgB,CAC3B,MAAM,SAAS;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAA;CAAE,EAC5E,CAAC,EACD,SAAS,SAAS,OAAO,GAAG,KAAK,EACjC,YAAY,GAAG,EAAE,EACjB,SAAS,GAAG,CAAC;IAED,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC;IAExF,YAAY,CAAC,CAAC,SAAS,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,EAC1D,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,GAAG;;;;;;;;;;;;;;;;;;CA6Bb"}
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/filtering.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEtE,qBAAa,gBAAgB,CAC3B,MAAM,SAAS;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAA;CAAE,EAC5E,CAAC,EACD,SAAS,SAAS,OAAO,GAAG,KAAK,EACjC,YAAY,GAAG,EAAE,EACjB,SAAS,GAAG,CAAC;IAED,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC;IAExF,YAAY,CAAC,CAAC,SAAS,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,EAC1D,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,GAAG;;;;;;;;;;;;;;;;;;IA+BZ;;;OAGG;IACH,eAAe;;;;;;;;;;;;;;;;;;IAkBf;;;OAGG;IACH,iBAAiB;;;;;;;;;;;;;;;;;;IAkBjB;;;OAGG;IACH,aAAa;;;;;;;;;;;;;;;;;;CAiBd"}

package/dist/core/features/filtering.js

@@ -10,7 +10,8 @@ export class FilteringFeature {
             column: String(column),
             operator,
             value,
-            conjunction
+            conjunction,
+            type: 'condition'
         });
         if (operator === 'in' || operator === 'notIn') {
             parameters.push(...value);
@@ -27,4 +28,61 @@ export class FilteringFeature {
             parameters
         };
     }
+    /**
+     * Adds a group-start marker to start a parenthesized group of conditions with AND conjunction
+     * @returns The updated query config
+     */
+    startWhereGroup() {
+        const config = this.builder.getConfig();
+        const where = config.where || [];
+        where.push({
+            column: '', // Not used for group markers
+            operator: 'eq', // Not used for group markers
+            value: null, // Not used for group markers
+            conjunction: 'AND',
+            type: 'group-start'
+        });
+        return {
+            ...config,
+            where
+        };
+    }
+    /**
+     * Adds a group-start marker to start a parenthesized group of conditions with OR conjunction
+     * @returns The updated query config
+     */
+    startOrWhereGroup() {
+        const config = this.builder.getConfig();
+        const where = config.where || [];
+        where.push({
+            column: '', // Not used for group markers
+            operator: 'eq', // Not used for group markers
+            value: null, // Not used for group markers
+            conjunction: 'OR',
+            type: 'group-start'
+        });
+        return {
+            ...config,
+            where
+        };
+    }
+    /**
+     * Adds a group-end marker to end a parenthesized group of conditions
+     * @returns The updated query config
+     */
+    endWhereGroup() {
+        const config = this.builder.getConfig();
+        const where = config.where || [];
+        where.push({
+            column: '', // Not used for group markers
+            operator: 'eq', // Not used for group markers
+            value: null, // Not used for group markers
+            conjunction: 'AND', // Not relevant for end markers
+            type: 'group-end'
+        });
+        return {
+            ...config,
+            where
+        };
+    }
 }

package/dist/core/features/joins.d.ts

@@ -0,0 +1,29 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType, JoinType } from '../../types';
+export declare class JoinFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    addJoin<TableName extends keyof Schema>(type: JoinType, table: TableName, leftColumn: keyof OriginalT, rightColumn: `${TableName & string}.${keyof Schema[TableName] & string}`, alias?: string): {
+        joins: import("../../types").JoinClause[];
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof T | import("../../types").TableColumn<Schema>;
+            direction: import("../../types").OrderDirection;
+        }[] | undefined;
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=joins.d.ts.map

package/dist/core/features/pagination.d.ts

@@ -0,0 +1,23 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType, PaginationOptions, PaginatedResult } from '../../types';
+export declare class PaginationFeature<Schema extends {
+    [tableName: string]: {
+        [columnName: string]: ColumnType;
+    };
+}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+    private builder;
+    private static cursorStacks;
+    private stackKey;
+    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    private get cursorStack();
+    private set cursorStack(value);
+    private get currentPosition();
+    private set currentPosition(value);
+    private encodeCursor;
+    private decodeCursor;
+    paginate(options: PaginationOptions<T>): Promise<PaginatedResult<T>>;
+    private generateCursor;
+    firstPage(pageSize: number): Promise<PaginatedResult<T>>;
+    iteratePages(pageSize: number): AsyncGenerator<PaginatedResult<T>>;
+}
+//# sourceMappingURL=pagination.d.ts.map