Fixes JsonAgg type definition

Updates the type definition for JsonAgg aggregate function to correctly infer the element type of the resulting array.

The previous type definition used `Selectable` which was too broad. The updated type definition now uses `SelectType` to extract the correct type and `ShallowDehydrateValue` to remove `undefined` from the type.
The change is accompanied by a fix in the typings tests.

Author: igalklebanov

src/query-builder/function-module.ts

@@ -28,7 +28,7 @@ import { AggregateFunctionBuilder } from './aggregate-function-builder.js'
 import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js'
 import { isString } from '../util/object-utils.js'
 import { parseTable } from '../parser/table-parser.js'
-import { Selectable } from '../util/column-type.js'
+import { Selectable, SelectType } from '../util/column-type.js'
 
 /**
  * Helpers for type safe SQL function calls.
@@ -732,7 +732,10 @@ export interface FunctionModule<DB, TB extends keyof DB> {
   ): AggregateFunctionBuilder<
     DB,
     TB,
-    ShallowDehydrateValue<ExtractTypeFromStringReference<DB, TB, RE>>[] | null
+    | ShallowDehydrateValue<
+        SelectType<ExtractTypeFromStringReference<DB, TB, RE>>
+      >[]
+    | null
   >
 
   /**

test/typings/test-d/postgres-json.test-d.ts

@@ -5,9 +5,8 @@ import {
   jsonObjectFrom,
   sql,
   ExpressionBuilder,
-  Selectable,
 } from '..'
-import { Database, Pet } from '../shared'
+import { Database } from '../shared'
 import { expectType } from 'tsd'
 
 async function testPostgresJsonSelects(db: Kysely<Database>) {
@@ -78,54 +77,85 @@ async function testPostgresConditionalJsonSelects(db: Kysely<Database>) {
 
 async function testPostgresJsonAgg(db: Kysely<Database>) {
   const r1 = await db
-    .selectFrom('person')
-    .innerJoin('pet', 'pet.owner_id', 'person.id')
-    .select((eb) => ['first_name', eb.fn.jsonAgg('pet').as('pets')])
-    .groupBy('person.first_name')
+    .selectFrom('pet')
+    .innerJoin('person', 'pet.owner_id', 'person.id')
+    .select((eb) => ['pet.name', eb.fn.jsonAgg('person').as('people')])
+    .groupBy('pet.name')
     .execute()
 
   expectType<
     {
-      first_name: string
-      pets: Selectable<Pet>[]
+      name: string
+      people: {
+        id: number
+        first_name: string
+        last_name: string | null
+        age: number
+        gender: 'male' | 'female' | 'other'
+        marital_status: 'single' | 'married' | 'divorced' | 'widowed' | null
+        modified_at: string
+        deleted_at: string | null
+      }[]
     }[]
   >(r1)
 
   const r2 = await db
-    .selectFrom('person')
+    .selectFrom('pet')
     .select((eb) => [
-      'first_name',
+      'name',
       eb
-        .selectFrom('pet')
-        .select((eb) => eb.fn.jsonAgg('pet').as('pet'))
+        .selectFrom('person')
+        .select((eb) => eb.fn.jsonAgg('person').as('people'))
         .whereRef('pet.owner_id', '=', 'person.id')
-        .as('pets'),
+        .as('people'),
     ])
     .execute()
 
   expectType<
     {
-      first_name: string
-      pets: Selectable<Pet>[] | null
+      name: string
+      people:
+        | {
+            id: number
+            first_name: string
+            last_name: string | null
+            age: number
+            gender: 'male' | 'female' | 'other'
+            marital_status: 'single' | 'married' | 'divorced' | 'widowed' | null
+            modified_at: string
+            deleted_at: string | null
+          }[]
+        | null
     }[]
   >(r2)
 
   const r3 = await db
-    .selectFrom('person')
+    .selectFrom('pet')
     .select((eb) => [
-      'first_name',
+      'name',
       eb
-        .selectFrom('pet')
-        .select((eb) => eb.fn.jsonAgg(eb.table('pet')).as('pet'))
+        .selectFrom('person')
+        .select((eb) => eb.fn.jsonAgg(eb.table('person')).as('people'))
         .whereRef('pet.owner_id', '=', 'person.id')
-        .as('pets'),
+        .as('people'),
     ])
     .execute()
 
   expectType<
     {
-      first_name: string
-      pets: Selectable<Pet>[] | null
+      name: string
+      people:
+        | {
+            id: number
+            first_name: string
+            last_name: string | null
+            age: number
+            gender: 'male' | 'female' | 'other'
+            marital_status: 'single' | 'married' | 'divorced' | 'widowed' | null
+            modified_at: string
+            deleted_at: string | null
+          }[]
+        | null
     }[]
   >(r3)
 
@@ -171,31 +201,43 @@ async function testPostgresJsonAgg(db: Kysely<Database>) {
   }>(r4)
 
   const r5 = await db
-    .selectFrom('person')
-    .innerJoin('pet', 'pet.owner_id', 'person.id')
-    .select((eb) => ['first_name', eb.fn.jsonAgg('owner_id').as('pet_names')])
-    .groupBy('person.first_name')
+    .selectFrom('pet')
+    .innerJoin('person', 'pet.owner_id', 'person.id')
+    .select((eb) => [
+      'name',
+      eb.fn.jsonAgg('person.modified_at').as('modified_at'),
+    ])
+    .groupBy('name')
     .execute()
 
   expectType<
     {
-      first_name: string
-      pet_names: number[] | null
+      name: string
+      modified_at: string[] | null
     }[]
   >(r5)
 }
 
 async function testPostgresToJson(db: Kysely<Database>) {
   const r1 = await db
-    .selectFrom('person')
-    .innerJoin('pet', 'pet.owner_id', 'person.id')
-    .select((eb) => ['first_name', eb.fn.toJson('pet').as('pet')])
+    .selectFrom('pet')
+    .innerJoin('person', 'pet.owner_id', 'person.id')
+    .select((eb) => ['name', eb.fn.toJson('person').as('person')])
     .execute()
 
   expectType<
     {
-      first_name: string
-      pet: Selectable<Pet>
+      name: string
+      person: {
+        id: number
+        first_name: string
+        last_name: string | null
+        age: number
+        gender: 'male' | 'female' | 'other'
+        marital_status: 'single' | 'married' | 'divorced' | 'widowed' | null
+        modified_at: string
+        deleted_at: string | null
+      }
     }[]
   >(r1)
 }