drizzle-orm 1.0.0-beta.21 → 1.0.0-beta.21-4fa69ab

package/pg-core/dialect.js

@@ -1,27 +1,37 @@
+import { resolvePgType } from "./codecs.js";
 import { PgViewBase } from "./view-base.js";
 import { entityKind, is } from "../entity.js";
 import { Subquery } from "../subquery.js";
 import { ViewBaseConfig } from "../view-common.js";
-import { Table, TableColumns, getTableName, getTableUniqueName } from "../table.js";
+import { Table, TableColumns, getTableName } from "../table.js";
 import { Column } from "../column.js";
-import { orderSelectedFields } from "../utils.js";
+import { makeDefaultQueryMapper, makeJitQueryMapper, orderSelectedFields } from "../utils.js";
+import { CodecsCollection } from "../codecs.js";
 import { Param, SQL, sql } from "../sql/sql.js";
-import * as V1 from "../_relations.js";
 import { DrizzleError } from "../errors.js";
-import { One, getTableAsAliasSQL, relationExtrasToSQL, relationToSQL, relationsFilterToSQL, relationsOrderToSQL } from "../relations.js";
-import { aliasedTable, aliasedTableColumn, getOriginalColumnFromAlias, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from "../alias.js";
+import { One, getTableAsAliasSQL, makeDefaultRqbMapper, makeJitRqbMapper, relationExtrasToSQL, relationToSQL, relationsFilterToSQL, relationsOrderToSQL } from "../relations.js";
+import { aliasedTable, getOriginalColumnFromAlias } from "../alias.js";
 import { CasingCache } from "../casing.js";
-import { View as View$1, and, eq, isSQLWrapper as isSQLWrapper$1 } from "../sql/index.js";
+import { View as View$1, and, isSQLWrapper as isSQLWrapper$1 } from "../sql/index.js";
 import { PgTable } from "./table.js";
 import { PgColumn, PgDate, PgDateString, PgJson, PgJsonb, PgNumeric, PgTime, PgTimestamp, PgTimestampString, PgUUID } from "./columns/index.js";
 
 //#region src/pg-core/dialect.ts
 var PgDialect = class {
 	static [entityKind] = "PgDialect";
-	/** @internal */
 	casing;
+	codecs;
+	mapperGenerators;
 	constructor(config) {
-		this.casing = new CasingCache(config?.casing);
+		this.casing = typeof config?.casing === "object" ? config.casing : new CasingCache(config?.casing);
+		this.codecs = new CodecsCollection(resolvePgType, config?.codecs);
+		this.mapperGenerators = config?.useJitMappers ? {
+			rows: makeJitQueryMapper,
+			relationalRows: makeJitRqbMapper
+		} : {
+			rows: makeDefaultQueryMapper,
+			relationalRows: makeDefaultRqbMapper
+		};
 	}
 	escapeName(name) {
 		return `"${name.replace(/"/g, "\"\"")}"`;
@@ -42,9 +52,12 @@ var PgDialect = class {
 		withSqlChunks.push(sql` `);
 		return sql.join(withSqlChunks);
 	}
-	buildDeleteQuery({ table, where, returning, withList, comment }) {
+	buildDeleteQuery({ table, where, returning, withList, comment, ignoreSelectionCastCodecs }) {
 		const withSql = this.buildWithCTE(withList);
-		const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
+		const returningSql = returning ? sql` returning ${this.buildSelection(returning, {
+			isSingleTable: true,
+			ignoreCastCodecs: ignoreSelectionCastCodecs
+		})}` : void 0;
 		return sql`${withSql}delete from ${table}${where ? sql` where ${where}` : void 0}${returningSql}${comment !== void 0 ? sql` ${comment}` : void 0}`;
 	}
 	buildUpdateSet(table, set) {
@@ -60,7 +73,7 @@ var PgDialect = class {
 			return [res];
 		}));
 	}
-	buildUpdateQuery({ table, set, where, returning, withList, from, joins, comment }) {
+	buildUpdateQuery({ table, set, where, returning, withList, from, joins, comment, ignoreSelectionCastCodecs }) {
 		const withSql = this.buildWithCTE(withList);
 		const tableName = table[PgTable.Symbol.Name];
 		const tableSchema = table[PgTable.Symbol.Schema];
@@ -70,7 +83,10 @@ var PgDialect = class {
 		const setSql = this.buildUpdateSet(table, set);
 		const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
 		const joinsSql = this.buildJoins(joins);
-		const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}` : void 0;
+		const returningSql = returning ? sql` returning ${this.buildSelection(returning, {
+			isSingleTable: !from,
+			ignoreCastCodecs: ignoreSelectionCastCodecs
+		})}` : void 0;
 		return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${where ? sql` where ${where}` : void 0}${returningSql}${comment !== void 0 ? sql` ${comment}` : void 0}`;
 	}
 	/**
@@ -84,7 +100,7 @@ var PgDialect = class {
 	*
 	* If `isSingleTable` is true, then columns won't be prefixed with table name
 	*/
-	buildSelection(fields, { isSingleTable = false } = {}) {
+	buildSelection(fields, { isSingleTable = false, ignoreCastCodecs = false } = {}) {
 		const columnsLen = fields.length;
 		const chunks = fields.flatMap(({ field }, i) => {
 			const chunk = [];
@@ -101,9 +117,13 @@ var PgDialect = class {
 					chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
 				} else chunk.push(query);
 				if (is(field, SQL.Aliased)) chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-			} else if (is(field, Column)) if (isSingleTable) chunk.push(field.isAlias ? sql`${sql.identifier(this.casing.getColumnCasing(getOriginalColumnFromAlias(field)))} as ${field}` : sql.identifier(this.casing.getColumnCasing(field)));
-			else chunk.push(field.isAlias ? sql`${getOriginalColumnFromAlias(field)} as ${field}` : field);
-			else if (is(field, Subquery)) {
+			} else if (is(field, Column)) {
+				let name;
+				if (isSingleTable) name = field.isAlias ? sql.identifier(this.casing.getColumnCasing(getOriginalColumnFromAlias(field))) : sql.identifier(this.casing.getColumnCasing(field));
+				else name = field.isAlias ? getOriginalColumnFromAlias(field) : field;
+				const casted = ignoreCastCodecs ? name : this.codecs.apply(field, "cast", name);
+				chunk.push(field.isAlias ? sql`${casted} as ${field}` : casted);
+			} else if (is(field, Subquery)) {
 				const entries = Object.entries(field._.selectedFields);
 				if (entries.length === 1) {
 					const entry = entries[0][1];
@@ -155,8 +175,8 @@ var PgDialect = class {
 		}
 		return table;
 	}
-	buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClause, distinct, setOperators, comment }) {
-		const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
+	buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClause, distinct, setOperators, comment, ignoreSelectionCastCodecs }) {
+		const fieldsList = fieldsFlat ?? orderSelectedFields(fields, void 0, this.codecs);
 		for (const f of fieldsList) if (is(f.field, Column) && getTableName(f.field.table) !== (is(table, Subquery) ? table._.alias : is(table, PgViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : getTableName(table)) && !((table) => joins?.some(({ alias }) => alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])))(f.field.table)) {
 			const tableName = getTableName(f.field.table);
 			throw new Error(`Your "${f.path.join("->")}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`);
@@ -165,7 +185,10 @@ var PgDialect = class {
 		const withSql = this.buildWithCTE(withList);
 		let distinctSql;
 		if (distinct) distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
-		const selection = this.buildSelection(fieldsList, { isSingleTable });
+		const selection = this.buildSelection(fieldsList, {
+			isSingleTable,
+			ignoreCastCodecs: ignoreSelectionCastCodecs
+		});
 		const tableSql = this.buildFromTable(table);
 		const joinsSql = this.buildJoins(joins);
 		const whereSql = where ? sql` where ${where}` : void 0;
@@ -221,7 +244,7 @@ var PgDialect = class {
 		const offsetSql = offset ? sql` offset ${offset}` : void 0;
 		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
-	buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_, comment }) {
+	buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_, comment, ignoreSelectionCastCodecs }) {
 		const valuesSqlList = [];
 		const columns = table[Table.Symbol.Columns];
 		const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
@@ -254,7 +277,10 @@ var PgDialect = class {
 		}
 		const withSql = this.buildWithCTE(withList);
 		const valuesSql = sql.join(valuesSqlList);
-		const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
+		const returningSql = returning ? sql` returning ${this.buildSelection(returning, {
+			isSingleTable: true,
+			ignoreCastCodecs: ignoreSelectionCastCodecs
+		})}` : void 0;
 		const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
 		return sql`${withSql}insert into ${table} ${insertOrder} ${overridingSystemValue_ === true ? sql`overriding system value ` : void 0}${valuesSql}${onConflictSql}${returningSql}${comment !== void 0 ? sql` ${comment}` : void 0}`;
 	}
@@ -277,224 +303,35 @@ var PgDialect = class {
 			escapeParam: this.escapeParam,
 			escapeString: this.escapeString,
 			prepareTyping: this.prepareTyping,
+			codecs: this.codecs,
 			invokeSource
 		});
 	}
-	/** @deprecated */
-	_buildRelationalQuery({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn }) {
-		let selection = [];
-		let limit, offset, orderBy = [], where;
-		const joins = [];
-		if (config === true) selection = Object.entries(tableConfig.columns).map(([key, value]) => ({
-			dbKey: value.name,
-			tsKey: key,
-			field: aliasedTableColumn(value, tableAlias),
-			relationTableTsKey: void 0,
-			isJson: false,
-			selection: []
-		}));
-		else {
-			const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
-			if (config.where) {
-				const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, V1.getOperators()) : config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
-			const fieldsSelection = [];
-			let selectedColumns = [];
-			if (config.columns) {
-				let isIncludeMode = false;
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === void 0) continue;
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) isIncludeMode = true;
-						selectedColumns.push(field);
-					}
-				}
-				if (selectedColumns.length > 0) selectedColumns = isIncludeMode ? selectedColumns.filter((c) => config.columns?.[c] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-			} else selectedColumns = Object.keys(tableConfig.columns);
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field];
-				fieldsSelection.push({
-					tsKey: field,
-					value: column
-				});
-			}
-			let selectedRelations = [];
-			if (config.with) selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({
-				tsKey,
-				queryConfig,
-				relation: tableConfig.relations[tsKey]
-			}));
-			let extras;
-			if (config.extras) {
-				extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) fieldsSelection.push({
-					tsKey,
-					value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
-				});
-			}
-			for (const { tsKey, value } of fieldsSelection) selection.push({
-				dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
-				tsKey,
-				field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-				relationTableTsKey: void 0,
-				isJson: false,
-				selection: []
-			});
-			let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, V1.getOrderByOperators()) : config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) orderByOrig = [orderByOrig];
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) return aliasedTableColumn(orderByValue, tableAlias);
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
-			limit = config.limit;
-			offset = config.offset;
-			for (const { tsKey: selectedRelationTsKey, queryConfig: selectedRelationConfigValue, relation } of selectedRelations) {
-				const normalizedRelation = V1.normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				const joinOn = and(...normalizedRelation.fields.map((field, i) => eq(aliasedTableColumn(normalizedRelation.references[i], relationTableAlias), aliasedTableColumn(field, tableAlias))));
-				const builtRelation = this._buildRelationalQuery({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName],
-					tableConfig: schema[relationTableTsName],
-					queryConfig: is(relation, V1.One) ? selectedRelationConfigValue === true ? { limit: 1 } : {
-						...selectedRelationConfigValue,
-						limit: 1
-					} : selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation
-				});
-				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier("data")}`.as(selectedRelationTsKey);
-				joins.push({
-					on: sql`true`,
-					table: new Subquery(builtRelation.sql, {}, relationTableAlias),
-					alias: relationTableAlias,
-					joinType: "left",
-					lateral: true
-				});
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection
-				});
-			}
-		}
-		if (selection.length === 0) throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
-		let result;
-		where = and(joinOn, where);
-		if (nestedQueryRelation) {
-			let field = sql`json_build_array(${sql.join(selection.map(({ field, tsKey, isJson }) => isJson ? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier("data")}` : is(field, SQL.Aliased) ? field.sql : field), sql`, `)})`;
-			if (is(nestedQueryRelation, V1.Many)) field = sql`coalesce(json_agg(${field}${orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : void 0}), '[]'::json)`;
-			const nestedSelection = [{
-				dbKey: "data",
-				tsKey: "data",
-				field: field.as("data"),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection
-			}];
-			if (limit !== void 0 || offset !== void 0 || orderBy.length > 0) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [{
-						path: [],
-						field: sql.raw("*")
-					}],
-					where,
-					limit,
-					offset,
-					orderBy,
-					setOperators: []
-				});
-				where = void 0;
-				limit = void 0;
-				offset = void 0;
-				orderBy = [];
-			} else result = aliasedTable(table, tableAlias);
-			result = this.buildSelectQuery({
-				table: is(result, PgTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: []
-			});
-		} else result = this.buildSelectQuery({
-			table: aliasedTable(table, tableAlias),
-			fields: {},
-			fieldsFlat: selection.map(({ field }) => ({
-				path: [],
-				field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
-			})),
-			joins,
-			where,
-			limit,
-			offset,
-			orderBy,
-			setOperators: []
-		});
-		if (config !== true && config.comment) {
-			const comment = sql.comment(config.comment);
-			result = comment ? sql`${result} ${comment}` : result;
-		}
-		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
-			selection
-		};
-	}
 	nestedSelectionerror() {
 		throw new DrizzleError({ message: `Views with nested selections are not supported by the relational query builder` });
 	}
-	buildRqbColumn(table, column, key) {
+	buildRqbColumn(table, column, key, inJson) {
 		if (is(column, Column)) {
 			const name = sql`${table}.${sql.identifier(this.casing.getColumnCasing(column))}`;
-			const targetType = column.columnType;
-			const dimensionCnt = is(column, PgColumn) ? column.dimensions : 0;
-			switch (targetType) {
-				case "PgNumeric":
-				case "PgNumericNumber":
-				case "PgNumericBigInt":
-				case "PgBigInt64":
-				case "PgBigIntString":
-				case "PgBigSerial64":
-				case "PgTimestampString":
-				case "PgGeometry":
-				case "PgGeometryObject":
-				case "PgBytea": {
-					const arrVal = "[]".repeat(dimensionCnt);
-					return sql`${name}::text${sql.raw(arrVal).if(arrVal)} as ${sql.identifier(key)}`;
-				}
-				case "PgCustomColumn": return sql`${column.jsonSelectIdentifier(name, sql, dimensionCnt > 0 ? dimensionCnt : void 0)} as ${sql.identifier(key)}`;
-				default: return sql`${name} as ${sql.identifier(key)}`;
-			}
+			return sql`${inJson && column.jsonSelectIdentifier ? column.jsonSelectIdentifier(name, sql, column.dimensions) : this.codecs.apply(column, inJson ? "castInJson" : "cast", name)} as ${sql.identifier(key)}`;
 		}
 		return sql`${table}.${is(column, SQL.Aliased) ? sql.identifier(column.fieldAlias) : isSQLWrapper$1(column) ? sql.identifier(key) : this.nestedSelectionerror()} as ${sql.identifier(key)}`;
 	}
-	unwrapAllColumns = (table, selection) => {
+	unwrapAllColumns = (table, selection, inJson) => {
 		return sql.join(Object.entries(table[TableColumns]).map(([k, v]) => {
-			selection.push({
+			selection.push(is(v, Column) ? {
+				key: k,
+				codec: this.codecs.get(v, inJson ? "normalizeInJson" : "normalize"),
+				arrayDimensions: v.dimensions,
+				field: v
+			} : {
 				key: k,
 				field: v
 			});
-			return this.buildRqbColumn(table, v, k);
+			return this.buildRqbColumn(table, v, k, inJson);
 		}), sql`, `);
 	};
-	buildColumns = (table, selection, config) => config?.columns ? (() => {
+	buildColumns = (table, selection, inJson, config) => config?.columns ? (() => {
 		const entries = Object.entries(config.columns);
 		const columnContainer = table[TableColumns];
 		const columnIdentifiers = [];
@@ -504,8 +341,13 @@ var PgDialect = class {
 			colSelectionMode = colSelectionMode || v;
 			if (v) {
 				const column = columnContainer[k];
-				columnIdentifiers.push(this.buildRqbColumn(table, column, k));
-				selection.push({
+				columnIdentifiers.push(this.buildRqbColumn(table, column, k, inJson));
+				selection.push(is(column, Column) ? {
+					key: k,
+					codec: this.codecs.get(column, inJson ? "normalizeInJson" : "normalize"),
+					arrayDimensions: column.dimensions,
+					field: column
+				} : {
 					key: k,
 					field: column
 				});
@@ -513,15 +355,20 @@ var PgDialect = class {
 		}
 		if (colSelectionMode === false) for (const [k, v] of Object.entries(columnContainer)) {
 			if (config.columns[k] === false) continue;
-			columnIdentifiers.push(this.buildRqbColumn(table, v, k));
-			selection.push({
+			columnIdentifiers.push(this.buildRqbColumn(table, v, k, inJson));
+			selection.push(is(v, Column) ? {
+				key: k,
+				codec: this.codecs.get(v, inJson ? "normalizeInJson" : "normalize"),
+				arrayDimensions: v.dimensions,
+				field: v
+			} : {
 				key: k,
 				field: v
 			});
 		}
 		return columnIdentifiers.length ? sql.join(columnIdentifiers, sql`, `) : void 0;
-	})() : this.unwrapAllColumns(table, selection);
-	buildRelationalQuery({ schema, table, tableConfig, queryConfig: config, relationWhere, mode, errorPath, depth, throughJoin }) {
+	})() : this.unwrapAllColumns(table, selection, inJson);
+	buildRelationalQuery({ schema, table, tableConfig, queryConfig: config, relationWhere, mode, errorPath, depth, throughJoin, nested }) {
 		const selection = [];
 		const isSingle = mode === "first";
 		const params = config === true ? void 0 : config;
@@ -532,7 +379,7 @@ var PgDialect = class {
 		const offset = params?.offset;
 		const where = params?.where && relationWhere ? and(relationsFilterToSQL(table, params.where, tableConfig.relations, schema, this.casing), relationWhere) : params?.where ? relationsFilterToSQL(table, params.where, tableConfig.relations, schema, this.casing) : relationWhere;
 		const order = params?.orderBy ? relationsOrderToSQL(table, params.orderBy) : void 0;
-		const columns = this.buildColumns(table, selection, params);
+		const columns = this.buildColumns(table, selection, !!nested, params);
 		const extras = params?.extras ? relationExtrasToSQL(table, params.extras) : void 0;
 		if (extras) selection.push(...extras.selection);
 		const selectionArr = columns ? [columns] : [];
@@ -558,7 +405,8 @@ var PgDialect = class {
 					relationWhere: filter,
 					errorPath: `${currentPath.length ? `${currentPath}.` : ""}${k}`,
 					depth: currentDepth + 1,
-					throughJoin
+					throughJoin,
+					nested: true
 				});
 				selection.push({
 					field: targetTable,