@simplysm/orm-common 14.0.16 → 14.0.18

package/src/query-builder/mssql/mssql-expr-renderer.ts

@@ -522,7 +522,7 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   protected random(_expr: ExprRandom): string {
-    return "NEWID()";
+    return "(ABS(CHECKSUM(NEWID())) / 2147483647.0)";
   }
 
   protected cast(expr: ExprCast): string {

package/src/query-builder/mysql/mysql-expr-renderer.ts

@@ -376,7 +376,7 @@ export class MysqlExprRenderer extends ExprRendererBase {
   }
 
   protected isoWeek(expr: ExprIsoWeek): string {
-    return `WEEK(${this.render(expr.arg)}, 1)`;
+    return `WEEK(${this.render(expr.arg)}, 3)`;
   }
 
   protected isoWeekStartDate(expr: ExprIsoWeekStartDate): string {

package/src/query-builder/mysql/mysql-query-builder.ts

@@ -731,7 +731,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       sql: `
 SET FOREIGN_KEY_CHECKS = 0;
 SET @tables = NULL;
-SELECT GROUP_CONCAT(table_name) INTO @tables FROM information_schema.tables WHERE table_schema = '${dbName}';
+SELECT GROUP_CONCAT(CONCAT('\`', REPLACE(table_name, '\`', '\`\`'), '\`')) INTO @tables FROM information_schema.tables WHERE table_schema = '${dbName}';
 SET @drop_stmt = IF(@tables IS NULL, 'SELECT 1', CONCAT('DROP TABLE IF EXISTS ', @tables));
 PREPARE stmt FROM @drop_stmt;
 EXECUTE stmt;

package/src/query-builder/postgresql/postgresql-query-builder.ts

@@ -240,13 +240,20 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
   protected update(def: UpdateQueryDef): QueryBuildResult {
     const table = this.tableName(def.table);
     const alias = this.expr.wrap(def.as);
+    const hasLimit = def.top != null || def.limit != null;
 
     // SET
     const setParts = Object.entries(def.record).map(
       ([col, e]) => `${this.expr.wrap(col)} = ${this.expr.render(e)}`,
     );
 
-    let sql = `UPDATE ${table} AS ${alias} SET ${setParts.join(", ")}`;
+    // CTE: top/limit → ctid 기반 서브쿼리
+    let ctePart = "";
+    if (hasLimit) {
+      ctePart = this._buildLimitCte(def, table, alias);
+    }
+
+    let sql = `${ctePart}UPDATE ${table} AS ${alias} SET ${setParts.join(", ")}`;
 
     // PostgreSQL: JOIN은 FROM 절로 처리
     if (def.joins != null && def.joins.length > 0) {
@@ -256,21 +263,29 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
       });
       sql += ` FROM ${joinTables.join(", ")}`;
 
-      // JOIN ON 조건을 WHERE에 추가
       const joinConditions = def.joins
         .filter((j) => j.where != null && j.where.length > 0)
         .map((j) => this.expr.renderWhere(j.where!));
-      if (joinConditions.length > 0) {
+
+      if (hasLimit) {
+        // CTE가 WHERE 조건을 포함하므로 ctid 필터 + JOIN 조건만
+        const conditions = [`${alias}.ctid IN (SELECT ctid FROM _limited)`, ...joinConditions];
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      } else {
         const whereCondition =
           def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
         const allConditions =
           whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
-        sql += ` WHERE ${allConditions.join(" AND ")}`;
+        if (allConditions.length > 0) {
+          sql += ` WHERE ${allConditions.join(" AND ")}`;
+        }
+      }
+    } else {
+      if (hasLimit) {
+        sql += ` WHERE ${alias}.ctid IN (SELECT ctid FROM _limited)`;
       } else {
         sql += this.renderWhere(def.where);
       }
-    } else {
-      sql += this.renderWhere(def.where);
     }
 
     // RETURNING 절
@@ -289,8 +304,15 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
   protected delete(def: DeleteQueryDef): QueryBuildResult {
     const table = this.tableName(def.table);
     const alias = this.expr.wrap(def.as);
+    const hasLimit = def.top != null || def.limit != null;
 
-    let sql = `DELETE FROM ${table} AS ${alias}`;
+    // CTE: top/limit → ctid 기반 서브쿼리
+    let ctePart = "";
+    if (hasLimit) {
+      ctePart = this._buildLimitCte(def, table, alias);
+    }
+
+    let sql = `${ctePart}DELETE FROM ${table} AS ${alias}`;
 
     // PostgreSQL: JOIN은 USING 절로 처리
     if (def.joins != null && def.joins.length > 0) {
@@ -300,21 +322,28 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
       });
       sql += ` USING ${joinTables.join(", ")}`;
 
-      // JOIN ON 조건을 WHERE에 추가
       const joinConditions = def.joins
         .filter((j) => j.where != null && j.where.length > 0)
         .map((j) => this.expr.renderWhere(j.where!));
-      if (joinConditions.length > 0) {
+
+      if (hasLimit) {
+        const conditions = [`${alias}.ctid IN (SELECT ctid FROM _limited)`, ...joinConditions];
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      } else {
         const whereCondition =
           def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
         const allConditions =
           whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
-        sql += ` WHERE ${allConditions.join(" AND ")}`;
+        if (allConditions.length > 0) {
+          sql += ` WHERE ${allConditions.join(" AND ")}`;
+        }
+      }
+    } else {
+      if (hasLimit) {
+        sql += ` WHERE ${alias}.ctid IN (SELECT ctid FROM _limited)`;
       } else {
         sql += this.renderWhere(def.where);
       }
-    } else {
-      sql += this.renderWhere(def.where);
     }
 
     // RETURNING (PostgreSQL: DELETE에서도 지원)
@@ -611,12 +640,62 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
   protected execProc(def: ExecProcQueryDef): QueryBuildResult {
     const proc = this.tableName(def.procedure);
     if (def.params == null || Object.keys(def.params).length === 0) {
-      return { sql: `SELECT ${proc}()` };
+      return { sql: `SELECT * FROM ${proc}()` };
     }
     const params = Object.values(def.params)
       .map((p) => this.expr.render(p))
       .join(", ");
-    return { sql: `SELECT ${proc}(${params})` };
+    return { sql: `SELECT * FROM ${proc}(${params})` };
+  }
+
+  /**
+   * UPDATE/DELETE의 top/limit를 CTE로 변환
+   *
+   * PostgreSQL은 UPDATE/DELETE에 LIMIT을 지원하지 않으므로
+   * ctid 기반 CTE로 변환한다.
+   */
+  private _buildLimitCte(
+    def: { table: QueryDefObjectName; as: string; top?: number; limit?: [number, number]; where?: unknown[]; joins?: SelectQueryDefJoin[] },
+    table: string,
+    alias: string,
+  ): string {
+    let sql = `WITH _limited AS (SELECT ${alias}.ctid FROM ${table} AS ${alias}`;
+
+    if (def.joins != null && def.joins.length > 0) {
+      const joinTables = def.joins.map((j) => {
+        const from = this.renderFrom(j.from);
+        return `${from} AS ${this.expr.wrap(j.as)}`;
+      });
+      sql += `, ${joinTables.join(", ")}`;
+
+      const joinConditions = def.joins
+        .filter((j) => j.where != null && j.where.length > 0)
+        .map((j) => this.expr.renderWhere(j.where!));
+      const whereCondition =
+        def.where != null && def.where.length > 0
+          ? this.expr.renderWhere(def.where as any)
+          : null;
+      const allConditions = [
+        ...(whereCondition != null ? [whereCondition] : []),
+        ...joinConditions,
+      ];
+      if (allConditions.length > 0) {
+        sql += ` WHERE ${allConditions.join(" AND ")}`;
+      }
+    } else if (def.where != null && def.where.length > 0) {
+      sql += ` WHERE ${this.expr.renderWhere(def.where as any)}`;
+    }
+
+    if (def.limit != null) {
+      const [offset, count] = def.limit;
+      sql += ` LIMIT ${count}`;
+      if (offset > 0) sql += ` OFFSET ${offset}`;
+    } else if (def.top != null) {
+      sql += ` LIMIT ${def.top}`;
+    }
+
+    sql += `) `;
+    return sql;
   }
 
   //#endregion

package/src/schema/factory/relation-builder.ts

@@ -12,6 +12,9 @@ import type { ViewBuilder } from "../view-builder";
  * 현재 Table에서 대상 Table로의 FK 관계를 정의
  * DB에 실제 FK 제약조건을 생성
  *
+ * description 설정은 factory 함수의 opts 파라미터로 전달한다.
+ * 메서드 체이닝(.description())은 TypeScript 순환 참조 시 TS7022를 유발하므로 제거됨.
+ *
  * @template TOwner - 소유 Table builder 타입
  * @template TTargetFn - 대상 Table builder factory 타입
  *
@@ -25,7 +28,7 @@ import type { ViewBuilder } from "../view-builder";
  *   .primaryKey("id")
  *   .relations((r) => ({
  *     // N:1 relationship - Post → User
- *     author: r.foreignKey(["authorId"], () => User),
+ *     author: r.foreignKey(["authorId"], () => User, { description: "작성자" }),
  *   }));
  * ```
  *
@@ -51,23 +54,16 @@ export class ForeignKeyBuilder<
       description?: string;
     },
   ) {}
-
-  /**
-   * 관계 설명 설정
-   *
-   * @param desc - 관계 설명
-   * @returns 새 ForeignKeyBuilder 인스턴스
-   */
-  description(desc: string): ForeignKeyBuilder<TOwner, TTargetFn> {
-    return new ForeignKeyBuilder({ ...this.meta, description: desc });
-  }
 }
 
 /**
  * Foreign Key 역참조 builder (1:N)
  *
  * 다른 Table이 현재 Table을 참조하는 FK의 역참조를 정의
- * include() 시 배열로 로드됨 (single() 호출 시 단일 객체)
+ * include() 시 배열로 로드됨 (opts.single: true 시 단일 객체)
+ *
+ * description, single 설정은 factory 함수의 opts 파라미터로 전달한다.
+ * 메서드 체이닝(.description(), .single())은 TypeScript 순환 참조 시 TS7022를 유발하므로 제거됨.
  *
  * @template TTargetTableFn - 참조하는 Table builder factory 타입
  * @template TIsSingle - 단일 객체 여부
@@ -85,7 +81,10 @@ export class ForeignKeyBuilder<
  *     posts: r.foreignKeyTarget(() => Post, "author"),
  *
  *     // 1:1 relation (single object)
- *     profile: r.foreignKeyTarget(() => Profile, "user").single(),
+ *     profile: r.foreignKeyTarget(() => Profile, "user", { single: true }),
+ *
+ *     // with description
+ *     comments: r.foreignKeyTarget(() => Comment, "user", { description: "댓글목록" }),
  *   }));
  * ```
  *
@@ -110,32 +109,6 @@ export class ForeignKeyTargetBuilder<
       isSingle?: TIsSingle;
     },
   ) {}
-
-  /**
-   * 관계 설명 설정
-   *
-   * @param desc - 관계 설명
-   * @returns 새 ForeignKeyTargetBuilder 인스턴스
-   */
-  description(desc: string): ForeignKeyTargetBuilder<TTargetTableFn, TIsSingle> {
-    return new ForeignKeyTargetBuilder({ ...this.meta, description: desc });
-  }
-
-  /**
-   * 단일 객체 관계로 설정 (1:1)
-   *
-   * 기본값은 배열(1:N), single() 호출 시 단일 객체
-   *
-   * @returns 새 ForeignKeyTargetBuilder 인스턴스 (isSingle=true)
-   *
-   * @example
-   * ```typescript
-   * profile: r.foreignKeyTarget(() => Profile, "user").single()
-   * ```
-   */
-  single(): ForeignKeyTargetBuilder<TTargetTableFn, true> {
-    return new ForeignKeyTargetBuilder({ ...this.meta, isSingle: true });
-  }
 }
 
 // ============================================
@@ -148,6 +121,8 @@ export class ForeignKeyTargetBuilder<
  * ForeignKeyBuilder와 동일하지만 DB에 FK 제약조건을 생성하지 않음
  * View에서도 사용 가능
  *
+ * description 설정은 factory 함수의 opts 파라미터로 전달한다.
+ *
  * @template TOwner - 소유 Table/View builder 타입
  * @template TTargetFn - 대상 Table/View builder factory 타입
  *
@@ -158,14 +133,7 @@ export class ForeignKeyTargetBuilder<
  *   .query((db: MyDb) => db.user().select(...))
  *   .relations((r) => ({
  *     // View → Table (FK 미생성)
- *     company: r.relationKey(["companyId"], () => Company),
- *   }));
- *
- * // FK 없는 Table 관계 정의
- * const Report = Table("Report")
- *   .columns((c) => ({ userId: c.bigint() }))
- *   .relations((r) => ({
- *     user: r.relationKey(["userId"], () => User),
+ *     company: r.relationKey(["companyId"], () => Company, { description: "소속회사" }),
  *   }));
  * ```
  *
@@ -190,16 +158,6 @@ export class RelationKeyBuilder<
       description?: string;
     },
   ) {}
-
-  /**
-   * 관계 설명 설정
-   *
-   * @param desc - 관계 설명
-   * @returns 새 RelationKeyBuilder 인스턴스
-   */
-  description(desc: string): RelationKeyBuilder<TOwner, TTargetFn> {
-    return new RelationKeyBuilder({ ...this.meta, description: desc });
-  }
 }
 
 /**
@@ -208,6 +166,8 @@ export class RelationKeyBuilder<
  * ForeignKeyTargetBuilder와 동일하지만 DB에 FK 제약조건을 생성하지 않음
  * View에서도 사용 가능
  *
+ * description, single 설정은 factory 함수의 opts 파라미터로 전달한다.
+ *
  * @template TTargetTableFn - 참조하는 Table/View builder factory 타입
  * @template TIsSingle - 단일 객체 여부
  *
@@ -218,6 +178,8 @@ export class RelationKeyBuilder<
  *   .relations((r) => ({
  *     // 역참조 (FK 미생성)
  *     employees: r.relationKeyTarget(() => UserSummary, "company"),
+ *     // 단일 객체 + 설명
+ *     ceo: r.relationKeyTarget(() => UserSummary, "company", { single: true, description: "대표" }),
  *   }));
  * ```
  *
@@ -242,27 +204,6 @@ export class RelationKeyTargetBuilder<
       isSingle?: TIsSingle;
     },
   ) {}
-
-  /**
-   * 관계 설명 설정
-   *
-   * @param desc - 관계 설명
-   * @returns 새 RelationKeyTargetBuilder 인스턴스
-   */
-  description(desc: string): RelationKeyTargetBuilder<TTargetTableFn, TIsSingle> {
-    return new RelationKeyTargetBuilder({ ...this.meta, description: desc });
-  }
-
-  /**
-   * 단일 객체 관계로 설정 (1:1)
-   *
-   * 기본값은 배열(1:N), single() 호출 시 단일 객체
-   *
-   * @returns 새 RelationKeyTargetBuilder 인스턴스 (isSingle=true)
-   */
-  single(): RelationKeyTargetBuilder<TTargetTableFn, true> {
-    return new RelationKeyTargetBuilder({ ...this.meta, isSingle: true });
-  }
 }
 
 /**
@@ -276,11 +217,18 @@ type RelationFkFactory<TOwner extends TableBuilder<any, any>, TColumnKey extends
   foreignKey<TTargetFn extends () => TableBuilder<any, any>>(
     columns: TColumnKey[],
     targetFn: TTargetFn,
+    opts?: { description?: string },
   ): ForeignKeyBuilder<TOwner, TTargetFn>;
-  /** 1:N FK 역참조 정의 */
+  /** 1:N FK 역참조 정의 (single: true → 단일 객체) */
+  foreignKeyTarget<TTargetTableFn extends () => TableBuilder<any, any>>(
+    targetTableFn: TTargetTableFn,
+    relationName: string,
+    opts: { single: true; description?: string },
+  ): ForeignKeyTargetBuilder<TTargetTableFn, true>;
   foreignKeyTarget<TTargetTableFn extends () => TableBuilder<any, any>>(
     targetTableFn: TTargetTableFn,
     relationName: string,
+    opts?: { single?: false; description?: string },
   ): ForeignKeyTargetBuilder<TTargetTableFn, false>;
 };
 
@@ -298,13 +246,22 @@ type RelationRkFactory<
   relationKey<TTargetFn extends () => TableBuilder<any, any> | ViewBuilder<any, any, any>>(
     columns: TColumnKey[],
     targetFn: TTargetFn,
+    opts?: { description?: string },
   ): RelationKeyBuilder<TOwner, TTargetFn>;
-  /** 1:N 논리적 역참조 정의 */
+  /** 1:N 논리적 역참조 정의 (single: true → 단일 객체) */
   relationKeyTarget<
     TTargetTableFn extends () => TableBuilder<any, any> | ViewBuilder<any, any, any>,
   >(
     targetTableFn: TTargetTableFn,
     relationName: string,
+    opts: { single: true; description?: string },
+  ): RelationKeyTargetBuilder<TTargetTableFn, true>;
+  relationKeyTarget<
+    TTargetTableFn extends () => TableBuilder<any, any> | ViewBuilder<any, any, any>,
+  >(
+    targetTableFn: TTargetTableFn,
+    relationName: string,
+    opts?: { single?: false; description?: string },
   ): RelationKeyTargetBuilder<TTargetTableFn, false>;
 };
 
@@ -348,25 +305,37 @@ export function createRelationFactory<
   ? RelationFkFactory<TOwner, TColumnKey> & RelationRkFactory<TOwner, TColumnKey>
   : RelationRkFactory<TOwner, TColumnKey> {
   return {
-    foreignKey(columns, targetFn) {
+    foreignKey(columns, targetFn, opts?) {
       return new ForeignKeyBuilder({
         ownerFn: ownerFn as () => TableBuilder<any, any>,
         columns,
         targetFn,
+        description: opts?.description,
       });
     },
-    foreignKeyTarget(targetTableFn, relationName) {
-      return new ForeignKeyTargetBuilder({ targetTableFn, relationName });
+    foreignKeyTarget(targetTableFn, relationName, opts?) {
+      return new ForeignKeyTargetBuilder({
+        targetTableFn,
+        relationName,
+        description: opts?.description,
+        isSingle: opts?.single,
+      });
     },
-    relationKey(columns, targetFn) {
+    relationKey(columns, targetFn, opts?) {
       return new RelationKeyBuilder({
         ownerFn: ownerFn,
         columns,
         targetFn,
+        description: opts?.description,
       });
     },
-    relationKeyTarget(targetTableFn, relationName) {
-      return new RelationKeyTargetBuilder({ targetTableFn, relationName });
+    relationKeyTarget(targetTableFn, relationName, opts?) {
+      return new RelationKeyTargetBuilder({
+        targetTableFn,
+        relationName,
+        description: opts?.description,
+        isSingle: opts?.single,
+      });
     },
   } as TOwner extends TableBuilder<any, any>
     ? RelationFkFactory<TOwner, TColumnKey> & RelationRkFactory<TOwner, TColumnKey>
@@ -414,7 +383,7 @@ export type ExtractRelationTarget<TRelation> = TRelation extends
 /**
  * FKTarget/RelationKeyTarget에서 대상 타입 추출 (배열 또는 단일 객체)
  *
- * 1:N 관계의 대상 타입 (single() 호출 시 단일 객체)
+ * 1:N 관계의 대상 타입 (opts.single: true 시 단일 객체)
  * TTargetTableFn: 순환 참조 방지를 위한 지연 평가용 () => Post 형태
  *
  * @template T - FKTarget 또는 RelationKeyTarget builder 타입

package/src/schema/view-builder.ts

@@ -168,9 +168,7 @@ export class ViewBuilder<
    */
   relations<T extends RelationBuilderRecord>(
     fn: (r: ReturnType<typeof createRelationFactory<this, keyof TData & string>>) => T,
-  ): ViewBuilder<TDbContext, TData & InferDeepRelations<T>, TRelations> {
-    // TypeScript 제네릭 타입 추론 한계로 인해 캐스팅이 불가피
-    // TRelations 타입 파라미터와 새로 생성된 관계 타입 T 간의 타입 불일치 해결
+  ): ViewBuilder<TDbContext, TData & InferDeepRelations<T>, T> {
     return new ViewBuilder({
       ...this.meta,
       relations: fn(createRelationFactory<this, keyof TData & string>(() => this)),

package/src/types/column.ts

@@ -157,7 +157,7 @@ export function inferColumnPrimitiveStr(value: ColumnPrimitive): ColumnPrimitive
   if (value instanceof Time) return "Time";
   if (value instanceof Uuid) return "Uuid";
   if (value instanceof Uint8Array) return "Bytes";
-  throw new Error(`알 수 없는 값 타입: ${typeof value}`);
+  throw new Error("NULL 값으로는 타입을 추론할 수 없습니다.");
 }
 
 // ============================================

package/src/types/db-context-def.ts

@@ -4,15 +4,14 @@ import type { ProcedureBuilder } from "../schema/procedure-builder";
 import type { ColumnBuilder } from "../schema/factory/column-builder";
 import type { ForeignKeyBuilder } from "../schema/factory/relation-builder";
 import type { IndexBuilder } from "../schema/factory/index-builder";
-import type { DataRecord, IsolationLevel, Migration, ResultMeta } from "./db";
+import type { DataRecord, ResultMeta } from "./db";
 import type { QueryDef, QueryDefObjectName } from "./query-def";
 
 /**
  * DbContext 핵심 인터페이스
  *
  * Queryable, Executable, ViewBuilder에서 사용하는 내부 인터페이스.
- * 기존 DbContext 클래스와 새로운 createDbContext 반환 객체 모두
- * 이 인터페이스를 만족함.
+ * DbContext class가 이 인터페이스를 구현한다.
  */
 export interface DbContextBase {
   status: DbContextStatus;
@@ -32,63 +31,6 @@ export interface DbContextBase {
 
 export type DbContextStatus = "ready" | "connect" | "transact";
 
-/**
- * DbContext 정의 (blueprint)
- *
- * defineDbContext()로 생성됨. Schema 메타데이터만 포함하며 런타임 상태는 없음.
- */
-export interface DbContextDef<
-  TTables extends Record<string, TableBuilder<any, any>>,
-  TViews extends Record<string, ViewBuilder<any, any, any>>,
-  TProcedures extends Record<string, ProcedureBuilder<any, any>> = {},
-> {
-  readonly meta: {
-    readonly tables: TTables;
-    readonly views: TViews;
-    readonly procedures: TProcedures;
-    readonly migrations: Migration[];
-  };
-}
-
-/**
- * 전체 DbContext 인스턴스 타입 (createDbContext로 생성)
- *
- * DbContextBase를 queryable 접근자, DDL 메서드,
- * 연결/트랜잭션 관리로 확장.
- */
-export type DbContextInstance<TDef extends DbContextDef<any, any, any>> = DbContextBase &
-  DbContextConnectionMethods &
-  DbContextDdlMethods & {
-    // 자동 매핑된 table queryable 접근자
-    [K in keyof TDef["meta"]["tables"]]: () => import("../exec/queryable").Queryable<
-      TDef["meta"]["tables"][K]["$inferSelect"],
-      TDef["meta"]["tables"][K]
-    >;
-  } & {
-    // 자동 매핑된 view queryable 접근자
-    [K in keyof TDef["meta"]["views"]]: () => import("../exec/queryable").Queryable<
-      TDef["meta"]["views"][K]["$inferSelect"],
-      never
-    >;
-  } & {
-    // 자동 매핑된 procedure executable 접근자
-    [K in keyof TDef["meta"]["procedures"]]: () => import("../exec/executable").Executable<
-      TDef["meta"]["procedures"][K]["$params"],
-      TDef["meta"]["procedures"][K]["$returns"]
-    >;
-  } & {
-    // 시스템 table
-    _migration: () => import("../exec/queryable").Queryable<{ code: string }, any>;
-    // 초기화
-    initialize(options?: { dbs?: string[]; force?: boolean }): Promise<void>;
-  };
-
-export interface DbContextConnectionMethods {
-  connect<TResult>(fn: () => Promise<TResult>, isolationLevel?: IsolationLevel): Promise<TResult>;
-  connectWithoutTransaction<TResult>(callback: () => Promise<TResult>): Promise<TResult>;
-  transaction<TResult>(fn: () => Promise<TResult>, isolationLevel?: IsolationLevel): Promise<TResult>;
-}
-
 export interface DbContextDdlMethods {
   createTable(table: TableBuilder<any, any>): Promise<void>;
   dropTable(table: QueryDefObjectName): Promise<void>;