drizzle-orm 0.40.0-262a7b0 → 0.40.0-53e792e

package/mysql-core/dialect.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var dialect_exports = {};
 __export(dialect_exports, {
   MySqlDialect: () => MySqlDialect
 });
 module.exports = __toCommonJS(dialect_exports);
+var V1 = __toESM(require("../_relations.cjs"), 1);
 var import_alias = require("../alias.cjs");
 var import_casing = require("../casing.cjs");
 var import_column = require("../column.cjs");
@@ -401,7 +412,8 @@ class MySqlDialect {
       invokeSource
     });
   }
-  buildRelationalQuery({
+  /** @deprecated */
+  _buildRelationalQuery({
     fullSchema,
     schema,
     tableNamesMap,
@@ -430,7 +442,7 @@ class MySqlDialect {
         Object.entries(tableConfig.columns).map(([key, value]) => [key, (0, import_alias.aliasedTableColumn)(value, tableAlias)])
       );
       if (config.where) {
-        const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, (0, import_relations.getOperators)()) : config.where;
+        const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, V1.getOperators()) : config.where;
         where = whereSql && (0, import_alias.mapColumnsInSQLToAlias)(whereSql, tableAlias);
       }
       const fieldsSelection = [];
@@ -482,7 +494,7 @@ class MySqlDialect {
           selection: []
         });
       }
-      let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, (0, import_relations.getOrderByOperators)()) : config.orderBy ?? [];
+      let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, V1.getOrderByOperators()) : config.orderBy ?? [];
       if (!Array.isArray(orderByOrig)) {
         orderByOrig = [orderByOrig];
       }
@@ -499,7 +511,7 @@ class MySqlDialect {
         queryConfig: selectedRelationConfigValue,
         relation
       } of selectedRelations) {
-        const normalizedRelation = (0, import_relations.normalizeRelation)(schema, tableNamesMap, relation);
+        const normalizedRelation = V1.normalizeRelation(schema, tableNamesMap, relation);
         const relationTableName = (0, import_table.getTableUniqueName)(relation.referencedTable);
         const relationTableTsName = tableNamesMap[relationTableName];
         const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
@@ -511,13 +523,13 @@ class MySqlDialect {
             )
           )
         );
-        const builtRelation = this.buildRelationalQuery({
+        const builtRelation = this._buildRelationalQuery({
           fullSchema,
           schema,
           tableNamesMap,
           table: fullSchema[relationTableTsName],
           tableConfig: schema[relationTableTsName],
-          queryConfig: (0, import_entity.is)(relation, import_relations.One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
+          queryConfig: (0, import_entity.is)(relation, V1.One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
           tableAlias: relationTableAlias,
           joinOn: joinOn2,
           nestedQueryRelation: relation
@@ -552,7 +564,7 @@ class MySqlDialect {
         ),
         import_sql.sql`, `
       )})`;
-      if ((0, import_entity.is)(nestedQueryRelation, import_relations.Many)) {
+      if ((0, import_entity.is)(nestedQueryRelation, V1.Many)) {
         field = import_sql.sql`coalesce(json_arrayagg(${field}), json_array())`;
       }
       const nestedSelection = [{
@@ -626,7 +638,8 @@ class MySqlDialect {
       selection
     };
   }
-  buildRelationalQueryWithoutLateralSubqueries({
+  /** @deprecated */
+  _buildRelationalQueryWithoutLateralSubqueries({
     fullSchema,
     schema,
     tableNamesMap,
@@ -654,7 +667,7 @@ class MySqlDialect {
         Object.entries(tableConfig.columns).map(([key, value]) => [key, (0, import_alias.aliasedTableColumn)(value, tableAlias)])
       );
       if (config.where) {
-        const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, (0, import_relations.getOperators)()) : config.where;
+        const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, V1.getOperators()) : config.where;
         where = whereSql && (0, import_alias.mapColumnsInSQLToAlias)(whereSql, tableAlias);
       }
       const fieldsSelection = [];
@@ -706,7 +719,7 @@ class MySqlDialect {
           selection: []
         });
       }
-      let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, (0, import_relations.getOrderByOperators)()) : config.orderBy ?? [];
+      let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, V1.getOrderByOperators()) : config.orderBy ?? [];
       if (!Array.isArray(orderByOrig)) {
         orderByOrig = [orderByOrig];
       }
@@ -723,7 +736,7 @@ class MySqlDialect {
         queryConfig: selectedRelationConfigValue,
         relation
       } of selectedRelations) {
-        const normalizedRelation = (0, import_relations.normalizeRelation)(schema, tableNamesMap, relation);
+        const normalizedRelation = V1.normalizeRelation(schema, tableNamesMap, relation);
         const relationTableName = (0, import_table.getTableUniqueName)(relation.referencedTable);
         const relationTableTsName = tableNamesMap[relationTableName];
         const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
@@ -735,19 +748,19 @@ class MySqlDialect {
             )
           )
         );
-        const builtRelation = this.buildRelationalQueryWithoutLateralSubqueries({
+        const builtRelation = this._buildRelationalQueryWithoutLateralSubqueries({
           fullSchema,
           schema,
           tableNamesMap,
           table: fullSchema[relationTableTsName],
           tableConfig: schema[relationTableTsName],
-          queryConfig: (0, import_entity.is)(relation, import_relations.One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
+          queryConfig: (0, import_entity.is)(relation, V1.One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
           tableAlias: relationTableAlias,
           joinOn: joinOn2,
           nestedQueryRelation: relation
         });
         let fieldSql = import_sql.sql`(${builtRelation.sql})`;
-        if ((0, import_entity.is)(relation, import_relations.Many)) {
+        if ((0, import_entity.is)(relation, V1.Many)) {
           fieldSql = import_sql.sql`coalesce(${fieldSql}, json_array())`;
         }
         const field = fieldSql.as(selectedRelationTsKey);
@@ -775,7 +788,7 @@ class MySqlDialect {
         ),
         import_sql.sql`, `
       )})`;
-      if ((0, import_entity.is)(nestedQueryRelation, import_relations.Many)) {
+      if ((0, import_entity.is)(nestedQueryRelation, V1.Many)) {
         field = import_sql.sql`json_arrayagg(${field})`;
       }
       const nestedSelection = [{
@@ -847,6 +860,176 @@ class MySqlDialect {
       selection
     };
   }
+  nestedSelectionerror() {
+    throw new import_errors.DrizzleError({
+      message: `Views with nested selections are not supported by the relational query builder`
+    });
+  }
+  buildRqbColumn(table, column, key) {
+    if ((0, import_entity.is)(column, import_column.Column)) {
+      switch (column.columnType) {
+        default: {
+          return import_sql.sql`${table}.${import_sql.sql.identifier(this.casing.getColumnCasing(column))} as ${import_sql.sql.identifier(key)}`;
+        }
+      }
+    }
+    return import_sql.sql`${table}.${(0, import_entity.is)(column, import_sql.SQL.Aliased) ? import_sql.sql.identifier(column.fieldAlias) : (0, import_sql.isSQLWrapper)(column) ? import_sql.sql.identifier(key) : this.nestedSelectionerror()} as ${import_sql.sql.identifier(key)}`;
+  }
+  unwrapAllColumns = (table, selection) => {
+    return import_sql.sql.join(
+      Object.entries(table[import_table.Columns]).map(([k, v]) => {
+        selection.push({
+          key: k,
+          field: v
+        });
+        return this.buildRqbColumn(table, v, k);
+      }),
+      import_sql.sql`, `
+    );
+  };
+  getSelectedTableColumns = (table, columns) => {
+    const selectedColumns = [];
+    const columnContainer = table[import_table.Columns];
+    const entries = Object.entries(columns);
+    let colSelectionMode;
+    for (const [k, v] of entries) {
+      if (v === void 0)
+        continue;
+      colSelectionMode = colSelectionMode || v;
+      if (v) {
+        const column = columnContainer[k];
+        selectedColumns.push({
+          column,
+          tsName: k
+        });
+      }
+    }
+    if (colSelectionMode === false) {
+      for (const [k, v] of Object.entries(columnContainer)) {
+        if (columns[k] === false)
+          continue;
+        selectedColumns.push({
+          column: v,
+          tsName: k
+        });
+      }
+    }
+    return selectedColumns;
+  };
+  buildColumns = (table, selection, params) => params?.columns ? (() => {
+    const columnIdentifiers = [];
+    const selectedColumns = this.getSelectedTableColumns(table, params.columns);
+    for (const { column, tsName } of selectedColumns) {
+      columnIdentifiers.push(this.buildRqbColumn(table, column, tsName));
+      selection.push({
+        key: tsName,
+        field: column
+      });
+    }
+    return columnIdentifiers.length ? import_sql.sql.join(columnIdentifiers, import_sql.sql`, `) : void 0;
+  })() : this.unwrapAllColumns(table, selection);
+  buildRelationalQuery({
+    tables,
+    schema,
+    tableNamesMap,
+    table,
+    tableConfig,
+    queryConfig: config,
+    relationWhere,
+    mode,
+    errorPath,
+    depth,
+    isNested,
+    throughJoin
+  }) {
+    const selection = [];
+    const isSingle = mode === "first";
+    const params = config === true ? void 0 : config;
+    const currentPath = errorPath ?? "";
+    const currentDepth = depth ?? 0;
+    if (!currentDepth)
+      table = (0, import_alias.aliasedTable)(table, `d${currentDepth}`);
+    const limit = isSingle ? 1 : params?.limit;
+    const offset = params?.offset;
+    const columns = this.buildColumns(table, selection, params);
+    const where = params?.where && relationWhere ? (0, import_expressions.and)(
+      (0, import_relations.relationsFilterToSQL)(table, params.where, tableConfig.relations, schema, tableNamesMap, this.casing),
+      relationWhere
+    ) : params?.where ? (0, import_relations.relationsFilterToSQL)(table, params.where, tableConfig.relations, schema, tableNamesMap, this.casing) : relationWhere;
+    const order = params?.orderBy ? (0, import_relations.relationsOrderToSQL)(table, params.orderBy) : void 0;
+    const extras = params?.extras ? (0, import_relations.relationExtrasToSQL)(table, params.extras) : void 0;
+    if (extras)
+      selection.push(...extras.selection);
+    const selectionArr = columns ? [columns] : [];
+    const joins = params ? (() => {
+      const { with: joins2 } = params;
+      if (!joins2)
+        return;
+      const withEntries = Object.entries(joins2).filter(([_, v]) => v);
+      if (!withEntries.length)
+        return;
+      return import_sql.sql.join(
+        withEntries.map(([k, join]) => {
+          selectionArr.push(import_sql.sql`${import_sql.sql.identifier(k)}.${import_sql.sql.identifier("r")} as ${import_sql.sql.identifier(k)}`);
+          const relation = tableConfig.relations[k];
+          const isSingle2 = (0, import_entity.is)(relation, import_relations.One);
+          const targetTable = (0, import_alias.aliasedTable)(relation.targetTable, `d${currentDepth + 1}`);
+          const throughTable = relation.throughTable ? (0, import_alias.aliasedTable)(relation.throughTable, `tr${currentDepth}`) : void 0;
+          const { filter, joinCondition } = (0, import_relations.relationToSQL)(
+            this.casing,
+            relation,
+            table,
+            targetTable,
+            throughTable
+          );
+          const throughJoin2 = throughTable ? import_sql.sql` inner join ${(0, import_relations.getTableAsAliasSQL)(throughTable)} on ${joinCondition}` : void 0;
+          const innerQuery = this.buildRelationalQuery({
+            table: targetTable,
+            mode: isSingle2 ? "first" : "many",
+            schema,
+            queryConfig: join,
+            tableConfig: schema[tableNamesMap[(0, import_table.getTableUniqueName)(relation.targetTable)]],
+            tableNamesMap,
+            tables,
+            relationWhere: filter,
+            errorPath: `${currentPath.length ? `${currentPath}.` : ""}${k}`,
+            depth: currentDepth + 1,
+            isNested: true,
+            throughJoin: throughJoin2
+          });
+          selection.push({
+            field: targetTable,
+            key: k,
+            selection: innerQuery.selection,
+            isArray: !isSingle2,
+            isOptional: (relation.optional ?? false) || join !== true && !!join.where
+          });
+          const jsonColumns = import_sql.sql.join(
+            innerQuery.selection.map((s) => import_sql.sql`${import_sql.sql.raw(this.escapeString(s.key))}, ${import_sql.sql.identifier(s.key)}`),
+            import_sql.sql`, `
+          );
+          const joinQuery = import_sql.sql` left join lateral(select ${import_sql.sql`${isSingle2 ? import_sql.sql`json_object(${jsonColumns})` : import_sql.sql`coalesce(json_arrayagg(json_object(${jsonColumns})), json_array())`} as ${import_sql.sql.identifier("r")}`} from (${innerQuery.sql}) as ${import_sql.sql.identifier("t")}) as ${import_sql.sql.identifier(k)} on true`;
+          return joinQuery;
+        })
+      );
+    })() : void 0;
+    if (extras?.sql)
+      selectionArr.push(extras.sql);
+    if (!selectionArr.length) {
+      throw new import_errors.DrizzleError({
+        message: `No fields selected for table "${tableConfig.tsName}"${currentPath ? ` ("${currentPath}")` : ""}`
+      });
+    }
+    if (isNested && order) {
+      selectionArr.push(import_sql.sql`row_number() over (order by ${order})`);
+    }
+    const selectionSet = import_sql.sql.join(selectionArr, import_sql.sql`, `);
+    const query = import_sql.sql`select ${selectionSet} from ${(0, import_relations.getTableAsAliasSQL)(table)}${throughJoin}${import_sql.sql`${joins}`.if(joins)}${import_sql.sql` where ${where}`.if(where)}${import_sql.sql` order by ${order}`.if(order)}${import_sql.sql` limit ${limit}`.if(limit !== void 0)}${import_sql.sql` offset ${offset}`.if(offset !== void 0)}`;
+    return {
+      sql: query,
+      selection
+    };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {