Initial commit - Event Planner application

node_modules/@mikro-orm/sql/AbstractSqlConnection.d.ts

@@ -0,0 +1,104 @@
+import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
+import {
+  type AnyEntity,
+  Connection,
+  type Dictionary,
+  type EntityData,
+  type IsolationLevel,
+  type LogContext,
+  type LoggingOptions,
+  type MaybePromise,
+  type QueryResult,
+  RawQueryFragment,
+  type Transaction,
+  type TransactionEventBroadcaster,
+} from '@mikro-orm/core';
+import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/** Base class for SQL database connections, built on top of Kysely. */
+export declare abstract class AbstractSqlConnection extends Connection {
+  #private;
+  protected platform: AbstractSqlPlatform;
+  /** Creates a Kysely dialect instance with driver-specific configuration. */
+  abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
+  /** Establishes the database connection and runs the onConnect hook. */
+  connect(options?: { skipOnConnect?: boolean }): Promise<void>;
+  /** Initializes the Kysely client from driver options or a user-provided Kysely instance. */
+  createKysely(): MaybePromise<void>;
+  /**
+   * @inheritDoc
+   */
+  close(force?: boolean): Promise<void>;
+  /**
+   * @inheritDoc
+   */
+  isConnected(): Promise<boolean>;
+  /**
+   * @inheritDoc
+   */
+  checkConnection(): Promise<
+    | {
+        ok: true;
+      }
+    | {
+        ok: false;
+        reason: string;
+        error?: Error;
+      }
+  >;
+  /** Returns the underlying Kysely client, creating it synchronously if needed. */
+  getClient<T = any>(): Kysely<T>;
+  /** Ensures the Kysely client is initialized, creating it asynchronously if needed. */
+  initClient(): Promise<void>;
+  /** Executes a callback within a transaction, committing on success and rolling back on error. */
+  transactional<T>(
+    cb: (trx: Transaction<ControlledTransaction<any, any>>) => Promise<T>,
+    options?: {
+      isolationLevel?: IsolationLevel;
+      readOnly?: boolean;
+      ctx?: ControlledTransaction<any>;
+      eventBroadcaster?: TransactionEventBroadcaster;
+      loggerContext?: LogContext;
+    },
+  ): Promise<T>;
+  /** Begins a new transaction or creates a savepoint if a transaction context already exists. */
+  begin(options?: {
+    isolationLevel?: IsolationLevel;
+    readOnly?: boolean;
+    ctx?: ControlledTransaction<any, any>;
+    eventBroadcaster?: TransactionEventBroadcaster;
+    loggerContext?: LogContext;
+  }): Promise<ControlledTransaction<any, any>>;
+  /** Commits the transaction or releases the savepoint. */
+  commit(
+    ctx: ControlledTransaction<any, any>,
+    eventBroadcaster?: TransactionEventBroadcaster,
+    loggerContext?: LogContext,
+  ): Promise<void>;
+  /** Rolls back the transaction or rolls back to the savepoint. */
+  rollback(
+    ctx: ControlledTransaction<any, any>,
+    eventBroadcaster?: TransactionEventBroadcaster,
+    loggerContext?: LogContext,
+  ): Promise<void>;
+  private prepareQuery;
+  /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
+  execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(
+    query: string | NativeQueryBuilder | RawQueryFragment,
+    params?: readonly unknown[],
+    method?: 'all' | 'get' | 'run',
+    ctx?: Transaction,
+    loggerContext?: LoggingOptions,
+  ): Promise<T>;
+  /** Executes a SQL query and returns an async iterable that yields results row by row. */
+  stream<T extends EntityData<AnyEntity>>(
+    query: string | NativeQueryBuilder | RawQueryFragment,
+    params?: readonly unknown[],
+    ctx?: Transaction<Kysely<any>>,
+    loggerContext?: LoggingOptions,
+  ): AsyncIterableIterator<T>;
+  /** @inheritDoc */
+  executeDump(dump: string): Promise<void>;
+  protected getSql(query: string, formatted: string, context?: LogContext): string;
+  protected transformRawResult<T>(res: any, method?: 'all' | 'get' | 'run'): T;
+}