@hypequery/clickhouse 1.6.2 → 2.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../../../src/core/features/analytics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACjG,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAGzE,qBAAa,gBAAgB,CAC3B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,GAAG,EAAE,eAAe,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;IAS3E,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;IASxD,eAAe,CACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,eAAe,EAC9J,OAAO,EAAE,UAAU;;;;;;;;;;;;;;;;;;IAarB,WAAW,CAAC,IAAI,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUrC"}
+{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../../../src/core/features/analytics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACjG,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,qBAAa,gBAAgB,CAC3B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,GAAG,EAAE,eAAe,CAAC,GAAG,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAStH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,mBAAmB,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IASnG,eAAe,CACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,eAAe,EAC9J,OAAO,EAAE,UAAU,GAClB,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAa3C,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAUhF"}

package/dist/core/features/analytics.js

@@ -5,36 +5,38 @@ export class AnalyticsFeature {
         this.builder = builder;
     }
     addCTE(alias, subquery) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         const cte = typeof subquery === 'string' ? subquery : subquery.toSQL();
         return {
-            ...config,
-            ctes: [...(config.ctes || []), `${alias} AS (${cte})`]
+            ...query,
+            ctes: [...(query.ctes || []), { kind: 'cte', expression: `${alias} AS (${cte})` }]
         };
     }
     addScalar(alias, expression) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         const scalarExpression = substituteParameters(expression.sql, expression.parameters);
         return {
-            ...config,
-            ctes: [...(config.ctes || []), `${scalarExpression} AS ${alias}`]
+            ...query,
+            ctes: [...(query.ctes || []), { kind: 'cte', expression: `${scalarExpression} AS ${alias}` }]
         };
     }
     addTimeInterval(column, interval, method, dialect) {
-        const config = this.builder.getConfig();
-        const groupBy = config.groupBy || [];
-        groupBy.push(dialect.formatTimeInterval(column, interval, method));
+        const query = this.builder.getQueryNode();
+        const groupBy = [
+            ...(query.groupBy || []),
+            { kind: 'group-by-item', expression: dialect.formatTimeInterval(column, interval, method) }
+        ];
         return {
-            ...config,
+            ...query,
             groupBy
         };
     }
     addSettings(opts) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         return {
-            ...config,
+            ...query,
             settings: {
-                ...(config.settings || {}),
+                ...(query.settings || {}),
                 ...opts,
             }
         };

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

@@ -4,7 +4,7 @@ import { CrossFilter } from '../cross-filter.js';
 export declare class CrossFilteringFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
     private builder;
     constructor(builder: QueryBuilder<Schema, State>);
-    applyCrossFilters(crossFilter: CrossFilter<Schema, Extract<keyof Schema, string>>): import("../../types/base.js").QueryConfig<State["output"], Schema>;
+    applyCrossFilters(crossFilter: CrossFilter<Schema, Extract<keyof Schema, string>>): QueryBuilder<Schema, State>;
     private applyAndConditions;
     private applyOrConditions;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"cross-filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/cross-filtering.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAe,MAAM,oBAAoB,CAAC;AAW9D,qBAAa,qBAAqB,CAChC,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,iBAAiB,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,CAAC;IAkBjF,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,iBAAiB;CAkD1B"}
+{"version":3,"file":"cross-filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/cross-filtering.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAoB,MAAM,oBAAoB,CAAC;AAanE,qBAAa,qBAAqB,CAChC,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,iBAAiB,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,CAAC;IAYjF,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,iBAAiB;CAsB1B"}

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

@@ -1,8 +1,5 @@
-function isFilterCondition(obj) {
-    return obj && 'column' in obj && 'operator' in obj && 'value' in obj;
-}
-function isFilterGroup(obj) {
-    return obj && 'conditions' in obj && 'operator' in obj;
+function isFilterCondition(node) {
+    return 'column' in node;
 }
 export class CrossFilteringFeature {
     builder;
@@ -10,81 +7,39 @@ export class CrossFilteringFeature {
         this.builder = builder;
     }
     applyCrossFilters(crossFilter) {
-        const filterGroup = crossFilter.getConditions();
-        if (filterGroup.conditions.length === 0) {
-            return this.builder.getConfig();
-        }
-        if (filterGroup.operator === 'AND') {
-            this.applyAndConditions(filterGroup.conditions);
-        }
-        else {
-            this.builder.whereGroup(builder => {
-                this.applyOrConditions(filterGroup.conditions, builder);
-            });
+        const root = crossFilter.getConditions();
+        if (root.conditions.length === 0) {
+            return this.builder;
         }
-        return this.builder.getConfig();
+        return root.operator === 'AND'
+            ? this.applyAndConditions(this.builder, root.conditions)
+            : this.builder.whereGroup(groupBuilder => this.applyOrConditions(groupBuilder, root.conditions));
     }
-    applyAndConditions(conditions) {
-        conditions.forEach(condition => {
+    applyAndConditions(builder, conditions) {
+        return conditions.reduce((currentBuilder, condition) => {
             if (isFilterCondition(condition)) {
-                this.builder.where(condition.column, condition.operator, condition.value);
+                return currentBuilder.where(condition.column, condition.operator, condition.value);
             }
-            else if (isFilterGroup(condition)) {
-                if (condition.operator === 'AND') {
-                    this.builder.whereGroup(builder => {
-                        const feature = new CrossFilteringFeature(builder);
-                        feature.applyAndConditions(condition.conditions);
-                    });
-                }
-                else {
-                    this.builder.whereGroup(builder => {
-                        const feature = new CrossFilteringFeature(builder);
-                        feature.applyOrConditions(condition.conditions, builder);
-                    });
-                }
-            }
-        });
+            return condition.operator === 'AND'
+                ? currentBuilder.whereGroup(groupBuilder => this.applyAndConditions(groupBuilder, condition.conditions))
+                : currentBuilder.whereGroup(groupBuilder => this.applyOrConditions(groupBuilder, condition.conditions));
+        }, builder);
     }
-    applyOrConditions(conditions, builder = this.builder) {
-        if (conditions.length === 0)
-            return;
-        const firstCondition = conditions[0];
-        if (isFilterCondition(firstCondition)) {
-            builder.where(firstCondition.column, firstCondition.operator, firstCondition.value);
-        }
-        else if (isFilterGroup(firstCondition)) {
-            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);
-                });
-            }
-        }
-        for (let i = 1; i < conditions.length; i++) {
-            const condition = conditions[i];
+    applyOrConditions(builder, conditions) {
+        return conditions.reduce((currentBuilder, condition, index) => {
             if (isFilterCondition(condition)) {
-                builder.orWhere(condition.column, condition.operator, condition.value);
+                return index === 0
+                    ? currentBuilder.where(condition.column, condition.operator, condition.value)
+                    : currentBuilder.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);
-                    });
-                }
+            if (condition.operator === 'AND') {
+                return index === 0
+                    ? currentBuilder.whereGroup(groupBuilder => this.applyAndConditions(groupBuilder, condition.conditions))
+                    : currentBuilder.orWhereGroup(groupBuilder => this.applyAndConditions(groupBuilder, condition.conditions));
             }
-        }
+            return index === 0
+                ? currentBuilder.whereGroup(groupBuilder => this.applyOrConditions(groupBuilder, condition.conditions))
+                : currentBuilder.orWhereGroup(groupBuilder => this.applyOrConditions(groupBuilder, condition.conditions));
+        }, builder);
     }
 }

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

@@ -15,7 +15,7 @@ export declare class ExecutorFeature<Schema extends SchemaDefinition<Schema>, St
     toSQL(): string;
     execute(options?: ExecutorRunOptions): Promise<State['output'][]>;
     stream(): Promise<ReadableStream<State['output'][]>>;
-    private toSQLWithoutParameters;
+    private compileQuery;
 }
 export {};
 //# sourceMappingURL=executor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/core/features/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG3D,UAAU,kBAAkB;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChC;AAED,qBAAa,eAAe,CAC1B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,eAAe,IAAI;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAA;KAAE;IAOrD,KAAK,IAAI,MAAM;IAMT,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;IAsDjE,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAgD1D,OAAO,CAAC,sBAAsB;CAM/B"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/core/features/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG3D,UAAU,kBAAkB;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChC;AAED,qBAAa,eAAe,CAC1B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,eAAe,IAAI;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAA;KAAE;IAKrD,KAAK,IAAI,MAAM;IAMT,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;IAsDjE,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAgD1D,OAAO,CAAC,YAAY;CAMrB"}

package/dist/core/features/executor.js

@@ -6,10 +6,8 @@ export class ExecutorFeature {
         this.builder = builder;
     }
     toSQLWithParams() {
-        const sql = this.toSQLWithoutParameters();
-        const config = this.builder.getConfig();
-        const parameters = config.parameters || [];
-        return { sql, parameters };
+        const compiled = this.compileQuery();
+        return { sql: compiled.query, parameters: [...compiled.parameters] };
     }
     toSQL() {
         const { sql, parameters } = this.toSQLWithParams();
@@ -18,8 +16,8 @@ export class ExecutorFeature {
     }
     async execute(options) {
         const adapter = this.builder.getAdapter();
+        const queryNode = this.builder.toQueryNode();
         const { sql, parameters } = this.toSQLWithParams();
-        const config = this.builder.getConfig();
         const renderSql = adapter.render ? adapter.render(sql, parameters) : substituteParameters(sql, parameters);
         const startTime = Date.now();
         logger.logQuery({
@@ -32,7 +30,7 @@ export class ExecutorFeature {
         });
         try {
             const rows = await adapter.query(sql, parameters, {
-                clickhouseSettings: config.settings,
+                clickhouseSettings: queryNode.settings,
                 queryId: options?.queryId,
             });
             const endTime = Date.now();
@@ -68,8 +66,8 @@ export class ExecutorFeature {
     }
     async stream() {
         const adapter = this.builder.getAdapter();
+        const queryNode = this.builder.toQueryNode();
         const { sql, parameters } = this.toSQLWithParams();
-        const config = this.builder.getConfig();
         const renderSql = adapter.render ? adapter.render(sql, parameters) : substituteParameters(sql, parameters);
         const startTime = Date.now();
         logger.logQuery({
@@ -83,7 +81,7 @@ export class ExecutorFeature {
                 throw new Error(`Streaming is not supported by adapter "${adapter.name}".`);
             }
             const webStream = await adapter.stream(sql, parameters, {
-                clickhouseSettings: config.settings,
+                clickhouseSettings: queryNode.settings,
             });
             const endTime = Date.now();
             logger.logQuery({
@@ -110,9 +108,9 @@ export class ExecutorFeature {
             throw error;
         }
     }
-    toSQLWithoutParameters() {
-        const config = this.builder.getConfig();
-        return this.builder.getDialect().compileQuery(config, {
+    compileQuery() {
+        const queryNode = this.builder.toQueryNode();
+        return this.builder.getDialect().compileQuery(queryNode, {
             tableName: this.builder.getTableName(),
         });
     }

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

@@ -1,99 +1,13 @@
 import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { FilterOperator } from '../../types/index.js';
+import { FilterOperator, type ExprNode, type SelectQueryNode } from '../../types/index.js';
 import { PredicateExpression } from '../utils/predicate-builder.js';
 export declare class FilteringFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
     private builder;
     constructor(builder: QueryBuilder<Schema, State>);
-    addCondition(conjunction: 'AND' | 'OR', column: string | string[], operator: FilterOperator, value: any): {
-        where: import("../../types/base.js").WhereCondition[];
-        parameters: any[];
-        select?: (string | keyof State["output"])[] | undefined;
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    addExpressionCondition(conjunction: 'AND' | 'OR', expression: PredicateExpression): {
-        where: import("../../types/base.js").WhereCondition[];
-        parameters: any[];
-        select?: (string | keyof State["output"])[] | undefined;
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    startWhereGroup(): {
-        where: import("../../types/base.js").WhereCondition[];
-        select?: (string | keyof State["output"])[] | undefined;
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    startOrWhereGroup(): {
-        where: import("../../types/base.js").WhereCondition[];
-        select?: (string | keyof State["output"])[] | undefined;
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    endWhereGroup(): {
-        where: import("../../types/base.js").WhereCondition[];
-        select?: (string | keyof State["output"])[] | undefined;
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
+    private wrapValue;
+    addCondition(clause: 'where' | 'prewhere', conjunction: 'AND' | 'OR', column: string | string[], operator: FilterOperator, value: any): SelectQueryNode<State['output'], Schema>;
+    addExpressionCondition(clause: 'where' | 'prewhere', conjunction: 'AND' | 'OR', expression: PredicateExpression): SelectQueryNode<State['output'], Schema>;
+    addGroup(clause: 'where' | 'prewhere', conjunction: 'AND' | 'OR', expression: ExprNode | undefined): SelectQueryNode<State['output'], Schema>;
 }
 //# 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,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEpE,qBAAa,gBAAgB,CAC3B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,YAAY,CACV,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EACzB,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,GAAG;;;;;;;;;;;;;;;;;;IAwDZ,sBAAsB,CACpB,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,UAAU,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;IAsBjC,eAAe;;;;;;;;;;;;;;;;;;IAkBf,iBAAiB;;;;;;;;;;;;;;;;;;IAkBjB,aAAa;;;;;;;;;;;;;;;;;;CAiBd"}
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../src/core/features/filtering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAkB,MAAM,sBAAsB,CAAC;AAC3G,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA2BpE,qBAAa,gBAAgB,CAC3B,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,OAAO,CAAC,SAAS;IAuBjB,YAAY,CACV,MAAM,EAAE,OAAO,GAAG,UAAU,EAC5B,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EACzB,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,GAAG,GACT,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAyC3C,sBAAsB,CACpB,MAAM,EAAE,OAAO,GAAG,UAAU,EAC5B,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,UAAU,EAAE,mBAAmB,GAC9B,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAe3C,QAAQ,CACN,MAAM,EAAE,OAAO,GAAG,UAAU,EAC5B,WAAW,EAAE,KAAK,GAAG,IAAI,EACzB,UAAU,EAAE,QAAQ,GAAG,SAAS,GAC/B,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAgB5C"}

package/dist/core/features/filtering.js

@@ -1,35 +1,58 @@
+function appendExpression(existing, next, conjunction) {
+    if (!existing) {
+        return next;
+    }
+    if (existing.kind === 'sequence') {
+        return {
+            ...existing,
+            items: [...existing.items, { conjunction, expression: next }],
+        };
+    }
+    return {
+        kind: 'sequence',
+        items: [
+            { expression: existing },
+            { conjunction, expression: next },
+        ],
+    };
+}
 export class FilteringFeature {
     builder;
     constructor(builder) {
         this.builder = builder;
     }
-    addCondition(conjunction, column, operator, value) {
-        const config = this.builder.getConfig();
-        const where = config.where || [];
-        const parameters = config.parameters || [];
+    wrapValue(operator, value) {
+        if (operator === 'inSubquery' || operator === 'globalInSubquery' || operator === 'inTable' || operator === 'globalInTable') {
+            return value;
+        }
+        if (operator === 'between') {
+            return [
+                { kind: 'value', value: value[0] },
+                { kind: 'value', value: value[1] },
+            ];
+        }
+        if (operator === 'inTuple' || operator === 'globalInTuple') {
+            return value.map((tuple) => tuple.map(tupleValue => ({ kind: 'value', value: tupleValue })));
+        }
+        if (operator === 'in' || operator === 'notIn' || operator === 'globalIn' || operator === 'globalNotIn') {
+            return value.map((item) => ({ kind: 'value', value: item }));
+        }
+        return { kind: 'value', value };
+    }
+    addCondition(clause, conjunction, column, operator, value) {
+        const query = this.builder.getQueryNode();
         const columnString = Array.isArray(column)
             ? `(${column.map(String).join(', ')})`
             : String(column);
-        where.push({
-            column: columnString,
-            operator,
-            value,
-            conjunction,
-            type: 'condition'
-        });
         if (operator === 'in' || operator === 'notIn' || operator === 'globalIn' || operator === 'globalNotIn') {
             if (!Array.isArray(value)) {
                 throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
             }
-            parameters.push(...value);
         }
         else if (operator === 'inTuple' || operator === 'globalInTuple') {
             if (!Array.isArray(value)) {
                 throw new Error(`Expected an array of tuples for ${operator} operator, but got ${typeof value}`);
             }
-            value.forEach((tuple) => {
-                parameters.push(...tuple);
-            });
         }
         else if (operator === 'inSubquery' || operator === 'globalInSubquery') {
             if (typeof value !== 'string') {
@@ -41,78 +64,41 @@ export class FilteringFeature {
                 throw new Error(`Expected a string (table name) for ${operator} operator, but got ${typeof value}`);
             }
         }
-        else if (operator === 'between') {
-            parameters.push(value[0], value[1]);
-        }
-        else {
-            parameters.push(value);
-        }
+        const nextExpr = {
+            kind: 'condition',
+            column: columnString,
+            operator,
+            value: this.wrapValue(operator, value),
+        };
         return {
-            ...config,
-            where,
-            parameters
+            ...query,
+            [clause]: appendExpression(query[clause], nextExpr, conjunction)
         };
     }
-    addExpressionCondition(conjunction, expression) {
-        const config = this.builder.getConfig();
-        const where = config.where || [];
-        const parameters = config.parameters || [];
-        where.push({
-            type: 'expression',
+    addExpressionCondition(clause, conjunction, expression) {
+        const query = this.builder.getQueryNode();
+        const nextExpr = {
+            kind: 'raw',
             expression: expression.sql,
-            parameters: expression.parameters,
-            conjunction
-        });
-        parameters.push(...expression.parameters);
-        return {
-            ...config,
-            where,
-            parameters
+            parameters: expression.parameters.map(value => ({ kind: 'value', value })),
         };
-    }
-    startWhereGroup() {
-        const config = this.builder.getConfig();
-        const where = config.where || [];
-        where.push({
-            column: '',
-            operator: 'eq',
-            value: null,
-            conjunction: 'AND',
-            type: 'group-start'
-        });
         return {
-            ...config,
-            where
+            ...query,
+            [clause]: appendExpression(query[clause], nextExpr, conjunction)
         };
     }
-    startOrWhereGroup() {
-        const config = this.builder.getConfig();
-        const where = config.where || [];
-        where.push({
-            column: '',
-            operator: 'eq',
-            value: null,
-            conjunction: 'OR',
-            type: 'group-start'
-        });
-        return {
-            ...config,
-            where
+    addGroup(clause, conjunction, expression) {
+        const query = this.builder.getQueryNode();
+        if (!expression) {
+            return query;
+        }
+        const grouped = {
+            kind: 'group',
+            expression,
         };
-    }
-    endWhereGroup() {
-        const config = this.builder.getConfig();
-        const where = config.where || [];
-        where.push({
-            column: '',
-            operator: 'eq',
-            value: null,
-            conjunction: 'AND',
-            type: 'group-end'
-        });
         return {
-            ...config,
-            where
+            ...query,
+            [clause]: appendExpression(query[clause], grouped, conjunction)
         };
     }
 }

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

@@ -1,26 +1,9 @@
 import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { JoinType } from '../../types/index.js';
+import { JoinType, type SelectQueryNode } from '../../types/index.js';
 export declare class JoinFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
     private builder;
     constructor(builder: QueryBuilder<Schema, State>);
-    addJoin<TableName extends keyof Schema>(type: JoinType, table: TableName, leftColumn: string, rightColumn: `${TableName & string}.${keyof Schema[TableName] & string}`, alias?: string): {
-        joins: import("../../types/base.js").JoinClause[];
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: import("../../types/base.js").OrderDirection;
-        }[] | undefined;
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
+    addJoin<TableName extends keyof Schema>(type: JoinType, table: TableName, leftColumn: string, rightColumn: `${TableName & string}.${keyof Schema[TableName] & string}`, alias?: string, leftSource?: string): SelectQueryNode<State['output'], Schema>;
 }
 //# sourceMappingURL=joins.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"joins.d.ts","sourceRoot":"","sources":["../../../src/core/features/joins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,qBAAa,WAAW,CACtB,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,OAAO,CAAC,SAAS,SAAS,MAAM,MAAM,EACpC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,GAAG,SAAS,GAAG,MAAM,IAAI,MAAM,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,EAAE,EACxE,KAAK,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;CAYjB"}
+{"version":3,"file":"joins.d.ts","sourceRoot":"","sources":["../../../src/core/features/joins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE,qBAAa,WAAW,CACtB,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,OAAO,CAAC,SAAS,SAAS,MAAM,MAAM,EACpC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,GAAG,SAAS,GAAG,MAAM,IAAI,MAAM,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,EAAE,EACxE,KAAK,CAAC,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAsB5C"}

package/dist/core/features/joins.js

@@ -3,13 +3,24 @@ export class JoinFeature {
     constructor(builder) {
         this.builder = builder;
     }
-    addJoin(type, table, leftColumn, rightColumn, alias) {
-        const config = this.builder.getConfig();
+    addJoin(type, table, leftColumn, rightColumn, alias, leftSource) {
+        const query = this.builder.getQueryNode();
+        const renderedRightColumn = alias
+            ? rightColumn.replace(`${String(table)}.`, `${alias}.`)
+            : rightColumn;
         const newConfig = {
-            ...config,
+            ...query,
             joins: [
-                ...(config.joins || []),
-                { type, table: String(table), leftColumn: String(leftColumn), rightColumn, alias }
+                ...(query.joins || []),
+                {
+                    kind: 'join',
+                    type,
+                    table: String(table),
+                    leftColumn: String(leftColumn),
+                    leftSource,
+                    rightColumn: renderedRightColumn,
+                    alias,
+                }
             ]
         };
         return newConfig;