relq 1.0.87 → 1.0.89

package/dist/cjs/cli/commands/generate.cjs

@@ -148,7 +148,7 @@ exports.default = (0, citty_1.defineCommand)({
             spin.start('Computing diff...');
             const rawPatterns = ignorePatterns.map(pat => pat.raw);
             const diff = (0, schema_diff_1.diffSchemas)((0, schema_hash_1.normalizeSchema)(dbSchema), (0, schema_hash_1.normalizeSchema)(desiredSchema));
-            const filteredDiff = (0, schema_diff_1.filterDiff)(diff, rawPatterns);
+            let filteredDiff = (0, schema_diff_1.filterDiff)(diff, rawPatterns);
             spin.stop('Diff computed');
             if (!filteredDiff.hasChanges) {
                 console.log('');
@@ -184,9 +184,17 @@ exports.default = (0, citty_1.defineCommand)({
                         message: 'Include destructive changes?',
                         initialValue: false,
                     });
-                    if (p.isCancel(proceed) || !proceed) {
+                    if (p.isCancel(proceed)) {
                         (0, ui_1.fatal)('Operation cancelled by user');
                     }
+                    if (!proceed) {
+                        filteredDiff = (0, schema_diff_1.stripDestructiveChanges)(filteredDiff);
+                        if (!filteredDiff.hasChanges) {
+                            p.log.info('No non-destructive changes to generate.');
+                            process.exit(0);
+                        }
+                        p.log.info('Destructive changes excluded. Continuing with safe changes only.');
+                    }
                 }
             }
             if (!migrationName) {

package/dist/cjs/cli/commands/push.cjs

@@ -158,7 +158,7 @@ async function runPush(config, projectRoot, opts = {}) {
         spin.stop(`Database: ${colors_1.colors.cyan(String(dbSchema.tables.length))} table(s) found`);
         spin.start('Computing diff...');
         const diff = (0, schema_diff_1.diffSchemas)((0, schema_hash_1.normalizeSchema)(dbSchema), (0, schema_hash_1.normalizeSchema)(desiredSchema));
-        const filteredDiff = (0, schema_diff_1.filterDiff)(diff, ignorePatterns.map(pat => pat.raw));
+        let filteredDiff = (0, schema_diff_1.filterDiff)(diff, ignorePatterns.map(pat => pat.raw));
         spin.stop('Diff computed');
         if (!filteredDiff.hasChanges) {
             console.log('');
@@ -215,9 +215,17 @@ async function runPush(config, projectRoot, opts = {}) {
                     message: 'Include destructive changes?',
                     initialValue: false,
                 });
-                if (p.isCancel(proceed) || !proceed) {
+                if (p.isCancel(proceed)) {
                     (0, ui_1.fatal)('Operation cancelled by user');
                 }
+                if (!proceed) {
+                    filteredDiff = (0, schema_diff_1.stripDestructiveChanges)(filteredDiff);
+                    if (!filteredDiff.hasChanges) {
+                        p.log.info('No non-destructive changes to push.');
+                        process.exit(0);
+                    }
+                    p.log.info('Destructive changes excluded. Continuing with safe changes only.');
+                }
             }
         }
         spin.start('Generating SQL...');

package/dist/cjs/cli/utils/migration-generator.cjs

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMigration = generateMigration;
 exports.generateMigrationFromComparison = generateMigrationFromComparison;
@@ -6,6 +39,7 @@ exports.generateMigrationFile = generateMigrationFile;
 exports.getNextMigrationNumber = getNextMigrationNumber;
 exports.generateTimestampedName = generateTimestampedName;
 exports.generateMigrationName = generateMigrationName;
+const fs = __importStar(require("node:fs"));
 function generateMigration(diff, options = {}) {
     const { includeDown = true } = options;
     const up = [];
@@ -580,7 +614,6 @@ function mapDataType(col) {
     return typeMap[type] || type;
 }
 function getNextMigrationNumber(migrationsDir) {
-    const fs = require('fs');
     if (!fs.existsSync(migrationsDir)) {
         return '001';
     }

package/dist/cjs/cli/utils/schema-diff.cjs

@@ -5,6 +5,7 @@ exports.formatDiff = formatDiff;
 exports.formatSummary = formatSummary;
 exports.filterDiff = filterDiff;
 exports.hasDestructiveChanges = hasDestructiveChanges;
+exports.stripDestructiveChanges = stripDestructiveChanges;
 exports.getDestructiveTables = getDestructiveTables;
 exports.compareSchemas = compareSchemas;
 const colors_1 = require("./colors.cjs");
@@ -493,6 +494,43 @@ function hasDestructiveChanges(diff) {
     }
     return false;
 }
+function stripDestructiveChanges(diff) {
+    const safeTables = diff.tables
+        .filter(t => t.type !== 'removed')
+        .map(t => {
+        if (t.type !== 'modified')
+            return t;
+        const safeColumns = t.columns?.filter(c => c.type !== 'removed');
+        return {
+            ...t,
+            columns: safeColumns,
+        };
+    })
+        .filter(t => {
+        if (t.type !== 'modified')
+            return true;
+        return (t.columns?.length || 0) > 0 || (t.indexes?.length || 0) > 0 || (t.constraints?.length || 0) > 0;
+    });
+    let columnsRemoved = 0;
+    let tablesRemoved = 0;
+    for (const t of diff.tables) {
+        if (t.type === 'removed')
+            tablesRemoved++;
+        if (t.columns)
+            columnsRemoved += t.columns.filter(c => c.type === 'removed').length;
+    }
+    return {
+        ...diff,
+        tables: safeTables,
+        hasChanges: safeTables.length > 0 || diff.extensions.length > 0,
+        summary: {
+            ...diff.summary,
+            tablesRemoved: 0,
+            columnsRemoved: 0,
+            tablesModified: safeTables.filter(t => t.type === 'modified').length,
+        },
+    };
+}
 function getDestructiveTables(diff) {
     const tables = [];
     for (const table of diff.tables) {

package/dist/cjs/cli/utils/schema-to-ast.cjs

@@ -86,8 +86,14 @@ function isExtensionsConfig(value) {
         typeof value.toSQL === 'function';
 }
 function isRelationsConfig(value) {
-    return value && typeof value === 'object' &&
-        value.$type === 'relations';
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    for (const val of Object.values(value)) {
+        if (Array.isArray(val) && val.length > 0 && val[0]?.$type === 'foreignKey') {
+            return true;
+        }
+    }
+    return false;
 }
 function generateTrackingId() {
     const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
@@ -178,8 +184,9 @@ function mapColumnTypeToPostgres(type) {
         'CUBE': 'cube',
         'VECTOR': 'vector',
     };
-    const upperType = type.toUpperCase();
-    return typeMap[upperType] || type.toLowerCase();
+    const baseType = type.replace(/\(.*\)$/, '');
+    const upperType = baseType.toUpperCase().trim();
+    return typeMap[upperType] || baseType.toLowerCase().trim();
 }
 function schemaToAST(schema) {
     const result = {
@@ -254,9 +261,61 @@ function schemaToAST(schema) {
             result.extensions.push(...value.extensions);
             continue;
         }
+        if (isRelationsConfig(value)) {
+            mergeRelationsIntoAST(result, value);
+            continue;
+        }
     }
     return result;
 }
+function mergeRelationsIntoAST(result, relations) {
+    for (const [_tableKey, fkDefs] of Object.entries(relations)) {
+        if (!Array.isArray(fkDefs))
+            continue;
+        for (const fk of fkDefs) {
+            if (!fk || fk.$type !== 'foreignKey')
+                continue;
+            const sourceTableSqlName = fk.$columns?.[0]?.table;
+            if (!sourceTableSqlName)
+                continue;
+            const table = result.tables.find(t => t.name === sourceTableSqlName);
+            if (!table)
+                continue;
+            const sourceColumns = fk.$columns.map(c => c.column);
+            const targetColumns = fk.$references
+                ? fk.$references.map(r => r.column)
+                : [];
+            const srcColList = sourceColumns.map(c => `"${c}"`).join(', ');
+            let definition = `FOREIGN KEY (${srcColList}) REFERENCES "${fk.$targetTable}"`;
+            if (targetColumns.length > 0) {
+                const tgtColList = targetColumns.map(c => `"${c}"`).join(', ');
+                definition += ` (${tgtColList})`;
+            }
+            if (fk.$onDelete && fk.$onDelete !== 'NO ACTION') {
+                definition += ` ON DELETE ${fk.$onDelete}`;
+            }
+            if (fk.$onUpdate && fk.$onUpdate !== 'NO ACTION') {
+                definition += ` ON UPDATE ${fk.$onUpdate}`;
+            }
+            const constraint = {
+                name: '',
+                type: 'FOREIGN KEY',
+                columns: sourceColumns,
+                references: {
+                    table: fk.$targetTable,
+                    columns: targetColumns.length > 0 ? targetColumns : sourceColumns,
+                    onDelete: fk.$onDelete,
+                    onUpdate: fk.$onUpdate,
+                    match: fk.$match,
+                    deferrable: fk.$deferrable,
+                    initiallyDeferred: fk.$initiallyDeferred,
+                },
+                trackingId: fk.$trackingId,
+            };
+            table.constraints.push(constraint);
+        }
+    }
+}
 function tableToAST(table) {
     if (!isTableDefinition(table))
         return null;
@@ -631,7 +690,7 @@ function triggerToAST(trigger) {
 function parsedColumnToColumnInfo(col) {
     return {
         name: col.name,
-        dataType: col.type,
+        dataType: col.isArray ? `${col.type}[]` : col.type,
         isNullable: col.isNullable,
         defaultValue: col.defaultValue || null,
         isPrimaryKey: col.isPrimaryKey,

package/dist/cjs/core/helpers/ConnectedSelectBuilder.cjs

@@ -5,6 +5,8 @@ const methods_1 = require("./methods.cjs");
 const select_joins_1 = require("./select-joins.cjs");
 const select_pagination_1 = require("./select-pagination.cjs");
 const capability_guard_1 = require("./capability-guard.cjs");
+const sql_expression_1 = require("../../select/sql-expression.cjs");
+const table_proxy_1 = require("../../select/table-proxy.cjs");
 class ConnectedSelectBuilder {
     builder;
     relq;
@@ -149,6 +151,28 @@ class ConnectedSelectBuilder {
         this.builder.having(callback);
         return this;
     }
+    include(callback) {
+        const agg = new sql_expression_1.AggregateFunctions();
+        const internal = this.relq[methods_1.INTERNAL];
+        const schema = internal.getSchema() || {};
+        const sourceSchemaKey = this.schemaKey || this.tableName;
+        const sourceAlias = this.builder.getTableIdentifier();
+        const tableProxies = new Proxy({}, {
+            get(_, tableKey) {
+                if (typeof tableKey === 'symbol')
+                    return undefined;
+                const tableDef = schema[tableKey];
+                const tableName = tableDef?.$name || tableKey;
+                const alias = tableKey === sourceSchemaKey ? sourceAlias : tableKey;
+                return (0, table_proxy_1.createTableProxy)(tableName, alias, tableDef);
+            }
+        });
+        const expressions = callback(agg, tableProxies);
+        for (const [alias, expr] of Object.entries(expressions)) {
+            this.builder.addIncludeExpression(alias, expr.sql);
+        }
+        return this;
+    }
     join(tableOrAlias, callback) {
         (0, select_joins_1.executeTypeSafeJoin)(this.joinCtx, 'JOIN', tableOrAlias, callback);
         return this;
@@ -175,14 +199,24 @@ class ConnectedSelectBuilder {
         this.builder.addRawJoin(`LEFT JOIN (${subquerySQL}) AS "${alias}" ON ${onClause}`);
         return this;
     }
-    joinMany(tableOrAlias, callback) {
+    joinMany(tableOrAlias, callbackOrOptions, throughCallback) {
         (0, capability_guard_1.requireCapability)(this.relq, 'lateral', 'LATERAL JOIN (joinMany)', 'Use separate queries for one-to-many relationships');
-        (0, select_joins_1.executeTypeSafeJoinMany)(this.joinCtx, 'JOIN', tableOrAlias, callback);
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeTypeSafeJoinManyThrough)(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeTypeSafeJoinMany)(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions);
+        }
         return this;
     }
-    leftJoinMany(tableOrAlias, callback) {
+    leftJoinMany(tableOrAlias, callbackOrOptions, throughCallback) {
         (0, capability_guard_1.requireCapability)(this.relq, 'lateral', 'LATERAL JOIN (leftJoinMany)', 'Use separate queries for one-to-many relationships');
-        (0, select_joins_1.executeTypeSafeJoinMany)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callback);
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            (0, select_joins_1.executeTypeSafeJoinManyThrough)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            (0, select_joins_1.executeTypeSafeJoinMany)(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions);
+        }
         return this;
     }
     distinct() {

package/dist/cjs/core/helpers/select-joins.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTypeSafeJoin = executeTypeSafeJoin;
 exports.executeTypeSafeJoinMany = executeTypeSafeJoinMany;
+exports.executeTypeSafeJoinManyThrough = executeTypeSafeJoinManyThrough;
 const table_proxy_1 = require("../../select/table-proxy.cjs");
 const join_condition_builder_1 = require("../../select/join-condition-builder.cjs");
 const join_internals_1 = require("../../select/join-internals.cjs");
@@ -118,12 +119,21 @@ function buildLateralSubquery(tableName, alias, builder, tableDef) {
     const internals = builder[join_internals_1.JOIN_INTERNAL];
     parts.push('SELECT');
     const selectedProps = internals.getSelectedColumns();
+    const innerJoins = internals.getInnerJoins();
+    const hasInnerJoins = innerJoins.length > 0;
+    const toSnake = (s) => s.replace(/[A-Z]/g, l => `_${l.toLowerCase()}`);
     if (selectedProps && selectedProps.length > 0) {
         const tableColumns = tableDef?.$columns || tableDef;
         const selectCols = selectedProps.map(prop => {
             const columnDef = tableColumns?.[prop];
-            const sqlName = columnDef?.$columnName || prop;
-            return `"${alias}"."${sqlName}" AS "${prop}"`;
+            if (columnDef || !hasInnerJoins) {
+                const sqlName = columnDef?.$columnName || toSnake(prop);
+                return `"${alias}"."${sqlName}" AS "${prop}"`;
+            }
+            else {
+                const sqlName = toSnake(prop);
+                return `"${sqlName}" AS "${prop}"`;
+            }
         }).join(', ');
         parts.push(selectCols);
     }
@@ -131,7 +141,6 @@ function buildLateralSubquery(tableName, alias, builder, tableDef) {
         parts.push(`"${alias}".*`);
     }
     parts.push(`FROM "${tableName}" AS "${alias}"`);
-    const innerJoins = internals.getInnerJoins();
     for (const join of innerJoins) {
         parts.push(`${join.type} "${join.table}" AS "${join.alias}" ON ${join.onClause}`);
     }
@@ -155,3 +164,88 @@ function buildLateralSubquery(tableName, alias, builder, tableDef) {
     parts.push(`) AS "${alias}_lateral"`);
     return parts.join(' ');
 }
+function executeTypeSafeJoinManyThrough(ctx, joinType, targetTableOrAlias, junctionTableKey, callback) {
+    const [targetKey, targetAlias] = Array.isArray(targetTableOrAlias)
+        ? targetTableOrAlias
+        : [targetTableOrAlias, targetTableOrAlias];
+    const internal = ctx.relq[methods_1.INTERNAL];
+    const schema = internal.getSchema();
+    const relations = internal.getRelations();
+    if (!schema || !relations) {
+        throw new relq_errors_1.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.` });
+    }
+    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 = (0, fk_resolver_1.resolveForeignKey)(relations, schema, ctx.schemaKey || ctx.tableName, junctionTableKey);
+    if (!leftToJunction) {
+        throw new relq_errors_1.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.` });
+    }
+    const junctionToTarget = (0, fk_resolver_1.resolveForeignKey)(relations, schema, junctionTableKey, targetKey);
+    if (!junctionToTarget) {
+        throw new relq_errors_1.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.` });
+    }
+    const conditionBuilder = new join_many_condition_builder_1.JoinManyConditionBuilder();
+    if (callback) {
+        callback(conditionBuilder);
+    }
+    const lateralSQL = buildThroughLateralSubquery(junctionTableName, junctionTableKey, targetTableName, targetAlias, leftAlias, leftToJunction, junctionToTarget, conditionBuilder, targetTableDef);
+    const lateralJoinType = joinType === 'LEFT JOIN' ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+    const joinClause = {
+        type: lateralJoinType,
+        table: targetTableName,
+        alias: targetAlias,
+        schemaKey: targetKey,
+        lateralSubquery: lateralSQL
+    };
+    ctx.builder.addStructuredJoin(joinClause);
+}
+function buildThroughLateralSubquery(junctionTableName, junctionAlias, targetTableName, targetAlias, leftAlias, leftToJunction, junctionToTarget, builder, targetTableDef) {
+    const parts = [];
+    const internals = builder[join_internals_1.JOIN_INTERNAL];
+    const toSnake = (s) => s.replace(/[A-Z]/g, l => `_${l.toLowerCase()}`);
+    parts.push('(SELECT');
+    parts.push(`COALESCE(jsonb_agg(row_to_json(sub.*)), '[]'::jsonb) AS ${targetAlias}`);
+    parts.push('FROM (');
+    parts.push('SELECT');
+    const selectedProps = internals.getSelectedColumns();
+    if (selectedProps && selectedProps.length > 0) {
+        const tableColumns = targetTableDef?.$columns || targetTableDef;
+        const selectCols = selectedProps.map(prop => {
+            const columnDef = tableColumns?.[prop];
+            const sqlName = columnDef?.$columnName || toSnake(prop);
+            return `"${targetAlias}"."${sqlName}" AS "${prop}"`;
+        }).join(', ');
+        parts.push(selectCols);
+    }
+    else {
+        parts.push(`"${targetAlias}".*`);
+    }
+    parts.push(`FROM "${junctionTableName}" AS "${junctionAlias}"`);
+    parts.push(`JOIN "${targetTableName}" AS "${targetAlias}" ON "${junctionAlias}"."${junctionToTarget.fromColumn}" = "${targetAlias}"."${junctionToTarget.toColumn}"`);
+    let whereSQL = `"${junctionAlias}"."${leftToJunction.toColumn}" = "${leftAlias}"."${leftToJunction.fromColumn}"`;
+    const userWhereSQL = internals.toWhereSQL();
+    if (userWhereSQL) {
+        whereSQL += ` AND ${userWhereSQL}`;
+    }
+    parts.push(`WHERE ${whereSQL}`);
+    const orderBySQL = internals.toOrderBySQL();
+    if (orderBySQL) {
+        parts.push(`ORDER BY ${orderBySQL}`);
+    }
+    const limitSQL = internals.toLimitSQL();
+    if (limitSQL) {
+        parts.push(limitSQL);
+    }
+    const offsetSQL = internals.toOffsetSQL();
+    if (offsetSQL) {
+        parts.push(offsetSQL);
+    }
+    parts.push(') sub');
+    parts.push(`) AS "${targetAlias}_lateral"`);
+    return parts.join(' ');
+}

package/dist/cjs/select/join-condition-builder.cjs

@@ -98,12 +98,12 @@ class JoinConditionBuilder {
         this.whereConditions.push(...collector.getConditions());
         return this;
     }
-    select(columns) {
-        if (columns === '*') {
-            this.selectedColumns = undefined;
+    select(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            this.selectedColumns = args[0];
         }
         else {
-            this.selectedColumns = columns;
+            this.selectedColumns = args;
         }
         return this;
     }

package/dist/cjs/select/join-many-condition-builder.cjs

@@ -34,28 +34,34 @@ class JoinManyConditionBuilder extends join_condition_builder_1.JoinConditionBui
             this.rightProxy = rightProxy;
         };
     }
-    innerJoin(table, callback) {
+    innerJoin(tableOrAlias, callback) {
         if (!this.proxyCreator) {
             throw new Error('innerJoin requires proxy creator - use raw innerJoinRaw() instead');
         }
-        const { proxy: innerProxy, tableName } = this.proxyCreator(table, table);
+        const [tableKey, alias] = Array.isArray(tableOrAlias)
+            ? tableOrAlias
+            : [tableOrAlias, tableOrAlias];
+        const { proxy: innerProxy, tableName } = this.proxyCreator(tableKey, alias);
         const conditionBuilder = new join_condition_builder_1.JoinConditionBuilder();
         callback(conditionBuilder, innerProxy);
         const internals = conditionBuilder[join_internals_1.JOIN_INTERNAL];
         const onClause = internals.toSQL();
-        this.innerJoins.push({ type: 'JOIN', table: tableName, alias: table, onClause });
+        this.innerJoins.push({ type: 'JOIN', table: tableName, alias, onClause });
         return this;
     }
-    leftInnerJoin(table, callback) {
+    leftInnerJoin(tableOrAlias, callback) {
         if (!this.proxyCreator) {
             throw new Error('leftInnerJoin requires proxy creator - use raw leftInnerJoinRaw() instead');
         }
-        const { proxy: innerProxy, tableName } = this.proxyCreator(table, table);
+        const [tableKey, alias] = Array.isArray(tableOrAlias)
+            ? tableOrAlias
+            : [tableOrAlias, tableOrAlias];
+        const { proxy: innerProxy, tableName } = this.proxyCreator(tableKey, alias);
         const conditionBuilder = new join_condition_builder_1.JoinConditionBuilder();
         callback(conditionBuilder, innerProxy);
         const internals = conditionBuilder[join_internals_1.JOIN_INTERNAL];
         const onClause = internals.toSQL();
-        this.innerJoins.push({ type: 'LEFT JOIN', table: tableName, alias: table, onClause });
+        this.innerJoins.push({ type: 'LEFT JOIN', table: tableName, alias, onClause });
         return this;
     }
     innerJoinRaw(table, alias, onClause) {
@@ -66,12 +72,12 @@ class JoinManyConditionBuilder extends join_condition_builder_1.JoinConditionBui
         this.innerJoins.push({ type: 'LEFT JOIN', table, alias, onClause });
         return this;
     }
-    select(columns) {
-        if (columns === '*') {
-            this.selectedColumns = undefined;
+    select(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            this.selectedColumns = args[0];
         }
         else {
-            this.selectedColumns = columns;
+            this.selectedColumns = args;
         }
         return this;
     }

package/dist/cjs/select/select-builder.cjs

@@ -22,6 +22,7 @@ class SelectBuilder {
     isDistinct = false;
     lockingClause;
     unionQueries = [];
+    includeExpressions = [];
     columnResolver;
     constructor(tableName, columns) {
         this.tableName = tableName;
@@ -208,6 +209,10 @@ class SelectBuilder {
     getStructuredJoins() {
         return [...this.structuredJoins];
     }
+    addIncludeExpression(alias, sql) {
+        this.includeExpressions.push({ alias, sql });
+        return this;
+    }
     qualifyWhereConditions(conditions, tableRef) {
         return conditions.map(cond => {
             if (!cond.column) {
@@ -286,6 +291,9 @@ class SelectBuilder {
                 columns.push(`row_to_json(${pg_format_1.default.ident(join.alias)}.*) AS ${pg_format_1.default.ident(join.alias)}`);
             }
         }
+        for (const expr of this.includeExpressions) {
+            columns.push(`${expr.sql} AS ${pg_format_1.default.ident(expr.alias)}`);
+        }
         const columnsSQL = columns.join(', ');
         let query = 'SELECT';
         if (this.distinctOnColumns.length > 0) {
@@ -318,7 +326,14 @@ class SelectBuilder {
             query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(conditions);
         }
         if (this.groupByColumns.length > 0) {
-            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return (0, pg_format_1.default)('%I.%I', tableRef, col);
+                return pg_format_1.default.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
         }
         if (this.havingConditions.length > 0) {
             let havingConds = this.transformConditionColumns(this.havingConditions);
@@ -389,7 +404,14 @@ class SelectBuilder {
             query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(conditions);
         }
         if (this.groupByColumns.length > 0) {
-            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return (0, pg_format_1.default)('%I.%I', tableRef, col);
+                return pg_format_1.default.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
         }
         if (this.havingConditions.length > 0) {
             let havingConds = this.transformConditionColumns(this.havingConditions);

package/dist/cjs/select/sql-expression.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateFunctions = exports.SqlExpression = void 0;
+const table_proxy_1 = require("./table-proxy.cjs");
+class SqlExpression {
+    sql;
+    _isSqlExpression = true;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+exports.SqlExpression = SqlExpression;
+class AggregateFunctions {
+    count(ref) {
+        if (!ref)
+            return new SqlExpression('COUNT(*)');
+        return new SqlExpression(`COUNT(${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    countDistinct(ref) {
+        return new SqlExpression(`COUNT(DISTINCT ${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    sum(ref) {
+        return new SqlExpression(`SUM(${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    avg(ref) {
+        return new SqlExpression(`AVG(${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    min(ref) {
+        return new SqlExpression(`MIN(${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    max(ref) {
+        return new SqlExpression(`MAX(${(0, table_proxy_1.columnRefToSQL)(ref)})`);
+    }
+    raw(sql) {
+        return new SqlExpression(sql);
+    }
+}
+exports.AggregateFunctions = AggregateFunctions;