@sqb/connect/client/sqb-connection.d.ts

Multi-dialect database connection framework written with TypeScript

import { classes } from '@sqb/builder';
import type { Type } from 'ts-gems';
import { Repository } from '../orm/repository.class.js';
import type { Adapter } from './adapter.js';
import type { SqbClient } from './sqb-client.js';
import type { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types.js';
interface SqbConnectionEvents {
    close: () => void;
    execute: (request: QueryRequest) => void;
    error: (error: Error) => void;
    retain: (refCount: number) => void;
    release: (refCount: number) => void;
    'start-transaction': () => void;
    'set-savepoint': () => void;
    'release-savepoint': () => void;
    'rollback-savepoint': () => void;
    commit: () => void;
    rollback: () => void;
}
declare const SqbConnection_base: Type<import("strict-typed-events").TypedEventEmitter<any, SqbConnectionEvents, SqbConnectionEvents>>;
export declare class SqbConnection extends SqbConnection_base {
    readonly client: SqbClient;
    private _intlcon?;
    private readonly _tasks;
    private readonly _options?;
    private _inTransaction;
    private _refCount;
    constructor(client: SqbClient, adapterConnection: Adapter.Connection, options?: ConnectionOptions);
    /**
     * Returns session id
     */
    get sessionId(): string;
    /**
     * Returns reference counter value
     */
    get refCount(): number;
    /**
     * Returns true if transaction started
     */
    get inTransaction(): boolean;
    /**
     * Increases internal reference counter to keep session alive
     */
    retain(): void;
    /**
     * Decreases the internal reference counter.
     * When reference count is 0, connection returns to the pool.
     * Returns true if connection released.
     */
    release(): boolean;
    /**
     * Immediately releases the connection.
     */
    close(): Promise<void>;
    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
    getRepository<T>(entity: Type<T> | string, opts?: {
        schema?: string;
    }): Repository<T>;
    getSchema(): Promise<string>;
    setSchema(schema: string): Promise<void>;
    /**
     * Executes a query
     */
    protected _execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
    startTransaction(): Promise<void>;
    commit(): Promise<void>;
    rollback(): Promise<void>;
    setSavepoint(savepoint: string): Promise<void>;
    releaseSavepoint(savepoint: string): Promise<void>;
    rollbackSavepoint(savepoint: string): Promise<void>;
    test(): Promise<void>;
    private _prepareQueryRequest;
}
export {};