drizzle-orm 0.26.0 → 0.26.1-c8de0ba

package/{relations-7adf6be2.mjs → relations-c9e54a8f.mjs}

@@ -1538,19 +1538,7 @@ class PgDialect {
             }));
             return {
                 tableTsKey: tableConfig.tsName,
-                sql: this.buildSelectQuery({
-                    table,
-                    fields: {},
-                    fieldsFlat: selectionEntries.map(([, c]) => ({
-                        path: [c.name],
-                        field: c,
-                    })),
-                    groupBy: [],
-                    orderBy: [],
-                    joins: [],
-                    lockingClauses: [],
-                    withList: [],
-                }),
+                sql: table,
                 selection,
             };
         }
@@ -1604,9 +1592,30 @@ class PgDialect {
         for (const { key, value } of selectedExtras) {
             fieldsSelection[key] = value;
         }
+        let where;
+        if (config.where) {
+            const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
+            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+        }
+        const groupBy = ((tableConfig.primaryKey.length > 0 && selectedRelations.length < 2)
+            ? tableConfig.primaryKey
+            : Object.values(tableConfig.columns)).map((c) => aliasedTableColumn(c, tableAlias));
+        let orderByOrig = typeof config.orderBy === 'function'
+            ? config.orderBy(aliasedFields, orderByOperators)
+            : config.orderBy ?? [];
+        if (!Array.isArray(orderByOrig)) {
+            orderByOrig = [orderByOrig];
+        }
+        const orderBy = orderByOrig.map((orderByValue) => {
+            if (orderByValue instanceof Column) {
+                return aliasedTableColumn(orderByValue, tableAlias);
+            }
+            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+        });
         const builtRelations = [];
-        const joins = [];
         const builtRelationFields = [];
+        let result;
+        let selectedRelationIndex = 0;
         for (const { key: selectedRelationKey, value: selectedRelationValue } of selectedRelations) {
             let relation;
             for (const [relationKey, relationValue] of Object.entries(tableConfig.relations)) {
@@ -1623,16 +1632,23 @@ class PgDialect {
             const relationConfig = schema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]];
             const builtRelation = this.buildRelationalQuery(fullSchema, schema, tableNamesMap, fullSchema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]], schema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]], selectedRelationValue, relationAlias, normalizedRelation.references);
             builtRelations.push({ key: selectedRelationKey, value: builtRelation });
-            joins.push({
-                table: new Subquery(builtRelation.sql, {}, relationAlias),
-                alias: selectedRelationKey,
+            let relationWhere;
+            if (typeof selectedRelationValue === 'object' && selectedRelationValue.limit) {
+                const field = sql `${sql.identifier(relationAlias)}.${sql.identifier('__drizzle_row_number')}`;
+                relationWhere = and(relationWhere, or(and(sql `${field} <= ${selectedRelationValue.limit}`), sql `(${field} is null)`));
+            }
+            const join = {
+                table: builtRelation.sql instanceof Table
+                    ? aliasedTable(builtRelation.sql, relationAlias)
+                    : new Subquery(builtRelation.sql, {}, relationAlias),
+                alias: relationAlias,
                 on: and(...normalizedRelation.fields.map((field, i) => eq(aliasedTableColumn(field, tableAlias), aliasedTableColumn(normalizedRelation.references[i], relationAlias)))),
                 joinType: 'left',
-            });
+            };
             const relationAliasedColumns = Object.fromEntries(Object.entries(relationConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
             const relationAliasedRelations = Object.fromEntries(Object.entries(relationConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]));
             const relationAliasedFields = Object.assign({}, relationAliasedColumns, relationAliasedRelations);
-            let orderBy;
+            let relationOrderBy;
             if (typeof selectedRelationValue === 'object') {
                 let orderByOrig = typeof selectedRelationValue.orderBy === 'function'
                     ? selectedRelationValue.orderBy(relationAliasedFields, orderByOperators)
@@ -1640,23 +1656,59 @@ class PgDialect {
                 if (!Array.isArray(orderByOrig)) {
                     orderByOrig = [orderByOrig];
                 }
-                orderBy = orderByOrig.map((orderByValue) => {
+                relationOrderBy = orderByOrig.map((orderByValue) => {
                     if (orderByValue instanceof Column) {
                         return aliasedTableColumn(orderByValue, relationAlias);
                     }
                     return mapColumnsInSQLToAlias(orderByValue, relationAlias);
                 });
             }
-            const orderBySql = orderBy?.length ? sql ` order by ${sql.join(orderBy, sql `, `)}` : undefined;
-            const elseField = sql `json_agg(json_build_array(${sql.join(builtRelation.selection.map(({ dbKey: key }) => {
-                const field = sql `${sql.identifier(relationAlias)}.${sql.identifier(key)}`;
+            const relationOrderBySql = relationOrderBy?.length
+                ? sql ` order by ${sql.join(relationOrderBy, sql `, `)}`
+                : undefined;
+            const elseField = sql `json_agg(json_build_array(${sql.join(builtRelation.selection.map(({ dbKey: key, isJson }) => {
+                let field = sql `${sql.identifier(relationAlias)}.${sql.identifier(key)}`;
+                if (isJson) {
+                    field = sql `${field}::json`;
+                }
                 return field;
-            }), sql `, `)})${orderBySql})`;
+            }), sql `, `)})${relationOrderBySql})`;
+            if (selectedRelations.length > 1) {
+                elseField.append(sql.raw('::text'));
+            }
             const field = sql `case when count(${sql.join(normalizedRelation.references.map((c) => aliasedTableColumn(c, relationAlias)), sql.raw(' or '))}) = 0 then '[]' else ${elseField} end`.as(selectedRelationKey);
-            builtRelationFields.push({
+            const builtRelationField = {
                 path: [selectedRelationKey],
                 field,
+            };
+            result = this.buildSelectQuery({
+                table: result ? new Subquery(result, {}, tableAlias) : aliasedTable(table, tableAlias),
+                fields: {},
+                fieldsFlat: [
+                    {
+                        path: [],
+                        field: sql `${sql.identifier(tableAlias)}.*`,
+                    },
+                    ...(selectedRelationIndex === selectedRelations.length - 1
+                        ? selectedExtras.map(({ key, value }) => ({
+                            path: [key],
+                            field: value,
+                        }))
+                        : []),
+                    builtRelationField,
+                ],
+                where: relationWhere,
+                groupBy: [
+                    ...groupBy,
+                    ...builtRelationFields.map(({ field }) => sql `${sql.identifier(tableAlias)}.${sql.identifier(field.fieldAlias)}`),
+                ],
+                orderBy: selectedRelationIndex === selectedRelations.length - 1 ? orderBy : [],
+                joins: [join],
+                withList: [],
+                lockingClauses: [],
             });
+            builtRelationFields.push(builtRelationField);
+            selectedRelationIndex++;
         }
         const finalFieldsSelection = Object.entries(fieldsSelection).map(([key, value]) => {
             return {
@@ -1664,30 +1716,6 @@ class PgDialect {
                 field: value instanceof Column ? aliasedTableColumn(value, tableAlias) : value,
             };
         });
-        const initialWhere = and(...selectedRelations.filter(({ key }) => {
-            const relation = config.with?.[key];
-            return typeof relation === 'object' && relation.limit !== undefined;
-        }).map(({ key }) => {
-            const field = sql `${sql.identifier(`${tableAlias}_${key}`)}.${sql.identifier('__drizzle_row_number')}`;
-            const value = config.with?.[key];
-            const cond = or(and(sql `${field} <= ${value.limit}`), sql `(${field} is null)`);
-            return cond;
-        }));
-        const groupBy = (builtRelationFields.length
-            ? (tableConfig.primaryKey.length ? tableConfig.primaryKey : Object.values(tableConfig.columns)).map((c) => aliasedTableColumn(c, tableAlias))
-            : []);
-        let orderByOrig = typeof config.orderBy === 'function'
-            ? config.orderBy(aliasedFields, orderByOperators)
-            : config.orderBy ?? [];
-        if (!Array.isArray(orderByOrig)) {
-            orderByOrig = [orderByOrig];
-        }
-        const orderBy = orderByOrig.map((orderByValue) => {
-            if (orderByValue instanceof Column) {
-                return aliasedTableColumn(orderByValue, tableAlias);
-            }
-            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-        });
         const finalFieldsFlat = isRoot
             ? [
                 ...finalFieldsSelection.map(({ path, field }) => ({
@@ -1696,24 +1724,21 @@ class PgDialect {
                 })),
                 ...builtRelationFields.map(({ path, field }) => ({
                     path,
-                    field: sql `${sql.identifier(field.fieldAlias)}`,
+                    field: sql `${sql.identifier(field.fieldAlias)}${selectedRelations.length > 1 ? sql.raw('::json') : undefined}`,
                 })),
             ]
-            : [{
+            : [
+                {
                     path: [],
                     field: sql `${sql.identifier(tableAlias)}.*`,
-                }];
-        const initialFieldsFlat = [
-            {
-                path: [],
-                field: sql `${sql.identifier(tableAlias)}.*`,
-            },
-            ...selectedExtras.map(({ key, value }) => ({
-                path: [key],
-                field: value,
-            })),
-            ...builtRelationFields,
-        ];
+                },
+                ...(builtRelationFields.length === 0
+                    ? selectedExtras.map(({ key, value }) => ({
+                        path: [key],
+                        field: value,
+                    }))
+                    : []),
+            ];
         let limit, offset;
         if (config.limit !== undefined || config.offset !== undefined) {
             if (isRoot) {
@@ -1728,24 +1753,8 @@ class PgDialect {
                 });
             }
         }
-        let result = this.buildSelectQuery({
-            table: aliasedTable(table, tableAlias),
-            fields: {},
-            fieldsFlat: initialFieldsFlat,
-            where: initialWhere,
-            groupBy,
-            orderBy: [],
-            joins,
-            lockingClauses: [],
-            withList: [],
-        });
-        let where;
-        if (config.where) {
-            const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
-            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-        }
         result = this.buildSelectQuery({
-            table: new Subquery(result, {}, tableAlias),
+            table: result ? new Subquery(result, {}, tableAlias) : aliasedTable(table, tableAlias),
             fields: {},
             fieldsFlat: finalFieldsFlat,
             where,
@@ -2951,4 +2960,4 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
 }
 
 export { name as $, notLike as A, ilike as B, ColumnAliasProxyHandler as C, notIlike as D, asc as E, desc as F, Relation as G, Relations as H, operators as I, orderByOperators as J, extractTablesRelationalConfig as K, relations as L, Many as M, createOne as N, One as O, createMany as P, QueryPromise as Q, RelationTableAliasProxyHandler as R, normalizeRelation as S, TableAliasProxyHandler as T, createTableRelationsHelpers as U, mapRelationalRow as V, FakePrimitiveParam as W, isSQLWrapper as X, StringChunk as Y, SQL as Z, Name as _, aliasedTable as a, PgTimestampStringBuilder as a$, isDriverValueEncoder as a0, noopDecoder as a1, noopEncoder as a2, noopMapper as a3, Param as a4, param as a5, sql as a6, Placeholder as a7, placeholder as a8, fillPlaceholders as a9, pgViewWithSchema as aA, pgMaterializedViewWithSchema as aB, CheckBuilder as aC, Check as aD, check as aE, PgArrayBuilder as aF, PgArray as aG, PgDateBuilder as aH, PgDate as aI, PgDateStringBuilder as aJ, PgDateString as aK, date as aL, PgJsonBuilder as aM, PgJson as aN, json as aO, PgJsonbBuilder as aP, PgJsonb as aQ, jsonb as aR, PgNumericBuilder as aS, PgNumeric as aT, numeric as aU, decimal as aV, PgTimeBuilder as aW, PgTime as aX, time as aY, PgTimestampBuilder as aZ, PgTimestamp as a_, SubqueryConfig as aa, Subquery as ab, WithSubquery as ac, SelectionProxyHandler as ad, TableName as ae, Schema as af, Columns as ag, OriginalName as ah, BaseName as ai, IsAlias as aj, ExtraConfigBuilder as ak, Table as al, isTable as am, getTableName as an, mapResultRow as ao, orderSelectedFields as ap, mapUpdateSet as aq, applyMixins as ar, getTableColumns as as, getTableLikeName as at, ViewBaseConfig as au, View as av, PgDialect as aw, PgColumnBuilder as ax, PgColumn as ay, pgTableWithSchema as az, aliasedRelation as b, PgTimestampString as b0, timestamp as b1, PgUUIDBuilder as b2, PgUUID as b3, uuid as b4, ForeignKeyBuilder as b5, ForeignKey as b6, foreignKey as b7, IndexBuilderOn as b8, IndexBuilder as b9, PgViewBase as bA, PgViewConfig as bB, PgView as bC, PgMaterializedViewConfig as bD, PgMaterializedView as bE, pgView as bF, pgMaterializedView as bG, TypedQueryBuilder as bH, Index as ba, index as bb, uniqueIndex as bc, primaryKey as bd, PrimaryKeyBuilder as be, PrimaryKey as bf, QueryBuilder as bg, PgSelectBuilder as bh, PgSelectQueryBuilder as bi, PgSelect as bj, InlineForeignKeys as bk, PgTable as bl, pgTable as bm, pgTableCreator as bn, getTableConfig as bo, getViewConfig as bp, getMaterializedViewConfig as bq, parsePgNestedArray as br, parsePgArray as bs, makePgArray as bt, DefaultViewBuilderCore as bu, ViewBuilder as bv, ManualViewBuilder as bw, MaterializedViewBuilderCore as bx, MaterializedViewBuilder as by, ManualMaterializedViewBuilder as bz, aliasedTableColumn as c, mapColumnsInSQLToAlias as d, Column as e, ColumnBuilder as f, bindIfParam as g, eq as h, and as i, not as j, gt as k, gte as l, mapColumnsInAliasedSQLToAlias as m, ne as n, or as o, lt as p, lte as q, inArray as r, notInArray as s, isNull as t, isNotNull as u, exists as v, notExists as w, between as x, notBetween as y, like as z };
-//# sourceMappingURL=relations-7adf6be2.mjs.map
+//# sourceMappingURL=relations-c9e54a8f.mjs.map