relq 1.0.39 → 1.0.41

package/dist/cjs/core/helpers/ConnectedDeleteBuilder.cjs

@@ -6,9 +6,32 @@ const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
 class ConnectedDeleteBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     where(callback) {
         this.builder.where(callback);
@@ -26,8 +49,11 @@ class ConnectedDeleteBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }
 exports.ConnectedDeleteBuilder = ConnectedDeleteBuilder;

package/dist/cjs/core/helpers/ConnectedInsertBuilder.cjs

@@ -6,9 +6,32 @@ const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
 class ConnectedInsertBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     addRow(row) {
         this.builder.addRow(row);
@@ -49,8 +72,11 @@ class ConnectedInsertBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }
 exports.ConnectedInsertBuilder = ConnectedInsertBuilder;

package/dist/cjs/core/helpers/ConnectedQueryBuilder.cjs

@@ -49,15 +49,15 @@ class ConnectedQueryBuilder {
     }
     insert(data) {
         const builder = new insert_builder_1.InsertBuilder(this.tableName, data);
-        return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq);
+        return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     update(data) {
         const builder = new update_builder_1.UpdateBuilder(this.tableName, data);
-        return new ConnectedUpdateBuilder_1.ConnectedUpdateBuilder(builder, this.relq);
+        return new ConnectedUpdateBuilder_1.ConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     delete() {
         const builder = new delete_builder_1.DeleteBuilder(this.tableName);
-        return new ConnectedDeleteBuilder_1.ConnectedDeleteBuilder(builder, this.relq);
+        return new ConnectedDeleteBuilder_1.ConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     count() {
         const builder = new count_builder_1.CountBuilder(this.tableName);

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

@@ -10,9 +10,6 @@ const join_condition_builder_1 = require("../../select/join-condition-builder.cj
 const join_internals_1 = require("../../select/join-internals.cjs");
 const join_many_condition_builder_1 = require("../../select/join-many-condition-builder.cjs");
 const table_proxy_1 = require("../../select/table-proxy.cjs");
-function camelToSnake(str) {
-    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-}
 const pagination_types_1 = require("../../types/pagination-types.cjs");
 const fk_resolver_1 = require("../../utils/fk-resolver.cjs");
 const methods_1 = require("./methods.cjs");
@@ -40,9 +37,9 @@ class ConnectedSelectBuilder {
         this.builder.setColumnResolver((column) => {
             const columnDef = tableColumns[column];
             if (columnDef) {
-                return columnDef.$sqlName || columnDef.$name || camelToSnake(column);
+                return columnDef.$columnName || column;
             }
-            return camelToSnake(column);
+            return column;
         });
     }
     where(callback) {
@@ -154,7 +151,7 @@ class ConnectedSelectBuilder {
             const tableColumns = tableDef?.$columns || tableDef;
             const selectCols = selectedProps.map(prop => {
                 const columnDef = tableColumns?.[prop];
-                const sqlName = columnDef?.$sqlName || columnDef?.$name || camelToSnake(prop);
+                const sqlName = columnDef?.$columnName || prop;
                 return `"${alias}"."${sqlName}" AS "${prop}"`;
             }).join(', ');
             parts.push(selectCols);
@@ -224,7 +221,7 @@ class ConnectedSelectBuilder {
             const rightColumns = rightTableDef?.$columns || rightTableDef;
             selectColumns = selectedProps.map(prop => {
                 const columnDef = rightColumns?.[prop];
-                const sqlName = columnDef?.$sqlName || columnDef?.$name || camelToSnake(prop);
+                const sqlName = columnDef?.$columnName || prop;
                 return { property: prop, sqlName };
             });
         }

package/dist/cjs/core/helpers/ConnectedUpdateBuilder.cjs

@@ -6,9 +6,32 @@ const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
 class ConnectedUpdateBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     where(callback) {
         this.builder.where(callback);
@@ -27,8 +50,11 @@ class ConnectedUpdateBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }
 exports.ConnectedUpdateBuilder = ConnectedUpdateBuilder;

package/dist/cjs/core/helpers/ReturningExecutor.cjs

@@ -7,9 +7,44 @@ const methods_1 = require("./methods.cjs");
 class ReturningExecutor {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    columnMapping;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnMapping();
+    }
+    setupColumnMapping() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.columnMapping = new Map();
+        for (const [propName, columnDef] of Object.entries(tableColumns)) {
+            if (columnDef && typeof columnDef === 'object') {
+                const sqlName = columnDef.$columnName || propName;
+                this.columnMapping.set(sqlName, propName);
+            }
+        }
+    }
+    transformRow(row) {
+        if (!this.columnMapping) {
+            return row;
+        }
+        const transformed = {};
+        for (const [sqlKey, value] of Object.entries(row)) {
+            const propName = this.columnMapping.get(sqlKey) || sqlKey;
+            transformed[propName] = value;
+        }
+        return transformed;
     }
     toString() {
         return this.builder.toString();
@@ -25,10 +60,11 @@ class ReturningExecutor {
         }
         const sql = this.builder.toString();
         const result = await this.relq[methods_1.INTERNAL].executeSelect(sql);
+        const transformedData = result.data.map(row => this.transformRow(row));
         if (withMetadata) {
-            return result;
+            return { ...result, data: transformedData };
         }
-        return result.data;
+        return transformedData;
     }
 }
 exports.ReturningExecutor = ReturningExecutor;

package/dist/cjs/delete/delete-builder.cjs

@@ -12,9 +12,47 @@ class DeleteBuilder {
     tableName;
     whereConditions = [];
     returningClause;
+    columnResolver;
     constructor(tableName) {
         this.tableName = tableName;
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
     where(callback) {
         const conditionBuilder = new condition_collector_1.ConditionCollector();
         callback(conditionBuilder);
@@ -64,7 +102,8 @@ class DeleteBuilder {
     toString() {
         let query = (0, pg_format_1.default)('DELETE FROM %I', this.tableName);
         if (this.whereConditions.length > 0) {
-            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(transformedConditions);
         }
         if (this.returningClause) {
             query += this.buildReturningClause();
@@ -111,8 +150,10 @@ class DeleteBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return (0, pg_format_1.default)(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return (0, pg_format_1.default)(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/cjs/insert/insert-builder.cjs

@@ -19,11 +19,22 @@ class InsertBuilder {
     _case = 'keep-case';
     _convertCase = '2snake';
     originalColumns;
+    columnResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.insertData = [data];
         this.originalColumns = Object.keys(data).sort();
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
     convertCase(type, conversionCase = '2snake') {
         this._case = type;
         this._convertCase = conversionCase;
@@ -176,7 +187,7 @@ class InsertBuilder {
             throw new relq_errors_1.RelqBuilderError('Cannot generate INSERT query: no rows to insert', { builder: 'InsertBuilder', missing: 'data', hint: 'Add rows using addRow() or addRows() first' });
         }
         const originalColumns = Object.keys(this.insertData[0]);
-        const columns = originalColumns.map(name => this.convertColumnName(name));
+        const columns = originalColumns.map(name => this.resolveColumnName(name));
         const allValuesGroups = [];
         for (const row of this.insertData) {
             const { values, placeholders } = this.processRowValues(row, originalColumns);
@@ -230,8 +241,10 @@ class InsertBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return (0, pg_format_1.default)(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return (0, pg_format_1.default)(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/cjs/update/update-builder.cjs

@@ -17,10 +17,48 @@ class UpdateBuilder {
     returningClause;
     _case = 'keep-case';
     _convertCase = '2snake';
+    columnResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.updateData = data;
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
     convertCase(type, conversionCase = '2snake') {
         this._case = type;
         this._convertCase = conversionCase;
@@ -110,7 +148,7 @@ class UpdateBuilder {
     }
     toString() {
         const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
-            const convertedCol = this.convertColumnName(col);
+            const convertedCol = this.resolveColumnName(col);
             if (typeof val === 'function') {
                 const arrayBuilder = new array_update_builder_1.ArrayUpdateBuilder(col);
                 const result = val(arrayBuilder);
@@ -124,7 +162,8 @@ class UpdateBuilder {
         });
         let query = (0, pg_format_1.default)('UPDATE %I SET %s', this.tableName, processedPairs.join(', '));
         if (this.whereConditions.length > 0) {
-            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(transformedConditions);
         }
         if (this.returningClause) {
             query += this.buildReturningClause();
@@ -171,8 +210,10 @@ class UpdateBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return (0, pg_format_1.default)(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return (0, pg_format_1.default)(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/config.d.ts

@@ -536,9 +536,10 @@ export type Simplify<T> = {
 	[K in keyof T]: T[K];
 } & {};
 /**
- * Clean a column type by removing DefaultValue union members
+ * Clean a column type by removing DefaultValue union members and symbols
+ * (symbols like EMPTY_OBJECT/EMPTY_ARRAY can leak into type inference from $default)
  */
-export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue)>;
+export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue) | symbol>;
 /**
  * Build SELECT type with smart required/optional:
  * - Required: NOT NULL, PRIMARY KEY, has DEFAULT/GENERATED columns

package/dist/esm/core/helpers/ConnectedDeleteBuilder.js

@@ -3,9 +3,32 @@ import { ReturningExecutor } from "./ReturningExecutor.js";
 export class ConnectedDeleteBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     where(callback) {
         this.builder.where(callback);
@@ -23,7 +46,10 @@ export class ConnectedDeleteBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }

package/dist/esm/core/helpers/ConnectedInsertBuilder.js

@@ -3,9 +3,32 @@ import { ReturningExecutor } from "./ReturningExecutor.js";
 export class ConnectedInsertBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     addRow(row) {
         this.builder.addRow(row);
@@ -46,7 +69,10 @@ export class ConnectedInsertBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }

package/dist/esm/core/helpers/ConnectedQueryBuilder.js

@@ -46,15 +46,15 @@ export class ConnectedQueryBuilder {
     }
     insert(data) {
         const builder = new InsertBuilder(this.tableName, data);
-        return new ConnectedInsertBuilder(builder, this.relq);
+        return new ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     update(data) {
         const builder = new UpdateBuilder(this.tableName, data);
-        return new ConnectedUpdateBuilder(builder, this.relq);
+        return new ConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     delete() {
         const builder = new DeleteBuilder(this.tableName);
-        return new ConnectedDeleteBuilder(builder, this.relq);
+        return new ConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
     count() {
         const builder = new CountBuilder(this.tableName);

package/dist/esm/core/helpers/ConnectedSelectBuilder.js

@@ -4,9 +4,6 @@ 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 { createTableProxy } from "../../select/table-proxy.js";
-function camelToSnake(str) {
-    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-}
 import { randomLimit } from "../../types/pagination-types.js";
 import { resolveForeignKey } from "../../utils/fk-resolver.js";
 import { INTERNAL } from "./methods.js";
@@ -34,9 +31,9 @@ export class ConnectedSelectBuilder {
         this.builder.setColumnResolver((column) => {
             const columnDef = tableColumns[column];
             if (columnDef) {
-                return columnDef.$sqlName || columnDef.$name || camelToSnake(column);
+                return columnDef.$columnName || column;
             }
-            return camelToSnake(column);
+            return column;
         });
     }
     where(callback) {
@@ -148,7 +145,7 @@ export class ConnectedSelectBuilder {
             const tableColumns = tableDef?.$columns || tableDef;
             const selectCols = selectedProps.map(prop => {
                 const columnDef = tableColumns?.[prop];
-                const sqlName = columnDef?.$sqlName || columnDef?.$name || camelToSnake(prop);
+                const sqlName = columnDef?.$columnName || prop;
                 return `"${alias}"."${sqlName}" AS "${prop}"`;
             }).join(', ');
             parts.push(selectCols);
@@ -218,7 +215,7 @@ export class ConnectedSelectBuilder {
             const rightColumns = rightTableDef?.$columns || rightTableDef;
             selectColumns = selectedProps.map(prop => {
                 const columnDef = rightColumns?.[prop];
-                const sqlName = columnDef?.$sqlName || columnDef?.$name || camelToSnake(prop);
+                const sqlName = columnDef?.$columnName || prop;
                 return { property: prop, sqlName };
             });
         }

package/dist/esm/core/helpers/ConnectedUpdateBuilder.js

@@ -3,9 +3,32 @@ import { ReturningExecutor } from "./ReturningExecutor.js";
 export class ConnectedUpdateBuilder {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
     }
     where(callback) {
         this.builder.where(callback);
@@ -24,7 +47,10 @@ export class ConnectedUpdateBuilder {
         return result.metadata.rowCount ?? 0;
     }
     returning(columns) {
+        if (columns === null) {
+            return this;
+        }
         this.builder.returning(columns);
-        return new ReturningExecutor(this.builder, this.relq);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
     }
 }

package/dist/esm/core/helpers/ReturningExecutor.js

@@ -4,9 +4,44 @@ import { INTERNAL } from "./methods.js";
 export class ReturningExecutor {
     builder;
     relq;
-    constructor(builder, relq) {
+    tableName;
+    schemaKey;
+    columnMapping;
+    constructor(builder, relq, tableName, schemaKey) {
         this.builder = builder;
         this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnMapping();
+    }
+    setupColumnMapping() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.columnMapping = new Map();
+        for (const [propName, columnDef] of Object.entries(tableColumns)) {
+            if (columnDef && typeof columnDef === 'object') {
+                const sqlName = columnDef.$columnName || propName;
+                this.columnMapping.set(sqlName, propName);
+            }
+        }
+    }
+    transformRow(row) {
+        if (!this.columnMapping) {
+            return row;
+        }
+        const transformed = {};
+        for (const [sqlKey, value] of Object.entries(row)) {
+            const propName = this.columnMapping.get(sqlKey) || sqlKey;
+            transformed[propName] = value;
+        }
+        return transformed;
     }
     toString() {
         return this.builder.toString();
@@ -22,9 +57,10 @@ export class ReturningExecutor {
         }
         const sql = this.builder.toString();
         const result = await this.relq[INTERNAL].executeSelect(sql);
+        const transformedData = result.data.map(row => this.transformRow(row));
         if (withMetadata) {
-            return result;
+            return { ...result, data: transformedData };
         }
-        return result.data;
+        return transformedData;
     }
 }

package/dist/esm/delete/delete-builder.js

@@ -6,9 +6,47 @@ export class DeleteBuilder {
     tableName;
     whereConditions = [];
     returningClause;
+    columnResolver;
     constructor(tableName) {
         this.tableName = tableName;
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
     where(callback) {
         const conditionBuilder = new ConditionCollector();
         callback(conditionBuilder);
@@ -58,7 +96,8 @@ export class DeleteBuilder {
     toString() {
         let query = format('DELETE FROM %I', this.tableName);
         if (this.whereConditions.length > 0) {
-            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + buildConditionsSQL(transformedConditions);
         }
         if (this.returningClause) {
             query += this.buildReturningClause();
@@ -105,8 +144,10 @@ export class DeleteBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return format(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return format(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/esm/insert/insert-builder.js

@@ -13,11 +13,22 @@ export class InsertBuilder {
     _case = 'keep-case';
     _convertCase = '2snake';
     originalColumns;
+    columnResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.insertData = [data];
         this.originalColumns = Object.keys(data).sort();
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
     convertCase(type, conversionCase = '2snake') {
         this._case = type;
         this._convertCase = conversionCase;
@@ -170,7 +181,7 @@ export class InsertBuilder {
             throw new RelqBuilderError('Cannot generate INSERT query: no rows to insert', { builder: 'InsertBuilder', missing: 'data', hint: 'Add rows using addRow() or addRows() first' });
         }
         const originalColumns = Object.keys(this.insertData[0]);
-        const columns = originalColumns.map(name => this.convertColumnName(name));
+        const columns = originalColumns.map(name => this.resolveColumnName(name));
         const allValuesGroups = [];
         for (const row of this.insertData) {
             const { values, placeholders } = this.processRowValues(row, originalColumns);
@@ -224,8 +235,10 @@ export class InsertBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return format(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return format(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/esm/update/update-builder.js

@@ -11,10 +11,48 @@ export class UpdateBuilder {
     returningClause;
     _case = 'keep-case';
     _convertCase = '2snake';
+    columnResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.updateData = data;
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
     convertCase(type, conversionCase = '2snake') {
         this._case = type;
         this._convertCase = conversionCase;
@@ -104,7 +142,7 @@ export class UpdateBuilder {
     }
     toString() {
         const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
-            const convertedCol = this.convertColumnName(col);
+            const convertedCol = this.resolveColumnName(col);
             if (typeof val === 'function') {
                 const arrayBuilder = new ArrayUpdateBuilder(col);
                 const result = val(arrayBuilder);
@@ -118,7 +156,8 @@ export class UpdateBuilder {
         });
         let query = format('UPDATE %I SET %s', this.tableName, processedPairs.join(', '));
         if (this.whereConditions.length > 0) {
-            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + buildConditionsSQL(transformedConditions);
         }
         if (this.returningClause) {
             query += this.buildReturningClause();
@@ -165,8 +204,10 @@ export class UpdateBuilder {
         if (!this.returningClause)
             return '';
         switch (this.returningClause.type) {
-            case 'columns':
-                return format(' RETURNING %I', this.returningClause.columns);
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return format(' RETURNING %I', resolvedColumns);
+            }
             case 'select': {
                 const selectSQL = this.returningClause.builder.toString();
                 return ` RETURNING (${selectSQL})`;

package/dist/index.d.ts

@@ -474,9 +474,10 @@ export type Simplify<T> = {
 	[K in keyof T]: T[K];
 } & {};
 /**
- * Clean a column type by removing DefaultValue union members
+ * Clean a column type by removing DefaultValue union members and symbols
+ * (symbols like EMPTY_OBJECT/EMPTY_ARRAY can leak into type inference from $default)
  */
-export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue)>;
+export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue) | symbol>;
 /**
  * Build SELECT type with smart required/optional:
  * - Required: NOT NULL, PRIMARY KEY, has DEFAULT/GENERATED columns
@@ -1671,7 +1672,18 @@ export declare class InsertBuilder {
 	private _case;
 	private _convertCase;
 	private originalColumns;
+	private columnResolver?;
 	constructor(tableName: string, data: Record<string, QueryValue>);
+	/**
+	 * Set a column resolver function to transform property names to SQL column names.
+	 * @internal Used by ConnectedInsertBuilder for schema-aware column name mapping.
+	 */
+	setColumnResolver(resolver: (column: string) => string): InsertBuilder;
+	/**
+	 * Resolve a column name using the column resolver or fallback to convertColumnName.
+	 * @internal
+	 */
+	private resolveColumnName;
 	convertCase(type: "keep-case" | "to-lower" | "to-upper"): InsertBuilder;
 	convertCase(type: "convert-case", conversionCase: ConversionType): InsertBuilder;
 	private validateColumns;
@@ -1817,7 +1829,24 @@ export declare class UpdateBuilder {
 	private returningClause?;
 	private _case;
 	private _convertCase;
+	private columnResolver?;
 	constructor(tableName: string, data: Record<string, UpdateValue$1>);
+	/**
+	 * Set a column resolver function to transform property names to SQL column names.
+	 * @internal Used by ConnectedUpdateBuilder for schema-aware column name mapping.
+	 */
+	setColumnResolver(resolver: (column: string) => string): UpdateBuilder;
+	/**
+	 * Resolve a column name using the column resolver or fallback to convertColumnName.
+	 * @internal
+	 */
+	private resolveColumnName;
+	/**
+	 * Transform column names in conditions using the column resolver.
+	 * Recursively handles nested or/and conditions.
+	 * @internal
+	 */
+	private transformConditionColumns;
 	convertCase(type: "keep-case" | "to-lower" | "to-upper"): UpdateBuilder;
 	convertCase(type: "convert-case", conversionCase: ConversionType): UpdateBuilder;
 	where(callback: (builder: ConditionBuilder) => ConditionBuilder): UpdateBuilder;
@@ -1932,7 +1961,24 @@ export declare class DeleteBuilder {
 	private tableName;
 	private whereConditions;
 	private returningClause?;
+	private columnResolver?;
 	constructor(tableName: string);
+	/**
+	 * Set a column resolver function to transform property names to SQL column names.
+	 * @internal Used by ConnectedDeleteBuilder for schema-aware column name mapping.
+	 */
+	setColumnResolver(resolver: (column: string) => string): DeleteBuilder;
+	/**
+	 * Resolve a column name using the column resolver or return as-is.
+	 * @internal
+	 */
+	private resolveColumnName;
+	/**
+	 * Transform column names in conditions using the column resolver.
+	 * Recursively handles nested or/and conditions.
+	 * @internal
+	 */
+	private transformConditionColumns;
 	where(callback: (builder: ConditionBuilder) => ConditionBuilder): DeleteBuilder;
 	/**
 	 * RETURNING clause with simple column list
@@ -6547,9 +6593,22 @@ declare class ConnectedCountBuilder<TTable = any, TGroups extends Record<string,
 declare class ReturningExecutor<TResult> {
 	private builder;
 	private relq;
+	private tableName?;
+	private schemaKey?;
+	private columnMapping?;
 	constructor(builder: {
 		toString(): string;
-	}, relq: Relq);
+	}, relq: Relq, tableName?: string | undefined, schemaKey?: string | undefined);
+	/**
+	 * Set up reverse column mapping (SQL name → TypeScript property name)
+	 * @internal
+	 */
+	private setupColumnMapping;
+	/**
+	 * Transform a row's keys from SQL column names to TypeScript property names
+	 * @internal
+	 */
+	private transformRow;
 	/**
 	 * Get SQL string
 	 */
@@ -6564,7 +6623,15 @@ declare class ReturningExecutor<TResult> {
 declare class ConnectedDeleteBuilder<TTable = any> {
 	private builder;
 	private relq;
-	constructor(builder: DeleteBuilder, relq: Relq);
+	private tableName?;
+	private schemaKey?;
+	constructor(builder: DeleteBuilder, relq: Relq, tableName?: string | undefined, schemaKey?: string | undefined);
+	/**
+	 * Set up column resolver to transform property names to SQL column names.
+	 * Uses schema metadata ($columnName) to resolve column names.
+	 * @internal
+	 */
+	private setupColumnResolver;
 	where(callback: (builder: TypedWhereCondition<TTable>) => any): this;
 	/**
 	 * Get SQL string (always available)
@@ -6579,17 +6646,35 @@ declare class ConnectedDeleteBuilder<TTable = any> {
 	/**
 	 * Set RETURNING clause - returns executor with typed run()
 	 * Use '*' to return all columns, or specify column names
+	 * Pass null to skip RETURNING clause (useful for conditional returning)
 	 */
-	returning<K extends string & ColumnName<TTable>>(columns: "*" | K | K[]): ReturningExecutor<Pick<TTable extends {
+	returning(columns: null): this;
+	returning(columns: "*"): ReturningExecutor<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable>;
+	returning<K extends string & ColumnName<TTable>>(columns: K | K[]): ReturningExecutor<Prettify<Pick<TTable extends {
 		$inferSelect: infer S;
 	} ? S : TTable, K & keyof (TTable extends {
 		$inferSelect: infer S;
-	} ? S : TTable)>>;
+	} ? S : TTable)>>>;
+	returning<K extends string & ColumnName<TTable>>(columns: K[] | null): this | ReturningExecutor<Prettify<Pick<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable, K & keyof (TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable)>>>;
 }
 declare class ConnectedInsertBuilder<TTable = any> {
 	private builder;
 	private relq;
-	constructor(builder: InsertBuilder, relq: Relq);
+	private tableName?;
+	private schemaKey?;
+	constructor(builder: InsertBuilder, relq: Relq, tableName?: string | undefined, schemaKey?: string | undefined);
+	/**
+	 * Set up column resolver to transform property names to SQL column names.
+	 * Uses schema metadata ($columnName) to resolve column names.
+	 * @internal
+	 */
+	private setupColumnResolver;
 	addRow(row: InsertData<TTable>): this;
 	addRows(rows: InsertData<TTable>[]): this;
 	clear(): this;
@@ -6623,17 +6708,35 @@ declare class ConnectedInsertBuilder<TTable = any> {
 	/**
 	 * Set RETURNING clause - returns executor with typed run()
 	 * Use '*' to return all columns, or specify column names
+	 * Pass null to skip RETURNING clause (useful for conditional returning)
 	 */
-	returning<K extends string & ColumnName<TTable>>(columns: "*" | K | K[]): ReturningExecutor<Pick<TTable extends {
+	returning(columns: null): this;
+	returning(columns: "*"): ReturningExecutor<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable>;
+	returning<K extends string & ColumnName<TTable>>(columns: K | K[]): ReturningExecutor<Prettify<Pick<TTable extends {
 		$inferSelect: infer S;
 	} ? S : TTable, K & keyof (TTable extends {
 		$inferSelect: infer S;
-	} ? S : TTable)>>;
+	} ? S : TTable)>>>;
+	returning<K extends string & ColumnName<TTable>>(columns: K[] | null): this | ReturningExecutor<Prettify<Pick<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable, K & keyof (TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable)>>>;
 }
 declare class ConnectedUpdateBuilder<TTable = any> {
 	private builder;
 	private relq;
-	constructor(builder: UpdateBuilder, relq: Relq);
+	private tableName?;
+	private schemaKey?;
+	constructor(builder: UpdateBuilder, relq: Relq, tableName?: string | undefined, schemaKey?: string | undefined);
+	/**
+	 * Set up column resolver to transform property names to SQL column names.
+	 * Uses schema metadata ($columnName) to resolve column names.
+	 * @internal
+	 */
+	private setupColumnResolver;
 	where(callback: (builder: TypedWhereCondition<TTable>) => any): this;
 	/**
 	 * Get SQL string (always available)
@@ -6648,12 +6751,22 @@ declare class ConnectedUpdateBuilder<TTable = any> {
 	/**
 	 * Set RETURNING clause - returns executor with typed run()
 	 * Use '*' to return all columns, or specify column names
+	 * Pass null to skip RETURNING clause (useful for conditional returning)
 	 */
-	returning<K extends string & ColumnName<TTable>>(columns: "*" | K | K[]): ReturningExecutor<Pick<TTable extends {
+	returning(columns: null): this;
+	returning(columns: "*"): ReturningExecutor<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable>;
+	returning<K extends string & ColumnName<TTable>>(columns: K | K[]): ReturningExecutor<Prettify<Pick<TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable, K & keyof (TTable extends {
+		$inferSelect: infer S;
+	} ? S : TTable)>>>;
+	returning<K extends string & ColumnName<TTable>>(columns: K[] | null): this | ReturningExecutor<Prettify<Pick<TTable extends {
 		$inferSelect: infer S;
 	} ? S : TTable, K & keyof (TTable extends {
 		$inferSelect: infer S;
-	} ? S : TTable)>>;
+	} ? S : TTable)>>>;
 }
 declare class PaginateBuilder<TSchema, TTable, T> {
 	private relq;

package/dist/schema-builder.d.ts

@@ -2779,9 +2779,10 @@ export type Simplify<T> = {
 	[K in keyof T]: T[K];
 } & {};
 /**
- * Clean a column type by removing DefaultValue union members
+ * Clean a column type by removing DefaultValue union members and symbols
+ * (symbols like EMPTY_OBJECT/EMPTY_ARRAY can leak into type inference from $default)
  */
-export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue)>;
+export type CleanType<T> = Exclude<T, DefaultValue | (object & DefaultValue) | symbol>;
 /**
  * Build SELECT type with smart required/optional:
  * - Required: NOT NULL, PRIMARY KEY, has DEFAULT/GENERATED columns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",