relq 1.0.80 → 1.0.82

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

@@ -34,6 +34,19 @@ class ConnectedInsertBuilder {
             }
             return column;
         });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
     }
     addRow(row) {
         this.builder.addRow(row);

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

@@ -33,6 +33,19 @@ class ConnectedUpdateBuilder {
             }
             return column;
         });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
     }
     where(callback) {
         this.builder.where(callback);

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

@@ -20,6 +20,7 @@ class InsertBuilder {
     _convertCase = '2snake';
     originalColumns;
     columnResolver;
+    columnTypeResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         const normalized = this.normalizeData(data);
@@ -37,6 +38,10 @@ class InsertBuilder {
         this.columnResolver = resolver;
         return this;
     }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
     resolveColumnName(name) {
         if (this.columnResolver) {
             return this.columnResolver(name);
@@ -151,19 +156,55 @@ class InsertBuilder {
             return (0, case_converter_1.convertCase)(name, this._convertCase);
         return name;
     }
-    formatArrayValue(value) {
+    formatPostgresArray(value, baseType = 'jsonb') {
         if (value.length === 0)
-            return 'ARRAY[]::jsonb[]';
-        const jsonValues = value.map(v => (0, pg_format_1.default)('%L', JSON.stringify(v))).join(',');
-        return `ARRAY[${jsonValues}]::jsonb[]`;
+            return `ARRAY[]::${baseType}[]`;
+        if (baseType === 'jsonb') {
+            const jsonValues = value.map(v => (0, pg_format_1.default)('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::jsonb[]`;
+        }
+        else if (baseType === 'text' || baseType === 'varchar') {
+            const textValues = value.map(v => (0, pg_format_1.default)('%L', String(v))).join(',');
+            return `ARRAY[${textValues}]::text[]`;
+        }
+        else if (baseType === 'integer' || baseType === 'int4' || baseType === 'bigint' || baseType === 'int8') {
+            return `ARRAY[${value.join(',')}]::${baseType}[]`;
+        }
+        else {
+            const jsonValues = value.map(v => (0, pg_format_1.default)('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::${baseType}[]`;
+        }
+    }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
     }
     processRowValues(row, originalColumns) {
         const processedValues = [];
         const placeholderTypes = [];
         for (const colName of originalColumns) {
             const value = row[colName];
-            if (Array.isArray(value)) {
-                processedValues.push(this.formatArrayValue(value));
+            if (Array.isArray(value) || (value !== null && typeof value === 'object' && !(value instanceof Date))) {
+                const typeInfo = this.columnTypeResolver?.(colName);
+                if (typeInfo) {
+                    if (Array.isArray(value)) {
+                        if (typeInfo.isArray) {
+                            processedValues.push(this.formatPostgresArray(value, typeInfo.type));
+                        }
+                        else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                        else {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                    }
+                    else {
+                        processedValues.push(this.formatJsonbValue(value));
+                    }
+                }
+                else {
+                    processedValues.push(this.formatJsonbValue(value));
+                }
                 placeholderTypes.push('%s');
             }
             else {

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

@@ -19,6 +19,7 @@ class UpdateBuilder {
     _case = 'keep-case';
     _convertCase = '2snake';
     columnResolver;
+    columnTypeResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.updateData = this.normalizeData(data);
@@ -34,6 +35,10 @@ class UpdateBuilder {
         this.columnResolver = resolver;
         return this;
     }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
     resolveColumnName(name) {
         if (this.columnResolver) {
             return this.columnResolver(name);
@@ -127,7 +132,7 @@ class UpdateBuilder {
             return (0, case_converter_1.convertCase)(name, this._convertCase);
         return name;
     }
-    formatArrayValue(value) {
+    formatPostgresArray(value) {
         if (value.length === 0)
             return 'ARRAY[]';
         const firstElement = value[0];
@@ -154,6 +159,25 @@ class UpdateBuilder {
         const stringValues = value.map(v => (0, pg_format_1.default)('%L', v)).join(',');
         return `ARRAY[${stringValues}]`;
     }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
+    }
+    formatArrayValueWithType(colName, value) {
+        const typeInfo = this.columnTypeResolver?.(colName);
+        if (typeInfo) {
+            if (typeInfo.isArray) {
+                return this.formatPostgresArray(value);
+            }
+            else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                return this.formatJsonbValue(value);
+            }
+            else {
+                return this.formatJsonbValue(value);
+            }
+        }
+        return this.formatJsonbValue(value);
+    }
     toString() {
         const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
             const convertedCol = this.resolveColumnName(col);
@@ -167,7 +191,10 @@ class UpdateBuilder {
                 return (0, pg_format_1.default)('%I = %s', convertedCol, finalResult);
             }
             if (Array.isArray(val)) {
-                return (0, pg_format_1.default)('%I = %s', convertedCol, this.formatArrayValue(val));
+                return (0, pg_format_1.default)('%I = %s', convertedCol, this.formatArrayValueWithType(col, val));
+            }
+            if (val !== null && typeof val === 'object' && !(val instanceof Date)) {
+                return (0, pg_format_1.default)('%I = %s', convertedCol, this.formatJsonbValue(val));
             }
             return (0, pg_format_1.default)('%I = %L', convertedCol, val);
         });

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

@@ -31,6 +31,19 @@ export class ConnectedInsertBuilder {
             }
             return column;
         });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
     }
     addRow(row) {
         this.builder.addRow(row);

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

@@ -30,6 +30,19 @@ export class ConnectedUpdateBuilder {
             }
             return column;
         });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
     }
     where(callback) {
         this.builder.where(callback);

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

@@ -14,6 +14,7 @@ export class InsertBuilder {
     _convertCase = '2snake';
     originalColumns;
     columnResolver;
+    columnTypeResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         const normalized = this.normalizeData(data);
@@ -31,6 +32,10 @@ export class InsertBuilder {
         this.columnResolver = resolver;
         return this;
     }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
     resolveColumnName(name) {
         if (this.columnResolver) {
             return this.columnResolver(name);
@@ -145,19 +150,55 @@ export class InsertBuilder {
             return convertCase(name, this._convertCase);
         return name;
     }
-    formatArrayValue(value) {
+    formatPostgresArray(value, baseType = 'jsonb') {
         if (value.length === 0)
-            return 'ARRAY[]::jsonb[]';
-        const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
-        return `ARRAY[${jsonValues}]::jsonb[]`;
+            return `ARRAY[]::${baseType}[]`;
+        if (baseType === 'jsonb') {
+            const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::jsonb[]`;
+        }
+        else if (baseType === 'text' || baseType === 'varchar') {
+            const textValues = value.map(v => format('%L', String(v))).join(',');
+            return `ARRAY[${textValues}]::text[]`;
+        }
+        else if (baseType === 'integer' || baseType === 'int4' || baseType === 'bigint' || baseType === 'int8') {
+            return `ARRAY[${value.join(',')}]::${baseType}[]`;
+        }
+        else {
+            const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::${baseType}[]`;
+        }
+    }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
     }
     processRowValues(row, originalColumns) {
         const processedValues = [];
         const placeholderTypes = [];
         for (const colName of originalColumns) {
             const value = row[colName];
-            if (Array.isArray(value)) {
-                processedValues.push(this.formatArrayValue(value));
+            if (Array.isArray(value) || (value !== null && typeof value === 'object' && !(value instanceof Date))) {
+                const typeInfo = this.columnTypeResolver?.(colName);
+                if (typeInfo) {
+                    if (Array.isArray(value)) {
+                        if (typeInfo.isArray) {
+                            processedValues.push(this.formatPostgresArray(value, typeInfo.type));
+                        }
+                        else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                        else {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                    }
+                    else {
+                        processedValues.push(this.formatJsonbValue(value));
+                    }
+                }
+                else {
+                    processedValues.push(this.formatJsonbValue(value));
+                }
                 placeholderTypes.push('%s');
             }
             else {

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

@@ -13,6 +13,7 @@ export class UpdateBuilder {
     _case = 'keep-case';
     _convertCase = '2snake';
     columnResolver;
+    columnTypeResolver;
     constructor(tableName, data) {
         this.tableName = tableName;
         this.updateData = this.normalizeData(data);
@@ -28,6 +29,10 @@ export class UpdateBuilder {
         this.columnResolver = resolver;
         return this;
     }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
     resolveColumnName(name) {
         if (this.columnResolver) {
             return this.columnResolver(name);
@@ -121,7 +126,7 @@ export class UpdateBuilder {
             return convertCase(name, this._convertCase);
         return name;
     }
-    formatArrayValue(value) {
+    formatPostgresArray(value) {
         if (value.length === 0)
             return 'ARRAY[]';
         const firstElement = value[0];
@@ -148,6 +153,25 @@ export class UpdateBuilder {
         const stringValues = value.map(v => format('%L', v)).join(',');
         return `ARRAY[${stringValues}]`;
     }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
+    }
+    formatArrayValueWithType(colName, value) {
+        const typeInfo = this.columnTypeResolver?.(colName);
+        if (typeInfo) {
+            if (typeInfo.isArray) {
+                return this.formatPostgresArray(value);
+            }
+            else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                return this.formatJsonbValue(value);
+            }
+            else {
+                return this.formatJsonbValue(value);
+            }
+        }
+        return this.formatJsonbValue(value);
+    }
     toString() {
         const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
             const convertedCol = this.resolveColumnName(col);
@@ -161,7 +185,10 @@ export class UpdateBuilder {
                 return format('%I = %s', convertedCol, finalResult);
             }
             if (Array.isArray(val)) {
-                return format('%I = %s', convertedCol, this.formatArrayValue(val));
+                return format('%I = %s', convertedCol, this.formatArrayValueWithType(col, val));
+            }
+            if (val !== null && typeof val === 'object' && !(val instanceof Date)) {
+                return format('%I = %s', convertedCol, this.formatJsonbValue(val));
             }
             return format('%I = %L', convertedCol, val);
         });

package/dist/index.d.ts

@@ -2358,6 +2358,15 @@ export type UpdateCallback = (builder: UpdateOperationsBuilder) => string;
  * Update value can be a direct value or a callback for array/jsonb operations
  */
 export type UpdateValue = QueryValue | UpdateCallback;
+/**
+ * Column type info returned by the type resolver
+ */
+export interface ColumnTypeInfo {
+	/** Base PostgreSQL type (e.g., 'jsonb', 'text', 'integer') */
+	type: string;
+	/** Whether this is a PostgreSQL array type (text[], jsonb[], etc.) */
+	isArray: boolean;
+}
 export declare class UpdateBuilder {
 	tableName: string;
 	updateData: Record<string, UpdateValue>;
@@ -2366,6 +2375,7 @@ export declare class UpdateBuilder {
 	private _case;
 	private _convertCase;
 	private columnResolver?;
+	private columnTypeResolver?;
 	constructor(tableName: string, data: Record<string, UpdateValue>);
 	/**
 	 * Normalize data by converting undefined values to null.
@@ -2379,6 +2389,12 @@ export declare class UpdateBuilder {
 	 * @internal Used by ConnectedUpdateBuilder for schema-aware column name mapping.
 	 */
 	setColumnResolver(resolver: (column: string) => string): UpdateBuilder;
+	/**
+	 * Set a column type resolver to get type info for proper value formatting.
+	 * This allows distinguishing between jsonb (single value) vs jsonb[] (PostgreSQL array).
+	 * @internal Used by ConnectedUpdateBuilder for schema-aware value serialization.
+	 */
+	setColumnTypeResolver(resolver: (column: string) => ColumnTypeInfo | undefined): UpdateBuilder;
 	/**
 	 * Resolve a column name using the column resolver or fallback to convertColumnName.
 	 * @internal
@@ -2475,10 +2491,20 @@ export declare class UpdateBuilder {
 	returningCount(callback: (builder: CountBuilder) => CountBuilder | null): UpdateBuilder;
 	private convertColumnName;
 	/**
-	 * Format array value with automatic type detection
-	 * Uses array.every() to verify homogeneous arrays
+	 * Format a JavaScript array as a PostgreSQL array literal.
+	 * Used for actual PostgreSQL array columns (text[], integer[], jsonb[], etc.)
+	 */
+	private formatPostgresArray;
+	/**
+	 * Format a JavaScript value as a single JSONB value.
+	 * Used for jsonb columns that contain arrays or objects.
+	 */
+	private formatJsonbValue;
+	/**
+	 * Format an array value using schema type info.
+	 * Schema is required for proper handling - defaults to JSONB if no schema.
 	 */
-	private formatArrayValue;
+	private formatArrayValueWithType;
 	toString(): string;
 	/**
 	 * Parse COUNT columns from SELECT clause
@@ -2910,6 +2936,12 @@ declare class ConflictBuilder<TTable = any> {
 	get whereClause(): string | undefined;
 	get tableName(): string;
 }
+interface ColumnTypeInfo$1 {
+	/** Base PostgreSQL type (e.g., 'jsonb', 'text', 'integer') */
+	type: string;
+	/** Whether this is a PostgreSQL array type (text[], jsonb[], etc.) */
+	isArray: boolean;
+}
 export declare class InsertBuilder {
 	tableName: string;
 	insertData: Record<string, QueryValue>[];
@@ -2920,6 +2952,7 @@ export declare class InsertBuilder {
 	private _convertCase;
 	private originalColumns;
 	private columnResolver?;
+	private columnTypeResolver?;
 	constructor(tableName: string, data: Record<string, QueryValue>);
 	/**
 	 * Normalize data by converting undefined values to null.
@@ -2933,6 +2966,12 @@ export declare class InsertBuilder {
 	 * @internal Used by ConnectedInsertBuilder for schema-aware column name mapping.
 	 */
 	setColumnResolver(resolver: (column: string) => string): InsertBuilder;
+	/**
+	 * Set a column type resolver to get type info for proper value formatting.
+	 * This allows distinguishing between jsonb (single value) vs jsonb[] (PostgreSQL array).
+	 * @internal Used by ConnectedInsertBuilder for schema-aware value serialization.
+	 */
+	setColumnTypeResolver(resolver: (column: string) => ColumnTypeInfo$1 | undefined): InsertBuilder;
 	/**
 	 * Resolve a column name using the column resolver or fallback to convertColumnName.
 	 * @internal
@@ -2971,7 +3010,16 @@ export declare class InsertBuilder {
 	 */
 	returningCount(callback: (builder: CountBuilder) => CountBuilder | null): InsertBuilder;
 	private convertColumnName;
-	private formatArrayValue;
+	/**
+	 * Format a JavaScript array as a PostgreSQL array literal.
+	 * Used for actual PostgreSQL array columns (text[], integer[], jsonb[], etc.)
+	 */
+	private formatPostgresArray;
+	/**
+	 * Format a JavaScript value as a single JSONB value.
+	 * Used for jsonb columns that contain arrays or objects.
+	 */
+	private formatJsonbValue;
 	private processRowValues;
 	private buildConflictClause;
 	toString(): string;

package/package.json

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