@hypequery/clickhouse 1.3.1-beta.0 → 1.3.2

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

@@ -1,19 +1,15 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { ColumnType } from '../../types/index.js';
-export declare class ExecutorFeature<Schema extends {
-    [tableName: string]: {
-        [columnName: string]: ColumnType;
-    };
-}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+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, T, HasSelect, Aggregations, OriginalT>);
+    constructor(builder: QueryBuilder<Schema, State>);
     toSQLWithParams(): {
         sql: string;
         parameters: any[];
     };
     toSQL(): string;
-    execute(): Promise<T[]>;
-    stream(): Promise<ReadableStream<T[]>>;
+    execute(): Promise<State['output'][]>;
+    stream(): Promise<ReadableStream<State['output'][]>>;
     private toSQLWithoutParameters;
 }
 //# 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,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKlD,qBAAa,eAAe,CAC1B,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,eAAe,IAAI;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAA;KAAE;IAOrD,KAAK,IAAI,MAAM;IAKT,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAgDvB,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;IA+C5C,OAAO,CAAC,sBAAsB;CA0C/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;AAKnD,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,IAAI,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;IAgDrC,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IA+C1D,OAAO,CAAC,sBAAsB;CA0C/B"}

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

@@ -1,23 +1,39 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { ColumnType, FilterOperator, TableColumn } from '../../types/index.js';
-export declare class FilteringFeature<Schema extends {
-    [tableName: string]: {
-        [columnName: string]: ColumnType;
-    };
-}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+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, T, HasSelect, Aggregations, OriginalT>);
-    addCondition<K extends keyof OriginalT | TableColumn<Schema>>(conjunction: 'AND' | 'OR', column: K | K[], operator: FilterOperator, value: any): {
+    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 T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         groupBy?: string[];
         having?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: import("../../types/base.js").OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -25,20 +41,16 @@ export declare class FilteringFeature<Schema extends {
         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/base.js").WhereCondition[];
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         groupBy?: string[];
         having?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: import("../../types/base.js").OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -47,20 +59,16 @@ export declare class FilteringFeature<Schema extends {
         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/base.js").WhereCondition[];
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         groupBy?: string[];
         having?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: import("../../types/base.js").OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -69,20 +77,16 @@ export declare class FilteringFeature<Schema extends {
         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/base.js").WhereCondition[];
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         groupBy?: string[];
         having?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: import("../../types/base.js").OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];

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,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAE/E,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"}
+{"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

@@ -7,7 +7,6 @@ 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);
@@ -18,7 +17,6 @@ export class FilteringFeature {
             conjunction,
             type: 'condition'
         });
-        // 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}`);
@@ -37,13 +35,11 @@ export class FilteringFeature {
             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]);
@@ -57,17 +53,30 @@ export class FilteringFeature {
             parameters
         };
     }
-    /**
-     * Adds a group-start marker to start a parenthesized group of conditions with AND conjunction
-     * @returns The updated query config
-     */
+    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: '', // Not used for group markers
-            operator: 'eq', // Not used for group markers
-            value: null, // Not used for group markers
+            column: '',
+            operator: 'eq',
+            value: null,
             conjunction: 'AND',
             type: 'group-start'
         });
@@ -76,17 +85,13 @@ export class FilteringFeature {
             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
+            column: '',
+            operator: 'eq',
+            value: null,
             conjunction: 'OR',
             type: 'group-start'
         });
@@ -95,18 +100,14 @@ export class FilteringFeature {
             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
+            column: '',
+            operator: 'eq',
+            value: null,
+            conjunction: 'AND',
             type: 'group-end'
         });
         return {

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

@@ -1,15 +1,12 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { ColumnType, JoinType } from '../../types/index.js';
-export declare class JoinFeature<Schema extends {
-    [tableName: string]: {
-        [columnName: string]: ColumnType;
-    };
-}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+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, 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): {
+    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 T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         having?: string[];
@@ -17,7 +14,7 @@ export declare class JoinFeature<Schema extends {
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: keyof T | import("../../types/base.js").TableColumn<Schema>;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: import("../../types/base.js").OrderDirection;
         }[] | undefined;
         parameters?: any[];

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,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE5D,qBAAa,WAAW,CACtB,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,OAAO,CAAC,SAAS,SAAS,MAAM,MAAM,EACpC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,SAAS,EAC3B,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,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/pagination.d.ts

@@ -1,23 +1,21 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { ColumnType, PaginationOptions, PaginatedResult } from '../../types/index.js';
-export declare class PaginationFeature<Schema extends {
-    [tableName: string]: {
-        [columnName: string]: ColumnType;
-    };
-}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+import { PaginatedResult, PaginationOptions } from '../../types/index.js';
+export declare class PaginationFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
     private builder;
     private static cursorStacks;
     private stackKey;
-    constructor(builder: QueryBuilder<Schema, T, HasSelect, Aggregations, OriginalT>);
+    constructor(builder: QueryBuilder<Schema, State>);
     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>>;
+    paginate(options: PaginationOptions<State['output']>): Promise<PaginatedResult<State['output']>>;
     private generateCursor;
-    firstPage(pageSize: number): Promise<PaginatedResult<T>>;
-    iteratePages(pageSize: number): AsyncGenerator<PaginatedResult<T>>;
+    firstPage(pageSize: number): Promise<PaginatedResult<State['output']>>;
+    iteratePages(pageSize: number): AsyncGenerator<PaginatedResult<State['output']>>;
+    private paginationGenerator;
 }
 //# sourceMappingURL=pagination.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/core/features/pagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,eAAe,EAAyB,MAAM,sBAAsB,CAAC;AAE7G,qBAAa,iBAAiB,CAC5B,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;IAKD,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,MAAM,CAAC,YAAY,CAAiE;IAC5F,OAAO,CAAC,QAAQ,CAAS;gBAEL,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC;IAQxF,OAAO,KAAK,WAAW,GAEtB;IAED,OAAO,KAAK,WAAW,QAGtB;IAED,OAAO,KAAK,eAAe,GAE1B;IAED,OAAO,KAAK,eAAe,QAG1B;IAED,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAId,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IA0I1E,OAAO,CAAC,cAAc;IAmBhB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAIvD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAkB1E"}
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/core/features/pagination.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,eAAe,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE1E,qBAAa,iBAAiB,CAC5B,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;IAKxF,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,MAAM,CAAC,YAAY,CAAiE;IAC5F,OAAO,CAAC,QAAQ,CAAS;gBAEL,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAOxD,OAAO,KAAK,WAAW,GAEtB;IAED,OAAO,KAAK,WAAW,QAGtB;IAED,OAAO,KAAK,eAAe,GAE1B;IAED,OAAO,KAAK,eAAe,QAG1B;IAED,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAId,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IA+GtG,OAAO,CAAC,cAAc;IAkBhB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IAI5E,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAAC,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;YAIjE,mBAAmB;CAWnC"}

package/dist/core/features/pagination.js

@@ -4,7 +4,6 @@ export class PaginationFeature {
     stackKey;
     constructor(builder) {
         this.builder = builder;
-        // Create a unique key for this pagination instance based on the table and sort
         this.stackKey = builder.getTableName();
         if (!PaginationFeature.cursorStacks.has(this.stackKey)) {
             PaginationFeature.cursorStacks.set(this.stackKey, { stack: [], position: -1 });
@@ -33,44 +32,34 @@ export class PaginationFeature {
     async paginate(options) {
         const { pageSize, after, before, orderBy = [] } = options;
         const requestSize = pageSize + 1;
-        // Update cursor stack
         if (after) {
-            // Moving forward: add new cursor and update position
             if (this.currentPosition < this.cursorStack.length - 1) {
-                // If we're not at the end, truncate the stack
                 this.cursorStack = this.cursorStack.slice(0, this.currentPosition + 1);
             }
             this.cursorStack = [...this.cursorStack, after];
             this.currentPosition = this.cursorStack.length - 1;
         }
         else if (before) {
-            // Moving backward: find the cursor in the stack
             const cursorIndex = this.cursorStack.indexOf(before);
             if (cursorIndex === -1) {
-                // If cursor not found in stack, add it
                 if (this.currentPosition === this.cursorStack.length - 1) {
                     this.cursorStack = [...this.cursorStack, before];
                 }
-                // Move back one position
                 this.currentPosition = Math.max(-1, this.currentPosition - 1);
             }
             else {
-                // Move to the previous cursor position
                 this.currentPosition = Math.max(-1, cursorIndex - 1);
             }
         }
         else {
-            // Reset for first page only if we don't have a cursor
             if (!this.cursorStack.length) {
                 this.cursorStack = [];
                 this.currentPosition = -1;
             }
         }
-        // Apply ordering first
         orderBy.forEach(({ column, direction }) => {
             this.builder.orderBy(column, direction);
         });
-        // Handle cursor-based pagination
         const cursor = after || before;
         if (cursor && orderBy && orderBy.length > 0) {
             const [{ column, direction }] = orderBy;
@@ -78,46 +67,33 @@ export class PaginationFeature {
             const cursorValues = this.decodeCursor(cursor);
             const value = cursorValues[columnName];
             if (before) {
-                // For backward pagination:
-                // If sorting DESC, we want records > cursor
-                // If sorting ASC, we want records < cursor
                 const operator = direction === 'DESC' ? 'gt' : 'lt';
                 this.builder.where(columnName, operator, value);
-                // Reverse the order for backward pagination
                 orderBy.forEach(({ column, direction }) => {
                     const reversedDirection = direction === 'DESC' ? 'ASC' : 'DESC';
                     this.builder.orderBy(column, reversedDirection);
                 });
             }
             else {
-                // For forward pagination:
-                // If sorting DESC, we want records < cursor
-                // If sorting ASC, we want records > cursor
                 const operator = direction === 'DESC' ? 'lt' : 'gt';
                 this.builder.where(columnName, operator, value);
             }
         }
         this.builder.limit(requestSize);
-        // Execute query
         let results = await this.builder.execute();
-        // For backward pagination, we need to reverse the results
         if (before) {
             results = results.reverse();
         }
-        // Only take pageSize records for the actual data
         const data = results.slice(0, pageSize);
-        // Generate cursors
         const startCursor = data.length > 0 ? this.generateCursor(data[0], orderBy) : '';
         const endCursor = data.length > 0 ? this.generateCursor(data[data.length - 1], orderBy) : '';
-        // Determine if there are more pages
         const hasMore = results.length > pageSize;
-        // For the first page
         if (!cursor) {
             return {
                 data,
                 pageInfo: {
                     hasNextPage: hasMore,
-                    hasPreviousPage: data.length > 0 && this.currentPosition > 0, // Only true if we have results AND previous cursors
+                    hasPreviousPage: data.length > 0 && this.currentPosition > 0,
                     startCursor,
                     endCursor,
                     totalCount: 0,
@@ -126,13 +102,12 @@ export class PaginationFeature {
                 }
             };
         }
-        // For pages accessed via 'before' cursor
         if (before) {
             return {
                 data,
                 pageInfo: {
-                    hasNextPage: true, // We can always go forward when we've gone back
-                    hasPreviousPage: data.length > 0 && (this.currentPosition >= 0 || hasMore), // Need results to have previous page
+                    hasNextPage: true,
+                    hasPreviousPage: data.length > 0 && (this.currentPosition >= 0 || hasMore),
                     startCursor,
                     endCursor,
                     totalCount: 0,
@@ -141,12 +116,11 @@ export class PaginationFeature {
                 }
             };
         }
-        // For pages accessed via 'after' cursor
         return {
             data,
             pageInfo: {
-                hasNextPage: hasMore, // Can go forward if we have more results
-                hasPreviousPage: data.length > 0, // Need results to have previous page
+                hasNextPage: hasMore,
+                hasPreviousPage: data.length > 0,
                 startCursor,
                 endCursor,
                 totalCount: 0,
@@ -164,7 +138,6 @@ export class PaginationFeature {
             });
         }
         else {
-            // Use primary key or first column as default
             const [firstColumn] = Object.keys(record);
             if (firstColumn) {
                 cursorData[firstColumn] = record[firstColumn];
@@ -175,18 +148,17 @@ export class PaginationFeature {
     async firstPage(pageSize) {
         return this.paginate({ pageSize });
     }
-    async *iteratePages(pageSize) {
-        let currentCursor;
+    iteratePages(pageSize) {
+        return this.paginationGenerator(pageSize);
+    }
+    async *paginationGenerator(pageSize) {
+        let cursor;
         while (true) {
-            const result = await this.paginate({
-                pageSize,
-                after: currentCursor
-            });
+            const result = await this.paginate({ pageSize, after: cursor });
             yield result;
-            if (!result.pageInfo.hasNextPage) {
+            if (!result.pageInfo.hasNextPage)
                 break;
-            }
-            currentCursor = result.pageInfo.endCursor;
+            cursor = result.pageInfo.endCursor;
         }
     }
 }

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

@@ -1,22 +1,19 @@
+import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { ColumnType, OrderDirection, TableColumn } from '../../types/index.js';
-export declare class QueryModifiersFeature<Schema extends {
-    [tableName: string]: {
-        [columnName: string]: ColumnType;
-    };
-}, T, HasSelect extends boolean = false, Aggregations = {}, OriginalT = T> {
+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, T, HasSelect, Aggregations, OriginalT>);
-    addGroupBy(columns: (keyof T | TableColumn<Schema>) | Array<keyof T | TableColumn<Schema>>): {
+    constructor(builder: QueryBuilder<Schema, State>);
+    addGroupBy(columns: string | string[]): {
         groupBy: string[];
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         having?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -27,14 +24,14 @@ export declare class QueryModifiersFeature<Schema extends {
     };
     addLimit(count: number): {
         limit: number;
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         having?: string[];
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -45,14 +42,14 @@ export declare class QueryModifiersFeature<Schema extends {
     };
     addOffset(count: number): {
         offset: number;
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         having?: string[];
         limit?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -61,12 +58,12 @@ export declare class QueryModifiersFeature<Schema extends {
         unionQueries?: string[];
         settings?: string;
     };
-    addOrderBy<K extends keyof T | TableColumn<Schema>>(column: K, direction?: OrderDirection): {
+    addOrderBy(column: string, direction?: OrderDirection): {
         orderBy: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[];
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         having?: string[];
@@ -82,14 +79,14 @@ export declare class QueryModifiersFeature<Schema extends {
     addHaving(condition: string, parameters?: any[]): {
         having: string[];
         parameters: any[] | undefined;
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         limit?: number;
         offset?: number;
         distinct?: boolean;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];
@@ -99,14 +96,14 @@ export declare class QueryModifiersFeature<Schema extends {
     };
     setDistinct(): {
         distinct: boolean;
-        select?: (string | keyof T)[] | undefined;
+        select?: (string | keyof State["output"])[] | undefined;
         where?: import("../../types/base.js").WhereCondition[];
         groupBy?: string[];
         having?: string[];
         limit?: number;
         offset?: number;
         orderBy?: {
-            column: TableColumn<Schema> | keyof T;
+            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
             direction: OrderDirection;
         }[] | undefined;
         joins?: import("../../types/base.js").JoinClause[];

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

@@ -1 +1 @@
-{"version":3,"file":"query-modifiers.d.ts","sourceRoot":"","sources":["../../../src/core/features/query-modifiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAE/E,qBAAa,qBAAqB,CAChC,MAAM,SAAS;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAA;CAAE,EAC5E,CAAC,EACD,SAAS,SAAS,OAAO,GAAG,KAAK,EACjC,YAAY,GAAG,EAAE,EACjB,SAAS,GAAG,CAAC;IAED,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC;IAExF,UAAU,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;IAQ1F,QAAQ,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQtB,SAAS,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQvB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,GAAE,cAAsB;;;;;;;;;;;;;;;;;;IAQhG,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,GAAG,EAAE;;;;;;;;;;;;;;;;;;IAY/C,WAAW;;;;;;;;;;;;;;;;;;CAOZ"}
+{"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"}