Skip to main content

Version: Next

abstractAbstractSqlConnection

Base class for SQL database connections, built on top of Kysely.

Hierarchy

Connection
- AbstractSqlConnection

Constructors

constructor

new AbstractSqlConnection(config, options, type): AbstractSqlConnection

Inherited from Connection.constructor
Parameters
- config: Configuration<IDatabaseDriver<Connection>, EntityManager<IDatabaseDriver<Connection>>>
- optionaloptions: ConnectionOptions
- type: ConnectionType = 'write'
Returns AbstractSqlConnection

Methods

begin

begin(options): Promise<ControlledTransaction<any, any>>

Overrides Connection.begin
Begins a new transaction or creates a savepoint if a transaction context already exists.
Parameters
- options: { ctx?: ControlledTransaction<any, any>; eventBroadcaster?: TransactionEventBroadcaster; isolationLevel?: IsolationLevel; loggerContext?: LogContext; readOnly?: boolean } = {}
Returns Promise<ControlledTransaction<any, any>>

checkConnection

checkConnection(): Promise<{ ok: true } | { error?: Error; ok: false; reason: string }>

Overrides Connection.checkConnection
Are we connected to the database
Returns Promise<{ ok: true } | { error?: Error; ok: false; reason: string }>

close

close(force): Promise<void>

Overrides Connection.close
Closes the database connection (aka disconnect)
Parameters
- optionalforce: boolean
Returns Promise<void>

commit

commit(ctx, eventBroadcaster, loggerContext): Promise<void>

Overrides Connection.commit
Commits the transaction or releases the savepoint.
Parameters
- ctx: ControlledTransaction<any, any>
- optionaleventBroadcaster: TransactionEventBroadcaster
- optionalloggerContext: LogContext
Returns Promise<void>

connect

connect(options): Promise<void>

Overrides Connection.connect
Establishes the database connection and runs the onConnect hook.
Parameters
- optionaloptions: { skipOnConnect?: boolean }
Returns Promise<void>

createKysely

createKysely(): MaybePromise<void>

Initializes the Kysely client from driver options or a user-provided Kysely instance.
Returns MaybePromise<void>

abstractcreateKyselyDialect

createKyselyDialect(overrides): MaybePromise<Dialect>

Creates a Kysely dialect instance with driver-specific configuration.
Parameters
- overrides: Dictionary
Returns MaybePromise<Dialect>

inheritedensureConnection

ensureConnection(): Promise<void>

Inherited from Connection.ensureConnection
Ensure the connection exists, this is used to support lazy connect when using new MikroORM() instead of the async init method.
Returns Promise<void>

execute

execute<T>(query, params, method, ctx, loggerContext): Promise<T>

Overrides Connection.execute
Executes a SQL query and returns the result based on the method: 'all' for rows, 'get' for single row, 'run' for affected count.
Parameters
- query: string | RawQueryFragment<string> | NativeQueryBuilder
- params: readonly unknown[] = []
- method: get | all | run = 'all'
- optionalctx: any
- optionalloggerContext: LoggingOptions
Returns Promise<T>

executeDump

executeDump(dump): Promise<void>

Overrides Connection.executeDump
Execute raw SQL queries, handy from running schema dump loaded from a file. This method doesn't support transactions, as opposed to orm.schema.execute(), which is used internally.
Parameters
- dump: string
Returns Promise<void>

getClient

getClient<T>(): Kysely<T>

Returns the underlying Kysely client, creating it synchronously if needed.
Returns Kysely<T>

inheritedgetConnectionOptions

getConnectionOptions(): ConnectionConfig

Inherited from Connection.getConnectionOptions
Parses and returns the resolved connection configuration (host, port, user, etc.).
Returns ConnectionConfig

inheritedgetPlatform

getPlatform(): Platform

Inherited from Connection.getPlatform
Returns the platform abstraction for this connection.
Returns Platform

initClient

initClient(): Promise<void>

Ensures the Kysely client is initialized, creating it asynchronously if needed.
Returns Promise<void>

isConnected

isConnected(): Promise<boolean>

Overrides Connection.isConnected
Are we connected to the database
Returns Promise<boolean>

rollback

rollback(ctx, eventBroadcaster, loggerContext): Promise<void>

Overrides Connection.rollback
Rolls back the transaction or rolls back to the savepoint.
Parameters
- ctx: ControlledTransaction<any, any>
- optionaleventBroadcaster: TransactionEventBroadcaster
- optionalloggerContext: LogContext
Returns Promise<void>

inheritedsetMetadata

setMetadata(metadata): void

Inherited from Connection.setMetadata
Sets the metadata storage on this connection.
Parameters
- metadata: MetadataStorage
Returns void

inheritedsetPlatform

setPlatform(platform): void

Inherited from Connection.setPlatform
Sets the platform abstraction on this connection.
Parameters
- platform: Platform
Returns void

stream

stream<T>(query, params, ctx, loggerContext): AsyncIterableIterator<T, any, any>

Executes a SQL query and returns an async iterable that yields results row by row.
Parameters
- query: string | RawQueryFragment<string> | NativeQueryBuilder
- params: readonly unknown[] = []
- optionalctx: Kysely<any>
- optionalloggerContext: LoggingOptions
Returns AsyncIterableIterator<T, any, any>

transactional

transactional<T>(cb, options): Promise<T>

Overrides Connection.transactional
Executes a callback within a transaction, committing on success and rolling back on error.
Parameters
- cb: (trx) => Promise<T>
- options: { ctx?: ControlledTransaction<any, []>; eventBroadcaster?: TransactionEventBroadcaster; isolationLevel?: IsolationLevel; loggerContext?: LogContext; readOnly?: boolean } = {}
Returns Promise<T>