drizzle-orm 0.40.0 → 1.0.0-beta.1-e30ede4

package/relations.js

@@ -1,7 +1,9 @@
-import { getTableUniqueName, Table } from "./table.js";
+import { getTableUniqueName, IsAlias, OriginalName, Schema, Table } from "./table.js";
+import { Columns } from "./table.js";
+import { aliasedTable } from "./alias.js";
 import { Column } from "./column.js";
 import { entityKind, is } from "./entity.js";
-import { PrimaryKeyBuilder } from "./pg-core/primary-keys.js";
+import { DrizzleError } from "./errors.js";
 import {
   and,
   asc,
@@ -27,290 +29,691 @@ import {
   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 { Placeholder, SQL, sql, View } from "./sql/sql.js";
 class Relations {
-  constructor(table, config) {
-    this.table = table;
+  constructor(schema, tables, config) {
+    this.schema = schema;
+    this.tables = tables;
     this.config = config;
+    for (const [tsName, table] of Object.entries(tables)) {
+      if (config[tsName]?.$drizzleTypeError)
+        continue;
+      const isTable = is(table, Table);
+      const isView = is(table, View);
+      if (!(isTable || isView))
+        continue;
+      this.tableNamesMap[getTableUniqueName(table)] = tsName;
+      this.tablesConfig[tsName] = {
+        table,
+        tsName,
+        dbName: table[Table.Symbol.Name],
+        schema: table[Table.Symbol.Schema],
+        columns: table[Table.Symbol.Columns],
+        relations: config[tsName] || {}
+      };
+    }
+    for (const tableConfig of Object.values(this.tablesConfig)) {
+      for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+        if (!is(relation, Relation)) {
+          continue;
+        }
+        relation.sourceTable = tableConfig.table;
+        relation.fieldName = relationFieldName;
+      }
+    }
+    for (const tableConfig of Object.values(this.tablesConfig)) {
+      for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+        if (!is(relation, Relation)) {
+          continue;
+        }
+        const relationPrintName = `relations -> ${tableConfig.tsName}: { ${relationFieldName}: r.${is(relation, One) ? "one" : "many"}.${this.tableNamesMap[getTableUniqueName(relation.targetTable)]}(...) }`;
+        if (typeof relation.alias === "string" && !relation.alias) {
+          throw new Error(`${relationPrintName}: "alias" cannot be an empty string - omit it if you don't need it`);
+        }
+        if (relation.sourceColumns?.length === 0) {
+          throw new Error(`${relationPrintName}: "from" cannot be an empty array`);
+        }
+        if (relation.targetColumns?.length === 0) {
+          throw new Error(`${relationPrintName}: "to" cannot be an empty array`);
+        }
+        if (relation.sourceColumns && relation.targetColumns) {
+          if (relation.sourceColumns.length !== relation.targetColumns.length && !relation.throughTable) {
+            throw new Error(
+              `${relationPrintName}: "from" and "to" fields without "through" must have the same length`
+            );
+          }
+          if (relation.through) {
+            if (relation.through.source.length !== relation.sourceColumns.length || relation.through.target.length !== relation.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 relation.through.source) {
+              if (tables[column._.tableName] !== relation.throughTable) {
+                throw new Error(
+                  `${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`
+                );
+              }
+            }
+            for (const column of relation.through.target) {
+              if (tables[column._.tableName] !== relation.throughTable) {
+                throw new Error(
+                  `${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`
+                );
+              }
+            }
+          }
+          continue;
+        }
+        if (relation.sourceColumns || relation.targetColumns) {
+          throw new Error(
+            `${relationPrintName}: relation must have either both "from" and "to" defined, or none of them`
+          );
+        }
+        let reverseRelation;
+        const targetTableTsName = this.tableNamesMap[getTableUniqueName(relation.targetTable)];
+        if (!targetTableTsName) {
+          throw new Error(
+            `Table "${getTableUniqueName(relation.targetTable)}" not found in provided TS schema`
+          );
+        }
+        const reverseTableConfig = this.tablesConfig[targetTableTsName];
+        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 "${targetTableTsName}" were found"`
+          );
+        }
+        if (relation.alias) {
+          const reverseRelations = Object.values(reverseTableConfig.relations).filter(
+            (it) => is(it, Relation) && it.alias === relation.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 "${relation.alias}" found in table "${targetTableTsName}": ${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 "${targetTableTsName}" with alias "${relation.alias}"`
+            );
+          }
+        } else {
+          const reverseRelations = Object.values(reverseTableConfig.relations).filter(
+            (it) => is(it, Relation) && it.targetTable === relation.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 "${targetTableTsName}" and "${getTableUniqueName(relation.sourceTable)}" were found.
+Hint: 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 "${targetTableTsName}" with target table "${getTableUniqueName(relation.sourceTable)}" 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 "${targetTableTsName}.${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 = !relation.where;
+        relation.where = relation.where ?? reverseRelation.where;
+      }
+    }
   }
-  static [entityKind] = "Relations";
+  static [entityKind] = "RelationsV2";
+  /** table DB name -> schema table key */
+  tableNamesMap = {};
+  tablesConfig = {};
 }
-class One extends Relation {
-  constructor(sourceTable, referencedTable, config, isNullable) {
-    super(sourceTable, referencedTable, config?.relationName);
-    this.config = config;
-    this.isNullable = isNullable;
+class Relation {
+  constructor(targetTable) {
+    this.targetTable = targetTable;
   }
-  static [entityKind] = "One";
-  withFieldName(fieldName) {
-    const relation = new One(
-      this.sourceTable,
-      this.referencedTable,
-      this.config,
-      this.isNullable
-    );
-    relation.fieldName = fieldName;
-    return relation;
+  static [entityKind] = "RelationV2";
+  fieldName;
+  sourceColumns;
+  targetColumns;
+  alias;
+  where;
+  sourceTable;
+  through;
+  throughTable;
+  isReversed;
+}
+class One extends Relation {
+  static [entityKind] = "OneV2";
+  optional;
+  constructor(tables, targetTable, config) {
+    super(targetTable);
+    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;
+        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;
+        return it._.column;
+      });
+    }
+    if (this.throughTable) {
+      this.through = {
+        source: (Array.isArray(config?.from) ? config.from : [config.from]).map((c) => c._.through),
+        target: (Array.isArray(config?.to) ? config.to : [config.to]).map((c) => c._.through)
+      };
+    }
+    this.optional = config?.optional ?? true;
   }
 }
 class Many extends Relation {
-  constructor(sourceTable, referencedTable, config) {
-    super(sourceTable, referencedTable, config?.relationName);
+  constructor(tables, targetTable, config) {
+    super(targetTable);
     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;
+        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;
+        return it._.column;
+      });
+    }
+    if (this.throughTable) {
+      this.through = {
+        source: (Array.isArray(config?.from) ? config.from : [config.from]).map((c) => c._.through),
+        target: (Array.isArray(config?.to) ? config.to : [config.to]).map((c) => c._.through)
+      };
+    }
   }
-  static [entityKind] = "Many";
-  withFieldName(fieldName) {
-    const relation = new Many(
-      this.sourceTable,
-      this.referencedTable,
-      this.config
-    );
-    relation.fieldName = fieldName;
-    return relation;
+  static [entityKind] = "ManyV2";
+}
+class AggregatedField {
+  static [entityKind] = "AggregatedField";
+  table;
+  onTable(table) {
+    this.table = table;
+    return this;
   }
 }
-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
-  };
+class Count 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,
+  isNull,
+  isNotNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notLike,
+  notIlike,
+  notInArray,
+  or,
+  sql
+};
+const orderByOperators = {
+  sql,
+  asc,
+  desc
+};
 function getOrderByOperators() {
-  return {
-    sql,
-    asc,
-    desc
-  };
+  return orderByOperators;
 }
-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);
-          }
+function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (value) => value, parseJson = false, path) {
+  for (const selectionItem of buildQueryResultSelection) {
+    if (selectionItem.selection) {
+      const currentPath = `${path ? `${path}.` : ""}${selectionItem.key}`;
+      if (row[selectionItem.key] === null)
+        continue;
+      if (parseJson)
+        row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
+      if (selectionItem.isArray) {
+        for (const item of row[selectionItem.key]) {
+          mapRelationalRow(
+            item,
+            selectionItem.selection,
+            mapColumnValue,
+            false,
+            currentPath
+          );
         }
+        continue;
       }
-    } else if (is(value, Relations)) {
-      const dbName = getTableUniqueName(value.table);
-      const tableName = tableNamesMap[dbName];
-      const relations2 = value.config(
-        configHelpers(value.table)
+      mapRelationalRow(
+        row[selectionItem.key],
+        selectionItem.selection,
+        mapColumnValue,
+        false,
+        currentPath
       );
-      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;
-        }
-      }
+      continue;
     }
+    const field = selectionItem.field;
+    const value = mapColumnValue(row[selectionItem.key]);
+    if (value === null)
+      continue;
+    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 {
+      decoder = field.getSQL().decoder;
+    }
+    row[selectionItem.key] = decoder.mapFromDriverValue(value);
   }
-  return { tables: tablesConfig, tableNamesMap };
+  return row;
 }
-function relations(table, relations2) {
-  return new Relations(
-    table,
-    (helpers) => Object.fromEntries(
-      Object.entries(relations2(helpers)).map(([key, value]) => [
-        key,
-        value.withFieldName(key)
-      ])
-    )
-  );
-}
-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 createMany(sourceTable) {
-  return function many(referencedTable, config) {
-    return new Many(sourceTable, referencedTable, config);
-  };
+class RelationsBuilderTable {
+  static [entityKind] = "RelationsBuilderTable";
+  _;
+  constructor(table, key) {
+    this._ = {
+      name: key,
+      table
+    };
+  }
 }
-function normalizeRelation(schema, tableNamesMap, relation) {
-  if (is(relation, One) && relation.config) {
-    return {
-      fields: relation.config.fields,
-      references: relation.config.references
+class RelationsBuilderColumn {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key) {
+    this._ = {
+      tableName,
+      data: void 0,
+      column,
+      key
     };
   }
-  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-  if (!referencedTableTsName) {
-    throw new Error(
-      `Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`
+  through(column) {
+    return new RelationsBuilderJunctionColumn(
+      this._.column,
+      this._.tableName,
+      this._.key,
+      column
     );
   }
-  const referencedTableConfig = schema[referencedTableTsName];
-  if (!referencedTableConfig) {
-    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+}
+class RelationsBuilderJunctionColumn {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key, through) {
+    this._ = {
+      tableName,
+      data: void 0,
+      column,
+      through,
+      key
+    };
   }
-  const sourceTable = relation.sourceTable;
-  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-  if (!sourceTableTsName) {
-    throw new Error(
-      `Table "${sourceTable[Table.Symbol.Name]}" not found in schema`
-    );
+}
+class RelationsHelperStatic {
+  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, config);
+      };
+      many[tableName] = (config) => {
+        return new Many(tables, table, config);
+      };
+    }
+    this.one = one;
+    this.many = many;
   }
-  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);
+  one;
+  many;
+  /** @internal - to be reworked */
+  aggs = {
+    count() {
+      return new Count();
+    }
+  };
+}
+function createRelationsHelper(schema) {
+  const schemaTables = Object.fromEntries(
+    Object.entries(schema).filter((e) => is(e[1], Table) || is(e[1], View))
+  );
+  const helperStatic = new RelationsHelperStatic(schemaTables);
+  const tables = Object.entries(schema).reduce((acc, [tKey, value]) => {
+    if (is(value, Table) || is(value, View)) {
+      const rTable = new RelationsBuilderTable(value, tKey);
+      const columns = Object.entries(value[Columns]).reduce(
+        (acc2, [cKey, column]) => {
+          const rbColumn = new RelationsBuilderColumn(column, tKey, cKey);
+          acc2[cKey] = rbColumn;
+          return acc2;
+        },
+        {}
+      );
+      acc[tKey] = Object.assign(rTable, columns);
+    }
+    return acc;
+  }, {});
+  return Object.assign(helperStatic, tables);
+}
+function defineRelations(schema, relations) {
+  return new Relations(
+    schema,
+    schema,
+    relations ? relations(createRelationsHelper(schema)) : {}
+  );
+}
+function fieldSelectionToSQL(table, target) {
+  const field = table[Columns][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 (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 (!parts.length)
+    return void 0;
+  return and(...parts);
+}
+function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelations = {}, tableNamesMap = {}, casing, 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, tableNamesMap, casing, depth)
+            )
+          )
+        );
+        continue;
+      }
+      case "AND": {
+        if (!value?.length)
+          continue;
+        parts.push(
+          and(
+            ...value.map(
+              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, tableNamesMap, casing, depth)
+            )
+          )
+        );
+        continue;
+      }
+      case "NOT": {
+        if (value === void 0)
+          continue;
+        const built = relationsFilterToSQL(
+          table,
+          value,
+          tableRelations,
+          tablesRelations,
+          tableNamesMap,
+          casing,
+          depth
+        );
+        if (!built)
+          continue;
+        parts.push(not(built));
+        continue;
+      }
+      default: {
+        if (table[Columns][target]) {
+          const column = fieldSelectionToSQL(table, target);
+          const colFilter = relationsFieldFilterToSQL(
+            column,
+            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[tableNamesMap[getTableUniqueName(relation.targetTable)]];
+        const {
+          filter: relationFilter,
+          joinCondition
+        } = relationToSQL(casing, relation, table, targetTable, throughTable);
+        const subfilter = typeof value === "boolean" ? void 0 : relationsFilterToSQL(
+          targetTable,
+          value,
+          targetConfig.relations,
+          tablesRelations,
+          tableNamesMap,
+          casing,
+          depth + 1
+        );
+        const filter2 = and(
+          relationFilter,
+          subfilter
+        );
+        const subquery = throughTable ? sql`(select * from ${getTableAsAliasSQL(targetTable)} inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition}${sql` where ${filter2}`.if(filter2)} limit 1)` : sql`(select * from ${getTableAsAliasSQL(targetTable)}${sql` where ${filter2}`.if(filter2)} limit 1)`;
+        if (filter2)
+          parts.push((value ? exists : notExists)(subquery));
+      }
+    }
   }
-  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
-    return {
-      fields: reverseRelations[0].config.references,
-      references: reverseRelations[0].config.fields
-    };
+  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;
   }
-  throw new Error(
-    `There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`
+  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 createTableRelationsHelpers(sourceTable) {
+function relationExtrasToSQL(table, extras) {
+  const subqueries = [];
+  const selection = [];
+  for (const [key, field] of Object.entries(extras)) {
+    if (!field)
+      continue;
+    const extra = typeof field === "function" ? field(table, { sql: operators.sql }) : field;
+    const query = sql`(${extra.getSQL()}) as ${sql.identifier(key)}`;
+    query.decoder = extra.getSQL().decoder;
+    subqueries.push(query);
+    selection.push({
+      key,
+      field: query
+    });
+  }
   return {
-    one: createOne(sourceTable),
-    many: createMany(sourceTable)
+    sql: subqueries.length ? sql.join(subqueries, sql`, `) : void 0,
+    selection
   };
 }
-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
-        )
+function relationToSQL(casing, 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(casing.getColumnCasing(s))}`,
+        sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? casing.getColumnCasing(t._.column) : t._.key)}`
       );
-    } 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);
-    }
+    });
+    const innerColumnWhere = relation.targetColumns.map((s, i) => {
+      const t = relation.through.target[i];
+      return eq(
+        sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? casing.getColumnCasing(t._.column) : t._.key)}`,
+        sql`${targetTable}.${sql.identifier(casing.getColumnCasing(s))}`
+      );
+    });
+    return {
+      filter: and(
+        relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0,
+        ...outerColumnWhere
+      ),
+      joinCondition: and(...innerColumnWhere)
+    };
   }
-  return result;
+  const columnWhere = relation.sourceColumns.map((s, i) => {
+    const t = relation.targetColumns[i];
+    return eq(
+      sql`${sourceTable}.${sql.identifier(casing.getColumnCasing(s))}`,
+      sql`${targetTable}.${sql.identifier(casing.getColumnCasing(t))}`
+    );
+  });
+  const fullWhere = and(
+    ...columnWhere,
+    relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0
+  );
+  return { filter: fullWhere };
+}
+function getTableAsAliasSQL(table) {
+  return sql`${table[IsAlias] ? sql`${sql`${sql.identifier(table[Schema] ?? "")}.`.if(table[Schema])}${sql.identifier(table[OriginalName])} as ${table}` : table}`;
 }
 export {
+  AggregatedField,
+  Count,
   Many,
   One,
   Relation,
   Relations,
-  createMany,
-  createOne,
-  createTableRelationsHelpers,
-  extractTablesRelationalConfig,
-  getOperators,
+  RelationsBuilderColumn,
+  RelationsBuilderJunctionColumn,
+  RelationsBuilderTable,
+  RelationsHelperStatic,
+  createRelationsHelper,
+  defineRelations,
+  fieldSelectionToSQL,
   getOrderByOperators,
+  getTableAsAliasSQL,
   mapRelationalRow,
-  normalizeRelation,
-  relations
+  operators,
+  orderByOperators,
+  relationExtrasToSQL,
+  relationToSQL,
+  relationsFilterToSQL,
+  relationsOrderToSQL
 };
 //# sourceMappingURL=relations.js.map