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

package/relations.js

@@ -1,5 +1,4 @@
-import { getTableUniqueName, IsAlias, OriginalName, Schema, Table } from "./table.js";
-import { Columns } from "./table.js";
+import { IsAlias, OriginalName, Table, TableColumns, TableSchema } from "./table.js";
 import { aliasedTable } from "./alias.js";
 import { Column } from "./column.js";
 import { entityKind, is } from "./entity.js";
@@ -33,152 +32,149 @@ import {
   or
 } from "./sql/expressions/index.js";
 import { Placeholder, SQL, sql, View } from "./sql/sql.js";
-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 = 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;
+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 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`);
+  }
+  for (const [sourceTableName, tableConfig] of Object.entries(tablesConfig)) {
+    for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+      if (!is(relation, Relation)) {
+        continue;
+      }
+      const relationPrintName = `relations -> ${tableConfig.name}: { ${relationFieldName}: r.${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) => 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[getTableUniqueName(relation.targetTable)];
-        if (!targetTableTsName) {
+        reverseRelation = reverseRelations[0];
+        if (!reverseRelation) {
           throw new Error(
-            `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) => 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) => 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 "${this.tableNamesMap[getTableUniqueName(relation.sourceTable)] ?? 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[getTableUniqueName(relation.sourceTable)] ?? 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 [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 [entityKind] = "RelationV2";
@@ -188,15 +184,17 @@ class Relation {
   alias;
   where;
   sourceTable;
+  targetTable;
   through;
   throughTable;
   isReversed;
 }
 class One extends Relation {
   static [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) {
@@ -221,8 +219,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;
@@ -246,6 +244,7 @@ class Many extends Relation {
     }
   }
   static [entityKind] = "ManyV2";
+  relationType = "many";
 }
 class AggregatedField {
   static [entityKind] = "AggregatedField";
@@ -348,9 +347,9 @@ function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (valu
 class RelationsBuilderTable {
   static [entityKind] = "RelationsBuilderTable";
   _;
-  constructor(table, key) {
+  constructor(table, name) {
     this._ = {
-      name: key,
+      name,
       table
     };
   }
@@ -361,7 +360,6 @@ class RelationsBuilderColumn {
   constructor(column, tableName, key) {
     this._ = {
       tableName,
-      data: void 0,
       column,
       key
     };
@@ -381,7 +379,6 @@ class RelationsBuilderJunctionColumn {
   constructor(column, tableName, key, through) {
     this._ = {
       tableName,
-      data: void 0,
       column,
       through,
       key
@@ -390,6 +387,7 @@ class RelationsBuilderJunctionColumn {
 }
 class RelationsHelperStatic {
   static [entityKind] = "RelationsHelperStatic";
+  // declare readonly $brand: 'RelationsHelperStatic';
   _;
   constructor(tables) {
     this._ = {
@@ -399,10 +397,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;
@@ -417,37 +415,44 @@ class RelationsHelperStatic {
     }
   };
 }
-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);
-    }
+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(
+      (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]) => is(e, Table) || is(e, 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[Columns][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) {
@@ -510,7 +515,7 @@ function relationsFieldFilterToSQL(column, filter) {
   if (!parts.length) return void 0;
   return 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 = [];
@@ -527,7 +532,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         parts.push(
           or(
             ...value.map(
-              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, tableNamesMap, casing, depth)
+              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, casing, depth)
             )
           )
         );
@@ -538,7 +543,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         parts.push(
           and(
             ...value.map(
-              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, tableNamesMap, casing, depth)
+              (subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, casing, depth)
             )
           )
         );
@@ -551,7 +556,6 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
           value,
           tableRelations,
           tablesRelations,
-          tableNamesMap,
           casing,
           depth
         );
@@ -560,7 +564,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         continue;
       }
       default: {
-        if (table[Columns][target]) {
+        if (table[TableColumns][target]) {
           const column = fieldSelectionToSQL(table, target);
           const colFilter = relationsFieldFilterToSQL(
             column,
@@ -577,7 +581,7 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
         }
         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 targetConfig = tablesRelations[relation.targetTableName];
         const {
           filter: relationFilter,
           joinCondition
@@ -587,7 +591,6 @@ function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelation
           value,
           targetConfig.relations,
           tablesRelations,
-          tableNamesMap,
           casing,
           depth + 1
         );
@@ -671,7 +674,7 @@ function relationToSQL(casing, relation, sourceTable, targetTable, throughTable)
   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}`;
+  return sql`${table[IsAlias] ? sql`${sql`${sql.identifier(table[TableSchema] ?? "")}.`.if(table[TableSchema])}${sql.identifier(table[OriginalName])} as ${table}` : table}`;
 }
 export {
   AggregatedField,
@@ -679,19 +682,23 @@ export {
   Many,
   One,
   Relation,
-  Relations,
   RelationsBuilderColumn,
   RelationsBuilderJunctionColumn,
   RelationsBuilderTable,
   RelationsHelperStatic,
+  buildRelations,
+  buildRelationsParts,
   createRelationsHelper,
   defineRelations,
+  defineRelationsPart,
+  extractTablesFromSchema,
   fieldSelectionToSQL,
   getOrderByOperators,
   getTableAsAliasSQL,
   mapRelationalRow,
   operators,
   orderByOperators,
+  processRelations,
   relationExtrasToSQL,
   relationToSQL,
   relationsFilterToSQL,