relq 1.0.38 → 1.0.40

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

@@ -26,6 +26,9 @@ 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);
     }

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

@@ -49,6 +49,9 @@ 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);
     }

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

@@ -28,6 +28,22 @@ class ConnectedSelectBuilder {
         this.tableName = tableName;
         this.columns = columns;
         this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        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.$sqlName || columnDef.$name || camelToSnake(column);
+            }
+            return camelToSnake(column);
+        });
     }
     where(callback) {
         this.builder.where(callback);

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

@@ -27,6 +27,9 @@ 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);
     }

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

@@ -21,12 +21,47 @@ class SelectBuilder {
     distinctOnColumns = [];
     lockingClause;
     unionQueries = [];
+    columnResolver;
     constructor(tableName, columns) {
         this.tableName = tableName;
         if (columns) {
             this.selectColumns = Array.isArray(columns) ? columns : [columns];
         }
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column) {
+                return cond;
+            }
+            if (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)
+            };
+        });
+    }
     setTableAlias(alias) {
         this.tableAlias = alias;
         return this;
@@ -273,18 +308,20 @@ class SelectBuilder {
             query += ' ' + structuredJoinSQL;
         }
         if (this.whereConditions.length > 0) {
-            const conditions = hasJoins
-                ? this.qualifyWhereConditions(this.whereConditions, tableRef)
-                : this.whereConditions;
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
             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(', ');
         }
         if (this.havingConditions.length > 0) {
-            const havingConds = hasJoins
-                ? this.qualifyWhereConditions(this.havingConditions, tableRef)
-                : this.havingConditions;
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
             query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(havingConds);
         }
         if (this.orderByColumns.length > 0) {
@@ -336,18 +373,20 @@ class SelectBuilder {
             query += ' ' + structuredJoinSQL;
         }
         if (this.whereConditions.length > 0) {
-            const conditions = hasJoins
-                ? this.qualifyWhereConditions(this.whereConditions, tableRef)
-                : this.whereConditions;
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
             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(', ');
         }
         if (this.havingConditions.length > 0) {
-            const havingConds = hasJoins
-                ? this.qualifyWhereConditions(this.havingConditions, tableRef)
-                : this.havingConditions;
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
             query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(havingConds);
         }
         return query;

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

@@ -23,6 +23,9 @@ 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);
     }

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

@@ -46,6 +46,9 @@ 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);
     }

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

@@ -22,6 +22,22 @@ export class ConnectedSelectBuilder {
         this.tableName = tableName;
         this.columns = columns;
         this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        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.$sqlName || columnDef.$name || camelToSnake(column);
+            }
+            return camelToSnake(column);
+        });
     }
     where(callback) {
         this.builder.where(callback);

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

@@ -24,6 +24,9 @@ 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);
     }

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

@@ -15,12 +15,47 @@ export class SelectBuilder {
     distinctOnColumns = [];
     lockingClause;
     unionQueries = [];
+    columnResolver;
     constructor(tableName, columns) {
         this.tableName = tableName;
         if (columns) {
             this.selectColumns = Array.isArray(columns) ? columns : [columns];
         }
     }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column) {
+                return cond;
+            }
+            if (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)
+            };
+        });
+    }
     setTableAlias(alias) {
         this.tableAlias = alias;
         return this;
@@ -267,18 +302,20 @@ export class SelectBuilder {
             query += ' ' + structuredJoinSQL;
         }
         if (this.whereConditions.length > 0) {
-            const conditions = hasJoins
-                ? this.qualifyWhereConditions(this.whereConditions, tableRef)
-                : this.whereConditions;
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
             query += ' WHERE ' + buildConditionsSQL(conditions);
         }
         if (this.groupByColumns.length > 0) {
             query += ' GROUP BY ' + this.groupByColumns.map(col => format.ident(col)).join(', ');
         }
         if (this.havingConditions.length > 0) {
-            const havingConds = hasJoins
-                ? this.qualifyWhereConditions(this.havingConditions, tableRef)
-                : this.havingConditions;
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
             query += ' HAVING ' + buildConditionsSQL(havingConds);
         }
         if (this.orderByColumns.length > 0) {
@@ -330,18 +367,20 @@ export class SelectBuilder {
             query += ' ' + structuredJoinSQL;
         }
         if (this.whereConditions.length > 0) {
-            const conditions = hasJoins
-                ? this.qualifyWhereConditions(this.whereConditions, tableRef)
-                : this.whereConditions;
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
             query += ' WHERE ' + buildConditionsSQL(conditions);
         }
         if (this.groupByColumns.length > 0) {
             query += ' GROUP BY ' + this.groupByColumns.map(col => format.ident(col)).join(', ');
         }
         if (this.havingConditions.length > 0) {
-            const havingConds = hasJoins
-                ? this.qualifyWhereConditions(this.havingConditions, tableRef)
-                : this.havingConditions;
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
             query += ' HAVING ' + buildConditionsSQL(havingConds);
         }
         return query;

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
@@ -1330,10 +1331,23 @@ export declare class SelectBuilder {
 	private distinctOnColumns;
 	private lockingClause?;
 	private unionQueries;
+	private columnResolver?;
 	constructor(tableName: string, columns?: string | Array<string | [
 		string,
 		string
 	]>);
+	/**
+	 * Set a column resolver to transform column names (e.g., camelCase to snake_case).
+	 * Used by ConnectedSelectBuilder to map TypeScript property names to SQL column names.
+	 * @internal
+	 */
+	setColumnResolver(resolver: (column: string) => string): SelectBuilder;
+	/**
+	 * Transform column names in conditions using the column resolver.
+	 * Recursively handles nested or/and conditions.
+	 * @internal
+	 */
+	private transformConditionColumns;
 	/**
 	 * Set an alias for the main table.
 	 * @internal Used by ConnectedSelectBuilder for self-joins
@@ -6038,6 +6052,9 @@ export interface JoinManyInternals extends JoinConditionInternals {
 	toWhereSQL(): string;
 	getInnerJoins(): InnerJoinSpec[];
 }
+type Prettify$1<T> = {
+	[K in keyof T]: T[K];
+} & {};
 /**
  * Extract only actual column names from a table type
  * Uses $inferSelect if available (Drizzle tables), otherwise keyof
@@ -6048,10 +6065,11 @@ export type ColumnKeys<T> = T extends {
 /**
  * Pick columns from a table's row type
  * Handles both table definitions (with $inferSelect) and plain interfaces
+ * Uses Prettify to flatten the type for better IDE display
  */
 export type PickColumns<T, K extends string> = T extends {
 	$inferSelect: infer TSelect;
-} ? Pick<TSelect, K & keyof TSelect> : Pick<T, K & keyof T>;
+} ? Prettify$1<Pick<TSelect, K & keyof TSelect>> : Prettify$1<Pick<T, K & keyof T>>;
 type ColumnValue$1<T, K extends ColumnKeys<T>> = T extends {
 	$inferSelect: infer TSelect;
 } ? K extends keyof TSelect ? TSelect[K] : unknown : K extends keyof T ? T[K] : unknown;
@@ -6562,12 +6580,22 @@ 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)>>>;
+	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 ConnectedInsertBuilder<TTable = any> {
 	private builder;
@@ -6606,12 +6634,22 @@ 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)>>>;
+	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 ConnectedUpdateBuilder<TTable = any> {
 	private builder;
@@ -6631,12 +6669,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;
@@ -7101,7 +7149,7 @@ export type TableAccessor<TSchema, TRelq> = {
 } & {
 	[K in keyof TSchema & string]: ConnectedQueryBuilder<TSchema, TSchema[K]>;
 };
-type Prettify$1<T> = {
+type Prettify$2<T> = {
 	[K in keyof T]: T[K];
 } & {};
 /**
@@ -7109,9 +7157,9 @@ type Prettify$1<T> = {
  */
 export type InferRowType<TTable> = TTable extends {
 	$inferSelect: infer TSelect;
-} ? Prettify$1<TSelect> : TTable extends {
+} ? Prettify$2<TSelect> : TTable extends {
 	$columns: infer TCols;
-} ? Prettify$1<{
+} ? Prettify$2<{
 	[K in keyof TCols]: any;
 }> : TTable;
 /**
@@ -7146,6 +7194,12 @@ declare class ConnectedSelectBuilder<TSchema = any, TTable = any, TColumns exten
 	]>) | undefined, 
 	/** Schema key (camelCase) - used for join callback params */
 	schemaKey?: string | undefined);
+	/**
+	 * Set up column resolver to transform property names to SQL column names.
+	 * Uses schema metadata to resolve column names.
+	 * @internal
+	 */
+	private setupColumnResolver;
 	where(callback: (q: TypedConditionBuilder<TTable>) => TypedConditionBuilder<TTable>): this;
 	orderBy(column: ColumnName<TTable>, direction?: "ASC" | "DESC"): this;
 	limit(count: number): this;
@@ -7430,13 +7484,13 @@ declare class ConnectedSelectBuilder<TSchema = any, TTable = any, TColumns exten
 	 * @param withMetadata - If true, returns { data, metadata }
 	 * @param asRequired - If true, all fields are required (removes optional)
 	 */
-	all(): Promise<Prettify$1<InferResultType<TSchema, TTable, TColumns> & TJoined>[]>;
+	all(): Promise<Prettify$2<InferResultType<TSchema, TTable, TColumns> & TJoined>[]>;
 	all(withMetadata: true): Promise<{
-		data: Prettify$1<InferResultType<TSchema, TTable, TColumns> & TJoined>[];
+		data: Prettify$2<InferResultType<TSchema, TTable, TColumns> & TJoined>[];
 		metadata: RelqMetadata;
 	}>;
 	all<R extends boolean>(withMetadata: true, asRequired: R): Promise<{
-		data: Prettify$1<R extends true ? Required<InferResultType<TSchema, TTable, TColumns> & TJoined> : InferResultType<TSchema, TTable, TColumns> & TJoined>[];
+		data: Prettify$2<R extends true ? Required<InferResultType<TSchema, TTable, TColumns> & TJoined> : InferResultType<TSchema, TTable, TColumns> & TJoined>[];
 		metadata: RelqMetadata;
 	}>;
 	/**
@@ -7445,13 +7499,13 @@ declare class ConnectedSelectBuilder<TSchema = any, TTable = any, TColumns exten
 	 * @param withMetadata - If true, returns { data, metadata }
 	 * @param asRequired - If true, all fields are required (removes optional)
 	 */
-	get(): Promise<Prettify$1<InferResultType<TSchema, TTable, TColumns> & TJoined> | null>;
+	get(): Promise<Prettify$2<InferResultType<TSchema, TTable, TColumns> & TJoined> | null>;
 	get(withMetadata: true): Promise<{
-		data: Prettify$1<InferResultType<TSchema, TTable, TColumns> & TJoined> | null;
+		data: Prettify$2<InferResultType<TSchema, TTable, TColumns> & TJoined> | null;
 		metadata: RelqMetadata;
 	}>;
 	get<R extends boolean>(withMetadata: true, asRequired: R): Promise<{
-		data: Prettify$1<R extends true ? Required<InferResultType<TSchema, TTable, TColumns> & TJoined> : InferResultType<TSchema, TTable, TColumns> & TJoined> | null;
+		data: Prettify$2<R extends true ? Required<InferResultType<TSchema, TTable, TColumns> & TJoined> : InferResultType<TSchema, TTable, TColumns> & TJoined> | null;
 		metadata: RelqMetadata;
 	}>;
 	/**

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.38",
+  "version": "1.0.40",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",