@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

import NextAuth from "next-auth"
import GoogleProvider from "next-auth/providers/google"
import { KyselyAdapter } from "@auth/kysely-adapter"
import { db } from "../../../db"
 
export default NextAuth({
  adapter: KyselyAdapter(db),
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    }),
  ],
})

import { PostgresDialect } from "kysely"
import { Pool } from "pg"
 
// This adapter exports a wrapper of the original `Kysely` class called `KyselyAuth`,
// that can be used to provide additional type-safety.
// While using it isn't required, it is recommended as it will verify
// that the database interface has all the fields that Auth.js expects.
import { KyselyAuth } from "@auth/kysely-adapter"
 
import type { GeneratedAlways } from "kysely"
 
interface Database {
  User: {
    id: GeneratedAlways<string>
    name: string | null
    email: string
    emailVerified: Date | null
    image: string | null
  }
  Account: {
    id: GeneratedAlways<string>
    userId: string
    type: string
    provider: string
    providerAccountId: string
    refresh_token: string | null
    access_token: string | null
    expires_at: number | null
    token_type: string | null
    scope: string | null
    id_token: string | null
    session_state: string | null
  }
  Session: {
    id: GeneratedAlways<string>
    userId: string
    sessionToken: string
    expires: Date
  }
  VerificationToken: {
    identifier: string
    token: string
    expires: Date
  }
}
 
export const db = new KyselyAuth<Database>({
  dialect: new PostgresDialect({
    pool: new Pool({
      host: process.env.DATABASE_HOST,
      database: process.env.DATABASE_NAME,
      user: process.env.DATABASE_USER,
      password: process.env.DATABASE_PASSWORD,
    }),
  }),
})

import { Kysely, sql } from "kysely"
 
export async function up(db: Kysely<any>): Promise<void> {
  await db.schema
    .createTable("User")
    .addColumn("id", "uuid", (col) =>
      col.primaryKey().defaultTo(sql`gen_random_uuid()`)
    )
    .addColumn("name", "text")
    .addColumn("email", "text", (col) => col.unique().notNull())
    .addColumn("emailVerified", "timestamptz")
    .addColumn("image", "text")
    .execute()
 
  await db.schema
    .createTable("Account")
    .addColumn("id", "uuid", (col) =>
      col.primaryKey().defaultTo(sql`gen_random_uuid()`)
    )
    .addColumn("userId", "uuid", (col) =>
      col.references("User.id").onDelete("cascade").notNull()
    )
    .addColumn("type", "text", (col) => col.notNull())
    .addColumn("provider", "text", (col) => col.notNull())
    .addColumn("providerAccountId", "text", (col) => col.notNull())
    .addColumn("refresh_token", "text")
    .addColumn("access_token", "text")
    .addColumn("expires_at", "bigint")
    .addColumn("token_type", "text")
    .addColumn("scope", "text")
    .addColumn("id_token", "text")
    .addColumn("session_state", "text")
    .execute()
 
  await db.schema
    .createTable("Session")
    .addColumn("id", "uuid", (col) =>
      col.primaryKey().defaultTo(sql`gen_random_uuid()`)
    )
    .addColumn("userId", "uuid", (col) =>
      col.references("User.id").onDelete("cascade").notNull()
    )
    .addColumn("sessionToken", "text", (col) => col.notNull().unique())
    .addColumn("expires", "timestamptz", (col) => col.notNull())
    .execute()
 
  await db.schema
    .createTable("VerificationToken")
    .addColumn("identifier", "text", (col) => col.notNull())
    .addColumn("token", "text", (col) => col.notNull().unique())
    .addColumn("expires", "timestamptz", (col) => col.notNull())
    .execute()
 
  await db.schema
    .createIndex("Account_userId_index")
    .on("Account")
    .column("userId")
    .execute()
 
  await db.schema
    .createIndex("Session_userId_index")
    .on("Session")
    .column("userId")
    .execute()
}
 
export async function down(db: Kysely<any>): Promise<void> {
  await db.schema.dropTable("Account").ifExists().execute()
  await db.schema.dropTable("Session").ifExists().execute()
  await db.schema.dropTable("User").ifExists().execute()
  await db.schema.dropTable("VerificationToken").ifExists().execute()
}