typings tests.

kysely-org · Jan 1, 2024 · ffd1634 · ffd1634
1 parent 7d83363
commit ffd1634
Show file tree

Hide file tree

Showing 2 changed files with 143 additions and 17 deletions.
diff --git a/test/typings/test-d/delete-query-builder.test-d.ts b/test/typings/test-d/delete-query-builder.test-d.ts
@@ -1,5 +1,5 @@
 import { expectError, expectType } from 'tsd'
-import { Kysely, DeleteResult, Selectable } from '..'
+import { Kysely, DeleteResult, Selectable, sql } from '..'
 import { Database, Person, Pet } from '../shared'
 
 async function testDelete(db: Kysely<Database>) {
@@ -76,8 +76,10 @@ async function testDelete(db: Kysely<Database>) {
       .using('pet')
       .leftJoin('person', 'NO_SUCH_COLUMN', 'pet.owner_id')
   )
+}
 
-  const r8 = await db
+async function testReturning(db: Kysely<Database>) {
+  const r1 = await db
     .deleteFrom('person')
     .using(['person', 'pet'])
     .leftJoin('toy', 'toy.pet_id', 'pet.id')
@@ -86,16 +88,16 @@ async function testDelete(db: Kysely<Database>) {
     )
     .returningAll('person')
     .execute()
-  expectType<Selectable<Person>[]>(r8)
+  expectType<Selectable<Person>[]>(r1)
 
-  const r9 = await db
+  const r2 = await db
     .deleteFrom('pet')
     .where('pet.species', '=', 'cat')
     .returningAll('pet')
     .execute()
-  expectType<Selectable<Pet>[]>(r9)
+  expectType<Selectable<Pet>[]>(r2)
 
-  const r10 = await db
+  const r3 = await db
     .deleteFrom('person')
     .using(['person', 'pet'])
     .leftJoin('toy', 'toy.pet_id', 'pet.id')
@@ -120,9 +122,9 @@ async function testDelete(db: Kysely<Database>) {
       price: number | null
       pet_id: string | null
     }[]
-  >(r10)
+  >(r3)
 
-  const r11 = await db
+  const r4 = await db
     .deleteFrom('person')
     .innerJoin('pet', 'pet.owner_id', 'person.id')
     .where('pet.species', '=', 'dog')
@@ -143,23 +145,23 @@ async function testDelete(db: Kysely<Database>) {
       owner_id: number
       species: 'dog' | 'cat'
     }[]
-  >(r11)
+  >(r4)
 
-  const r12 = await db
+  const r5 = await db
     .deleteFrom('pet')
     .where('pet.species', '=', 'cat')
     .returningAll(['pet'])
     .execute()
-  expectType<Selectable<Pet>[]>(r12)
+  expectType<Selectable<Pet>[]>(r5)
 
-  const r13 = await db
+  const r6 = await db
     .deleteFrom('pet')
     .where('pet.species', '=', 'dog')
     .returningAll()
     .execute()
-  expectType<Selectable<Pet>[]>(r13)
+  expectType<Selectable<Pet>[]>(r6)
 
-  const r14 = await db
+  const r7 = await db
     .deleteFrom('person')
     .using(['person', 'pet'])
     .leftJoin('toy', 'toy.pet_id', 'pet.id')
@@ -184,14 +186,14 @@ async function testDelete(db: Kysely<Database>) {
       price: number | null
       pet_id: string | null
     }[]
-  >(r14)
+  >(r7)
 
-  const r15 = await db
+  const r8 = await db
     .deleteFrom('person as p')
     .where('p.first_name', '=', 'Jennifer')
     .returning('p.id')
     .executeTakeFirstOrThrow()
-  expectType<{ id: number }>(r15)
+  expectType<{ id: number }>(r8)
 }
 
 async function testIf(db: Kysely<Database>) {
@@ -244,3 +246,61 @@ async function testIf(db: Kysely<Database>) {
     f20?: string
   }>(r)
 }
+
+async function testOutput(db: Kysely<Database>) {
+  const r1 = await db
+    .deleteFrom('pet')
+    .outputAll('deleted')
+    .where('pet.species', '=', 'cat')
+    .execute()
+  expectType<Selectable<Pet>[]>(r1)
+
+  const r2 = await db
+    .deleteFrom('person as p')
+    .output('deleted.id')
+    .where('p.first_name', '=', 'Jennifer')
+    .executeTakeFirstOrThrow()
+  expectType<{ id: number }>(r2)
+
+  const r3 = await db
+    .deleteFrom('person as p')
+    .output(['deleted.id', 'deleted.last_name as surname'])
+    .where('p.first_name', '=', 'Jennifer')
+    .executeTakeFirstOrThrow()
+  expectType<{ id: number; surname: string | null }>(r3)
+
+  const r4 = await db
+    .deleteFrom('person')
+    .output((eb) => [
+      'deleted.age',
+      eb
+        .fn<string>('concat', [
+          eb.ref('deleted.first_name'),
+          sql.lit(' '),
+          'deleted.last_name',
+        ])
+        .as('full_name'),
+    ])
+    .where('deleted_at', '<', new Date())
+    .executeTakeFirstOrThrow()
+  expectType<{ age: number; full_name: string }>(r4)
+
+  // Non-existent column
+  expectError(db.deleteFrom('person').output('deleted.NO_SUCH_COLUMN'))
+
+  // Wrong prefix
+  expectError(db.deleteFrom('person').output('inserted.id'))
+  expectError(db.deleteFrom('person').outputAll('inserted'))
+
+  // Non-existent prefix
+  expectError(db.deleteFrom('person').output('NO_SUCH_PREFIX.id'))
+  expectError(db.deleteFrom('person').outputAll('NO_SUCH_PREFIX'))
+
+  // table prefix
+  expectError(db.deleteFrom('person').output('person.id'))
+  expectError(db.deleteFrom('person').outputAll('person'))
+
+  // No prefix
+  expectError(db.deleteFrom('person').output('id'))
+  expectError(db.deleteFrom('person').outputAll())
+}
diff --git a/test/typings/test-d/insert.test-d.ts b/test/typings/test-d/insert.test-d.ts
@@ -187,3 +187,69 @@ async function testReturning(db: Kysely<Database>) {
   // Non-existent column
   expectError(db.insertInto('person').values(person).returning('not_column'))
 }
+
+async function testOutput(db: Kysely<Database>) {
+  const person = {
+    first_name: 'Jennifer',
+    last_name: 'Aniston',
+    gender: 'other' as const,
+    age: 30,
+  }
+
+  // One returning expression
+  const r1 = await db
+    .insertInto('person')
+    .output('inserted.id')
+    .values(person)
+    .executeTakeFirst()
+
+  expectType<{ id: number } | undefined>(r1)
+
+  // Multiple returning expressions
+  const r2 = await db
+    .insertInto('person')
+    .output(['inserted.id', 'inserted.first_name as fn'])
+    .values(person)
+    .execute()
+
+  expectType<{ id: number; fn: string }[]>(r2)
+
+  // Non-column reference returning expressions
+  const r3 = await db
+    .insertInto('person')
+    .output([
+      'inserted.id',
+      sql<string>`concat(inserted.first_name, ' ', inserted.last_name)`.as(
+        'full_name'
+      ),
+    ])
+    .values(person)
+    .execute()
+
+  expectType<{ id: number; full_name: string }[]>(r3)
+
+  const r4 = await db
+    .insertInto('movie')
+    .outputAll('inserted')
+    .values({ stars: 5 })
+    .executeTakeFirstOrThrow()
+
+  expectType<{ id: string; stars: number }>(r4)
+
+  // Non-existent column
+  expectError(
+    db.insertInto('person').output('inserted.not_column').values(person)
+  )
+
+  // Without prefix
+  expectError(db.insertInto('person').output('age').values(person))
+  expectError(db.insertInto('person').outputAll().values(person))
+
+  // Non-existent prefix
+  expectError(db.insertInto('person').output('foo.age').values(person))
+  expectError(db.insertInto('person').outputAll('foo').values(person))
+
+  // Wrong prefix
+  expectError(db.insertInto('person').output('deleted.age').values(person))
+  expectError(db.insertInto('person').outputAll('deleted').values(person))
+}