@relq/orm 0.1.3 → 0.1.4

package/dist/esm/{core → pg}/helpers/query-convenience.js

@@ -1,8 +1,9 @@
-import { CountBuilder } from "../../count/count-builder.js";
-import { InsertBuilder } from "../../insert/insert-builder.js";
-import { SelectBuilder } from "../../select/select-builder.js";
-import { UpdateBuilder } from "../../update/update-builder.js";
-import { INTERNAL } from "./methods.js";
+import { CountBuilder } from "../count/count-builder.js";
+import { InsertBuilder } from "../insert/insert-builder.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { UpdateBuilder } from "../update/update-builder.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
 export async function executeFindById(ctx, id, getPrimaryKeyColumn) {
     const pkColumn = getPrimaryKeyColumn();
     const dbColumn = ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, { [pkColumn]: id });
@@ -106,8 +107,7 @@ export async function executeCreateWith(ctx, parentData, related) {
     const schema = internal.getSchema();
     const relations = internal.getRelations();
     if (!schema || !relations) {
-        throw new Error('Cannot use createWith() without schema and relations config. ' +
-            'Use separate insert calls with a transaction instead.');
+        throw new RelqBuilderError('Cannot use createWith() without schema and relations config', { builder: 'createWith', hint: 'Pass schema and relations to your Relq client, or use separate insert calls with a transaction instead' });
     }
     const parentSchemaKey = findSchemaKeyByTableName(schema, ctx.tableName) || ctx.tableName;
     try {
@@ -118,20 +118,19 @@ export async function executeCreateWith(ctx, parentData, related) {
         const parentSQL = parentBuilder.toString();
         const parentResult = await internal.executeQuery(parentSQL);
         if (!parentResult.result.rows || parentResult.result.rows.length === 0) {
-            throw new Error('Parent insert returned no rows');
+            throw new RelqBuilderError('Parent insert returned no rows', { builder: 'createWith', hint: 'Ensure the parent table supports RETURNING * and the insert data is valid' });
         }
         const parentRow = parentResult.result.rows[0];
         for (const [relationKey, childData] of Object.entries(related)) {
             const childTableDef = schema[relationKey];
             if (!childTableDef) {
-                throw new Error(`Unknown table "${relationKey}" in createWith(). Check your schema.`);
+                throw new RelqBuilderError(`Unknown table "${relationKey}" in createWith()`, { builder: 'createWith', hint: 'Verify the relation key matches a table name defined in your schema' });
             }
             const childTableName = childTableDef.$name || relationKey;
-            const { resolveForeignKey } = await import("../../utils/fk-resolver.js");
+            const { resolveForeignKey } = await import("../utils/fk-resolver.js");
             const fk = resolveForeignKey(relations, schema, parentSchemaKey, relationKey);
             if (!fk) {
-                throw new Error(`No FK relationship between "${parentSchemaKey}" and "${relationKey}". ` +
-                    'Define the relationship in your relations config.');
+                throw new RelqBuilderError(`No FK relationship between "${parentSchemaKey}" and "${relationKey}"`, { builder: 'createWith', hint: 'Define the relationship in your relations config, or use separate insert calls with explicit FK values' });
             }
             let fkColumn;
             let fkValue;

package/dist/esm/{core → pg}/helpers/select-joins.js

@@ -1,10 +1,10 @@
-import { createTableProxy } from "../../select/table-proxy.js";
-import { JoinConditionBuilder } from "../../select/join-condition-builder.js";
-import { JOIN_INTERNAL, JOIN_SETUP } from "../../select/join-internals.js";
-import { JoinManyConditionBuilder } from "../../select/join-many-condition-builder.js";
-import { RelqQueryError } from "../../shared/errors/relq-errors.js";
-import { resolveForeignKey } from "../../utils/fk-resolver.js";
-import { INTERNAL } from "./methods.js";
+import { createTableProxy } from "../select/table-proxy.js";
+import { JoinConditionBuilder } from "../select/join-condition-builder.js";
+import { JOIN_INTERNAL, JOIN_SETUP } from "../select/join-internals.js";
+import { JoinManyConditionBuilder } from "../select/join-many-condition-builder.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+import { resolveForeignKey } from "../utils/fk-resolver.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 export function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
     const [rightTableKey, rightAlias] = Array.isArray(tableOrAlias)
         ? tableOrAlias
@@ -37,8 +37,8 @@ export function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
             conditionBuilder.equal(leftCol, rightCol);
         }
         else {
-            throw new RelqQueryError(`Cannot auto-resolve FK relationship between "${ctx.schemaKey || ctx.tableName}" and "${rightTableKey}". ` +
-                `Either provide a callback with explicit join conditions, or define the relationship in your relations config.`, { hint: `Use .join('${rightTableKey}', (on, ${rightTableKey}, source) => on.equal(${rightTableKey}.id, source.columnName))` });
+            throw new RelqBuilderError(`No foreign key relationship found between "${ctx.schemaKey || ctx.tableName}" and "${rightTableKey}". ` +
+                `Either provide a callback with explicit join conditions, or define the relationship in your relations config.`, { builder: 'join', hint: `Use .join('${rightTableKey}', (on, ${rightTableKey}, source) => on.equal(${rightTableKey}.fkColumn, source.id))` });
         }
     }
     const selectedProps = conditionInternals.getSelectedColumns();
@@ -61,6 +61,7 @@ export function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
             sqlName: colDef.$columnName || toSnake(propName),
         }));
     }
+    const flatConfig = conditionInternals.getFlatConfig();
     const joinClause = {
         type: joinType,
         table: rightTableName,
@@ -68,7 +69,11 @@ export function executeTypeSafeJoin(ctx, joinType, tableOrAlias, callback) {
         schemaKey: rightTableKey,
         onClause: conditionInternals.toSQL() || undefined,
         usingColumns: conditionInternals.getUsingColumns() || undefined,
-        selectColumns
+        selectColumns,
+        flat: flatConfig ? {
+            mode: 'prefix',
+            prefix: flatConfig.prefix || rightAlias,
+        } : undefined,
     };
     ctx.builder.addStructuredJoin(joinClause);
 }
@@ -167,22 +172,20 @@ export function executeTypeSafeJoinManyThrough(ctx, joinType, targetTableOrAlias
     const schema = internal.getSchema();
     const relations = internal.getRelations();
     if (!schema || !relations) {
-        throw new RelqQueryError(`Cannot use { through } without schema and relations config.`, { hint: `Define relations in your schema to use the { through } pattern, or use the callback form of joinMany instead.` });
+        throw new RelqBuilderError(`Cannot use { through } without schema and relations config. Pass relations when creating Relq: new Relq(schema, dialect, { relations }).`, { builder: 'joinMany', hint: `Use the callback form of joinMany instead, or add relations to your Relq config.` });
     }
-    const leftTableDef = internal.getTableDef(ctx.schemaKey || ctx.tableName);
     const junctionTableDef = internal.getTableDef(junctionTableKey);
     const targetTableDef = internal.getTableDef(targetKey);
-    const leftTableName = leftTableDef?.$name || ctx.tableName;
     const junctionTableName = junctionTableDef?.$name || junctionTableKey;
     const targetTableName = targetTableDef?.$name || targetKey;
     const leftAlias = ctx.builder.getTableIdentifier();
     const leftToJunction = resolveForeignKey(relations, schema, ctx.schemaKey || ctx.tableName, junctionTableKey);
     if (!leftToJunction) {
-        throw new RelqQueryError(`Cannot resolve FK between "${ctx.schemaKey || ctx.tableName}" and junction table "${junctionTableKey}".`, { hint: `Define a foreign key relationship between these tables in your relations config, or use the callback form of joinMany instead.` });
+        throw new RelqBuilderError(`No foreign key relationship found between "${ctx.schemaKey || ctx.tableName}" and junction table "${junctionTableKey}". Define the relationship in your relations config.`, { builder: 'joinMany', hint: `Add a relation from "${ctx.schemaKey || ctx.tableName}" to "${junctionTableKey}" in pgRelations(), or use the callback form of joinMany.` });
     }
     const junctionToTarget = resolveForeignKey(relations, schema, junctionTableKey, targetKey);
     if (!junctionToTarget) {
-        throw new RelqQueryError(`Cannot resolve FK between junction table "${junctionTableKey}" and target table "${targetKey}".`, { hint: `Define a foreign key relationship between these tables in your relations config, or use the callback form of joinMany instead.` });
+        throw new RelqBuilderError(`No foreign key relationship found between junction table "${junctionTableKey}" and target table "${targetKey}". Define the relationship in your relations config.`, { builder: 'joinMany', hint: `Add a relation from "${junctionTableKey}" to "${targetKey}" in pgRelations(), or use the callback form of joinMany.` });
     }
     const conditionBuilder = new JoinManyConditionBuilder();
     if (callback) {

package/dist/esm/{core → pg}/helpers/select-pagination.js

@@ -1,7 +1,7 @@
 import Cursor from "../../addon/cursor.js";
 import { RelqConfigError, RelqQueryError } from "../../shared/errors/relq-errors.js";
 import { randomLimit } from "../../types/pagination-types.js";
-import { INTERNAL } from "./methods.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 export async function executeCursorEach(ctx, callback, options = {}) {
     const batchSize = options.batchSize ?? 100;
     const sql = ctx.builder.toString();

package/dist/esm/{insert → pg/insert}/conflict-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 function isColumnRef(value) {
     return typeof value === 'object' && value !== null && value.__type === 'column_ref';
 }
@@ -173,7 +173,7 @@ export class ConflictBuilder {
         return this._tableName;
     }
 }
-export function buildConflictUpdateSql(updateData, tableName, columnResolver) {
+export function buildConflictUpdateSql(updateData, _tableName, columnResolver) {
     const resolve = (col) => columnResolver ? columnResolver(col) : col;
     const setClauses = [];
     for (const [column, value] of Object.entries(updateData)) {

package/dist/esm/{insert → pg/insert}/insert-builder.js

@@ -1,9 +1,9 @@
-import format from "../shared/pg-format.js";
-import { convertCase } from "../utils/case-converter.js";
+import format from "../../shared/pg-format.js";
+import { convertCase } from "../../utils/case-converter.js";
 import { SelectBuilder } from "../select/select-builder.js";
 import { CountBuilder } from "../count/count-builder.js";
 import { ConflictBuilder, buildConflictUpdateSql } from "./conflict-builder.js";
-import { RelqBuilderError } from "../shared/errors/relq-errors.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
 export class InsertBuilder {
     tableName;
     insertData;
@@ -76,8 +76,11 @@ export class InsertBuilder {
         if (this.insertData.length === 0) {
             this.originalColumns = Object.keys(normalizedRows[0]).sort();
         }
-        for (const row of normalizedRows) {
-            this.validateColumns(row);
+        if (normalizedRows.length > 0) {
+            this.validateColumns(normalizedRows[0]);
+            if (normalizedRows.length > 1) {
+                this.validateColumns(normalizedRows[normalizedRows.length - 1]);
+            }
         }
         this.insertData.push(...normalizedRows);
         return this;

package/dist/esm/{insert → pg/insert}/insert-from-select-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { buildConflictUpdateSql } from "./conflict-builder.js";
 export class InsertFromSelectBuilder {
     tableName;

package/dist/esm/{pubsub → pg/pubsub}/listen-notify-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class ListenBuilder {
     channelName;
     constructor(channelName) {

package/dist/esm/{pubsub → pg/pubsub}/listener-connection.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { Client } from "../addon/pg.js";
-import format from "../shared/pg-format.js";
+import { Client } from "../../addon/pg.js";
+import format from "../../shared/pg-format.js";
 export class ListenerConnection extends EventEmitter {
     client = null;
     config;

package/dist/esm/{raw → pg/raw}/raw-query-builder.js

@@ -1,5 +1,5 @@
-import format from "../shared/pg-format.js";
-import { RelqQueryError } from "../shared/errors/relq-errors.js";
+import format from "../../shared/pg-format.js";
+import { RelqQueryError } from "../../shared/errors/relq-errors.js";
 export class RawQueryBuilder {
     query;
     params;

package/dist/esm/{raw → pg/raw}/sql-template.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class SqlFragment {
     text;
     _isSqlFragment = true;
@@ -12,9 +12,6 @@ export class SqlFragment {
 function sqlIdentifier(name) {
     return new SqlFragment(format.ident(name));
 }
-function sqlRaw(text) {
-    return new SqlFragment(text);
-}
 function sql(strings, ...values) {
     let result = '';
     for (let i = 0; i < strings.length; i++) {
@@ -61,6 +58,4 @@ function formatValue(value) {
     return format('%L', String(value));
 }
 sql.id = sqlIdentifier;
-sql.raw = sqlRaw;
-sql.fragment = sqlRaw;
 export { sql };

package/dist/esm/{select → pg/select}/aggregate-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
 const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
 export class AggregateQueryBuilder {
@@ -81,10 +81,15 @@ export class AggregateQueryBuilder {
         this.entries.push({ func: 'BOOL_OR', column, alias: alias || column });
         return this;
     }
-    where(callback) {
-        const collector = new ConditionCollector();
-        callback(collector);
-        this.whereConditions.push(...collector.getConditions());
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const collector = new ConditionCollector();
+            callbackOrCondition(collector);
+            this.whereConditions.push(...collector.getConditions());
+        }
         return this;
     }
     having(callback) {

package/dist/esm/{select → pg/select}/join-builder.js

@@ -1,7 +1,7 @@
 import { JoinConditionBuilder } from "./join-condition-builder.js";
 import { columnRefToSQL, columnRefToSQLUnqualified } from "./table-proxy.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class JoinManyBuilder extends JoinConditionBuilder {
     orderBySpecs = [];
     selectColumns = [];
@@ -120,7 +120,7 @@ export class JoinManyBuilder extends JoinConditionBuilder {
             .map(col => columnRefToSQLUnqualified(col))
             .join(', ');
     }
-    buildWherePart(leftAlias) {
+    buildWherePart(_leftAlias) {
         const parts = [];
         for (const cond of this.conditions) {
             if (cond.type === 'using' || cond.type === 'raw') {

package/dist/esm/{select → pg/select}/join-condition-builder.js

@@ -1,11 +1,12 @@
 import { columnRefToSQL, isColumnRef } from "./table-proxy.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { JOIN_INTERNAL } from "./join-internals.js";
 export class JoinConditionBuilder {
     conditions = [];
     whereConditions = [];
     selectedColumns;
+    flatConfig;
     equal(left, right) {
         this.conditions.push({
             type: 'equal',
@@ -100,6 +101,14 @@ export class JoinConditionBuilder {
         }
         return this;
     }
+    flat() {
+        if (!this.selectedColumns || this.selectedColumns.length === 0) {
+            throw new Error('Relq: .flat() requires .select() with explicit columns. ' +
+                'Cannot flatten without knowing the column set.');
+        }
+        this.flatConfig = { mode: 'prefix' };
+        return this;
+    }
     get [JOIN_INTERNAL]() {
         return {
             toSQL: () => this.internalToSQL(),
@@ -111,6 +120,7 @@ export class JoinConditionBuilder {
             hasConditions: () => this.conditions.length > 0,
             hasWhereConditions: () => this.whereConditions.length > 0,
             getSelectedColumns: () => this.selectedColumns ?? null,
+            getFlatConfig: () => this.flatConfig ?? null,
         };
     }
     internalToSQL() {

package/dist/esm/{select → pg/select}/join-many-condition-builder.js

@@ -1,14 +1,13 @@
 import { columnRefToSQL } from "./table-proxy.js";
 import { JoinConditionBuilder } from "./join-condition-builder.js";
 import { JOIN_INTERNAL, JOIN_SETUP } from "./join-internals.js";
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class JoinManyConditionBuilder extends JoinConditionBuilder {
     orderSpecs = [];
     limitValue;
     offsetValue;
     innerJoins = [];
     proxyCreator;
-    rightProxy;
     orderBy(column, direction = 'ASC', nulls) {
         this.orderSpecs.push({ column, direction, nulls });
         return this;
@@ -22,9 +21,8 @@ export class JoinManyConditionBuilder extends JoinConditionBuilder {
         return this;
     }
     get [JOIN_SETUP]() {
-        return (creator, rightProxy) => {
+        return (creator, _rightProxy) => {
             this.proxyCreator = creator;
-            this.rightProxy = rightProxy;
         };
     }
     innerJoin(tableOrAlias, callback) {
@@ -85,6 +83,7 @@ export class JoinManyConditionBuilder extends JoinConditionBuilder {
             hasConditions: () => this.conditions.length > 0,
             hasWhereConditions: () => this.whereConditions.length > 0,
             getSelectedColumns: () => this.selectedColumns ?? null,
+            getFlatConfig: () => this.flatConfig ?? null,
             toSelectSQL: (alias) => this.buildSelectSQL(alias),
             toOrderBySQL: () => this.buildOrderBySQL(),
             toLimitSQL: () => this.buildLimitSQL(),

package/dist/esm/{select → pg/select}/scalar-query-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
 class ScalarResultImpl {
     sql;
@@ -66,6 +66,36 @@ export class ScalarQueryBuilderImpl {
         const sql = `(EXISTS(SELECT 1 FROM ${format.ident(this.tableName)}${whereClause}))`;
         return new ScalarResultImpl(sql);
     }
+    countDistinct(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COUNT(DISTINCT ${format.ident(sqlColumn)})`);
+        return new ScalarResultImpl(sql);
+    }
+    stringAgg(column, delimiter = ', ') {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`STRING_AGG(${format.ident(sqlColumn)}::text, ${format.literal(delimiter)})`);
+        return new ScalarResultImpl(sql);
+    }
+    arrayAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(ARRAY_AGG(${format.ident(sqlColumn)}), ARRAY[]::text[])`);
+        return new ScalarResultImpl(sql);
+    }
+    jsonAgg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(JSON_AGG(${format.ident(sqlColumn)}), '[]'::json)`);
+        return new ScalarResultImpl(sql);
+    }
+    boolAnd(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`BOOL_AND(${format.ident(sqlColumn)})`);
+        return new ScalarResultImpl(sql);
+    }
+    boolOr(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`BOOL_OR(${format.ident(sqlColumn)})`);
+        return new ScalarResultImpl(sql);
+    }
     resolveColumn(column) {
         if (this.columnResolver) {
             return this.columnResolver(column);

package/dist/esm/{select → pg/select}/scalar-select-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { createScalarTableAccessor } from "./scalar-query-builder.js";
 export class ScalarSelectBuilder {
     executeQuery;

package/dist/esm/{select → pg/select}/select-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
 export class SelectBuilder {
     tableName;
@@ -69,10 +69,15 @@ export class SelectBuilder {
         this.isDistinct = true;
         return this;
     }
-    where(callback) {
-        const conditionBuilder = new ConditionCollector();
-        callback(conditionBuilder);
-        this.whereConditions.push(...conditionBuilder.getConditions());
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new ConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
         return this;
     }
     join(table, condition) {
@@ -271,10 +276,32 @@ export class SelectBuilder {
             }
             return format.ident(col);
         });
+        const hasGroupBy = this.groupByColumns.length > 0
+            || (this.includeExpressions.length > 0 && this.selectColumns.some(c => typeof c === 'string' && c !== '*'));
         for (const join of this.structuredJoins) {
             if (join.type === 'LEFT JOIN LATERAL' || join.type === 'JOIN LATERAL') {
                 columns.push(`${format.ident(join.alias + '_lateral')}.${format.ident(join.alias)} AS ${format.ident(join.alias)}`);
             }
+            else if (hasGroupBy) {
+                if (join.selectColumns && join.selectColumns.length > 0) {
+                    const jsonArgs = join.selectColumns
+                        .map(col => `'${col.property}', ${format.ident(join.alias)}.${format.ident(col.sqlName)}`)
+                        .join(', ');
+                    columns.push(`COALESCE(json_agg(json_build_object(${jsonArgs})) FILTER (WHERE ${format.ident(join.alias)}.${format.ident(join.selectColumns[0].sqlName)} IS NOT NULL), '[]'::json) AS ${format.ident(join.alias)}`);
+                }
+                else {
+                    columns.push(`COALESCE(json_agg(row_to_json(${format.ident(join.alias)}.*)) FILTER (WHERE ${format.ident(join.alias)} IS NOT NULL), '[]'::json) AS ${format.ident(join.alias)}`);
+                }
+            }
+            else if (join.flat && join.selectColumns && join.selectColumns.length > 0) {
+                const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+                const prefix = join.flat.prefix || join.alias;
+                for (const col of join.selectColumns) {
+                    const sqlRef = `${format.ident(join.alias)}.${format.ident(col.sqlName)}`;
+                    const alias = `${prefix}${capitalize(col.property)}`;
+                    columns.push(`${sqlRef} AS ${format.ident(alias)}`);
+                }
+            }
             else if (join.selectColumns && join.selectColumns.length > 0) {
                 const jsonArgs = join.selectColumns
                     .map(col => `'${col.property}', ${format.ident(join.alias)}.${format.ident(col.sqlName)}`)
@@ -319,8 +346,14 @@ export class SelectBuilder {
             }
             query += ' WHERE ' + buildConditionsSQL(conditions);
         }
-        if (this.groupByColumns.length > 0) {
-            const groupBySQL = this.groupByColumns.map(col => {
+        let effectiveGroupBy = this.groupByColumns;
+        if (effectiveGroupBy.length === 0 && this.includeExpressions.length > 0) {
+            effectiveGroupBy = this.selectColumns
+                .filter(col => typeof col === 'string' && col !== '*')
+                .map(col => col);
+        }
+        if (effectiveGroupBy.length > 0) {
+            const groupBySQL = effectiveGroupBy.map(col => {
                 if (col.includes('.'))
                     return col;
                 if (hasJoins)

package/dist/esm/pg/select/sql-expression.js

@@ -0,0 +1,51 @@
+import { columnRefToSQL } from "./table-proxy.js";
+export class SqlExpression {
+    sql;
+    _isSqlExpression = true;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+export class AggregateFunctions {
+    count(ref) {
+        if (!ref)
+            return new SqlExpression('COALESCE(COUNT(*)::integer, 0)');
+        return new SqlExpression(`COALESCE(COUNT(${columnRefToSQL(ref)})::integer, 0)`);
+    }
+    countDistinct(ref) {
+        return new SqlExpression(`COALESCE(COUNT(DISTINCT ${columnRefToSQL(ref)})::integer, 0)`);
+    }
+    sum(ref) {
+        return new SqlExpression(`COALESCE(SUM(${columnRefToSQL(ref)})::float, 0)`);
+    }
+    avg(ref) {
+        return new SqlExpression(`AVG(${columnRefToSQL(ref)})::float`);
+    }
+    min(ref) {
+        return new SqlExpression(`MIN(${columnRefToSQL(ref)})`);
+    }
+    max(ref) {
+        return new SqlExpression(`MAX(${columnRefToSQL(ref)})`);
+    }
+    stringAgg(ref, delimiter = ', ') {
+        return new SqlExpression(`COALESCE(STRING_AGG(${columnRefToSQL(ref)}::text, '${delimiter}'), '')`);
+    }
+    arrayAgg(ref) {
+        return new SqlExpression(`COALESCE(ARRAY_AGG(${columnRefToSQL(ref)}) FILTER (WHERE ${columnRefToSQL(ref)} IS NOT NULL), '{}')`);
+    }
+    arrayAggDistinct(ref) {
+        return new SqlExpression(`COALESCE(ARRAY_AGG(DISTINCT ${columnRefToSQL(ref)}) FILTER (WHERE ${columnRefToSQL(ref)} IS NOT NULL), '{}')`);
+    }
+    boolAnd(ref) {
+        return new SqlExpression(`COALESCE(BOOL_AND(${columnRefToSQL(ref)}), false)`);
+    }
+    boolOr(ref) {
+        return new SqlExpression(`COALESCE(BOOL_OR(${columnRefToSQL(ref)}), false)`);
+    }
+    stddev(ref) {
+        return new SqlExpression(`STDDEV(${columnRefToSQL(ref)})::float`);
+    }
+    variance(ref) {
+        return new SqlExpression(`VARIANCE(${columnRefToSQL(ref)})::float`);
+    }
+}

package/dist/esm/{transaction → pg/transaction}/transaction-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class TransactionBuilder {
     isolationLevel;
     mode;

package/dist/esm/{update → pg/update}/array-update-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class ArrayStringUpdateBuilder {
     set(values) {
         if (values.length === 0)
@@ -188,10 +188,7 @@ export class ArrayJsonbUpdateBuilder {
     }
 }
 export class ArrayUpdateBuilder {
-    currentColumn;
-    constructor(currentColumn) {
-        this.currentColumn = currentColumn;
-    }
+    constructor(_currentColumn) { }
     get string() {
         return new ArrayStringUpdateBuilder();
     }

package/dist/esm/pg/update/column-expression-builder.js

@@ -0,0 +1,42 @@
+import format from "../../shared/pg-format.js";
+export class ColumnExpressionBuilder {
+    increment(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) + ${format.literal(amount)}`;
+    }
+    decrement(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) - ${format.literal(amount)}`;
+    }
+    multiply(factor) {
+        return `COALESCE(__COLUMN__, 0) * ${format.literal(factor)}`;
+    }
+    toggle() {
+        return `NOT COALESCE(__COLUMN__, false)`;
+    }
+    concat(suffix) {
+        return `COALESCE(__COLUMN__, '') || ${format.literal(suffix)}`;
+    }
+    prepend(prefix) {
+        return `${format.literal(prefix)} || COALESCE(__COLUMN__, '')`;
+    }
+    replace(search, replacement) {
+        return `REPLACE(COALESCE(__COLUMN__, ''), ${format.literal(search)}, ${format.literal(replacement)})`;
+    }
+    lower() {
+        return `LOWER(__COLUMN__)`;
+    }
+    upper() {
+        return `UPPER(__COLUMN__)`;
+    }
+    trim() {
+        return `TRIM(__COLUMN__)`;
+    }
+    now() {
+        return `NOW()`;
+    }
+    addInterval(value, unit) {
+        return `COALESCE(__COLUMN__, NOW()) + INTERVAL '${value} ${unit}'`;
+    }
+    subtractInterval(value, unit) {
+        return `COALESCE(__COLUMN__, NOW()) - INTERVAL '${value} ${unit}'`;
+    }
+}

package/dist/esm/{update → pg/update}/jsonb-update-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class JsonbArrayBuilder {
     currentColumn;
     constructor(currentColumn) {