@hypequery/clickhouse 0.0.0-canary-20260306132943

package/dist/core/features/executor.js

@@ -0,0 +1,146 @@
+import { ClickHouseConnection } from '../connection.js';
+import { substituteParameters } from '../utils.js';
+import { logger } from '../utils/logger.js';
+import { createJsonEachRowStream } from '../utils/streaming-helpers.js';
+export class ExecutorFeature {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    toSQLWithParams() {
+        const sql = this.toSQLWithoutParameters();
+        const config = this.builder.getConfig();
+        const parameters = config.parameters || [];
+        return { sql, parameters };
+    }
+    toSQL() {
+        const { sql, parameters } = this.toSQLWithParams();
+        return substituteParameters(sql, parameters);
+    }
+    async execute(options) {
+        const client = ClickHouseConnection.getClient();
+        const { sql, parameters } = this.toSQLWithParams();
+        const finalSQL = substituteParameters(sql, parameters);
+        const startTime = Date.now();
+        logger.logQuery({
+            query: finalSQL,
+            parameters,
+            startTime,
+            status: 'started',
+            queryId: options?.queryId,
+            ...options?.logContext
+        });
+        try {
+            const result = await client.query({
+                query: finalSQL,
+                format: 'JSONEachRow'
+            });
+            const rows = await result.json();
+            const endTime = Date.now();
+            logger.logQuery({
+                query: finalSQL,
+                parameters,
+                startTime,
+                endTime,
+                duration: endTime - startTime,
+                status: 'completed',
+                rowCount: rows.length,
+                queryId: options?.queryId,
+                cacheRowCount: rows.length,
+                ...options?.logContext
+            });
+            return rows;
+        }
+        catch (error) {
+            const endTime = Date.now();
+            logger.logQuery({
+                query: finalSQL,
+                parameters,
+                startTime,
+                endTime,
+                duration: endTime - startTime,
+                status: 'error',
+                error: error,
+                queryId: options?.queryId,
+                ...options?.logContext
+            });
+            throw error;
+        }
+    }
+    async stream() {
+        const client = ClickHouseConnection.getClient();
+        const { sql, parameters } = this.toSQLWithParams();
+        const finalSQL = substituteParameters(sql, parameters);
+        const startTime = Date.now();
+        logger.logQuery({
+            query: finalSQL,
+            parameters,
+            startTime,
+            status: 'started'
+        });
+        try {
+            const result = await client.query({
+                query: finalSQL,
+                format: 'JSONEachRow'
+            });
+            const stream = result.stream();
+            const webStream = createJsonEachRowStream(stream);
+            const endTime = Date.now();
+            logger.logQuery({
+                query: finalSQL,
+                parameters,
+                startTime,
+                endTime,
+                duration: endTime - startTime,
+                status: 'completed'
+            });
+            return webStream;
+        }
+        catch (error) {
+            const endTime = Date.now();
+            logger.logQuery({
+                query: finalSQL,
+                parameters,
+                startTime,
+                endTime,
+                duration: endTime - startTime,
+                status: 'error',
+                error: error
+            });
+            throw error;
+        }
+    }
+    toSQLWithoutParameters() {
+        const config = this.builder.getConfig();
+        const formatter = this.builder.getFormatter();
+        const parts = [];
+        if (config.ctes?.length) {
+            parts.push(`WITH ${config.ctes.join(', ')}`);
+        }
+        parts.push(`SELECT ${formatter.formatSelect(config)}`);
+        parts.push(`FROM ${this.builder.getTableName()}`);
+        if (config.joins?.length) {
+            parts.push(formatter.formatJoins(config));
+        }
+        if (config.where?.length) {
+            parts.push(`WHERE ${formatter.formatWhere(config)}`);
+        }
+        if (config.groupBy?.length) {
+            parts.push(`GROUP BY ${formatter.formatGroupBy(config)}`);
+        }
+        if (config.having?.length) {
+            parts.push(`HAVING ${config.having.join(' AND ')}`);
+        }
+        if (config.orderBy?.length) {
+            const orderBy = config.orderBy
+                .map(({ column, direction }) => `${String(column)} ${direction}`.trim())
+                .join(', ');
+            parts.push(`ORDER BY ${orderBy}`);
+        }
+        if (config.limit) {
+            const offsetClause = config.offset ? `OFFSET ${config.offset}` : '';
+            parts.push(`LIMIT ${config.limit} ${offsetClause}`);
+        }
+        return parts.join(' ').trim();
+    }
+}

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

@@ -0,0 +1,99 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+import { FilterOperator } 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?: string;
+    };
+    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?: string;
+    };
+    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?: string;
+    };
+    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?: string;
+    };
+    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?: string;
+    };
+}
+//# sourceMappingURL=filtering.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/features/filtering.js

@@ -0,0 +1,118 @@
+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 || [];
+        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') {
+                throw new Error(`Expected a string (subquery) for ${operator} operator, but got ${typeof value}`);
+            }
+        }
+        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}`);
+            }
+        }
+        else if (operator === 'between') {
+            parameters.push(value[0], value[1]);
+        }
+        else {
+            parameters.push(value);
+        }
+        return {
+            ...config,
+            where,
+            parameters
+        };
+    }
+    addExpressionCondition(conjunction, expression) {
+        const config = this.builder.getConfig();
+        const where = config.where || [];
+        const parameters = config.parameters || [];
+        where.push({
+            type: 'expression',
+            expression: expression.sql,
+            parameters: expression.parameters,
+            conjunction
+        });
+        parameters.push(...expression.parameters);
+        return {
+            ...config,
+            where,
+            parameters
+        };
+    }
+    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
+        };
+    }
+    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
+        };
+    }
+    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
+        };
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+import { JoinType } 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?: string;
+    };
+}
+//# sourceMappingURL=joins.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/features/joins.js

@@ -0,0 +1,17 @@
+export class JoinFeature {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    addJoin(type, table, leftColumn, rightColumn, alias) {
+        const config = this.builder.getConfig();
+        const newConfig = {
+            ...config,
+            joins: [
+                ...(config.joins || []),
+                { type, table: String(table), leftColumn: String(leftColumn), rightColumn, alias }
+            ]
+        };
+        return newConfig;
+    }
+}

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

@@ -0,0 +1,116 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
+import { QueryBuilder } from '../query-builder.js';
+import { OrderDirection } from '../../types/index.js';
+export declare class QueryModifiersFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
+    private builder;
+    constructor(builder: QueryBuilder<Schema, State>);
+    addGroupBy(columns: string | string[]): {
+        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("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addLimit(count: number): {
+        limit: number;
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addOffset(count: number): {
+        offset: number;
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addOrderBy(column: string, direction?: OrderDirection): {
+        orderBy: {
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[];
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    addHaving(condition: string, parameters?: any[]): {
+        having: string[];
+        parameters: any[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        limit?: number;
+        offset?: number;
+        distinct?: boolean;
+        orderBy?: {
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+    setDistinct(): {
+        distinct: boolean;
+        select?: (string | keyof State["output"])[] | undefined;
+        where?: import("../../types/base.js").WhereCondition[];
+        groupBy?: string[];
+        having?: string[];
+        limit?: number;
+        offset?: number;
+        orderBy?: {
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
+            direction: OrderDirection;
+        }[] | undefined;
+        joins?: import("../../types/base.js").JoinClause[];
+        parameters?: any[];
+        ctes?: string[];
+        unionQueries?: string[];
+        settings?: string;
+    };
+}
+//# sourceMappingURL=query-modifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-modifiers.d.ts","sourceRoot":"","sources":["../../../src/core/features/query-modifiers.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;AAEtD,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,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;;;;;;IAQrC,QAAQ,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQtB,SAAS,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQvB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,GAAE,cAAsB;;;;;;;;;;;;;;;;;;IAQ5D,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,GAAG,EAAE;;;;;;;;;;;;;;;;;;IAY/C,WAAW;;;;;;;;;;;;;;;;;;CAOZ"}

package/dist/core/features/query-modifiers.js

@@ -0,0 +1,51 @@
+export class QueryModifiersFeature {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    addGroupBy(columns) {
+        const config = this.builder.getConfig();
+        return {
+            ...config,
+            groupBy: Array.isArray(columns) ? columns.map(String) : [String(columns)]
+        };
+    }
+    addLimit(count) {
+        const config = this.builder.getConfig();
+        return {
+            ...config,
+            limit: count
+        };
+    }
+    addOffset(count) {
+        const config = this.builder.getConfig();
+        return {
+            ...config,
+            offset: count
+        };
+    }
+    addOrderBy(column, direction = 'ASC') {
+        const config = this.builder.getConfig();
+        return {
+            ...config,
+            orderBy: [...(config.orderBy || []), { column, direction }]
+        };
+    }
+    addHaving(condition, parameters) {
+        const config = this.builder.getConfig();
+        const having = [...(config.having || []), condition];
+        const newParams = parameters ? [...(config.parameters || []), ...parameters] : config.parameters;
+        return {
+            ...config,
+            having,
+            parameters: newParams
+        };
+    }
+    setDistinct() {
+        const config = this.builder.getConfig();
+        return {
+            ...config,
+            distinct: true
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+import { QueryConfig } from '../../types/index.js';
+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

@@ -0,0 +1 @@
+{"version":3,"file":"sql-formatter.d.ts","sourceRoot":"","sources":["../../../src/core/formatters/sql-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,sBAAsB,CAAC;AAEnE,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;IAoGlD,OAAO,CAAC,cAAc;IActB,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;CAUnD"}