drizzle-orm 1.0.0-beta.1-84d9a79 → 1.0.0-beta.1-d407048

package/query-builders/select.types.d.cts

@@ -1,4 +1,4 @@
-import type { ChangeColumnTableName, ColumnDataType, Dialect } from "../column-builder.cjs";
+import type { ChangeColumnTableName, ColumnType, Dialect } from "../column-builder.cjs";
 import type { AnyColumn, Column, ColumnBaseConfig, GetColumnData, UpdateColConfig } from "../column.cjs";
 import type { SelectedFields } from "../operations.cjs";
 import type { ColumnsSelection, SQL, View } from "../sql/sql.cjs";
@@ -10,7 +10,7 @@ export type JoinNullability = 'nullable' | 'not-null';
 export type ApplyNullability<T, TNullability extends JoinNullability> = TNullability extends 'nullable' ? T | null : TNullability extends 'null' ? null : T;
 export type ApplyNullabilityToColumn<TColumn extends Column, TNullability extends JoinNullability> = TNullability extends 'not-null' ? TColumn : Column<Assume<UpdateColConfig<TColumn['_'], {
     notNull: TNullability extends 'nullable' ? false : TColumn['_']['notNull'];
-}>, ColumnBaseConfig<ColumnDataType, string>>>;
+}>, ColumnBaseConfig<ColumnType>>>;
 export type ApplyNotNullMapToJoins<TResult, TNullabilityMap extends Record<string, JoinNullability>> = {
     [TTableName in keyof TResult & keyof TNullabilityMap & string]: ApplyNullability<TResult[TTableName], TNullabilityMap[TTableName]>;
 } & {};

package/query-builders/select.types.d.ts

@@ -1,4 +1,4 @@
-import type { ChangeColumnTableName, ColumnDataType, Dialect } from "../column-builder.js";
+import type { ChangeColumnTableName, ColumnType, Dialect } from "../column-builder.js";
 import type { AnyColumn, Column, ColumnBaseConfig, GetColumnData, UpdateColConfig } from "../column.js";
 import type { SelectedFields } from "../operations.js";
 import type { ColumnsSelection, SQL, View } from "../sql/sql.js";
@@ -10,7 +10,7 @@ export type JoinNullability = 'nullable' | 'not-null';
 export type ApplyNullability<T, TNullability extends JoinNullability> = TNullability extends 'nullable' ? T | null : TNullability extends 'null' ? null : T;
 export type ApplyNullabilityToColumn<TColumn extends Column, TNullability extends JoinNullability> = TNullability extends 'not-null' ? TColumn : Column<Assume<UpdateColConfig<TColumn['_'], {
     notNull: TNullability extends 'nullable' ? false : TColumn['_']['notNull'];
-}>, ColumnBaseConfig<ColumnDataType, string>>>;
+}>, ColumnBaseConfig<ColumnType>>>;
 export type ApplyNotNullMapToJoins<TResult, TNullabilityMap extends Record<string, JoinNullability>> = {
     [TTableName in keyof TResult & keyof TNullabilityMap & string]: ApplyNullability<TResult[TTableName], TNullabilityMap[TTableName]>;
 } & {};

package/relations.cjs

@@ -23,19 +23,23 @@ __export(relations_exports, {
   Many: () => Many,
   One: () => One,
   Relation: () => Relation,
-  Relations: () => Relations,
   RelationsBuilderColumn: () => RelationsBuilderColumn,
   RelationsBuilderJunctionColumn: () => RelationsBuilderJunctionColumn,
   RelationsBuilderTable: () => RelationsBuilderTable,
   RelationsHelperStatic: () => RelationsHelperStatic,
+  buildRelations: () => buildRelations,
+  buildRelationsParts: () => buildRelationsParts,
   createRelationsHelper: () => createRelationsHelper,
   defineRelations: () => defineRelations,
+  defineRelationsPart: () => defineRelationsPart,
+  extractTablesFromSchema: () => extractTablesFromSchema,
   fieldSelectionToSQL: () => fieldSelectionToSQL,
   getOrderByOperators: () => getOrderByOperators,
   getTableAsAliasSQL: () => getTableAsAliasSQL,
   mapRelationalRow: () => mapRelationalRow,
   operators: () => operators,
   orderByOperators: () => orderByOperators,
+  processRelations: () => processRelations,
   relationExtrasToSQL: () => relationExtrasToSQL,
   relationToSQL: () => relationToSQL,
   relationsFilterToSQL: () => relationsFilterToSQL,
@@ -43,159 +47,155 @@ __export(relations_exports, {
 });
 module.exports = __toCommonJS(relations_exports);
 var import_table = require("./table.cjs");
-var import_table2 = require("./table.cjs");
 var import_alias = require("./alias.cjs");
 var import_column = require("./column.cjs");
 var import_entity = require("./entity.cjs");
 var import_errors = require("./errors.cjs");
 var import_expressions = require("./sql/expressions/index.cjs");
 var import_sql = require("./sql/sql.cjs");
-class Relations {
-  constructor(schema, tables, config) {
-    this.schema = schema;
-    this.tables = tables;
-    this.config = config;
-    for (const [tsName, table] of Object.entries(tables)) {
-      const isTable = (0, import_entity.is)(table, import_table.Table);
-      const isView = (0, import_entity.is)(table, import_sql.View);
-      if (!(isTable || isView)) continue;
-      this.tableNamesMap[(0, import_table.getTableUniqueName)(table)] = tsName;
-      this.tablesConfig[tsName] = {
-        table,
-        tsName,
-        dbName: table[import_table.Table.Symbol.Name],
-        schema: table[import_table.Table.Symbol.Schema],
-        columns: table[import_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 (!(0, import_entity.is)(relation, Relation)) {
-          continue;
-        }
-        relation.sourceTable = tableConfig.table;
-        relation.fieldName = relationFieldName;
+function processRelations(tablesConfig, tables) {
+  for (const tableConfig of Object.values(tablesConfig)) {
+    for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+      if (!(0, import_entity.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 (!(0, import_entity.is)(relation, Relation)) {
-          continue;
-        }
-        const relationPrintName = `relations -> ${tableConfig.tsName}: { ${relationFieldName}: r.${(0, import_entity.is)(relation, One) ? "one" : "many"}.${this.tableNamesMap[(0, import_table.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`);
+  }
+  for (const [sourceTableName, tableConfig] of Object.entries(tablesConfig)) {
+    for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+      if (!(0, import_entity.is)(relation, Relation)) {
+        continue;
+      }
+      const relationPrintName = `relations -> ${tableConfig.name}: { ${relationFieldName}: r.${(0, import_entity.is)(relation, One) ? "one" : "many"}.${relation.targetTableName}(...) }`;
+      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.sourceColumns && relation.targetColumns) {
-          if (relation.sourceColumns.length !== relation.targetColumns.length && !relation.throughTable) {
+        if (relation.through) {
+          if (relation.through.source.length !== relation.sourceColumns.length || relation.through.target.length !== relation.targetColumns.length) {
             throw new Error(
-              `${relationPrintName}: "from" and "to" fields without "through" must have the same length`
+              `${relationPrintName}: ".through(column)" must be used either on all columns in "from" and "to" or not defined on any of them`
             );
           }
-          if (relation.through) {
-            if (relation.through.source.length !== relation.sourceColumns.length || relation.through.target.length !== relation.targetColumns.length) {
+          for (const column of relation.through.source) {
+            if (tables[column._.tableName] !== relation.throughTable) {
               throw new Error(
-                `${relationPrintName}: ".through(column)" must be used either on all columns in "from" and "to" or not defined on any of them`
+                `${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`
               );
             }
-            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`
-                );
-              }
+          }
+          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) {
+        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 = relation.targetTableName;
+      const reverseTableConfig = 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) => (0, import_entity.is)(it, Relation) && it.alias === relation.alias && it !== relation
+        );
+        if (reverseRelations.length > 1) {
           throw new Error(
-            `${relationPrintName}: relation must have either both "from" and "to" defined, or none of them`
+            `${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(", ")}`
           );
         }
-        let reverseRelation;
-        const targetTableTsName = this.tableNamesMap[(0, import_table.getTableUniqueName)(relation.targetTable)];
-        if (!targetTableTsName) {
+        reverseRelation = reverseRelations[0];
+        if (!reverseRelation) {
           throw new Error(
-            `Table "${(0, import_table.getTableUniqueName)(relation.targetTable)}" not found in provided TS schema`
+            `${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}"`
           );
         }
-        const reverseTableConfig = this.tablesConfig[targetTableTsName];
-        if (!reverseTableConfig) {
+      } else {
+        const reverseRelations = Object.values(reverseTableConfig.relations).filter(
+          (it) => (0, import_entity.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 no reverse relations of table "${targetTableTsName}" were found"`
-          );
-        }
-        if (relation.alias) {
-          const reverseRelations = Object.values(reverseTableConfig.relations).filter(
-            (it) => (0, import_entity.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) => (0, import_entity.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 "${this.tableNamesMap[(0, import_table.getTableUniqueName)(relation.sourceTable)] ?? (0, import_table.getTableUniqueName)(relation.sourceTable)}" were found.
+            `${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and multiple relations between "${targetTableTsName}" and "${sourceTableName}" 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 "${this.tableNamesMap[(0, import_table.getTableUniqueName)(relation.sourceTable)] ?? (0, import_table.getTableUniqueName)(relation.sourceTable)}" was found`
-            );
-          }
+          );
         }
-        if (!reverseRelation.sourceColumns || !reverseRelation.targetColumns) {
+        reverseRelation = reverseRelations[0];
+        if (!reverseRelation) {
           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`
+            `${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and no reverse relation of table "${targetTableTsName}" with target table "${sourceTableName}" was found`
           );
         }
-        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;
       }
+      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 [import_entity.entityKind] = "RelationsV2";
-  /** table DB name -> schema table key */
-  tableNamesMap = {};
-  tablesConfig = {};
+  return tablesConfig;
+}
+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);
+}
+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 Relation {
-  constructor(targetTable) {
+  constructor(targetTable, targetTableName) {
+    this.targetTableName = targetTableName;
     this.targetTable = targetTable;
   }
   static [import_entity.entityKind] = "RelationV2";
@@ -205,15 +205,17 @@ class Relation {
   alias;
   where;
   sourceTable;
+  targetTable;
   through;
   throughTable;
   isReversed;
 }
 class One extends Relation {
   static [import_entity.entityKind] = "OneV2";
+  relationType = "one";
   optional;
-  constructor(tables, targetTable, config) {
-    super(targetTable);
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
     this.alias = config?.alias;
     this.where = config?.where;
     if (config?.from) {
@@ -238,8 +240,8 @@ class One extends Relation {
   }
 }
 class Many extends Relation {
-  constructor(tables, targetTable, config) {
-    super(targetTable);
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
     this.config = config;
     this.alias = config?.alias;
     this.where = config?.where;
@@ -263,6 +265,7 @@ class Many extends Relation {
     }
   }
   static [import_entity.entityKind] = "ManyV2";
+  relationType = "many";
 }
 class AggregatedField {
   static [import_entity.entityKind] = "AggregatedField";
@@ -365,9 +368,9 @@ function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (valu
 class RelationsBuilderTable {
   static [import_entity.entityKind] = "RelationsBuilderTable";
   _;
-  constructor(table, key) {
+  constructor(table, name) {
     this._ = {
-      name: key,
+      name,
       table
     };
   }
@@ -378,7 +381,6 @@ class RelationsBuilderColumn {
   constructor(column, tableName, key) {
     this._ = {
       tableName,
-      data: void 0,
       column,
       key
     };
@@ -398,7 +400,6 @@ class RelationsBuilderJunctionColumn {
   constructor(column, tableName, key, through) {
     this._ = {
       tableName,
-      data: void 0,
       column,
       through,
       key
@@ -407,6 +408,7 @@ class RelationsBuilderJunctionColumn {
 }
 class RelationsHelperStatic {
   static [import_entity.entityKind] = "RelationsHelperStatic";
+  // declare readonly $brand: 'RelationsHelperStatic';
   _;
   constructor(tables) {
     this._ = {
@@ -416,10 +418,10 @@ class RelationsHelperStatic {
     const many = {};
     for (const [tableName, table] of Object.entries(tables)) {
       one[tableName] = (config) => {
-        return new One(tables, table, config);
+        return new One(tables, table, tableName, config);
       };
       many[tableName] = (config) => {
-        return new Many(tables, table, config);
+        return new Many(tables, table, tableName, config);
       };
     }
     this.one = one;
@@ -434,37 +436,44 @@ class RelationsHelperStatic {
     }
   };
 }
-function createRelationsHelper(schema) {
-  const schemaTables = Object.fromEntries(
-    Object.entries(schema).filter((e) => (0, import_entity.is)(e[1], import_table.Table) || (0, import_entity.is)(e[1], import_sql.View))
-  );
-  const helperStatic = new RelationsHelperStatic(schemaTables);
-  const tables = Object.entries(schema).reduce((acc, [tKey, value]) => {
-    if ((0, import_entity.is)(value, import_table.Table) || (0, import_entity.is)(value, import_sql.View)) {
-      const rTable = new RelationsBuilderTable(value, tKey);
-      const columns = Object.entries(value[import_table2.Columns]).reduce(
-        (acc2, [cKey, column]) => {
-          const rbColumn = new RelationsBuilderColumn(column, tKey, cKey);
-          acc2[cKey] = rbColumn;
-          return acc2;
-        },
-        {}
-      );
-      acc[tKey] = Object.assign(rTable, columns);
-    }
+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[import_table.TableColumns]).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);
+  return Object.assign(helperStatic, relationsTables);
 }
-function defineRelations(schema, relations) {
-  return new Relations(
-    schema,
-    schema,
-    relations ? relations(createRelationsHelper(schema)) : {}
+function extractTablesFromSchema(schema) {
+  return Object.fromEntries(
+    Object.entries(schema).filter(([_, e]) => (0, import_entity.is)(e, import_table.Table) || (0, import_entity.is)(e, import_sql.View))
   );
 }
+function defineRelations(schema, relations) {
+  const tables = extractTablesFromSchema(schema);
+  const config = relations ? relations(
+    createRelationsHelper(tables)
+  ) : {};
+  return buildRelations(tables, config);
+}
+function defineRelationsPart(schema, relations) {
+  const tables = extractTablesFromSchema(schema);
+  const config = relations ? relations(
+    createRelationsHelper(tables)
+  ) : Object.fromEntries(Object.keys(tables).map((k) => [k, {}]));
+  return buildRelationsParts(tables, config);
+}
 function fieldSelectionToSQL(table, target) {
-  const field = table[import_table2.Columns][target];
+  const field = table[import_table.TableColumns][target];
   return field ? (0, import_entity.is)(field, import_column.Column) ? field : (0, import_entity.is)(field, import_sql.SQL.Aliased) ? import_sql.sql`${table}.${import_sql.sql.identifier(field.fieldAlias)}` : import_sql.sql`${table}.${import_sql.sql.identifier(target)}` : import_sql.sql`${table}.${import_sql.sql.identifier(target)}`;
 }
 function relationsFieldFilterToSQL(column, filter) {
@@ -527,7 +536,7 @@ function relationsFieldFilterToSQL(column, filter) {
   if (!parts.length) return void 0;
   return (0, import_expressions.and)(...parts);
 }
-function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelations = {}, tableNamesMap = {}, casing, depth = 0) {
+function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelations = {}, casing, depth = 0) {
   const entries = Object.entries(filter);
   if (!entries.length) return void 0;
   const parts = [];
@@ -544,7 +553,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         parts.push(
           (0, import_expressions.or)(
             ...value.map(
-              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, tableNamesMap, casing, depth)
+              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, casing, depth)
             )
           )
         );
@@ -555,7 +564,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         parts.push(
           (0, import_expressions.and)(
             ...value.map(
-              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, tableNamesMap, casing, depth)
+              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, casing, depth)
             )
           )
         );
@@ -568,7 +577,6 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
           value,
           tableRelations,
           tablesRelations,
-          tableNamesMap,
           casing,
           depth
         );
@@ -577,7 +585,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         continue;
       }
       default: {
-        if (table[import_table2.Columns][target]) {
+        if (table[import_table.TableColumns][target]) {
           const column = fieldSelectionToSQL(table, target);
           const colFilter = relationsFieldFilterToSQL(
             column,
@@ -594,7 +602,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         }
         const targetTable = (0, import_alias.aliasedTable)(relation.targetTable, `f${depth}`);
         const throughTable = relation.throughTable ? (0, import_alias.aliasedTable)(relation.throughTable, `ft${depth}`) : void 0;
-        const targetConfig = tablesRelations[tableNamesMap[(0, import_table.getTableUniqueName)(relation.targetTable)]];
+        const targetConfig = tablesRelations[relation.targetTableName];
         const {
           filter: relationFilter,
           joinCondition
@@ -604,7 +612,6 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
           value,
           targetConfig.relations,
           tablesRelations,
-          tableNamesMap,
           casing,
           depth + 1
         );
@@ -688,7 +695,7 @@ function relationToSQL(casing, relation, sourceTable, targetTable, throughTable)
   return { filter: fullWhere };
 }
 function getTableAsAliasSQL(table) {
-  return import_sql.sql`${table[import_table.IsAlias] ? import_sql.sql`${import_sql.sql`${import_sql.sql.identifier(table[import_table.Schema] ?? "")}.`.if(table[import_table.Schema])}${import_sql.sql.identifier(table[import_table.OriginalName])} as ${table}` : table}`;
+  return import_sql.sql`${table[import_table.IsAlias] ? import_sql.sql`${import_sql.sql`${import_sql.sql.identifier(table[import_table.TableSchema] ?? "")}.`.if(table[import_table.TableSchema])}${import_sql.sql.identifier(table[import_table.OriginalName])} as ${table}` : table}`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -697,19 +704,23 @@ function getTableAsAliasSQL(table) {
   Many,
   One,
   Relation,
-  Relations,
   RelationsBuilderColumn,
   RelationsBuilderJunctionColumn,
   RelationsBuilderTable,
   RelationsHelperStatic,
+  buildRelations,
+  buildRelationsParts,
   createRelationsHelper,
   defineRelations,
+  defineRelationsPart,
+  extractTablesFromSchema,
   fieldSelectionToSQL,
   getOrderByOperators,
   getTableAsAliasSQL,
   mapRelationalRow,
   operators,
   orderByOperators,
+  processRelations,
   relationExtrasToSQL,
   relationToSQL,
   relationsFilterToSQL,