@hypequery/clickhouse 0.2.1 → 0.2.2-beta.0

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/executor.js

@@ -1,6 +1,6 @@
-import { ClickHouseConnection } from '../connection';
-import { substituteParameters } from '../utils';
-import { logger } from '../utils/logger';
+import { ClickHouseConnection } from '../connection.js';
+import { substituteParameters } from '../utils.js';
+import { logger } from '../utils/logger.js';
 export class ExecutorFeature {
     constructor(builder) {
         this.builder = builder;

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 | 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,GAAG,CAAC,EAAE,EACf,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,GAAG;;;;;;;;;;;;;;;;;;IA4DZ;;;OAGG;IACH,eAAe;;;;;;;;;;;;;;;;;;IAkBf;;;OAGG;IACH,iBAAiB;;;;;;;;;;;;;;;;;;IAkBjB;;;OAGG;IACH,aAAa;;;;;;;;;;;;;;;;;;CAiBd"}

package/dist/core/features/filtering.js

@@ -6,15 +6,44 @@ export class FilteringFeature {
         const config = this.builder.getConfig();
         const where = config.where || [];
         const parameters = config.parameters || [];
+        // Handle tuple columns
+        const columnString = Array.isArray(column)
+            ? `(${column.map(String).join(', ')})`
+            : String(column);
         where.push({
-            column: String(column),
+            column: columnString,
             operator,
             value,
-            conjunction
+            conjunction,
+            type: 'condition'
         });
-        if (operator === 'in' || operator === 'notIn') {
+        // Handle different parameter types based on operator
+        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') {
+                throw new Error(`Expected a string (subquery) for ${operator} operator, but got ${typeof value}`);
+            }
+            // No parameters
+        }
+        else if (operator === 'inTable' || operator === 'globalInTable') {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected a string (table name) for ${operator} operator, but got ${typeof value}`);
+            }
+            // No parameters
+        }
         else if (operator === 'between') {
             parameters.push(value[0], value[1]);
         }
@@ -27,4 +56,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

package/dist/core/features/query-modifiers.d.ts

@@ -0,0 +1,119 @@
+import { QueryBuilder } from '../query-builder';
+import { ColumnType, OrderDirection, TableColumn } from '../../types';
+export declare class QueryModifiersFeature<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>);
+    addGroupBy(columns: (keyof T | TableColumn<Schema>) | Array<keyof T | TableColumn<Schema>>): {
+        groupBy: string[];
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addLimit(count: number): {
+        limit: number;
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addOffset(count: number): {
+        offset: number;
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addOrderBy<K extends keyof T | TableColumn<Schema>>(column: K, direction?: OrderDirection): {
+        orderBy: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[];
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addHaving(condition: string, parameters?: any[]): {
+        having: string[];
+        parameters: any[] | undefined;
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    setDistinct(): {
+        distinct: boolean;
+        select?: (string | keyof T)[] | undefined;
+        where?: import("../../types").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        orderBy?: {
+            column: TableColumn<Schema> | keyof T;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=query-modifiers.d.ts.map

package/dist/core/formatters/sql-formatter.d.ts

@@ -0,0 +1,9 @@
+import { QueryConfig } from '../../types';
+export declare class SQLFormatter {
+    formatSelect(config: QueryConfig<any, any>): string;
+    formatGroupBy(config: QueryConfig<any, any>): string;
+    formatWhere(config: QueryConfig<any, any>): string;
+    private getSqlOperator;
+    formatJoins(config: QueryConfig<any, any>): string;
+}
+//# sourceMappingURL=sql-formatter.d.ts.map

package/dist/core/formatters/sql-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-formatter.d.ts","sourceRoot":"","sources":["../../../src/core/formatters/sql-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE1D,qBAAa,YAAY;IACvB,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAMnD,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IASpD,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IA4BlD,OAAO,CAAC,cAAc;IActB,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;CAUnD"}
+{"version":3,"file":"sql-formatter.d.ts","sourceRoot":"","sources":["../../../src/core/formatters/sql-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE1D,qBAAa,YAAY;IACvB,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAMnD,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IASpD,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IA6FlD,OAAO,CAAC,cAAc;IActB,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;CAUnD"}

package/dist/core/formatters/sql-formatter.js

@@ -17,10 +17,26 @@ export class SQLFormatter {
     formatWhere(config) {
         if (!config.where?.length)
             return '';
-        return config.where
-            .map((condition, index) => {
+        let afterGroupStart = false; // Track whether we're immediately after a group-start
+        // First pass - generate the SQL fragments for each condition
+        const fragments = config.where.map((condition, index) => {
+            // Handle special group markers
+            if (condition.type === 'group-start') {
+                const prefix = index === 0 ? '' : ` ${condition.conjunction} `;
+                afterGroupStart = true; // Mark that the next condition follows a group-start
+                return `${prefix}(`.trim();
+            }
+            if (condition.type === 'group-end') {
+                afterGroupStart = false; // Reset the flag after group-end
+                return ')';
+            }
+            // Normal conditions
             const { column, operator, value, conjunction } = condition;
-            const prefix = index === 0 ? '' : ` ${conjunction} `;
+            // Don't add conjunction if it's the first condition or right after a group-start
+            const prefix = index === 0 || afterGroupStart ? '' : ` ${conjunction} `;
+            // Reset the afterGroupStart flag
+            afterGroupStart = false;
+            // Handle IN operators
             if (operator === 'in' || operator === 'notIn') {
                 if (!Array.isArray(value)) {
                     throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
@@ -31,6 +47,42 @@ export class SQLFormatter {
                 const placeholders = value.map(() => '?').join(', ');
                 return `${prefix}${column} ${operator === 'in' ? 'IN' : 'NOT IN'} (${placeholders})`.trim();
             }
+            // Handle GLOBAL IN operators
+            else if (operator === 'globalIn' || operator === 'globalNotIn') {
+                if (!Array.isArray(value)) {
+                    throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
+                }
+                if (value.length === 0) {
+                    return `${prefix}1 = 0`;
+                }
+                const placeholders = value.map(() => '?').join(', ');
+                return `${prefix}${column} ${operator === 'globalIn' ? 'GLOBAL IN' : 'GLOBAL NOT IN'} (${placeholders})`.trim();
+            }
+            // Handle subquery IN operators
+            else if (operator === 'inSubquery' || operator === 'globalInSubquery') {
+                if (typeof value !== 'string') {
+                    throw new Error(`Expected a string (subquery) for ${operator} operator, but got ${typeof value}`);
+                }
+                return `${prefix}${column} ${operator === 'inSubquery' ? 'IN' : 'GLOBAL IN'} (${value})`.trim();
+            }
+            // Handle table reference IN operators
+            else if (operator === 'inTable' || operator === 'globalInTable') {
+                if (typeof value !== 'string') {
+                    throw new Error(`Expected a string (table name) for ${operator} operator, but got ${typeof value}`);
+                }
+                return `${prefix}${column} ${operator === 'inTable' ? 'IN' : 'GLOBAL IN'} ${value}`.trim();
+            }
+            // Handle tuple IN operators
+            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}`);
+                }
+                if (value.length === 0) {
+                    return `${prefix}1 = 0`;
+                }
+                const placeholders = value.map(() => '(?, ?)').join(', ');
+                return `${prefix}${column} ${operator === 'inTuple' ? 'IN' : 'GLOBAL IN'} (${placeholders})`.trim();
+            }
             else if (operator === 'between') {
                 return `${prefix}${column} BETWEEN ? AND ?`.trim();
             }
@@ -40,8 +92,12 @@ export class SQLFormatter {
             else {
                 return `${prefix}${column} ${this.getSqlOperator(operator)} ?`.trim();
             }
-        })
-            .join(' ');
+        });
+        // Join fragments and then remove extra spaces around parentheses
+        let result = fragments.join(' ');
+        // Replace "( " with "(" and " )" with ")"
+        result = result.replace(/\(\s+/g, '(').replace(/\s+\)/g, ')');
+        return result;
     }
     getSqlOperator(operator) {
         switch (operator) {