@visactor/vquery 0.4.9 → 0.4.10

package/dist/browser/esm/browser.js

@@ -51,7 +51,17 @@ const inlineParameters = (sql, params)=>{
     });
     return sql;
 };
-const applyWhere = (where)=>{
+const operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
+};
+const toSqlOperator = (op)=>operatorMap[op] ?? op;
+const applyWhere = (qb, where)=>{
+    if (!where) return qb;
     const toRaw = (w)=>{
         if ('op' in w && 'conditions' in w) {
             const parts = w.conditions.map((c)=>toRaw(c));
@@ -61,6 +71,7 @@ const applyWhere = (where)=>{
         const leaf = w;
         const field = leaf.field;
         const value = leaf.value;
+        const sqlOp = toSqlOperator(leaf.op);
         switch(leaf.op){
             case 'is null':
                 return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
@@ -91,10 +102,10 @@ const applyWhere = (where)=>{
                     return external_kysely_sql`${external_kysely_sql.ref(field)} not between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
                 }
             default:
-                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(leaf.op)} ${external_kysely_sql.val(value)}`;
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(sqlOp)} ${external_kysely_sql.val(value)}`;
         }
     };
-    return toRaw(where);
+    return qb.where(toRaw(where));
 };
 const applyGroupBy = (qb, fields)=>{
     if (fields && fields.length > 0) {
@@ -103,60 +114,17 @@ const applyGroupBy = (qb, fields)=>{
     }
     return qb;
 };
-const applyLimit = (qb, limit)=>{
-    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
-    return qb;
-};
-const DATE_FORMAT_MAP = {
-    year: '%Y',
-    month: '%Y-%m',
-    day: '%Y-%m-%d',
-    week: '%Y-W%W',
-    hour: '%Y-%m-%d %H',
-    minute: '%Y-%m-%d %H:%M',
-    second: '%Y-%m-%d %H:%M:%S'
+const having_operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
 };
-const applySelect = (qb, select)=>{
-    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
-            if (isSelectItem(item)) {
-                const field = item.field;
-                const expression = eb.ref(field);
-                if (item.aggr) {
-                    const { func } = item.aggr;
-                    const sqlAlias = field;
-                    if ([
-                        'avg',
-                        'sum',
-                        'min',
-                        'max',
-                        'variance',
-                        'variancePop',
-                        'stddev',
-                        'median'
-                    ].includes(func)) {
-                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(sqlAlias);
-                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(sqlAlias);
-                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(sqlAlias);
-                    }
-                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
-                    if ('quantile' === func) {
-                        const q = item.aggr.quantile ?? 0.5;
-                        return external_kysely_sql`quantile(${expression}, ${q})`.as(sqlAlias);
-                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
-                    else if (func.startsWith('to_')) {
-                        const dateTrunc = func.replace('to_', '');
-                        const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
-                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
-                    }
-                }
-                return expression.as(field);
-            }
-            return item;
-        }));
-    return qb.selectAll();
-};
-const applyHaving = (having)=>{
+const having_toSqlOperator = (op)=>having_operatorMap[op] ?? op;
+const applyHaving = (qb, having)=>{
+    if (!having) return qb;
     const toRaw = (h)=>{
         if ('op' in h && 'conditions' in h) {
             const parts = h.conditions.map((c)=>toRaw(c));
@@ -166,7 +134,7 @@ const applyHaving = (having)=>{
         const leaf = h;
         const field = leaf.field;
         const value = leaf.value;
-        const op = leaf.op;
+        const op = having_toSqlOperator(leaf.op);
         if ([
             'sum',
             'avg',
@@ -177,7 +145,7 @@ const applyHaving = (having)=>{
             const aggrExpr = external_kysely_sql`${external_kysely_sql.raw(op.toLowerCase())}(${external_kysely_sql.ref(field)})`;
             return external_kysely_sql`${aggrExpr} = ${external_kysely_sql.val(value)}`;
         }
-        switch(op){
+        switch(leaf.op){
             case 'is null':
                 return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
             case 'is not null':
@@ -210,22 +178,66 @@ const applyHaving = (having)=>{
                 return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(op)} ${external_kysely_sql.val(value)}`;
         }
     };
-    return toRaw(having);
+    return qb.having(toRaw(having));
 };
-const resolveHavingAliases = (having, aliasToFieldMap)=>{
-    if (!having) return having;
-    if ('op' in having && 'conditions' in having) return {
-        ...having,
-        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
-    };
-    if ('field' in having) {
-        const resolvedField = aliasToFieldMap[having.field] || having.field;
-        return {
-            ...having,
-            field: resolvedField
-        };
-    }
-    return having;
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const applyOrder = (qb, orderBy)=>{
+    if (orderBy && orderBy.length > 0) orderBy.forEach((o)=>{
+        qb = qb.orderBy(o.field, o.order ?? 'asc');
+    });
+    return qb;
+};
+const DATE_FORMAT_MAP = {
+    year: '%Y',
+    month: '%Y-%m',
+    day: '%Y-%m-%d',
+    week: '%Y-W%W',
+    hour: '%Y-%m-%d %H',
+    minute: '%Y-%m-%d %H:%M',
+    second: '%Y-%m-%d %H:%M:%S'
+};
+const applySelect = (qb, select)=>{
+    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
+            if (isSelectItem(item)) {
+                const field = item.field;
+                const expression = eb.ref(field);
+                const alias = item.alias ?? field;
+                if (item.aggr) {
+                    const { func } = item.aggr;
+                    if ([
+                        'avg',
+                        'sum',
+                        'min',
+                        'max',
+                        'variance',
+                        'variancePop',
+                        'stddev',
+                        'median'
+                    ].includes(func)) {
+                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(alias);
+                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(alias);
+                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(alias);
+                    }
+                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('quantile' === func) {
+                        const q = item.aggr.quantile ?? 0.5;
+                        return external_kysely_sql`quantile(${expression}, ${q})`.as(alias);
+                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                    else if (func.startsWith('to_')) {
+                        const dateTrunc = func.replace('to_', '');
+                        const format = DATE_FORMAT_MAP[dateTrunc];
+                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
+                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                    }
+                }
+                return expression.as(alias);
+            }
+            return item;
+        }));
+    return qb.selectAll();
 };
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new Kysely({
@@ -233,30 +245,13 @@ const convertDSLToSQL = (dsl, tableName)=>{
     });
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
-    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    const aliasToFieldMap = {};
-    if (dsl.select && Array.isArray(dsl.select)) {
-        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
-            const field = item.field;
-            const alias = item.alias;
-            if (alias && field) aliasToFieldMap[alias] = field;
-        }
-    }
-    let resolvedGroupBy = dsl.groupBy;
-    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
-    qb = applyGroupBy(qb, resolvedGroupBy);
-    if (dsl.having) {
-        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
-        qb = qb.having(applyHaving(resolvedHaving));
-    }
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
-        const fieldStr = o.field;
-        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
-        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
-    }
+    qb = applyWhere(qb, dsl.where);
+    qb = applyGroupBy(qb, dsl.groupBy);
+    qb = applyHaving(qb, dsl.having);
+    qb = applyOrder(qb, dsl.orderBy);
     qb = applyLimit(qb, dsl.limit);
-    const compiled = qb.compile();
-    return inlineParameters(compiled.sql, compiled.parameters);
+    const { sql, parameters } = qb.compile();
+    return inlineParameters(sql, parameters);
 };
 const READ_FUNCTION_MAP = {
     csv: 'read_csv_auto',

package/dist/browser/esm/sql-builder/builders/having.d.ts

@@ -1,3 +1,3 @@
+import type { SelectQueryBuilder } from 'kysely';
 import { Having, HavingClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;
+export declare const applyHaving: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, having?: Having<T> | HavingClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/browser/esm/sql-builder/builders/index.d.ts

@@ -1,5 +1,6 @@
 export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
+export { applyHaving } from './having';
 export { applyLimit } from './limit';
+export { applyOrder } from './order';
 export { applySelect } from './select';
-export { applyHaving } from './having';

package/dist/browser/esm/sql-builder/builders/order.d.ts

@@ -0,0 +1,7 @@
+import type { SelectQueryBuilder } from 'kysely';
+type OrderByItem = {
+    field: string;
+    order?: 'asc' | 'desc';
+};
+export declare const applyOrder: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, orderBy?: Array<OrderByItem>) => SelectQueryBuilder<DB, TB, O>;
+export {};

package/dist/browser/esm/sql-builder/builders/where.d.ts

@@ -1,3 +1,3 @@
 import { Where, WhereClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyWhere: <T>(where: Where<T> | WhereClause<T>) => RawBuilder<boolean>;
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyWhere: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, where?: Where<T> | WhereClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/browser/esm/sql-builder/dslToSQL.d.ts

@@ -1,2 +1,2 @@
-import { QueryDSL, VQueryDSL } from '../types';
+import type { QueryDSL, VQueryDSL } from '../types';
 export declare const convertDSLToSQL: <T, TableName extends string>(dsl: QueryDSL<T> | VQueryDSL<T>, tableName: TableName) => string;

package/dist/browser/esm/types/dsl/QueryDSL.d.ts

@@ -1,8 +1,8 @@
 import { GroupBy } from './GroupBy';
+import { Having } from './Having';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
-import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;

package/dist/node/cjs/node.cjs

@@ -89,7 +89,17 @@ const inlineParameters = (sql, params)=>{
     });
     return sql;
 };
-const applyWhere = (where)=>{
+const operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
+};
+const toSqlOperator = (op)=>operatorMap[op] ?? op;
+const applyWhere = (qb, where)=>{
+    if (!where) return qb;
     const toRaw = (w)=>{
         if ('op' in w && 'conditions' in w) {
             const parts = w.conditions.map((c)=>toRaw(c));
@@ -99,6 +109,7 @@ const applyWhere = (where)=>{
         const leaf = w;
         const field = leaf.field;
         const value = leaf.value;
+        const sqlOp = toSqlOperator(leaf.op);
         switch(leaf.op){
             case 'is null':
                 return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is null`;
@@ -129,10 +140,10 @@ const applyWhere = (where)=>{
                     return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} not between ${external_kysely_namespaceObject.sql.val(a)} and ${external_kysely_namespaceObject.sql.val(b)}`;
                 }
             default:
-                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} ${external_kysely_namespaceObject.sql.raw(leaf.op)} ${external_kysely_namespaceObject.sql.val(value)}`;
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} ${external_kysely_namespaceObject.sql.raw(sqlOp)} ${external_kysely_namespaceObject.sql.val(value)}`;
         }
     };
-    return toRaw(where);
+    return qb.where(toRaw(where));
 };
 const applyGroupBy = (qb, fields)=>{
     if (fields && fields.length > 0) {
@@ -141,60 +152,17 @@ const applyGroupBy = (qb, fields)=>{
     }
     return qb;
 };
-const applyLimit = (qb, limit)=>{
-    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
-    return qb;
-};
-const DATE_FORMAT_MAP = {
-    year: '%Y',
-    month: '%Y-%m',
-    day: '%Y-%m-%d',
-    week: '%Y-W%W',
-    hour: '%Y-%m-%d %H',
-    minute: '%Y-%m-%d %H:%M',
-    second: '%Y-%m-%d %H:%M:%S'
+const having_operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
 };
-const applySelect = (qb, select)=>{
-    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
-            if (isSelectItem(item)) {
-                const field = item.field;
-                const expression = eb.ref(field);
-                if (item.aggr) {
-                    const { func } = item.aggr;
-                    const sqlAlias = field;
-                    if ([
-                        'avg',
-                        'sum',
-                        'min',
-                        'max',
-                        'variance',
-                        'variancePop',
-                        'stddev',
-                        'median'
-                    ].includes(func)) {
-                        if ('variance' === func) return (0, external_kysely_namespaceObject.sql)`var_samp(${expression})`.as(sqlAlias);
-                        if ('variancePop' === func) return (0, external_kysely_namespaceObject.sql)`var_pop(${expression})`.as(sqlAlias);
-                        return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(func)}(${expression})`.as(sqlAlias);
-                    }
-                    if ('count' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
-                    if ('quantile' === func) {
-                        const q = item.aggr.quantile ?? 0.5;
-                        return (0, external_kysely_namespaceObject.sql)`quantile(${expression}, ${q})`.as(sqlAlias);
-                    } else if ('count_distinct' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
-                    else if (func.startsWith('to_')) {
-                        const dateTrunc = func.replace('to_', '');
-                        const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
-                        if ('quarter' === dateTrunc) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
-                    }
-                }
-                return expression.as(field);
-            }
-            return item;
-        }));
-    return qb.selectAll();
-};
-const applyHaving = (having)=>{
+const having_toSqlOperator = (op)=>having_operatorMap[op] ?? op;
+const applyHaving = (qb, having)=>{
+    if (!having) return qb;
     const toRaw = (h)=>{
         if ('op' in h && 'conditions' in h) {
             const parts = h.conditions.map((c)=>toRaw(c));
@@ -204,7 +172,7 @@ const applyHaving = (having)=>{
         const leaf = h;
         const field = leaf.field;
         const value = leaf.value;
-        const op = leaf.op;
+        const op = having_toSqlOperator(leaf.op);
         if ([
             'sum',
             'avg',
@@ -215,7 +183,7 @@ const applyHaving = (having)=>{
             const aggrExpr = (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(op.toLowerCase())}(${external_kysely_namespaceObject.sql.ref(field)})`;
             return (0, external_kysely_namespaceObject.sql)`${aggrExpr} = ${external_kysely_namespaceObject.sql.val(value)}`;
         }
-        switch(op){
+        switch(leaf.op){
             case 'is null':
                 return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is null`;
             case 'is not null':
@@ -248,22 +216,66 @@ const applyHaving = (having)=>{
                 return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} ${external_kysely_namespaceObject.sql.raw(op)} ${external_kysely_namespaceObject.sql.val(value)}`;
         }
     };
-    return toRaw(having);
+    return qb.having(toRaw(having));
 };
-const resolveHavingAliases = (having, aliasToFieldMap)=>{
-    if (!having) return having;
-    if ('op' in having && 'conditions' in having) return {
-        ...having,
-        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
-    };
-    if ('field' in having) {
-        const resolvedField = aliasToFieldMap[having.field] || having.field;
-        return {
-            ...having,
-            field: resolvedField
-        };
-    }
-    return having;
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const applyOrder = (qb, orderBy)=>{
+    if (orderBy && orderBy.length > 0) orderBy.forEach((o)=>{
+        qb = qb.orderBy(o.field, o.order ?? 'asc');
+    });
+    return qb;
+};
+const DATE_FORMAT_MAP = {
+    year: '%Y',
+    month: '%Y-%m',
+    day: '%Y-%m-%d',
+    week: '%Y-W%W',
+    hour: '%Y-%m-%d %H',
+    minute: '%Y-%m-%d %H:%M',
+    second: '%Y-%m-%d %H:%M:%S'
+};
+const applySelect = (qb, select)=>{
+    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
+            if (isSelectItem(item)) {
+                const field = item.field;
+                const expression = eb.ref(field);
+                const alias = item.alias ?? field;
+                if (item.aggr) {
+                    const { func } = item.aggr;
+                    if ([
+                        'avg',
+                        'sum',
+                        'min',
+                        'max',
+                        'variance',
+                        'variancePop',
+                        'stddev',
+                        'median'
+                    ].includes(func)) {
+                        if ('variance' === func) return (0, external_kysely_namespaceObject.sql)`var_samp(${expression})`.as(alias);
+                        if ('variancePop' === func) return (0, external_kysely_namespaceObject.sql)`var_pop(${expression})`.as(alias);
+                        return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(func)}(${expression})`.as(alias);
+                    }
+                    if ('count' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('quantile' === func) {
+                        const q = item.aggr.quantile ?? 0.5;
+                        return (0, external_kysely_namespaceObject.sql)`quantile(${expression}, ${q})`.as(alias);
+                    } else if ('count_distinct' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                    else if (func.startsWith('to_')) {
+                        const dateTrunc = func.replace('to_', '');
+                        const format = DATE_FORMAT_MAP[dateTrunc];
+                        if (format) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
+                        if ('quarter' === dateTrunc) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                    }
+                }
+                return expression.as(alias);
+            }
+            return item;
+        }));
+    return qb.selectAll();
 };
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new external_kysely_namespaceObject.Kysely({
@@ -271,30 +283,13 @@ const convertDSLToSQL = (dsl, tableName)=>{
     });
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
-    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    const aliasToFieldMap = {};
-    if (dsl.select && Array.isArray(dsl.select)) {
-        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
-            const field = item.field;
-            const alias = item.alias;
-            if (alias && field) aliasToFieldMap[alias] = field;
-        }
-    }
-    let resolvedGroupBy = dsl.groupBy;
-    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
-    qb = applyGroupBy(qb, resolvedGroupBy);
-    if (dsl.having) {
-        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
-        qb = qb.having(applyHaving(resolvedHaving));
-    }
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
-        const fieldStr = o.field;
-        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
-        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
-    }
+    qb = applyWhere(qb, dsl.where);
+    qb = applyGroupBy(qb, dsl.groupBy);
+    qb = applyHaving(qb, dsl.having);
+    qb = applyOrder(qb, dsl.orderBy);
     qb = applyLimit(qb, dsl.limit);
-    const compiled = qb.compile();
-    return inlineParameters(compiled.sql, compiled.parameters);
+    const { sql, parameters } = qb.compile();
+    return inlineParameters(sql, parameters);
 };
 const READ_FUNCTION_MAP = {
     csv: 'read_csv_auto',

package/dist/node/cjs/sql-builder/builders/having.d.ts

@@ -1,3 +1,3 @@
+import type { SelectQueryBuilder } from 'kysely';
 import { Having, HavingClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;
+export declare const applyHaving: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, having?: Having<T> | HavingClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/cjs/sql-builder/builders/index.d.ts

@@ -1,5 +1,6 @@
 export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
+export { applyHaving } from './having';
 export { applyLimit } from './limit';
+export { applyOrder } from './order';
 export { applySelect } from './select';
-export { applyHaving } from './having';

package/dist/node/cjs/sql-builder/builders/order.d.ts

@@ -0,0 +1,7 @@
+import type { SelectQueryBuilder } from 'kysely';
+type OrderByItem = {
+    field: string;
+    order?: 'asc' | 'desc';
+};
+export declare const applyOrder: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, orderBy?: Array<OrderByItem>) => SelectQueryBuilder<DB, TB, O>;
+export {};

package/dist/node/cjs/sql-builder/builders/where.d.ts

@@ -1,3 +1,3 @@
 import { Where, WhereClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyWhere: <T>(where: Where<T> | WhereClause<T>) => RawBuilder<boolean>;
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyWhere: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, where?: Where<T> | WhereClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/cjs/sql-builder/dslToSQL.d.ts

@@ -1,2 +1,2 @@
-import { QueryDSL, VQueryDSL } from '../types';
+import type { QueryDSL, VQueryDSL } from '../types';
 export declare const convertDSLToSQL: <T, TableName extends string>(dsl: QueryDSL<T> | VQueryDSL<T>, tableName: TableName) => string;

package/dist/node/cjs/types/dsl/QueryDSL.d.ts

@@ -1,8 +1,8 @@
 import { GroupBy } from './GroupBy';
+import { Having } from './Having';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
-import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;

package/dist/node/esm/node.js

@@ -52,7 +52,17 @@ const inlineParameters = (sql, params)=>{
     });
     return sql;
 };
-const applyWhere = (where)=>{
+const operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
+};
+const toSqlOperator = (op)=>operatorMap[op] ?? op;
+const applyWhere = (qb, where)=>{
+    if (!where) return qb;
     const toRaw = (w)=>{
         if ('op' in w && 'conditions' in w) {
             const parts = w.conditions.map((c)=>toRaw(c));
@@ -62,6 +72,7 @@ const applyWhere = (where)=>{
         const leaf = w;
         const field = leaf.field;
         const value = leaf.value;
+        const sqlOp = toSqlOperator(leaf.op);
         switch(leaf.op){
             case 'is null':
                 return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
@@ -92,10 +103,10 @@ const applyWhere = (where)=>{
                     return external_kysely_sql`${external_kysely_sql.ref(field)} not between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
                 }
             default:
-                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(leaf.op)} ${external_kysely_sql.val(value)}`;
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(sqlOp)} ${external_kysely_sql.val(value)}`;
         }
     };
-    return toRaw(where);
+    return qb.where(toRaw(where));
 };
 const applyGroupBy = (qb, fields)=>{
     if (fields && fields.length > 0) {
@@ -104,60 +115,17 @@ const applyGroupBy = (qb, fields)=>{
     }
     return qb;
 };
-const applyLimit = (qb, limit)=>{
-    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
-    return qb;
-};
-const DATE_FORMAT_MAP = {
-    year: '%Y',
-    month: '%Y-%m',
-    day: '%Y-%m-%d',
-    week: '%Y-W%W',
-    hour: '%Y-%m-%d %H',
-    minute: '%Y-%m-%d %H:%M',
-    second: '%Y-%m-%d %H:%M:%S'
+const having_operatorMap = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    eq: '=',
+    neq: '!='
 };
-const applySelect = (qb, select)=>{
-    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
-            if (isSelectItem(item)) {
-                const field = item.field;
-                const expression = eb.ref(field);
-                if (item.aggr) {
-                    const { func } = item.aggr;
-                    const sqlAlias = field;
-                    if ([
-                        'avg',
-                        'sum',
-                        'min',
-                        'max',
-                        'variance',
-                        'variancePop',
-                        'stddev',
-                        'median'
-                    ].includes(func)) {
-                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(sqlAlias);
-                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(sqlAlias);
-                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(sqlAlias);
-                    }
-                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
-                    if ('quantile' === func) {
-                        const q = item.aggr.quantile ?? 0.5;
-                        return external_kysely_sql`quantile(${expression}, ${q})`.as(sqlAlias);
-                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
-                    else if (func.startsWith('to_')) {
-                        const dateTrunc = func.replace('to_', '');
-                        const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
-                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
-                    }
-                }
-                return expression.as(field);
-            }
-            return item;
-        }));
-    return qb.selectAll();
-};
-const applyHaving = (having)=>{
+const having_toSqlOperator = (op)=>having_operatorMap[op] ?? op;
+const applyHaving = (qb, having)=>{
+    if (!having) return qb;
     const toRaw = (h)=>{
         if ('op' in h && 'conditions' in h) {
             const parts = h.conditions.map((c)=>toRaw(c));
@@ -167,7 +135,7 @@ const applyHaving = (having)=>{
         const leaf = h;
         const field = leaf.field;
         const value = leaf.value;
-        const op = leaf.op;
+        const op = having_toSqlOperator(leaf.op);
         if ([
             'sum',
             'avg',
@@ -178,7 +146,7 @@ const applyHaving = (having)=>{
             const aggrExpr = external_kysely_sql`${external_kysely_sql.raw(op.toLowerCase())}(${external_kysely_sql.ref(field)})`;
             return external_kysely_sql`${aggrExpr} = ${external_kysely_sql.val(value)}`;
         }
-        switch(op){
+        switch(leaf.op){
             case 'is null':
                 return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
             case 'is not null':
@@ -211,22 +179,66 @@ const applyHaving = (having)=>{
                 return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(op)} ${external_kysely_sql.val(value)}`;
         }
     };
-    return toRaw(having);
+    return qb.having(toRaw(having));
 };
-const resolveHavingAliases = (having, aliasToFieldMap)=>{
-    if (!having) return having;
-    if ('op' in having && 'conditions' in having) return {
-        ...having,
-        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
-    };
-    if ('field' in having) {
-        const resolvedField = aliasToFieldMap[having.field] || having.field;
-        return {
-            ...having,
-            field: resolvedField
-        };
-    }
-    return having;
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const applyOrder = (qb, orderBy)=>{
+    if (orderBy && orderBy.length > 0) orderBy.forEach((o)=>{
+        qb = qb.orderBy(o.field, o.order ?? 'asc');
+    });
+    return qb;
+};
+const DATE_FORMAT_MAP = {
+    year: '%Y',
+    month: '%Y-%m',
+    day: '%Y-%m-%d',
+    week: '%Y-W%W',
+    hour: '%Y-%m-%d %H',
+    minute: '%Y-%m-%d %H:%M',
+    second: '%Y-%m-%d %H:%M:%S'
+};
+const applySelect = (qb, select)=>{
+    if (select && select.length > 0) return qb.select((eb)=>select.map((item)=>{
+            if (isSelectItem(item)) {
+                const field = item.field;
+                const expression = eb.ref(field);
+                const alias = item.alias ?? field;
+                if (item.aggr) {
+                    const { func } = item.aggr;
+                    if ([
+                        'avg',
+                        'sum',
+                        'min',
+                        'max',
+                        'variance',
+                        'variancePop',
+                        'stddev',
+                        'median'
+                    ].includes(func)) {
+                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(alias);
+                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(alias);
+                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(alias);
+                    }
+                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('quantile' === func) {
+                        const q = item.aggr.quantile ?? 0.5;
+                        return external_kysely_sql`quantile(${expression}, ${q})`.as(alias);
+                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                    else if (func.startsWith('to_')) {
+                        const dateTrunc = func.replace('to_', '');
+                        const format = DATE_FORMAT_MAP[dateTrunc];
+                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
+                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                    }
+                }
+                return expression.as(alias);
+            }
+            return item;
+        }));
+    return qb.selectAll();
 };
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new Kysely({
@@ -234,30 +246,13 @@ const convertDSLToSQL = (dsl, tableName)=>{
     });
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
-    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    const aliasToFieldMap = {};
-    if (dsl.select && Array.isArray(dsl.select)) {
-        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
-            const field = item.field;
-            const alias = item.alias;
-            if (alias && field) aliasToFieldMap[alias] = field;
-        }
-    }
-    let resolvedGroupBy = dsl.groupBy;
-    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
-    qb = applyGroupBy(qb, resolvedGroupBy);
-    if (dsl.having) {
-        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
-        qb = qb.having(applyHaving(resolvedHaving));
-    }
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
-        const fieldStr = o.field;
-        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
-        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
-    }
+    qb = applyWhere(qb, dsl.where);
+    qb = applyGroupBy(qb, dsl.groupBy);
+    qb = applyHaving(qb, dsl.having);
+    qb = applyOrder(qb, dsl.orderBy);
     qb = applyLimit(qb, dsl.limit);
-    const compiled = qb.compile();
-    return inlineParameters(compiled.sql, compiled.parameters);
+    const { sql, parameters } = qb.compile();
+    return inlineParameters(sql, parameters);
 };
 const READ_FUNCTION_MAP = {
     csv: 'read_csv_auto',

package/dist/node/esm/sql-builder/builders/having.d.ts

@@ -1,3 +1,3 @@
+import type { SelectQueryBuilder } from 'kysely';
 import { Having, HavingClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;
+export declare const applyHaving: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, having?: Having<T> | HavingClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/esm/sql-builder/builders/index.d.ts

@@ -1,5 +1,6 @@
 export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
+export { applyHaving } from './having';
 export { applyLimit } from './limit';
+export { applyOrder } from './order';
 export { applySelect } from './select';
-export { applyHaving } from './having';

package/dist/node/esm/sql-builder/builders/order.d.ts

@@ -0,0 +1,7 @@
+import type { SelectQueryBuilder } from 'kysely';
+type OrderByItem = {
+    field: string;
+    order?: 'asc' | 'desc';
+};
+export declare const applyOrder: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, orderBy?: Array<OrderByItem>) => SelectQueryBuilder<DB, TB, O>;
+export {};

package/dist/node/esm/sql-builder/builders/where.d.ts

@@ -1,3 +1,3 @@
 import { Where, WhereClause } from '../../types';
-import type { RawBuilder } from 'kysely';
-export declare const applyWhere: <T>(where: Where<T> | WhereClause<T>) => RawBuilder<boolean>;
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyWhere: <DB, TB extends keyof DB & string, O, T>(qb: SelectQueryBuilder<DB, TB, O>, where?: Where<T> | WhereClause<T>) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/esm/sql-builder/dslToSQL.d.ts

@@ -1,2 +1,2 @@
-import { QueryDSL, VQueryDSL } from '../types';
+import type { QueryDSL, VQueryDSL } from '../types';
 export declare const convertDSLToSQL: <T, TableName extends string>(dsl: QueryDSL<T> | VQueryDSL<T>, tableName: TableName) => string;

package/dist/node/esm/types/dsl/QueryDSL.d.ts

@@ -1,8 +1,8 @@
 import { GroupBy } from './GroupBy';
+import { Having } from './Having';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
-import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "type": "module",
   "exports": {
     ".": {