@auth/kysely-adapter

new KyselyAuth<DB, T>(args): KyselyAuth<DB, T>

new KyselyAuth<DB, T>(args): KyselyAuth<DB, T>

private #private: any;

private #private: any;

get dynamic(): DynamicModule

get fn(): FunctionModule<DB, keyof DB>

const { count } = db.fn
 
await db.selectFrom('person')
  .innerJoin('pet', 'pet.owner_id', 'person.id')
  .select([
    'person.id',
    count('pet.id').as('pet_count')
  ])
  .groupBy('person.id')
  .having(count('pet.id'), '>', 10)
  .execute()

select "person"."id", count("pet"."id") as "pet_count"
from "person"
inner join "pet" on "pet"."owner_id" = "person"."id"
group by "person"."id"
having count("pet"."id") > $1

get introspection(): DatabaseIntrospector

get isTransaction(): boolean

get schema(): SchemaModule

connection(): ConnectionBuilder<DB>

await db
  .connection()
  .execute(async (db) => {
    // `db` is an instance of `Kysely` that's bound to a single
    // database connection. All queries executed through `db` use
    // the same connection.
    await doStuff(db)
  })

deleteFrom<TR>(from): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>

const result = await db
  .deleteFrom('person')
  .where('person.id', '=', 1)
  .executeTakeFirst()
 
console.log(result.numDeletedRows)

delete from "person" where "person"."id" = $1

const result = await db
  .deleteFrom(['person', 'pet'])
  .using('person')
  .innerJoin('pet', 'pet.owner_id', '=', 'person.id')
  .where('person.id', '=', 1)
  .executeTakeFirst()

delete from `person`, `pet`
using `person`
inner join `pet` on `pet`.`owner_id` = `person`.`id`
where `person`.`id` = ?

deleteFrom<TR>(tables): DeleteQueryBuilder<From<DB, TR>, ExtractAliasFromTableExpression<DB, TR>, DeleteResult>

deleteFrom<TR>(from): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>

deleteFrom<TR>(table): DeleteQueryBuilder<From<DB, TR>, ExtractAliasFromTableExpression<DB, TR>, DeleteResult>

destroy(): Promise<void>

executeQuery<R>(query, queryId?): Promise<QueryResult<R>>

insertInto<T>(table): InsertQueryBuilder<DB, T, InsertResult>

const result = await db
  .insertInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .executeTakeFirst()
 
console.log(result.insertId)

const { id } = await db
  .insertInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .returning('id')
  .executeTakeFirst()

replaceInto<T>(table): InsertQueryBuilder<DB, T, InsertResult>

const result = await db
  .replaceInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .executeTakeFirst()
 
console.log(result.insertId)

selectFrom<TE>(from): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>

db.selectFrom('person').selectAll()

select * from "person"

const persons = await db.selectFrom('person as p')
  .select(['p.id', 'first_name'])
  .execute()
 
console.log(persons[0].id)

select "p"."id", "first_name" from "person" as "p"

const persons = await db.selectFrom(
    (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
  )
  .select('p.identifier')
  .execute()
 
console.log(persons[0].identifier)

select "p"."identifier",
from (
  select "person"."id" as "identifier" from "person"
) as p

import { sql } from 'kysely'
 
const items = await db
  .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
  .select('q.one')
  .execute()
 
console.log(items[0].one)

select "q"."one",
from (
  select 1 as one
) as q

import { sql } from 'kysely'
 
const items = await db.selectFrom([
    'person as p',
    db.selectFrom('pet').select('pet.species').as('a'),
    sql<{ one: number }>`(select 1 as one)`.as('q')
  ])
  .select(['p.id', 'a.species', 'q.one'])
  .execute()

select "p".id, "a"."species", "q"."one"
from
  "person" as "p",
  (select "pet"."species" from "pet") as a,
  (select 1 as one) as "q"

selectFrom<TE>(from): SelectQueryBuilder<From<DB, TE>, ExtractAliasFromTableExpression<DB, TE>, {}>

selectFrom<TE>(from): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>

selectFrom<TE>(from): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB, TE>, {}>

selectFrom<TE>(from): SelectQueryBuilder<From<DB, TE>, ExtractAliasFromTableExpression<DB, TE>, {}>

transaction(): TransactionBuilder<DB>

const catto = await db.transaction().execute(async (trx) => {
  const jennifer = await trx.insertInto('person')
    .values({
      first_name: 'Jennifer',
      last_name: 'Aniston',
    })
    .returning('id')
    .executeTakeFirstOrThrow()
 
  await someFunction(trx, jennifer)
 
  return await trx.insertInto('pet')
    .values({
      user_id: jennifer.id,
      name: 'Catto',
      species: 'cat'
    })
    .returning('*')
    .executeTakeFirst()
})

await db
  .transaction()
  .setIsolationLevel('serializable')
  .execute(async (trx) => {
    await doStuff(trx)
  })

updateTable<TR>(table): UpdateQueryBuilder<DB, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>

const result = await db
  .updateTable('person')
  .set({ first_name: 'Jennifer' })
  .where('person.id', '=', 1)
  .executeTakeFirst()
 
console.log(result.numUpdatedRows)

updateTable<TR>(table): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>

updateTable<TR>(table): UpdateQueryBuilder<From<DB, TR>, ExtractAliasFromTableExpression<DB, TR>, ExtractAliasFromTableExpression<DB, TR>, UpdateResult>

with<N, E>(name, expression): QueryCreatorWithCommonTableExpression<DB, N, E>

await db
  .with('jennifers', (db) => db
    .selectFrom('person')
    .where('first_name', '=', 'Jennifer')
    .select(['id', 'age'])
  )
  .with('adult_jennifers', (db) => db
    .selectFrom('jennifers')
    .where('age', '>', 18)
    .select(['id', 'age'])
  )
  .selectFrom('adult_jennifers')
  .where('age', '<', 60)
  .selectAll()
  .execute()

await db
  .with('jennifers(id, age)', (db) => db
    .selectFrom('person')
    .where('first_name', '=', 'Jennifer')
    // This is ok since we return columns with the same
    // names as specified by `jennifers(id, age)`.
    .select(['id', 'age'])
  )
  .selectFrom('jennifers')
  .selectAll()
  .execute()

withPlugin(plugin): Kysely<DB>

withRecursive<N, E>(name, expression): QueryCreatorWithCommonTableExpression<DB, N, E>

withSchema(schema): QueryCreator<DB>

await db
  .withSchema('mammals')
  .selectFrom('pet')
  .selectAll()
  .innerJoin('public.person', 'public.person.id', 'pet.owner_id')
  .execute()

select * from "mammals"."pet"
inner join "public"."person"
on "public"."person"."id" = "mammals"."pet"."owner_id"

await db
  .withSchema('mammals')
  .selectFrom('pet as p')
  .select('p.name')
  .execute()

select "p"."name" from "mammals"."pet" as "p"

withTables<T>(): Kysely<DB & T>

await db.schema
  .createTable('temp_table')
  .temporary()
  .addColumn('some_column', 'integer')
  .execute()
 
const tempDb = db.withTables<{
  temp_table: {
    some_column: number
  }
}>()
 
await tempDb
  .insertInto('temp_table')
  .values({ some_column: 100 })
  .execute()

withoutPlugins(): Kysely<DB>

Account: AdapterAccount;

Session: AdapterSession;

User: AdapterUser;

VerificationToken: VerificationToken;

type Codegen: { [K in keyof Database]: { [J in keyof Database[K]]: unknown } };

const format: {
  from: T;
  to: T;
};

KyselyAdapter(db): Adapter