@erfanium/drizzle-orm 0.1.0 → 1.0.0

package/relations.js

@@ -1,316 +1,698 @@
-import { getTableUniqueName, Table } from "./table.js";
-import { Column } from "./column.js";
 import { entityKind, is } from "./entity.js";
-import { PrimaryKeyBuilder } from "./pg-core/primary-keys.js";
-import {
-  and,
-  asc,
-  between,
-  desc,
-  eq,
-  exists,
-  gt,
-  gte,
-  ilike,
-  inArray,
-  isNotNull,
-  isNull,
-  like,
-  lt,
-  lte,
-  ne,
-  not,
-  notBetween,
-  notExists,
-  notIlike,
-  notInArray,
-  notLike,
-  or
-} from "./sql/expressions/index.js";
-import { SQL, sql } from "./sql/sql.js";
-class Relation {
-  constructor(sourceTable, referencedTable, relationName) {
-    this.sourceTable = sourceTable;
-    this.referencedTable = referencedTable;
-    this.relationName = relationName;
-    this.referencedTableName = referencedTable[Table.Symbol.Name];
-  }
-  static [entityKind] = "Relation";
-  referencedTableName;
-  fieldName;
+import { Column } from "./column.js";
+import { Placeholder, SQL, View, noopDecoder, sql } from "./sql/sql.js";
+import { and, arrayContained, arrayContains, arrayOverlaps, between, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, ne, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/conditions.js";
+import { asc, desc } from "./sql/expressions/select.js";
+import { aliasedTable } from "./alias.js";
+import { DrizzleError } from "./errors.js";
+import { FnConstructor, getColumnFromDecoder } from "./utils.js";
+import { IsAlias, OriginalName, Table, TableColumns, TableSchema } from "./table.js";
+
+//#region src/relations.ts
+function processRelations(tablesConfig, tables) {
+	for (const tableConfig of Object.values(tablesConfig)) for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+		if (!is(relation, Relation)) continue;
+		relation.sourceTable = tableConfig.table;
+		relation.fieldName = relationFieldName;
+	}
+	for (const [sourceTableName, tableConfig] of Object.entries(tablesConfig)) for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+		if (!is(relation, Relation)) continue;
+		let reverseRelation;
+		const { targetTableName, alias, sourceColumns, targetColumns, throughTable, sourceTable, through, where, sourceColumnTableNames, targetColumnTableNames } = relation;
+		const relationPrintName = `relations -> ${tableConfig.name}: { ${relationFieldName}: r.${is(relation, One) ? "one" : "many"}.${targetTableName}(...) }`;
+		if (relationFieldName in tableConfig.table[TableColumns]) throw new Error(`${relationPrintName}: relation name collides with column "${relationFieldName}" of table "${tableConfig.name}"`);
+		if (typeof alias === "string" && !alias) throw new Error(`${relationPrintName}: "alias" cannot be an empty string - omit it if you don't need it`);
+		if (sourceColumns?.length === 0) throw new Error(`${relationPrintName}: "from" cannot be empty`);
+		if (targetColumns?.length === 0) throw new Error(`${relationPrintName}: "to" cannot be empty`);
+		if (sourceColumns && targetColumns) {
+			if (sourceColumns.length !== targetColumns.length && !throughTable) throw new Error(`${relationPrintName}: "from" and "to" fields without "through" must have the same length`);
+			for (const sName of sourceColumnTableNames) if (sName !== sourceTableName) throw new Error(`${relationPrintName}: all "from" columns must belong to table "${sourceTableName}", found column of table "${sName}"`);
+			for (const tName of targetColumnTableNames) if (tName !== targetTableName) throw new Error(`${relationPrintName}: all "to" columns must belong to table "${targetTableName}", found column of table "${tName}"`);
+			if (through) {
+				if (through.source.length !== sourceColumns.length || through.target.length !== targetColumns.length) throw new Error(`${relationPrintName}: ".through(column)" must be used either on all columns in "from" and "to" or not defined on any of them`);
+				for (const column of through.source) if (tables[column._.tableName] !== throughTable) throw new Error(`${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`);
+				for (const column of through.target) if (tables[column._.tableName] !== throughTable) throw new Error(`${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`);
+			}
+			continue;
+		}
+		if (sourceColumns || targetColumns) throw new Error(`${relationPrintName}: relation must have either both "from" and "to" defined, or none of them`);
+		const reverseTableConfig = tablesConfig[targetTableName];
+		if (!reverseTableConfig) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and no reverse relations of table "${targetTableName}" were found"`);
+		if (alias) {
+			const reverseRelations = Object.values(reverseTableConfig.relations).filter((it) => is(it, Relation) && it.alias === alias && it !== relation);
+			if (reverseRelations.length > 1) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and multiple relations with alias "${alias}" found in table "${targetTableName}": ${reverseRelations.map((it) => `"${it.fieldName}"`).join(", ")}`);
+			reverseRelation = reverseRelations[0];
+			if (!reverseRelation) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and there is no reverse relation of table "${targetTableName}" with alias "${alias}"`);
+		} else {
+			const reverseRelations = Object.values(reverseTableConfig.relations).filter((it) => is(it, Relation) && it.targetTable === sourceTable && !it.alias && it !== relation);
+			if (reverseRelations.length > 1) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and multiple relations between "${targetTableName}" and "${sourceTableName}" were found.\nHint: you can specify "alias" on both sides of the relation with the same value`);
+			reverseRelation = reverseRelations[0];
+			if (!reverseRelation) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and no reverse relation of table "${targetTableName}" with target table "${sourceTableName}" was found`);
+		}
+		if (!reverseRelation.sourceColumns || !reverseRelation.targetColumns) throw new Error(`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and reverse relation "${targetTableName}.${reverseRelation.fieldName}" does not have "from"/"to" defined`);
+		relation.sourceColumns = reverseRelation.targetColumns;
+		relation.targetColumns = reverseRelation.sourceColumns;
+		relation.through = reverseRelation.through ? {
+			source: reverseRelation.through.target,
+			target: reverseRelation.through.source
+		} : void 0;
+		relation.throughTable = reverseRelation.throughTable;
+		relation.isReversed = !where;
+		relation.where = where ?? reverseRelation.where;
+	}
+	return tablesConfig;
 }
-class Relations {
-  constructor(table, config) {
-    this.table = table;
-    this.config = config;
-  }
-  static [entityKind] = "Relations";
+/** Builds relational config for every table in schema */
+function buildRelations(tables, config) {
+	const tablesConfig = {};
+	for (const [tsName, table] of Object.entries(tables)) tablesConfig[tsName] = {
+		table,
+		name: tsName,
+		relations: config[tsName] ?? {}
+	};
+	return processRelations(tablesConfig, tables);
 }
-class One extends Relation {
-  constructor(sourceTable, referencedTable, config, isNullable) {
-    super(sourceTable, referencedTable, config?.relationName);
-    this.config = config;
-    this.isNullable = isNullable;
-  }
-  static [entityKind] = "One";
-  withFieldName(fieldName) {
-    const relation = new One(
-      this.sourceTable,
-      this.referencedTable,
-      this.config,
-      this.isNullable
-    );
-    relation.fieldName = fieldName;
-    return relation;
-  }
+/** Builds relational config only for tables present in relational config */
+function buildRelationsParts(tables, config) {
+	const tablesConfig = {};
+	for (const [tsName, relations] of Object.entries(config)) {
+		if (!relations || !tables[tsName]) continue;
+		tablesConfig[tsName] = {
+			table: tables[tsName],
+			name: tsName,
+			relations
+		};
+	}
+	return processRelations(tablesConfig, tables);
 }
-class Many extends Relation {
-  constructor(sourceTable, referencedTable, config) {
-    super(sourceTable, referencedTable, config?.relationName);
-    this.config = config;
-  }
-  static [entityKind] = "Many";
-  withFieldName(fieldName) {
-    const relation = new Many(
-      this.sourceTable,
-      this.referencedTable,
-      this.config
-    );
-    relation.fieldName = fieldName;
-    return relation;
-  }
+var Relation = class {
+	static [entityKind] = "RelationV2";
+	fieldName;
+	sourceColumns;
+	targetColumns;
+	alias;
+	where;
+	sourceTable;
+	targetTable;
+	through;
+	throughTable;
+	isReversed;
+	/** @internal */
+	sourceColumnTableNames = [];
+	/** @internal */
+	targetColumnTableNames = [];
+	constructor(targetTable, targetTableName) {
+		this.targetTableName = targetTableName;
+		this.targetTable = targetTable;
+	}
+};
+var One = class extends Relation {
+	static [entityKind] = "OneV2";
+	relationType = "one";
+	optional;
+	constructor(tables, targetTable, targetTableName, config) {
+		super(targetTable, targetTableName);
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.sourceColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.targetColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (this.throughTable) this.through = {
+			source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+			target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+		};
+		this.optional = config?.optional ?? true;
+	}
+};
+var Many = class extends Relation {
+	static [entityKind] = "ManyV2";
+	relationType = "many";
+	constructor(tables, targetTable, targetTableName, config) {
+		super(targetTable, targetTableName);
+		this.config = config;
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.sourceColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.targetColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (this.throughTable) this.through = {
+			source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+			target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+		};
+	}
+};
+var AggregatedField = class {
+	static [entityKind] = "AggregatedField";
+	table;
+	onTable(table) {
+		this.table = table;
+		return this;
+	}
+};
+var Count = class extends AggregatedField {
+	static [entityKind] = "AggregatedFieldCount";
+	query;
+	getSQL() {
+		if (!this.query) {
+			if (!this.table) throw new Error("Table must be set before building aggregate field");
+			this.query = sql`select count(*) as ${sql.identifier("r")} from ${getTableAsAliasSQL(this.table)}`.mapWith(Number);
+		}
+		return this.query;
+	}
+};
+const operators = {
+	and,
+	between,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	arrayContains,
+	arrayContained,
+	arrayOverlaps,
+	isNull,
+	isNotNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notLike,
+	notIlike,
+	notInArray,
+	or,
+	sql
+};
+const orderByOperators = {
+	sql,
+	asc,
+	desc
+};
+function getOrderByOperators() {
+	return orderByOperators;
 }
-function getOperators() {
-  return {
-    and,
-    between,
-    eq,
-    exists,
-    gt,
-    gte,
-    ilike,
-    inArray,
-    isNull,
-    isNotNull,
-    like,
-    lt,
-    lte,
-    ne,
-    not,
-    notBetween,
-    notExists,
-    notLike,
-    notIlike,
-    notInArray,
-    or,
-    sql
-  };
+function mapRelationalRow(rows, isOne, buildQueryResultSelection, parseJson = false, parseJsonIfString = false, useJsonMappers = true) {
+	const maxIdx = isOne ? 1 : rows.length;
+	const decoders = buildQueryResultSelection.map(({ field, codec, arrayDimensions }) => {
+		let decoder;
+		if (is(field, Column)) decoder = field;
+		else if (is(field, SQL)) decoder = field.decoder;
+		else if (is(field, SQL.Aliased)) decoder = field.sql.decoder;
+		else if (is(field, Table) || is(field, View)) decoder = noopDecoder;
+		else decoder = field.getSQL().decoder;
+		if (useJsonMappers && field.mapFromJsonValue) return (v) => field.mapFromJsonValue(v);
+		return decoder.mapFromDriverValue.isNoop ? codec ? (value) => codec(value, arrayDimensions) : void 0 : codec ? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions)) : (value) => decoder.mapFromDriverValue(value);
+	});
+	for (let i = 0; i < maxIdx; ++i) {
+		const row = isOne ? rows : rows[i];
+		for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+			const selectionItem = buildQueryResultSelection[selectionItemIdx];
+			if (selectionItem.selection) {
+				if (row[selectionItem.key] === null) continue;
+				if (parseJson) {
+					row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
+					if (row[selectionItem.key] === null) continue;
+				} else if (parseJsonIfString && typeof row[selectionItem.key] === "string") row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
+				if (selectionItem.isArray) {
+					mapRelationalRow(row[selectionItem.key], false, selectionItem.selection, false, parseJsonIfString);
+					continue;
+				}
+				mapRelationalRow(row[selectionItem.key], true, selectionItem.selection, false, parseJsonIfString);
+				continue;
+			}
+			if (row[selectionItem.key] === null) continue;
+			const decoder = decoders[selectionItemIdx];
+			if (!decoder) continue;
+			row[selectionItem.key] = decoder(row[selectionItem.key]);
+		}
+	}
+	return rows;
 }
-function getOrderByOperators() {
-  return {
-    sql,
-    asc,
-    desc
-  };
+function mapRelationalRowFromArrays(rows, isOne, buildQueryResultSelection, parseJson = false, parseJsonIfString = false) {
+	const maxIdx = isOne ? 1 : rows.length;
+	const decoders = buildQueryResultSelection.map(({ field, codec, arrayDimensions }) => {
+		let decoder;
+		if (is(field, Column)) decoder = field;
+		else if (is(field, SQL)) decoder = field.decoder;
+		else if (is(field, SQL.Aliased)) decoder = field.sql.decoder;
+		else if (is(field, Table) || is(field, View)) decoder = noopDecoder;
+		else decoder = field.getSQL().decoder;
+		return decoder.mapFromDriverValue.isNoop ? codec ? (value) => codec(value, arrayDimensions) : void 0 : codec ? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions)) : (value) => decoder.mapFromDriverValue(value);
+	});
+	const results = Array.from({ length: maxIdx });
+	for (let i = 0; i < maxIdx; ++i) {
+		const row = isOne ? rows : rows[i];
+		const result = {};
+		for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+			const selectionItem = buildQueryResultSelection[selectionItemIdx];
+			let value = row[selectionItemIdx];
+			if (selectionItem.selection) {
+				if (value === null) {
+					result[selectionItem.key] = null;
+					continue;
+				}
+				if (parseJson) {
+					value = JSON.parse(value);
+					if (value === null) {
+						result[selectionItem.key] = null;
+						continue;
+					}
+				} else if (parseJsonIfString && typeof value === "string") value = JSON.parse(value);
+				if (selectionItem.isArray) mapRelationalRow(value, false, selectionItem.selection, false, parseJsonIfString);
+				else mapRelationalRow(value, true, selectionItem.selection, false, parseJsonIfString);
+				result[selectionItem.key] = value;
+				continue;
+			}
+			if (value === null) {
+				result[selectionItem.key] = null;
+				continue;
+			}
+			const decoder = decoders[selectionItemIdx];
+			result[selectionItem.key] = decoder ? decoder(value) : value;
+		}
+		results[i] = result;
+	}
+	return isOne ? results[0] : results;
 }
-function extractTablesRelationalConfig(schema, configHelpers) {
-  if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
-    schema = schema["default"];
-  }
-  const tableNamesMap = {};
-  const relationsBuffer = {};
-  const tablesConfig = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (is(value, Table)) {
-      const dbName = getTableUniqueName(value);
-      const bufferedRelations = relationsBuffer[dbName];
-      tableNamesMap[dbName] = key;
-      tablesConfig[key] = {
-        tsName: key,
-        dbName: value[Table.Symbol.Name],
-        schema: value[Table.Symbol.Schema],
-        columns: value[Table.Symbol.Columns],
-        relations: bufferedRelations?.relations ?? {},
-        primaryKey: bufferedRelations?.primaryKey ?? []
-      };
-      for (const column of Object.values(
-        value[Table.Symbol.Columns]
-      )) {
-        if (column.primary) {
-          tablesConfig[key].primaryKey.push(column);
-        }
-      }
-      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
-      if (extraConfig) {
-        for (const configEntry of Object.values(extraConfig)) {
-          if (is(configEntry, PrimaryKeyBuilder)) {
-            tablesConfig[key].primaryKey.push(...configEntry.columns);
-          }
-        }
-      }
-    } else if (is(value, Relations)) {
-      const dbName = getTableUniqueName(value.table);
-      const tableName = tableNamesMap[dbName];
-      const relations2 = value.config(
-        configHelpers(value.table)
-      );
-      let primaryKey;
-      for (const [relationName, relation] of Object.entries(relations2)) {
-        if (tableName) {
-          const tableConfig = tablesConfig[tableName];
-          tableConfig.relations[relationName] = relation;
-          if (primaryKey) {
-            tableConfig.primaryKey.push(...primaryKey);
-          }
-        } else {
-          if (!(dbName in relationsBuffer)) {
-            relationsBuffer[dbName] = {
-              relations: {},
-              primaryKey
-            };
-          }
-          relationsBuffer[dbName].relations[relationName] = relation;
-        }
-      }
-    }
-  }
-  return { tables: tablesConfig, tableNamesMap };
+function makeDefaultRqbMapper({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
+	return ((rows) => {
+		if (isFirst && !rows[0]) return rows[0];
+		return arrayModeRoot ? mapRelationalRowFromArrays(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString) : mapRelationalRow(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString, rootJsonMappers);
+	});
 }
-function relations(table, relations2) {
-  return new Relations(
-    table,
-    (helpers) => Object.fromEntries(
-      Object.entries(relations2(helpers)).map(([key, value]) => [
-        key,
-        value.withFieldName(key)
-      ])
-    )
-  );
+function makeJitRqbMapperInner(selection, rowExpr, selectionVar, parseJson, parseJsonIfString, useJsonMappers, preFn, counter, accessByIdx) {
+	const bodyStmts = [];
+	const literalEntries = [];
+	let hasWork = false;
+	const fieldVars = selection.map(() => `c${counter.n++}`);
+	const destructurePieces = selection.map((item, idx) => accessByIdx ? fieldVars[idx] : `${JSON.stringify(item.key)}: ${fieldVars[idx]}`);
+	bodyStmts.push(accessByIdx ? `let [ ${destructurePieces.join(", ")} ] = ${rowExpr};` : `let { ${destructurePieces.join(", ")} } = ${rowExpr};`);
+	for (const [idx, { field, key, codec, isArray, selection: innerSelection, arrayDimensions }] of selection.entries()) {
+		const sel = `${selectionVar}[${idx}]`;
+		const keyStr = JSON.stringify(key);
+		const slot = fieldVars[idx];
+		if (innerSelection) {
+			if (parseJson) {
+				bodyStmts.push(`if (${slot} !== null) ${slot} = JSON.parse(${slot});`);
+				hasWork = true;
+			} else if (parseJsonIfString) {
+				bodyStmts.push(`if (typeof ${slot} === 'string') ${slot} = JSON.parse(${slot});`);
+				hasWork = true;
+			}
+			const nestedSelVar = `s${counter.n++}`;
+			const savedPreFnLen = preFn.length;
+			preFn.push(`const { selection: ${nestedSelVar} } = ${sel};`);
+			if (isArray) {
+				const j = `j${counter.n++}`;
+				const inner = makeJitRqbMapperInner(innerSelection, `${slot}[${j}]`, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
+				if (inner.hasWork) {
+					hasWork = true;
+					bodyStmts.push(`if (${slot} !== null) {`);
+					bodyStmts.push(`\tfor (let ${j} = 0; ${j} < ${slot}.length; ++${j}) {`);
+					for (const s of inner.bodyStmts) bodyStmts.push(`\t\t${s}`);
+					bodyStmts.push(`\t\t${slot}[${j}] = ${inner.literal};`);
+					bodyStmts.push(`\t}`);
+					bodyStmts.push(`}`);
+				} else preFn.splice(savedPreFnLen, 1);
+			} else {
+				const inner = makeJitRqbMapperInner(innerSelection, slot, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
+				if (inner.hasWork) {
+					hasWork = true;
+					bodyStmts.push(`if (${slot} !== null) {`);
+					for (const s of inner.bodyStmts) bodyStmts.push(`\t${s}`);
+					bodyStmts.push(`\t${slot} = ${inner.literal};`);
+					bodyStmts.push(`}`);
+				} else preFn.splice(savedPreFnLen, 1);
+			}
+			literalEntries.push(`${keyStr}: ${slot}`);
+			continue;
+		}
+		let decoderExpr = "";
+		let destructure = "";
+		let bypassCodecs = false;
+		if (is(field, Column)) {
+			if (useJsonMappers && field.mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: dec${id}`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: dec${id}`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, SQL)) {
+			if (useJsonMappers && field.decoder.mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: { decoder: dec${id} }`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: { decoder: dec${id} }`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, SQL.Aliased)) {
+			if (useJsonMappers && field.sql.decoder.mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: { sql: { decoder: dec${id} } }`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.sql.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: { sql: { decoder: dec${id} } }`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, Table) || is(field, View)) {} else {
+			const sqlExpr = field.getSQL();
+			if (useJsonMappers && sqlExpr.decoder.mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!sqlExpr.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		}
+		let codecVar = "";
+		if (!bypassCodecs && codec) codecVar = `codec${counter.n++}`;
+		if (destructure || codecVar) {
+			const parts = [];
+			if (destructure) parts.push(destructure);
+			if (codecVar) parts.push(`codec: ${codecVar}`);
+			preFn.push(`const { ${parts.join(", ")} } = ${sel};`);
+		}
+		if (decoderExpr || codecVar) {
+			hasWork = true;
+			let decoded = slot;
+			if (codecVar) decoded = `${codecVar}(${decoded}, ${arrayDimensions})`;
+			if (decoderExpr) decoded = `${decoderExpr}(${decoded})`;
+			literalEntries.push(`${keyStr}: ${slot} === null ? null : ${decoded}`);
+		} else literalEntries.push(`${keyStr}: ${slot}`);
+	}
+	return {
+		bodyStmts,
+		literal: `{ ${literalEntries.join(", ")} }`,
+		hasWork
+	};
 }
-function createOne(sourceTable) {
-  return function one(table, config) {
-    return new One(
-      sourceTable,
-      table,
-      config,
-      config?.fields.reduce((res, f) => res && f.notNull, true) ?? false
-    );
-  };
+function makeJitRqbMapper({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
+	const preFn = [];
+	const inner = makeJitRqbMapperInner(selection, "row", "selection", parseJson, parseJsonIfString, arrayModeRoot ? false : rootJsonMappers, preFn, { n: 0 }, !!arrayModeRoot);
+	const lines = [];
+	lines.push(`\t"use strict";
+	const { selection } = this;`);
+	for (const p of preFn) lines.push(`\t${p}`);
+	if (arrayModeRoot) if (isFirst) {
+		lines.push(`\tconst row = rows[0];`);
+		lines.push(`\tif (!row) return undefined;`);
+		for (const s of inner.bodyStmts) lines.push(`\t${s}`);
+		lines.push(`\treturn ${inner.literal};`);
+	} else {
+		lines.push(`\tconst { length } = rows;`);
+		lines.push(`\tconst mapped = Array.from({ length });`);
+		lines.push(`\tfor (let i = 0; i < length; ++i) {`);
+		lines.push(`\t\tconst row = rows[i];`);
+		for (const s of inner.bodyStmts) lines.push(`\t\t${s}`);
+		lines.push(`\t\tmapped[i] = ${inner.literal};`);
+		lines.push(`\t}`);
+		lines.push(`\treturn mapped;`);
+	}
+	else if (!inner.hasWork) lines.push(isFirst ? `\treturn rows[0];` : `\treturn rows;`);
+	else if (isFirst) {
+		lines.push(`\tconst row = rows[0];`);
+		lines.push(`\tif (!row) return undefined;`);
+		for (const s of inner.bodyStmts) lines.push(`\t${s}`);
+		lines.push(`\trows[0] = ${inner.literal};`);
+		lines.push(`\treturn rows[0];`);
+	} else {
+		lines.push(`\tfor (let i = 0; i < rows.length; ++i) {`);
+		lines.push(`\t\tconst row = rows[i];`);
+		for (const s of inner.bodyStmts) lines.push(`\t\t${s}`);
+		lines.push(`\t\trows[i] = ${inner.literal};`);
+		lines.push(`\t}`);
+		lines.push(`\treturn rows;`);
+	}
+	lines.push("	//# sourceURL=drizzle:jit-relational-query-mapper");
+	const compiled = lines.join("\n");
+	return Object.assign(new FnConstructor("rows", compiled).bind({ selection }), { body: `function jitRqbMapper (rows) {\n${compiled}\n}` });
 }
-function createMany(sourceTable) {
-  return function many(referencedTable, config) {
-    return new Many(sourceTable, referencedTable, config);
-  };
+var RelationsBuilderTable = class {
+	static [entityKind] = "RelationsBuilderTable";
+	_;
+	constructor(table, name) {
+		this._ = {
+			name,
+			table
+		};
+	}
+};
+var RelationsBuilderColumn = class {
+	static [entityKind] = "RelationsBuilderColumn";
+	_;
+	constructor(column, tableName, key) {
+		this._ = {
+			tableName,
+			column,
+			key
+		};
+	}
+	through(column) {
+		return new RelationsBuilderJunctionColumn(this._.column, this._.tableName, this._.key, column);
+	}
+};
+var RelationsBuilderJunctionColumn = class {
+	static [entityKind] = "RelationsBuilderColumn";
+	_;
+	constructor(column, tableName, key, through) {
+		this._ = {
+			tableName,
+			column,
+			through,
+			key
+		};
+	}
+};
+var RelationsHelperStatic = class {
+	static [entityKind] = "RelationsHelperStatic";
+	_;
+	constructor(tables) {
+		this._ = { tables };
+		const one = {};
+		const many = {};
+		for (const [tableName, table] of Object.entries(tables)) {
+			one[tableName] = (config) => {
+				return new One(tables, table, tableName, config);
+			};
+			many[tableName] = (config) => {
+				return new Many(tables, table, tableName, config);
+			};
+		}
+		this.one = one;
+		this.many = many;
+	}
+	one;
+	many;
+	/** @internal - to be reworked */
+	aggs = { count() {
+		return new Count();
+	} };
+};
+function createRelationsHelper(tables) {
+	const helperStatic = new RelationsHelperStatic(tables);
+	const relationsTables = Object.entries(tables).reduce((acc, [tKey, value]) => {
+		const rTable = new RelationsBuilderTable(value, tKey);
+		const columns = Object.entries(value[TableColumns]).reduce((acc, [cKey, column]) => {
+			acc[cKey] = new RelationsBuilderColumn(column, tKey, cKey);
+			return acc;
+		}, {});
+		acc[tKey] = Object.assign(rTable, columns);
+		return acc;
+	}, {});
+	return Object.assign(helperStatic, relationsTables);
 }
-function normalizeRelation(schema, tableNamesMap, relation) {
-  if (is(relation, One) && relation.config) {
-    return {
-      fields: relation.config.fields,
-      references: relation.config.references
-    };
-  }
-  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-  if (!referencedTableTsName) {
-    throw new Error(
-      `Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`
-    );
-  }
-  const referencedTableConfig = schema[referencedTableTsName];
-  if (!referencedTableConfig) {
-    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
-  }
-  const sourceTable = relation.sourceTable;
-  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-  if (!sourceTableTsName) {
-    throw new Error(
-      `Table "${sourceTable[Table.Symbol.Name]}" not found in schema`
-    );
-  }
-  const reverseRelations = [];
-  for (const referencedTableRelation of Object.values(
-    referencedTableConfig.relations
-  )) {
-    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
-      reverseRelations.push(referencedTableRelation);
-    }
-  }
-  if (reverseRelations.length > 1) {
-    throw relation.relationName ? new Error(
-      `There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`
-    ) : new Error(
-      `There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`
-    );
-  }
-  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
-    return {
-      fields: reverseRelations[0].config.references,
-      references: reverseRelations[0].config.fields
-    };
-  }
-  throw new Error(
-    `There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`
-  );
+function extractTablesFromSchema(schema) {
+	return Object.fromEntries(Object.entries(schema).filter(([_, e]) => is(e, Table) || is(e, View)));
 }
-function createTableRelationsHelpers(sourceTable) {
-  return {
-    one: createOne(sourceTable),
-    many: createMany(sourceTable)
-  };
+function defineRelations(schema, relations) {
+	const tables = extractTablesFromSchema(schema);
+	return buildRelations(tables, relations ? relations(createRelationsHelper(tables)) : {});
 }
-function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
-  const result = {};
-  for (const [
-    selectionItemIndex,
-    selectionItem
-  ] of buildQueryResultSelection.entries()) {
-    if (selectionItem.isJson) {
-      const relation = tableConfig.relations[selectionItem.tsKey];
-      const rawSubRows = row[selectionItemIndex];
-      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
-      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(
-        tablesConfig,
-        tablesConfig[selectionItem.relationTableTsKey],
-        subRows,
-        selectionItem.selection,
-        mapColumnValue
-      ) : subRows.map(
-        (subRow) => mapRelationalRow(
-          tablesConfig,
-          tablesConfig[selectionItem.relationTableTsKey],
-          subRow,
-          selectionItem.selection,
-          mapColumnValue
-        )
-      );
-    } else {
-      const value = mapColumnValue(row[selectionItemIndex]);
-      const field = selectionItem.field;
-      let decoder;
-      if (is(field, Column)) {
-        decoder = field;
-      } else if (is(field, SQL)) {
-        decoder = field.decoder;
-      } else {
-        decoder = field.sql.decoder;
-      }
-      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
-    }
-  }
-  return result;
+function defineRelationsPart(schema, relations) {
+	const tables = extractTablesFromSchema(schema);
+	return buildRelationsParts(tables, relations ? relations(createRelationsHelper(tables)) : Object.fromEntries(Object.keys(tables).map((k) => [k, {}])));
 }
-export {
-  Many,
-  One,
-  Relation,
-  Relations,
-  createMany,
-  createOne,
-  createTableRelationsHelpers,
-  extractTablesRelationalConfig,
-  getOperators,
-  getOrderByOperators,
-  mapRelationalRow,
-  normalizeRelation,
-  relations
-};
+/** @internal */
+function fieldSelectionToSQL(table, target) {
+	const field = table[TableColumns][target];
+	return field ? is(field, Column) ? field : is(field, SQL.Aliased) ? sql`${table}.${sql.identifier(field.fieldAlias)}` : sql`${table}.${sql.identifier(target)}` : sql`${table}.${sql.identifier(target)}`;
+}
+function relationsFieldFilterToSQL(column, filter) {
+	if (typeof filter !== "object" || is(filter, Placeholder)) return eq(column, filter);
+	const entries = Object.entries(filter);
+	if (!entries.length) return void 0;
+	const parts = [];
+	for (const [target, value] of entries) {
+		if (value === void 0) continue;
+		switch (target) {
+			case "NOT": {
+				const res = relationsFieldFilterToSQL(column, value);
+				if (!res) continue;
+				parts.push(not(res));
+				continue;
+			}
+			case "OR":
+				if (!value.length) continue;
+				parts.push(or(...value.map((subFilter) => relationsFieldFilterToSQL(column, subFilter))));
+				continue;
+			case "AND":
+				if (!value.length) continue;
+				parts.push(and(...value.map((subFilter) => relationsFieldFilterToSQL(column, subFilter))));
+				continue;
+			case "isNotNull":
+			case "isNull":
+				if (!value) continue;
+				parts.push(operators[target](column));
+				continue;
+			case "in":
+				parts.push(operators.inArray(column, value));
+				continue;
+			case "notIn":
+				parts.push(operators.notInArray(column, value));
+				continue;
+			default:
+				parts.push(operators[target](column, value));
+				continue;
+		}
+	}
+	if (!parts.length) return void 0;
+	return and(...parts);
+}
+function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelations = {}, depth = 0) {
+	const entries = Object.entries(filter);
+	if (!entries.length) return void 0;
+	const parts = [];
+	for (const [target, value] of entries) {
+		if (value === void 0) continue;
+		switch (target) {
+			case "RAW": {
+				const processed = typeof value === "function" ? value(table, operators) : value.getSQL();
+				parts.push(processed);
+				continue;
+			}
+			case "OR":
+				if (!value?.length) continue;
+				parts.push(or(...value.map((subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth))));
+				continue;
+			case "AND":
+				if (!value?.length) continue;
+				parts.push(and(...value.map((subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth))));
+				continue;
+			case "NOT": {
+				if (value === void 0) continue;
+				const built = relationsFilterToSQL(table, value, tableRelations, tablesRelations, depth);
+				if (!built) continue;
+				parts.push(not(built));
+				continue;
+			}
+			default: {
+				if (table[TableColumns][target]) {
+					const colFilter = relationsFieldFilterToSQL(fieldSelectionToSQL(table, target), value);
+					if (colFilter) parts.push(colFilter);
+					continue;
+				}
+				const relation = tableRelations[target];
+				if (!relation) throw new DrizzleError({ message: `Unknown relational filter field: "${target}"` });
+				const targetTable = aliasedTable(relation.targetTable, `f${depth}`);
+				const throughTable = relation.throughTable ? aliasedTable(relation.throughTable, `ft${depth}`) : void 0;
+				const targetConfig = tablesRelations[relation.targetTableName];
+				const { filter: relationFilter, joinCondition } = relationToSQL(relation, table, targetTable, throughTable);
+				const filter = and(relationFilter, typeof value === "boolean" ? void 0 : relationsFilterToSQL(targetTable, value, targetConfig.relations, tablesRelations, depth + 1));
+				const subquery = throughTable ? sql`(select * from ${getTableAsAliasSQL(targetTable)} inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition}${sql` where ${filter}`.if(filter)} limit 1)` : sql`(select * from ${getTableAsAliasSQL(targetTable)}${sql` where ${filter}`.if(filter)} limit 1)`;
+				if (filter) parts.push((value ? exists : notExists)(subquery));
+			}
+		}
+	}
+	return and(...parts);
+}
+function relationsOrderToSQL(table, orders) {
+	if (typeof orders === "function") {
+		const data = orders(table, orderByOperators);
+		return is(data, SQL) ? data : Array.isArray(data) ? data.length ? sql.join(data.map((o) => is(o, SQL) ? o : asc(o)), sql`, `) : void 0 : is(data, Column) ? asc(data) : void 0;
+	}
+	const entries = Object.entries(orders).filter(([_, value]) => value);
+	if (!entries.length) return void 0;
+	return sql.join(entries.map(([target, value]) => (value === "asc" ? asc : desc)(fieldSelectionToSQL(table, target))), sql`, `);
+}
+function relationExtrasToSQL(table, extras, codecs, inJson) {
+	const subqueries = [];
+	const selection = [];
+	for (const [key, field] of Object.entries(extras)) {
+		if (!field) continue;
+		const subq = (typeof field === "function" ? field(table, { sql: operators.sql }) : field).getSQL();
+		const column = codecs ? getColumnFromDecoder(subq) : void 0;
+		const query = column && (!inJson || !column.jsonSelectIdentifier) ? sql`${codecs.apply(column, inJson ? "castInJson" : "cast", sql`(${subq})`)} as ${sql.identifier(key)}` : sql`(${subq}) as ${sql.identifier(key)}`;
+		query.decoder = subq.decoder;
+		subqueries.push(query);
+		selection.push(column && (!inJson || !column.mapFromJsonValue) ? {
+			key,
+			field: query,
+			codec: codecs.get(column, inJson ? "normalizeInJson" : "normalize"),
+			arrayDimensions: column.dimensions
+		} : {
+			key,
+			field: query
+		});
+	}
+	return {
+		sql: subqueries.length ? sql.join(subqueries, sql`, `) : void 0,
+		selection
+	};
+}
+function relationToSQL(relation, sourceTable, targetTable, throughTable) {
+	if (relation.through) {
+		const outerColumnWhere = relation.sourceColumns.map((s, i) => {
+			const t = relation.through.source[i];
+			return eq(sql`${sourceTable}.${sql.identifier(s.name)}`, sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`);
+		});
+		const innerColumnWhere = relation.targetColumns.map((s, i) => {
+			const t = relation.through.target[i];
+			return eq(sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`, sql`${targetTable}.${sql.identifier(s.name)}`);
+		});
+		return {
+			filter: and(relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0, ...outerColumnWhere),
+			joinCondition: and(...innerColumnWhere)
+		};
+	}
+	return { filter: and(...relation.sourceColumns.map((s, i) => {
+		const t = relation.targetColumns[i];
+		return eq(sql`${sourceTable}.${sql.identifier(s.name)}`, sql`${targetTable}.${sql.identifier(t.name)}`);
+	}), relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0) };
+}
+function getTableAsAliasSQL(table) {
+	return sql`${table[IsAlias] ? sql`${sql`${sql.identifier(table[TableSchema] ?? "")}.`.if(table[TableSchema])}${sql.identifier(table[OriginalName])} as ${table}` : table}`;
+}
+
+//#endregion
+export { AggregatedField, Count, Many, One, Relation, RelationsBuilderColumn, RelationsBuilderJunctionColumn, RelationsBuilderTable, RelationsHelperStatic, buildRelations, buildRelationsParts, createRelationsHelper, defineRelations, defineRelationsPart, extractTablesFromSchema, fieldSelectionToSQL, getOrderByOperators, getTableAsAliasSQL, makeDefaultRqbMapper, makeJitRqbMapper, mapRelationalRow, mapRelationalRowFromArrays, operators, orderByOperators, processRelations, relationExtrasToSQL, relationToSQL, relationsFilterToSQL, relationsOrderToSQL };
 //# sourceMappingURL=relations.js.map