drizzle-orm 0.38.4-e36471e → 0.39.0-0cc153d

package/relations.cjs

@@ -29,7 +29,9 @@ __export(relations_exports, {
   RelationsHelperStatic: () => RelationsHelperStatic,
   createRelationsHelper: () => createRelationsHelper,
   defineRelations: () => defineRelations,
+  fieldSelectionToSQL: () => fieldSelectionToSQL,
   getOrderByOperators: () => getOrderByOperators,
+  getTableAsAliasSQL: () => getTableAsAliasSQL,
   mapRelationalRow: () => mapRelationalRow,
   operators: () => operators,
   orderByOperators: () => orderByOperators,
@@ -43,41 +45,27 @@ var import_table = require("./table.cjs");
 var import_table2 = require("./table.cjs");
 var import_column = require("./column.cjs");
 var import_entity = require("./entity.cjs");
-var import_primary_keys = require("./pg-core/primary-keys.cjs");
 var import_expressions = require("./sql/expressions/index.cjs");
 var import_sql = require("./sql/sql.cjs");
-var import_utils = require("./utils.cjs");
 class Relations {
   constructor(schema, tables, config) {
     this.schema = schema;
     this.tables = tables;
     this.config = config;
     for (const [tsName, table] of Object.entries(tables)) {
-      if (!(0, import_entity.is)(table, import_table.Table))
+      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;
-      const tableConfig = this.tablesConfig[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] || {},
-        primaryKey: []
+        relations: config[tsName] || {}
       };
-      for (const column of Object.values(table[import_table.Table.Symbol.Columns])) {
-        if (column.primary) {
-          tableConfig.primaryKey.push(column);
-        }
-      }
-      const extraConfig = table[import_table.Table.Symbol.ExtraConfigBuilder]?.(table);
-      if (extraConfig) {
-        for (const configEntry of Object.values(extraConfig)) {
-          if ((0, import_entity.is)(configEntry, import_primary_keys.PrimaryKeyBuilder)) {
-            tableConfig.primaryKey.push(...configEntry.columns);
-          }
-        }
-      }
     }
     for (const tableConfig of Object.values(this.tablesConfig)) {
       for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
@@ -116,14 +104,14 @@ class Relations {
               );
             }
             for (const column of relation.through.source) {
-              if (column.table !== relation.throughTable) {
+              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 (column.table !== relation.throughTable) {
+              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`
                 );
@@ -222,65 +210,59 @@ class Relation {
 class One extends Relation {
   static [import_entity.entityKind] = "OneV2";
   optional;
-  constructor(targetTable, config) {
+  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?._.column.table;
+        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?._.column.table;
+        this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
         return it._.column;
       });
     }
     if (this.throughTable) {
       this.through = Array.isArray(config?.from) ? {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain -- in case it's undefined, error will be thrown in Relations constructor
-        source: config.from.map((e) => e._.through?._.column),
-        target: (config.to ?? []).map((e) => e._.column)
+        source: config.from.map((c) => c._.through),
+        target: (config.to ?? []).map((c) => c._.through)
       } : {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain -- in case it's undefined, error will be thrown in Relations constructor
-        source: [config?.from?._.through?._.column],
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-        target: [config?.to?._.through?._.column]
+        source: (config?.from ? [config.from] : []).map((c) => c._.through),
+        target: (config?.to ? [config.to] : []).map((c) => c._.through)
       };
     }
     this.optional = config?.optional ?? true;
   }
 }
 class Many extends Relation {
-  constructor(targetTable, config) {
+  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?._.column.table;
+        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?._.column.table;
+        this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
         return it._.column;
       });
     }
     if (this.throughTable) {
       this.through = Array.isArray(config?.from) ? {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain -- in case it's undefined, error will be thrown in Relations constructor
-        source: config.from.map((e) => e._.through?._.column),
-        target: (config.to ?? []).map((e) => e._.column)
+        source: config.from.map((c) => c._.through),
+        target: (config.to ?? []).map((c) => c._.through)
       } : {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain -- in case it's undefined, error will be thrown in Relations constructor
-        source: [config?.from?._.through?._.column],
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-        target: [config?.to?._.through?._.column]
+        source: (config?.from ? [config.from] : []).map((c) => c._.through),
+        target: (config?.to ? [config.to] : []).map((c) => c._.through)
       };
     }
   }
@@ -301,8 +283,7 @@ class Count extends AggregatedField {
     if (!this.query) {
       if (!this.table)
         throw new Error("Table must be set before building aggregate field");
-      const table = this.table;
-      this.query = import_sql.sql`select count(*) as ${import_sql.sql.identifier("r")} from ${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}`.mapWith(Number);
+      this.query = import_sql.sql`select count(*) as ${import_sql.sql.identifier("r")} from ${getTableAsAliasSQL(this.table)}`.mapWith(Number);
     }
     return this.query;
   }
@@ -341,8 +322,7 @@ function getOrderByOperators() {
 }
 function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (value) => value, parseJson = false, path) {
   for (const selectionItem of buildQueryResultSelection) {
-    const field = selectionItem.field;
-    if ((0, import_entity.is)(field, import_table.Table)) {
+    if (selectionItem.selection) {
       const currentPath = `${path ? `${path}.` : ""}${selectionItem.key}`;
       if (row[selectionItem.key] === null)
         continue;
@@ -369,6 +349,7 @@ function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (valu
       );
       continue;
     }
+    const field = selectionItem.field;
     const value = mapColumnValue(row[selectionItem.key]);
     if (value === null)
       continue;
@@ -389,9 +370,9 @@ function mapRelationalRow(row, buildQueryResultSelection, mapColumnValue = (valu
 class RelationsBuilderTable {
   static [import_entity.entityKind] = "RelationsBuilderTable";
   _;
-  constructor(table) {
+  constructor(table, key) {
     this._ = {
-      name: (0, import_table2.getTableName)(table),
+      name: key,
       table
     };
   }
@@ -402,16 +383,22 @@ class RelationsBuilderTable {
 class RelationsBuilderColumn {
   static [import_entity.entityKind] = "RelationsBuilderColumn";
   _;
-  constructor(column, through) {
+  constructor(column, tableName, key, through) {
     this._ = {
-      tableName: (0, import_table2.getTableName)(column.table),
+      tableName,
       data: void 0,
       column,
-      through
+      through,
+      key
     };
   }
   through(column) {
-    return new RelationsBuilderColumn(this._.column, column);
+    return new RelationsBuilderColumn(
+      this._.column,
+      this._.tableName,
+      this._.key,
+      column
+    );
   }
   getSQL() {
     return this._.column.getSQL();
@@ -428,10 +415,10 @@ class RelationsHelperStatic {
     const many = {};
     for (const [tableName, table] of Object.entries(tables)) {
       one[tableName] = (config) => {
-        return new One(table, config);
+        return new One(tables, table, config);
       };
       many[tableName] = (config) => {
-        return new Many(table, config);
+        return new Many(tables, table, config);
       };
     }
     this.one = one;
@@ -447,21 +434,21 @@ class RelationsHelperStatic {
 }
 function createRelationsHelper(schema) {
   const schemaTables = Object.fromEntries(
-    Object.entries(schema).filter((e) => (0, import_entity.is)(e[1], import_table.Table))
+    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, [key, value]) => {
-    if ((0, import_entity.is)(value, import_table.Table)) {
-      const rTable = new RelationsBuilderTable(value);
-      const columns = Object.entries((0, import_utils.getTableColumns)(value)).reduce(
-        (acc2, [key2, column]) => {
-          const rbColumn = new RelationsBuilderColumn(column);
-          acc2[key2] = rbColumn;
+  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[key] = Object.assign(rTable, columns);
+      acc[tKey] = Object.assign(rTable, columns);
     }
     return acc;
   }, {});
@@ -474,6 +461,10 @@ function defineRelations(schema, relations) {
     relations(createRelationsHelper(schema))
   );
 }
+function fieldSelectionToSQL(table, target) {
+  const field = table[import_table2.Columns][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) {
   if (typeof filter !== "object")
     return (0, import_expressions.eq)(column, filter);
@@ -554,9 +545,7 @@ function relationsFilterToSQL(table, filter) {
           continue;
         parts.push(
           (0, import_expressions.or)(
-            ...value.map(
-              (subFilter) => relationsFilterToSQL(table, subFilter)
-            )
+            ...value.map((subFilter) => relationsFilterToSQL(table, subFilter))
           )
         );
         continue;
@@ -571,8 +560,9 @@ function relationsFilterToSQL(table, filter) {
         continue;
       }
       default: {
+        const column = fieldSelectionToSQL(table, target);
         const colFilter = relationsFieldFilterToSQL(
-          table[target],
+          column,
           value
         );
         if (colFilter)
@@ -591,7 +581,10 @@ function relationsOrderToSQL(table, orders) {
   const entries = Object.entries(orders).filter(([_, value]) => value);
   if (!entries.length)
     return void 0;
-  return import_sql.sql.join(entries.map(([column, value]) => (value === "asc" ? import_expressions.asc : import_expressions.desc)(table[import_table2.Columns][column])), import_sql.sql`, `);
+  return import_sql.sql.join(
+    entries.map(([target, value]) => (value === "asc" ? import_expressions.asc : import_expressions.desc)(fieldSelectionToSQL(table, target))),
+    import_sql.sql`, `
+  );
 }
 function relationExtrasToSQL(table, extras) {
   const subqueries = [];
@@ -620,19 +613,19 @@ function relationToSQL(relation, sourceTable, targetTable, throughTable) {
       const t = relation.through.source[i];
       return (0, import_expressions.eq)(
         import_sql.sql`${sourceTable}.${import_sql.sql.identifier(s.name)}`,
-        import_sql.sql`${throughTable}.${import_sql.sql.identifier(t.name)}`
+        import_sql.sql`${throughTable}.${import_sql.sql.identifier((0, import_entity.is)(t._.column, import_column.Column) ? t._.column.name : t._.key)}`
       );
     });
     const innerColumnWhere = relation.targetColumns.map((s, i) => {
       const t = relation.through.target[i];
       return (0, import_expressions.eq)(
-        import_sql.sql`${throughTable}.${import_sql.sql.identifier(t.name)}`,
+        import_sql.sql`${throughTable}.${import_sql.sql.identifier((0, import_entity.is)(t._.column, import_column.Column) ? t._.column.name : t._.key)}`,
         import_sql.sql`${targetTable}.${import_sql.sql.identifier(s.name)}`
       );
     });
     return {
       filter: (0, import_expressions.and)(
-        relation.where ? relation.isReversed ? relationsFilterToSQL(targetTable, relation.where) : relationsFilterToSQL(sourceTable, relation.where) : void 0
+        relation.where ? relationsFilterToSQL(relation.isReversed ? targetTable : sourceTable, relation.where) : void 0
       ),
       joinCondition: (0, import_expressions.and)(
         ...outerColumnWhere,
@@ -649,10 +642,13 @@ function relationToSQL(relation, sourceTable, targetTable, throughTable) {
   });
   const fullWhere = (0, import_expressions.and)(
     ...columnWhere,
-    relation.where ? relation.isReversed ? relationsFilterToSQL(targetTable, relation.where) : relationsFilterToSQL(sourceTable, relation.where) : void 0
+    relation.where ? relationsFilterToSQL(relation.isReversed ? targetTable : sourceTable, relation.where) : void 0
   );
   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}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AggregatedField,
@@ -666,7 +662,9 @@ function relationToSQL(relation, sourceTable, targetTable, throughTable) {
   RelationsHelperStatic,
   createRelationsHelper,
   defineRelations,
+  fieldSelectionToSQL,
   getOrderByOperators,
+  getTableAsAliasSQL,
   mapRelationalRow,
   operators,
   orderByOperators,