kysely
    Preparing search index...

    Interface ReadonlyKysely<DB>

    A helper type that allows you to expose a type-level read-only Kysely version to your service's consumers.

    import * as Sqlite from 'better-sqlite3'
    import { type Generated, Kysely, SqliteDialect } from 'kysely'
    import type { ReadonlyKysely } from 'kysely/readonly'

    interface Database {
      person: {
        id: Generated<number>
        first_name: string
        last_name: string | null
      }
    }

    function getDB(): ReadonlyKysely<Database> {
      return new Kysely({
        dialect: new SqliteDialect({
          database: new Sqlite(':memory:'),
        })
      }) as never
    }

    const db = getDB()

    db.selectFrom('person') // works!
    db.deleteFrom('person') // typescript compiler error!
    interface ReadonlyKysely<DB> {
        dynamic: DynamicModule<DB>;
        fn: FunctionModule<DB, keyof DB>;
        introspection: DatabaseIntrospector;
        isTransaction: boolean;
        get schema(): KyselyTypeError<
            "not allowed with a read-only Kysely instance.",
        >;
        $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<
            DrainOuterGeneric<DB & T>,
        >;
        $omitTables<T extends string | number | symbol>(): ReadonlyKysely<
            DB extends object ? Omit<DB, T> : DB,
        >;
        $pickTables<T extends string | number | symbol>(): ReadonlyKysely<
            DB extends object ? Pick<DB, T> : DB,
        >;
        case(): CaseBuilder<DB, keyof DB>;
        case<V>(value: Expression<V>): CaseBuilder<DB, keyof DB, V>;
        connection(): ReadonlyConnectionBuilder<DB>;
        deleteFrom(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        destroy(): Promise<void>;
        executeQuery<R>(
            query: ReadonlyCompiledQuery<R> | SelectQueryBuilder<DB, any, R>,
            options?: AbortableQueryOptions,
        ): Promise<ReadonlyQueryResult<R>>;
        executeQuery(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        getExecutor(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        insertInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        mergeInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        replaceInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        selectFrom<
            TE extends
                | string
                | AliasedExpression<any, any>
                | AliasedDynamicTableBuilder<any, any>
                | AliasedExpressionFactory<DB, never>
                | readonly TableExpression<DB, never>[],
        >(
            from: TE,
        ): SelectFrom<DB, never, TE>;
        selectNoFrom<SE extends SelectExpression<DB, never>>(
            selections: readonly SE[],
        ): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
        selectNoFrom<const CB extends SelectCallback<DB, never>>(
            callback: CB,
        ): SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>;
        selectNoFrom<SE extends SelectExpression<DB, never>>(
            selection: SE,
        ): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
        startTransaction(): ReadonlyControlledTransactionBuilder<DB>;
        transaction(): ReadonlyTransactionBuilder<DB>;
        updateTable(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        with<N extends string, E extends ReadonlyCommonTableExpression<DB, N>>(
            nameOrBuilder: N | CTEBuilderCallback<N>,
            expression: E,
        ): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
        withoutPlugins(): ReadonlyKysely<DB>;
        withPlugin(plugin: KyselyPlugin): ReadonlyKysely<DB>;
        withRecursive<
            N extends string,
            E extends ReadonlyRecursiveCommonTableExpression<DB, N>,
        >(
            nameOrBuilder: N | CTEBuilderCallback<N>,
            expression: E,
        ): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
        withSchema(schema: string): ReadonlyKysely<DB>;
        withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<
            DrainOuterGeneric<DB & T>,
        >;
    }

    Type Parameters

    • DB

    Hierarchy (View Summary)

    Index

    Properties

    dynamic fn introspection isTransaction

    Accessors

    schema

    Methods

    $extendTables $omitTables $pickTables case connection deleteFrom destroy executeQuery getExecutor insertInto mergeInto replaceInto selectFrom selectNoFrom startTransaction transaction updateTable with withoutPlugins withPlugin withRecursive withSchema withTables

    Properties

    dynamic: DynamicModule<DB>
    fn: FunctionModule<DB, keyof DB>
    introspection: DatabaseIntrospector
    isTransaction: boolean

    Accessors

    Methods

    • Releases all resources and disconnects from the database.

      You need to call this when you are done using the Kysely instance.

      Returns Promise<void>

    • Creates a select query builder for the given table or tables.

      The tables passed to this method are built as the query's from clause.

      Create a select query for one table:

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

      The generated SQL (PostgreSQL):

      select * from "person"

      Create a select query for one table with an alias:

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

      console.log(persons[0].id)

      The generated SQL (PostgreSQL):

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

      Create a select query from a subquery:

      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)

      The generated SQL (PostgreSQL):

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

      Create a select query from raw sql:

      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)

      The generated SQL (PostgreSQL):

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

      When you use the sql tag you need to also provide the result type of the raw snippet / query so that Kysely can figure out what columns are available for the rest of the query.

      The selectFrom method also accepts an array for multiple tables. All the above examples can also be used in an array.

      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()

      The generated SQL (PostgreSQL):

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

      Type Parameters

      Parameters

      Returns SelectFrom<DB, never, TE>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • selections: readonly SE[]

      Returns SelectQueryBuilder<DB, never, Selection<DB, never, SE>>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • callback: CB

      Returns SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • selection: SE

      Returns SelectQueryBuilder<DB, never, Selection<DB, never, SE>>

    Settings

    Member Visibility

    On This Page

    Examples
    Properties
    Accessors
    Methods