Class SqlEntityManager

packages/sql/src/SqlEntityManager.ts:46–239

 * @inheritDoc
 */
export class SqlEntityManager<Driver extends AbstractSqlDriver = AbstractSqlDriver> extends EntityManager<Driver> {
  /**
   * Creates a QueryBuilder instance
   */
  createQueryBuilder<Entity extends object, RootAlias extends string = never>(
    entityName: EntityName<Entity> | QueryBuilder<Entity>,
    alias?: RootAlias,
    type?: ConnectionType,
    loggerContext?: LoggingOptions,
  ): QueryBuilder<Entity, RootAlias> {
    const context = this.getContext(false);
    const qb = this.driver.createQueryBuilder(
      entityName as EntityName<Entity>,
      context.getTransactionContext(),
      type,
      true,
      loggerContext ?? context.loggerContext,
      alias,
      this,
    );
    qb.setAbortOptions(context.getAbortOptions());
    return qb as any;
  }

  /**
   * Shortcut for `createQueryBuilder()`
   */
  qb<Entity extends object, RootAlias extends string = never>(
    entityName: EntityName<Entity>,
    alias?: RootAlias,
    type?: ConnectionType,
    loggerContext?: LoggingOptions,
  ): QueryBuilder<Entity, RootAlias> {
    return this.createQueryBuilder(entityName, alias, type, loggerContext);
  }

  /**
   * Returns a configured Kysely instance bound to this EntityManager.
   *
   * When the EntityManager is inside a transaction (e.g. within `em.transactional(...)`, or after
   * `em.begin()`), the returned Kysely instance automatically uses the transaction context, so any
   * queries executed via Kysely's own `.execute()` / `.executeTakeFirst*()` participate in the
   * current transaction.
   *
   * If you need a Kysely instance that is **not** bound to the current transaction (e.g. to perform
   * a side query against the pool while inside a transactional block), fork the EntityManager first:
   *
   * ```ts
   * await em.transactional(async em => {
   *   // bound to the current transaction
   *   await em.getKysely().selectFrom('user').selectAll().execute();
   *
   *   // bound to the pool, runs outside the transaction
   *   await em.fork().getKysely().selectFrom('audit_log').selectAll().execute();
   * });
   * ```
   *
   * The `options.type` (`'read'` / `'write'`) is only honored outside a transaction — inside a