@simplysm/orm-node 13.0.69 → 13.0.70

package/src/connections/mysql-db-conn.ts

@@ -25,9 +25,9 @@ import {
 const logger = consola.withTag("mysql-db-conn");
 
 /**
- * MySQL 데이터베이스 연결 클래스
+ * MySQL database connection class
  *
- * mysql2/promise 라이브러리를 사용하여 MySQL 연결을 관리합니다.
+ * Manages MySQL connections using the mysql2/promise library.
  */
 export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn {
   private static readonly _ROOT_USER = "root";
@@ -56,12 +56,12 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       port: this.config.port,
       user: this.config.username,
       password: this.config.password,
-      // root 사용자는 특정 database에 바인딩되지 않고 연결하여
-      // 모든 데이터베이스에 접근할 수 있도록 함 (관리 작업용)
+      // Root user connects without binding to specific database
+      // to allow access to all databases (for admin operations)
       database: this.config.username === MysqlDbConn._ROOT_USER ? undefined : this.config.database,
       multipleStatements: true,
       charset: "utf8mb4",
-      infileStreamFactory: (filePath: string) => fs.createReadStream(filePath), // LOAD DATA LOCAL INFILE 지원
+      infileStreamFactory: (filePath: string) => fs.createReadStream(filePath), // Support for LOAD DATA LOCAL INFILE
     } as Parameters<typeof this._mysql2.createConnection>[0]);
 
     conn.on("end", () => {
@@ -70,7 +70,7 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
     });
 
     conn.on("error", (error) => {
-      logger.error("DB 연결 오류", error.message);
+      logger.error("DB connection error", error.message);
     });
 
     this._conn = conn;
@@ -100,13 +100,13 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       "READ_UNCOMMITTED"
     ).replace(/_/g, " ");
 
-    // 격리 수준을 먼저 설정 (다음 트랜잭션에 적용됨)
+    // Set isolation level first (applies to next transaction)
     await conn.query({
       sql: `SET SESSION TRANSACTION ISOLATION LEVEL ${level}`,
       timeout: this._timeout,
     });
 
-    // 그 다음 트랜잭션 시작
+    // Then start transaction
     await conn.beginTransaction();
 
     this.isInTransaction = true;
@@ -139,7 +139,7 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
   ): Promise<Record<string, unknown>[][]> {
     const conn = this._assertConnected();
 
-    logger.debug("쿼리 실행", { queryLength: query.length, params });
+    logger.debug("Query execution", { queryLength: query.length, params });
 
     try {
       const [queryResults] = await conn.query({
@@ -150,9 +150,9 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
 
       this._startTimeout();
 
-      // MySQL은 INSERT/UPDATE/DELETE 문에 대해 ResultSetHeader를 반환함
-      // SELECT 결과만 추출하기 위해 ResultSetHeader 객체를 필터링함
-      // ResultSetHeader는 affectedRows, fieldCount 등의 필드를 가지고 있음
+      // MySQL returns ResultSetHeader for INSERT/UPDATE/DELETE statements
+      // Filter ResultSetHeader objects to extract only SELECT results
+      // ResultSetHeader has fields like affectedRows, fieldCount, etc.
       const result: Record<string, unknown>[] = [];
       if (queryResults instanceof Array) {
         for (const queryResult of queryResults.filter(
@@ -174,7 +174,7 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       const error = err as Error & { sql?: string };
       throw new SdError(
         error,
-        "쿼리 수행중 오류발생" +
+        "Error executing query" +
           (error.sql != null ? "\n-- query\n" + error.sql.trim() + "\n--" : ""),
       );
     }
@@ -191,12 +191,12 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
 
     const colNames = Object.keys(columnMetas);
 
-    // 임시 CSV 파일 생성
+    // Create temporary CSV file
     const tmpDir = os.tmpdir();
     const tmpFile = path.join(tmpDir, `mysql_bulk_${randomUUID()}.csv`);
 
     try {
-      // CSV 데이터 생성
+      // Generate CSV data
       const csvLines: string[] = [];
       for (const record of records) {
         const row = colNames.map((colName) =>
@@ -206,10 +206,10 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       }
       const csvContent = csvLines.join("\n");
 
-      // 파일 쓰기
+      // Write file
       await fs.promises.writeFile(tmpFile, csvContent, "utf8");
 
-      // UUID/binary 컬럼은 임시 변수로 읽고 SET 절에서 UNHEX() 변환
+      // UUID/binary columns are read as temporary variables and converted with UNHEX() in SET clause
       const binaryColNames = colNames.filter((c) => {
         const dt = columnMetas[c].dataType.type;
         return dt === "uuid" || dt === "binary";
@@ -220,7 +220,7 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       });
       const setClauses = binaryColNames.map((c) => `\`${c}\` = UNHEX(@_${c})`);
 
-      // LOAD DATA LOCAL INFILE 실행
+      // Execute LOAD DATA LOCAL INFILE
       let query = `LOAD DATA LOCAL INFILE ? INTO TABLE ${tableName} FIELDS TERMINATED BY '\\t' LINES TERMINATED BY '\\n' (${normalCols.join(", ")})`;
       if (setClauses.length > 0) {
         query += ` SET ${setClauses.join(", ")}`;
@@ -228,11 +228,11 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
 
       await conn.query({ sql: query, timeout: this._timeout, values: [tmpFile] });
     } finally {
-      // 임시 파일 삭제
+      // Delete temporary file
       try {
         await fs.promises.unlink(tmpFile);
       } catch {
-        // 삭제 실패 무시
+        // Ignore deletion failure
       }
     }
   }
@@ -242,11 +242,11 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
   // ─────────────────────────────────────────────
 
   /**
-   * MySQL LOAD DATA INFILE용 값 이스케이프
+   * Escape value for MySQL LOAD DATA INFILE
    */
   private _escapeForCsv(value: unknown, dataType: DataType): string {
     if (value == null) {
-      return "\\N"; // MySQL NULL 표현
+      return "\\N"; // MySQL NULL representation
     }
 
     switch (dataType.type) {
@@ -264,7 +264,7 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
       case "char":
       case "text": {
         const str = value as string;
-        // 탭, 줄바꿈, 백슬래시 이스케이프
+        // Escape tab, newline, backslash
         return str
           .replace(/\\/g, "\\\\")
           .replace(/\0/g, "\\0")
@@ -283,13 +283,13 @@ export class MysqlDbConn extends EventEmitter<{ close: void }> implements DbConn
         return (value as Time).toFormatString("HH:mm:ss");
 
       case "uuid":
-        return (value as Uuid).toString().replace(/-/g, ""); // BINARY(16) 저장용 hex
+        return (value as Uuid).toString().replace(/-/g, ""); // Hex for BINARY(16) storage
 
       case "binary":
         return bytesToHex(value as Uint8Array);
 
       default:
-        throw new SdError(`지원하지 않는 DataType: ${JSON.stringify(dataType)}`);
+        throw new SdError(`Unsupported DataType: ${JSON.stringify(dataType)}`);
     }
   }
 

package/src/connections/postgresql-db-conn.ts

@@ -23,9 +23,9 @@ import type { Client } from "pg";
 const logger = consola.withTag("postgresql-db-conn");
 
 /**
- * PostgreSQL 데이터베이스 연결 클래스
+ * PostgreSQL database connection class
  *
- * pg 라이브러리를 사용하여 PostgreSQL 연결을 관리합니다.
+ * Manages PostgreSQL connections using the pg library.
  */
 export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements DbConn {
   private readonly _timeout = DB_CONN_DEFAULT_TIMEOUT;
@@ -65,7 +65,7 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
     });
 
     client.on("error", (error) => {
-      logger.error("DB 연결 오류", error.message);
+      logger.error("DB connection error", error.message);
     });
 
     await client.connect();
@@ -130,19 +130,19 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
   ): Promise<Record<string, unknown>[][]> {
     this._assertConnected();
 
-    logger.debug("쿼리 실행", { queryLength: query.length, params });
+    logger.debug("Query execution", { queryLength: query.length, params });
 
     try {
       const result = await this._client!.query(query, params);
 
       this._startTimeout();
 
-      // PostgreSQL은 단일 결과셋 반환
+      // PostgreSQL returns a single result set
       return [result.rows];
     } catch (err) {
       this._startTimeout();
       const error = err instanceof Error ? err : new Error(String(err));
-      throw new SdError(error, "쿼리 수행중 오류발생\n-- query\n" + query.trim() + "\n--");
+      throw new SdError(error, "Error executing query\n-- query\n" + query.trim() + "\n--");
     }
   }
 
@@ -158,11 +158,11 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
     const colNames = Object.keys(columnMetas);
     const wrappedCols = colNames.map((c) => `"${c}"`).join(", ");
 
-    // COPY FROM STDIN 스트림 생성
+    // Create COPY FROM STDIN stream
     const copyQuery = `COPY ${tableName} (${wrappedCols}) FROM STDIN WITH (FORMAT csv, NULL '\\N')`;
     const stream = this._client!.query(this._pgCopyStreams.from(copyQuery));
 
-    // CSV 데이터 생성
+    // Generate CSV data
     const csvLines: string[] = [];
     for (const record of records) {
       const row = colNames.map((colName) =>
@@ -172,7 +172,7 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
     }
     const csvContent = csvLines.join("\n") + "\n";
 
-    // 스트림으로 데이터 전송
+    // Send data via stream
     await new Promise<void>((resolve, reject) => {
       const readable = Readable.from([csvContent]);
 
@@ -189,11 +189,11 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
   // ─────────────────────────────────────────────
 
   /**
-   * PostgreSQL COPY CSV용 값 이스케이프
+   * Escape value for PostgreSQL COPY CSV
    */
   private _escapeForCsv(value: unknown, dataType: DataType): string {
     if (value == null) {
-      return "\\N"; // NULL 표현
+      return "\\N"; // NULL representation
     }
 
     switch (dataType.type) {
@@ -211,7 +211,7 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
       case "char":
       case "text": {
         const str = value as string;
-        // CSV 형식: 쌍따옴표로 감싸고, 내부 쌍따옴표는 두 번
+        // CSV format: wrap with double quotes, escape internal double quotes with double quotes
         if (
           str.includes('"') ||
           str.includes(",") ||
@@ -237,10 +237,10 @@ export class PostgresqlDbConn extends EventEmitter<{ close: void }> implements D
         return (value as Uuid).toString();
 
       case "binary":
-        return '"\\x' + bytesToHex(value as Uint8Array) + '"'; // PostgreSQL bytea hex 형식 (CSV 쌍따옴표로 감쌈)
+        return '"\\x' + bytesToHex(value as Uint8Array) + '"'; // PostgreSQL bytea hex format (wrapped in CSV double quotes)
 
       default:
-        throw new SdError(`지원하지 않는 DataType: ${JSON.stringify(dataType)}`);
+        throw new SdError(`Unsupported DataType: ${JSON.stringify(dataType)}`);
     }
   }
 

package/src/create-db-conn.ts

@@ -7,19 +7,19 @@ import { MssqlDbConn } from "./connections/mssql-db-conn";
 import { PostgresqlDbConn } from "./connections/postgresql-db-conn";
 
 /**
- * DB 연결 팩토리
+ * DB connection factory
  *
- * 데이터베이스 연결 인스턴스를 생성하고 풀링을 관리한다.
- * MSSQL, MySQL, PostgreSQL을 지원한다.
+ * Creates database connection instances and manages pooling.
+ * Supports MSSQL, MySQL, and PostgreSQL.
  */
 
-// 설정별 커넥션 풀 캐싱
+// Cache connection pools by configuration
 const poolMap = new Map<string, Pool<DbConn>>();
 
-// 풀 생성 실패 시 마지막 에러 캐싱 (configKey 기준)
+// Cache last error when pool creation fails (by configKey)
 const poolLastErrorMap = new Map<string, Error>();
 
-// 지연 로딩 모듈 캐시
+// Lazy-loaded module cache
 const modules: {
   tedious?: typeof import("tedious");
   mysql?: typeof import("mysql2/promise");
@@ -28,19 +28,19 @@ const modules: {
 } = {};
 
 /**
- * DB 연결 생성
+ * Create DB connection
  *
- * 커넥션 풀에서 연결을 획득하여 반환한다.
- * 풀이 없는 경우 새로 생성한다.
+ * Acquires and returns a connection from the connection pool.
+ * Creates a new pool if one does not exist.
  *
- * @param config - 데이터베이스 연결 설정
- * @returns 풀링된 DB 연결 객체
+ * @param config - Database connection configuration
+ * @returns Pooled DB connection object
  */
 export function createDbConn(config: DbConnConfig): Promise<DbConn> {
-  // 1. 풀 가져오기 (없으면 생성)
+  // 1. Get pool (create if not exists)
   const { pool, getLastCreateError } = getOrCreatePool(config);
 
-  // 2. 래퍼 객체 반환
+  // 2. Return wrapper object
   return Promise.resolve(new PooledDbConn(pool, config, getLastCreateError));
 }
 
@@ -48,7 +48,7 @@ function getOrCreatePool(config: DbConnConfig): {
   pool: Pool<DbConn>;
   getLastCreateError: () => Error | undefined;
 } {
-  // 객체를 키로 쓰기 위해 문자열 변환 (중첩 객체도 정렬하여 동일 설정의 일관된 키 보장)
+  // Convert object to string key (sort nested objects to ensure consistent keys for identical configurations)
   const configKey = JSON.stringify(config, (_, value: unknown) =>
     value != null && typeof value === "object" && !Array.isArray(value)
       ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)))
@@ -64,10 +64,10 @@ function getOrCreatePool(config: DbConnConfig): {
           return conn;
         },
         destroy: async (conn) => {
-          await conn.close(); // 풀에서 제거될 때 실제 연결 종료
+          await conn.close(); // Close actual connection when removed from pool
         },
         validate: (conn) => {
-          // 획득 시 연결 상태 확인 (끊겨있으면 Pool이 폐기하고 새로 만듦)
+          // Check connection status on acquisition (Pool will dispose and recreate if disconnected)
           return Promise.resolve(conn.isConnected);
         },
       },
@@ -76,7 +76,7 @@ function getOrCreatePool(config: DbConnConfig): {
         max: config.pool?.max ?? 10,
         acquireTimeoutMillis: config.pool?.acquireTimeoutMillis ?? 30000,
         idleTimeoutMillis: config.pool?.idleTimeoutMillis ?? 30000,
-        testOnBorrow: true, // [중요] 빌려줄 때 validate 실행 여부
+        testOnBorrow: true, // [IMPORTANT] Whether to run validate when borrowing
       },
     );
 

package/src/create-orm.ts

@@ -8,26 +8,26 @@ import type { DbConnConfig } from "./types/db-conn";
 import { NodeDbContextExecutor } from "./node-db-context-executor";
 
 /**
- * Orm 옵션
+ * ORM options
  *
- * DbConnConfig보다 우선 적용되는 DbContext 옵션
+ * DbContext options that take precedence over DbConnConfig
  */
 export interface OrmOptions {
   /**
-   * 데이터베이스 이름 (DbConnConfig의 database 대신 사용)
+   * Database name (used instead of DbConnConfig's database)
    */
   database?: string;
 
   /**
-   * 스키마 이름 (MSSQL: dbo, PostgreSQL: public)
+   * Schema name (MSSQL: dbo, PostgreSQL: public)
    */
   schema?: string;
 }
 
 /**
- * Orm 인스턴스 타입
+ * ORM instance type
  *
- * createOrm에서 반환되는 객체의 타입
+ * Type of the object returned from createOrm
  */
 export interface Orm<TDef extends DbContextDef<any, any, any>> {
   readonly dbContextDef: TDef;
@@ -35,11 +35,11 @@ export interface Orm<TDef extends DbContextDef<any, any, any>> {
   readonly options?: OrmOptions;
 
   /**
-   * 트랜잭션 내에서 콜백 실행
+   * Execute callback within a transaction
    *
-   * @param callback - DB 연결 후 실행할 콜백
-   * @param isolationLevel - 트랜잭션 격리 수준
-   * @returns 콜백 결과
+   * @param callback - Callback to execute after DB connection
+   * @param isolationLevel - Transaction isolation level
+   * @returns Callback result
    */
   connect<R>(
     callback: (conn: DbContextInstance<TDef>) => Promise<R>,
@@ -47,19 +47,19 @@ export interface Orm<TDef extends DbContextDef<any, any, any>> {
   ): Promise<R>;
 
   /**
-   * 트랜잭션 없이 콜백 실행
+   * Execute callback without a transaction
    *
-   * @param callback - DB 연결 후 실행할 콜백
-   * @returns 콜백 결과
+   * @param callback - Callback to execute after DB connection
+   * @returns Callback result
    */
   connectWithoutTransaction<R>(callback: (conn: DbContextInstance<TDef>) => Promise<R>): Promise<R>;
 }
 
 /**
- * Node.js ORM 팩토리 함수
+ * Node.js ORM factory function
  *
- * DbContext와 DB 연결을 관리하는 인스턴스를 생성합니다.
- * DbContext 정의와 연결 설정을 받아 트랜잭션을 관리합니다.
+ * Creates an instance that manages DbContext and DB connections.
+ * Receives DbContext definition and connection configuration to manage transactions.
  *
  * @example
  * ```typescript
@@ -76,13 +76,13 @@ export interface Orm<TDef extends DbContextDef<any, any, any>> {
  *   database: "mydb",
  * });
  *
- * // 트랜잭션 내에서 실행
+ * // Execute within a transaction
  * await orm.connect(async (db) => {
  *   const users = await db.user().result();
  *   return users;
  * });
  *
- * // 트랜잭션 없이 실행
+ * // Execute without a transaction
  * await orm.connectWithoutTransaction(async (db) => {
  *   const users = await db.user().result();
  *   return users;
@@ -95,13 +95,13 @@ export function createOrm<TDef extends DbContextDef<any, any, any>>(
   options?: OrmOptions,
 ): Orm<TDef> {
   function _createDbContext(): DbContextInstance<TDef> {
-    // database는 options에서 우선, 없으면 config에서
+    // database from options first, then from config
     const database = options?.database ?? ("database" in config ? config.database : undefined);
     if (database == null || database === "") {
       throw new Error("database is required");
     }
 
-    // schema는 options에서 우선, 없으면 config에서
+    // schema from options first, then from config
     const schema = options?.schema ?? ("schema" in config ? config.schema : undefined);
 
     return createDbContext(dbContextDef, new NodeDbContextExecutor(config), {

package/src/node-db-context-executor.ts

@@ -14,9 +14,9 @@ import { DB_CONN_ERRORS, getDialectFromConfig } from "./types/db-conn";
 import { createDbConn } from "./create-db-conn";
 
 /**
- * Node.js 환경용 DbContextExecutor
+ * DbContextExecutor for Node.js environment
  *
- * DbContext에서 사용하는 실행기로, 실제 DB 연결을 담당한다.
+ * Executor used by DbContext that handles actual DB connections.
  */
 export class NodeDbContextExecutor implements DbContextExecutor {
   private _conn?: DbConn;
@@ -27,9 +27,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * DB 연결 수립
+   * Establish DB connection
    *
-   * 커넥션 풀에서 연결을 획득하고 연결 상태를 활성화한다.
+   * Acquires connection from connection pool and activates the connection state.
    */
   async connect(): Promise<void> {
     this._conn = await createDbConn(this._config);
@@ -37,11 +37,11 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * DB 연결 종료
+   * Close DB connection
    *
-   * 커넥션 풀에 연결을 반환한다.
+   * Returns connection to the connection pool.
    *
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @throws {Error} When not connected
    */
   async close(): Promise<void> {
     const conn = this._requireConn();
@@ -50,10 +50,10 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * 트랜잭션 시작
+   * Begin transaction
    *
-   * @param isolationLevel - 트랜잭션 격리 수준
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @param isolationLevel - Transaction isolation level
+   * @throws {Error} When not connected
    */
   async beginTransaction(isolationLevel?: IsolationLevel): Promise<void> {
     const conn = this._requireConn();
@@ -61,9 +61,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * 트랜잭션 커밋
+   * Commit transaction
    *
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @throws {Error} When not connected
    */
   async commitTransaction(): Promise<void> {
     const conn = this._requireConn();
@@ -71,9 +71,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * 트랜잭션 롤백
+   * Rollback transaction
    *
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @throws {Error} When not connected
    */
   async rollbackTransaction(): Promise<void> {
     const conn = this._requireConn();
@@ -81,12 +81,12 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * 파라미터화된 쿼리 실행
+   * Execute parameterized query
    *
-   * @param query - SQL 쿼리 문자열
-   * @param params - 쿼리 파라미터 배열
-   * @returns 쿼리 결과 배열
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @param query - SQL query string
+   * @param params - Query parameter array
+   * @returns Query result array
+   * @throws {Error} When not connected
    */
   async executeParametrized(
     query: string,
@@ -97,12 +97,12 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * 대량 데이터 삽입 (네이티브 벌크 API 사용)
+   * Bulk insert data (using native bulk API)
    *
-   * @param tableName - 대상 테이블명
-   * @param columnMetas - 컬럼 메타데이터
-   * @param records - 삽입할 레코드 배열
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @param tableName - Target table name
+   * @param columnMetas - Column metadata
+   * @param records - Record array to insert
+   * @throws {Error} When not connected
    */
   async bulkInsert(
     tableName: string,
@@ -114,14 +114,14 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * QueryDef 배열 실행
+   * Execute QueryDef array
    *
-   * QueryDef를 SQL로 변환하여 실행하고, ResultMeta를 사용하여 결과를 파싱한다.
+   * Converts QueryDef to SQL and executes, parses results using ResultMeta.
    *
-   * @param defs - 실행할 QueryDef 배열
-   * @param resultMetas - 결과 파싱용 메타데이터 배열 (타입 변환에 사용)
-   * @returns 각 QueryDef의 실행 결과 배열
-   * @throws {Error} 연결되지 않은 상태일 때
+   * @param defs - QueryDef array to execute
+   * @param resultMetas - Result parsing metadata array (used for type conversion)
+   * @returns Array of execution results for each QueryDef
+   * @throws {Error} When not connected
    */
   async executeDefs<T = DataRecord>(
     defs: QueryDef[],
@@ -131,15 +131,15 @@ export class NodeDbContextExecutor implements DbContextExecutor {
 
     const builder = createQueryBuilder(this._dialect);
 
-    // 가져올 데이터가 없는 것으로 옵션 설정을 했을 때, 하나의 쿼리로 한번의 요청 보냄
-    // 결과가 필요 없으므로 defs.length개의 빈 배열을 반환하여 인터페이스 계약 유지
+    // When configured not to fetch data, send one request with a single query
+    // Since results are not needed, return empty arrays matching defs.length to maintain interface contract
     if (resultMetas != null && resultMetas.every((item) => item == null)) {
       const combinedSql = defs.map((def) => builder.build(def).sql).join("\n");
       await conn.execute([combinedSql]);
       return defs.map(() => []) as T[][];
     }
 
-    // 각 def를 개별 실행
+    // Execute each def individually
     const results: T[][] = [];
     for (let i = 0; i < defs.length; i++) {
       const def = defs[i];
@@ -148,7 +148,7 @@ export class NodeDbContextExecutor implements DbContextExecutor {
 
       const rawResults = await conn.execute([buildResult.sql]);
 
-      // resultSetIndex가 지정된 경우 해당 인덱스의 결과셋 사용
+      // Use result set at specified index if resultSetIndex is specified
       const targetResultSet =
         buildResult.resultSetIndex != null ? rawResults[buildResult.resultSetIndex] : rawResults[0];