@hypequery/clickhouse 0.0.0-canary-20260306132943

package/dist/core/cross-filter.js

@@ -0,0 +1,142 @@
+import { FilterValidator } from './validators/filter-validator.js';
+/**
+ * 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 class CrossFilter {
+    // Root group holding filter conditions or nested groups, defaulting to an implicit AND.
+    rootGroup;
+    schema;
+    targetTable;
+    constructor(schema, tableName) {
+        this.schema = schema;
+        this.targetTable = tableName;
+        this.rootGroup = { operator: 'AND', conditions: [] };
+    }
+    /**
+     * Adds a single filter condition to the root group with an implicit AND conjunction.
+     * Performs type-safe validation if a schema is provided.
+     */
+    add(condition) {
+        if (this.schema) {
+            const columnType = this.getColumnType(String(condition.column));
+            this.validateValueType(columnType, condition.value, String(condition.column), condition.operator);
+        }
+        // Convert Date objects to ISO strings for ClickHouse
+        let value = condition.value;
+        if (Array.isArray(value)) {
+            value = value.map(v => v instanceof Date ? v.toISOString() : v);
+        }
+        else if (value instanceof Date) {
+            value = value.toISOString();
+        }
+        this.rootGroup.conditions.push({
+            ...condition,
+            value
+        });
+        return this;
+    }
+    /**
+     * Adds multiple filter conditions to the root group.
+     */
+    addMultiple(conditions) {
+        if (this.schema) {
+            this.validateGroup(conditions);
+        }
+        this.rootGroup.conditions.push(...conditions);
+        return 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, operator) {
+        if (this.schema) {
+            this.validateGroup(groupConditions);
+        }
+        const group = {
+            operator,
+            conditions: groupConditions
+        };
+        this.rootGroup.conditions.push(group);
+        return this;
+    }
+    /**
+     * Returns the current filter tree representing all conditions and groups.
+     */
+    getConditions() {
+        return this.rootGroup;
+    }
+    /**
+     * 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.
+     */
+    getColumnType(column) {
+        if (!this.schema) {
+            return 'String';
+        }
+        const tables = this.targetTable ? [this.targetTable] : Object.keys(this.schema);
+        for (const table of tables) {
+            const tableSchema = this.schema[table];
+            if (column in tableSchema) {
+                const columnKey = column;
+                return tableSchema[columnKey];
+            }
+        }
+        throw new Error(`Column '${column}' not found in schema`);
+    }
+    /**
+     * Validates the value of a filter condition against its expected column type.
+     */
+    validateValueType(columnType, value, columnName, operator) {
+        FilterValidator.validateFilterCondition({ column: columnName, operator, value }, columnType, { allowNull: true } // CrossFilter allows null values
+        );
+    }
+    /**
+     * Recursively validates an array of filter conditions and nested groups.
+     */
+    validateGroup(conditions) {
+        for (const condition of conditions) {
+            if (this.isGroup(condition)) {
+                // Recursively validate nested groups
+                this.validateGroup(condition.conditions);
+            }
+            else {
+                const columnType = this.getColumnType(String(condition.column));
+                this.validateValueType(columnType, condition.value, String(condition.column), condition.operator);
+            }
+        }
+    }
+    /**
+     * Type guard to check if an item is a FilterGroup.
+     */
+    isGroup(item) {
+        return typeof item.conditions !== 'undefined';
+    }
+    /**
+     * 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(valueColumn, n, orderBy = 'desc') {
+        this.add({
+            column: valueColumn,
+            operator: 'gt',
+            value: 0
+        });
+        // Store limit and order information in the root group's metadata
+        this.rootGroup = {
+            ...this.rootGroup,
+            limit: n,
+            orderBy: {
+                column: valueColumn,
+                direction: orderBy.toUpperCase()
+            }
+        };
+        return this;
+    }
+}

package/dist/core/env/auto-client.browser.d.ts

@@ -0,0 +1,3 @@
+import type { AutoClientModule } from './auto-client.js';
+export declare function getAutoClientModule(): AutoClientModule;
+//# sourceMappingURL=auto-client.browser.d.ts.map

package/dist/core/env/auto-client.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-client.browser.d.ts","sourceRoot":"","sources":["../../../src/core/env/auto-client.browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD"}

package/dist/core/env/auto-client.browser.js

@@ -0,0 +1,3 @@
+export function getAutoClientModule() {
+    throw new Error('Auto-detecting a ClickHouse client is not supported in browser environments.');
+}

package/dist/core/env/auto-client.d.ts

@@ -0,0 +1,9 @@
+import type { ClickHouseSettings } from '@clickhouse/client-common';
+type NodeClientModule = typeof import('@clickhouse/client');
+export interface AutoClientModule {
+    createClient: NodeClientModule['createClient'];
+    ClickHouseSettings?: ClickHouseSettings;
+}
+export declare function getAutoClientModule(): AutoClientModule;
+export {};
+//# sourceMappingURL=auto-client.d.ts.map

package/dist/core/env/auto-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-client.d.ts","sourceRoot":"","sources":["../../../src/core/env/auto-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,KAAK,gBAAgB,GAAG,cAAc,oBAAoB,CAAC,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;IAC/C,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAID,wBAAgB,mBAAmB,IAAI,gBAAgB,CAqBtD"}

package/dist/core/env/auto-client.js

@@ -0,0 +1,21 @@
+import { createRequire } from 'module';
+let cachedModule;
+export function getAutoClientModule() {
+    if (!cachedModule) {
+        try {
+            const nodeRequire = createRequire(`${process.cwd()}/noop.js`);
+            const clientModule = nodeRequire('@clickhouse/client');
+            const settings = clientModule.ClickHouseSettings;
+            cachedModule = {
+                createClient: clientModule.createClient,
+                ClickHouseSettings: settings ?? {}
+            };
+        }
+        catch (error) {
+            throw new Error('@clickhouse/client is required for Node.js environments.\n\n' +
+                'Install with: npm install @clickhouse/client\n\n' +
+                'Alternatively, you can provide a client instance directly in the config.client option.', { cause: error instanceof Error ? error : undefined });
+        }
+    }
+    return cachedModule;
+}

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

@@ -0,0 +1,98 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+export declare class AggregationFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, State>);
+    private createAggregation;
+    sum(column: string, alias: string): {
+        select: string[];
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    count(column: string, alias: string): {
+        select: string[];
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    avg(column: string, alias: string): {
+        select: string[];
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    min(column: string, alias: string): {
+        select: string[];
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    max(column: string, alias: string): {
+        select: string[];
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=aggregations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregations.d.ts","sourceRoot":"","sources":["../../../src/core/features/aggregations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,qBAAa,kBAAkB,CAC7B,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,iBAAiB;IAsBzB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAIjC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAInC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAIjC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAIjC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;CAGlC"}

package/dist/core/features/aggregations.js

@@ -0,0 +1,36 @@
+export class AggregationFeature {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    createAggregation(column, fn, alias) {
+        const aggregationSQL = `${fn}(${column}) AS ${alias}`;
+        const config = this.builder.getConfig();
+        if (config.select) {
+            return {
+                ...config,
+                select: [...(config.select || []).map(String), aggregationSQL],
+                groupBy: (config.select || []).map(String).filter(col => !col.includes(' AS '))
+            };
+        }
+        return {
+            ...config,
+            select: [aggregationSQL]
+        };
+    }
+    sum(column, alias) {
+        return this.createAggregation(column, 'SUM', alias);
+    }
+    count(column, alias) {
+        return this.createAggregation(column, 'COUNT', alias);
+    }
+    avg(column, alias) {
+        return this.createAggregation(column, 'AVG', alias);
+    }
+    min(column, alias) {
+        return this.createAggregation(column, 'MIN', alias);
+    }
+    max(column, alias) {
+        return this.createAggregation(column, 'MAX', alias);
+    }
+}

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

@@ -0,0 +1,81 @@
+import { ClickHouseSettings } from '@clickhouse/client-common';
+import type { AnyBuilderState, BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+import type { PredicateExpression } from '../utils/predicate-builder.js';
+export declare class AnalyticsFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, State>);
+    addCTE(alias: string, subquery: QueryBuilder<any, AnyBuilderState> | string): {
+        ctes: string[];
+        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("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addScalar(alias: string, expression: PredicateExpression): {
+        ctes: string[];
+        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("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addTimeInterval(column: string, interval: string, method: 'toStartOfInterval' | 'toStartOfMinute' | 'toStartOfHour' | 'toStartOfDay' | 'toStartOfWeek' | 'toStartOfMonth' | 'toStartOfQuarter' | 'toStartOfYear'): {
+        groupBy: string[];
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addSettings(opts: ClickHouseSettings): {
+        settings: string;
+        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("../../index.js").TableColumn<Schema>;
+            direction: import("../../index.js").OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+    };
+}
+//# sourceMappingURL=analytics.d.ts.map

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

@@ -0,0 +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,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;;;;;;;;;;;;;;;;;;IAiBhK,WAAW,CAAC,IAAI,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;CAQrC"}

package/dist/core/features/analytics.js

@@ -0,0 +1,45 @@
+import { substituteParameters } from '../utils.js';
+export class AnalyticsFeature {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    addCTE(alias, subquery) {
+        const config = this.builder.getConfig();
+        const cte = typeof subquery === 'string' ? subquery : subquery.toSQL();
+        return {
+            ...config,
+            ctes: [...(config.ctes || []), `${alias} AS (${cte})`]
+        };
+    }
+    addScalar(alias, expression) {
+        const config = this.builder.getConfig();
+        const scalarExpression = substituteParameters(expression.sql, expression.parameters);
+        return {
+            ...config,
+            ctes: [...(config.ctes || []), `${scalarExpression} AS ${alias}`]
+        };
+    }
+    addTimeInterval(column, interval, method) {
+        const config = this.builder.getConfig();
+        const groupBy = config.groupBy || [];
+        if (method === 'toStartOfInterval') {
+            groupBy.push(`${method}(${column}, INTERVAL ${interval})`);
+        }
+        else {
+            groupBy.push(`${method}(${column})`);
+        }
+        return {
+            ...config,
+            groupBy
+        };
+    }
+    addSettings(opts) {
+        const config = this.builder.getConfig();
+        const settingsFragments = Object.entries(opts).map(([key, value]) => `${key}=${value}`);
+        return {
+            ...config,
+            settings: settingsFragments.join(', ')
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+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>;
+    private applyAndConditions;
+    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":"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"}

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

@@ -0,0 +1,90 @@
+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;
+}
+export class CrossFilteringFeature {
+    builder;
+    constructor(builder) {
+        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);
+            });
+        }
+        return this.builder.getConfig();
+    }
+    applyAndConditions(conditions) {
+        conditions.forEach(condition => {
+            if (isFilterCondition(condition)) {
+                this.builder.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);
+                    });
+                }
+            }
+        });
+    }
+    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];
+            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,21 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+import { type QueryLog } from '../utils/logger.js';
+interface ExecutorRunOptions {
+    queryId?: string;
+    logContext?: Partial<QueryLog>;
+}
+export declare class ExecutorFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, State>);
+    toSQLWithParams(): {
+        sql: string;
+        parameters: any[];
+    };
+    toSQL(): string;
+    execute(options?: ExecutorRunOptions): Promise<State['output'][]>;
+    stream(): Promise<ReadableStream<State['output'][]>>;
+    private toSQLWithoutParameters;
+}
+export {};
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +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;AAGnD,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;IAKT,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;IAuDjE,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAgD1D,OAAO,CAAC,sBAAsB;CA0C/B"}