@simplysm/orm-common 13.0.70 → 13.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/orm-common",
-  "version": "13.0.70",
+  "version": "13.0.71",
   "description": "Simplysm Package - ORM Module (common)",
   "author": "simplysm",
   "license": "Apache-2.0",
@@ -19,6 +19,6 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@simplysm/core-common": "13.0.70"
+    "@simplysm/core-common": "13.0.71"
   }
 }

package/tests/ddl/column-builder.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== 데이터 타입 Basic 테스트 ==========
+//#region ========== Data Type Basic Tests ==========
 
 export const intType: ExpectedSql = {
   mysql: mysql`
@@ -215,7 +215,7 @@ export const uuidType: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 메서드 조합 테스트 ==========
+//#region ========== Method Combination Tests ==========
 
 export const nullableColumn: ExpectedSql = {
   mysql: mysql`

package/tests/dml/update.expected.ts

@@ -147,7 +147,7 @@ export const updateWithTop: ExpectedSql = {
 
 //#endregion
 
-//#region ========== FK 스위치 ==========
+//#region ========== FK Switch ==========
 
 export const fkOff: ExpectedSql = {
   mysql: mysql`

package/tests/dml/update.spec.ts

@@ -160,7 +160,7 @@ describe("UPDATE - Basic", () => {
       .employee()
       .where((e) => [expr.eq(e.id, 1)])
       .getUpdateQueryDef((e) => ({
-        // managerId = managerId + 1 (예시)
+        // managerId = managerId + 1 (example)
         managerId: expr.raw("number")`${e.managerId} + 1`,
       }));
 

package/tests/errors/queryable-errors.spec.ts

@@ -19,7 +19,7 @@ describe("Queryable error cases", () => {
     it("Error when passing parameters to procedure without parameters", () => {
       const db = createTestDb();
       expect(() => {
-        // @ts-expect-error - 파라미터 없는 프로시저에 파라미터 전달 테스트
+        // @ts-expect-error - test passing parameters to a procedure that expects none
         db.getAllUsers().getExecProcQueryDef({ unexpectedParam: 1 });
       }).toThrow("has no parameters.");
     });

package/tests/escape.spec.ts

@@ -50,13 +50,13 @@ describe("MysqlExprRenderer.escapeString", () => {
     expect(result).toBe("''; DROP TABLE users; --");
   });
 
-  it("백슬래시와 따옴표 조합을 방어해야 함", () => {
+  it("should defend against backslash + quote combination", () => {
     const malicious = "\\'";
     const result = renderer.escapeString(malicious);
     expect(result).toBe("\\\\''");
   });
 
-  it("NULL 바이트와 SQL 주석 조합을 방어해야 함", () => {
+  it("should defend against NULL byte + SQL comment combination", () => {
     const malicious = "admin\0-- ";
     const result = renderer.escapeString(malicious);
     expect(result).toBe("admin\\0-- ");
@@ -68,32 +68,32 @@ describe("MysqlExprRenderer.escapeString", () => {
 describe("MysqlExprRenderer.escapeValue", () => {
   const renderer = new MysqlExprRenderer(() => "");
 
-  it("문자열을 escapeString()으로 이스케이프하고 따옴표로 감싸야 함", () => {
+  it("escapes string with escapeString() and wraps in quotes", () => {
     const result = renderer.escapeValue("O'Reilly");
     expect(result).toBe("'O''Reilly'");
   });
 
-  it("백슬래시가 포함된 문자열을 올바르게 이스케이프해야 함", () => {
+  it("correctly escapes string containing backslashes", () => {
     const result = renderer.escapeValue("C:\\path");
     expect(result).toBe("'C:\\\\path'");
   });
 
-  it("SQL 인젝션 시도를 방어해야 함", () => {
+  it("defends against SQL injection attempts", () => {
     const result = renderer.escapeValue("'; DROP TABLE users; --");
     expect(result).toBe("'''; DROP TABLE users; --'");
   });
 
-  it("NULL을 'NULL' 문자열로 반환해야 함", () => {
+  it("returns 'NULL' string for null", () => {
     const result = renderer.escapeValue(null);
     expect(result).toBe("NULL");
   });
 
-  it("Number를 문자열로 conversion해야 함", () => {
+  it("converts number to string", () => {
     const result = renderer.escapeValue(123);
     expect(result).toBe("123");
   });
 
-  it("불리언을 TRUE/FALSE로 conversion해야 함", () => {
+  it("converts boolean to TRUE/FALSE", () => {
     expect(renderer.escapeValue(true)).toBe("TRUE");
     expect(renderer.escapeValue(false)).toBe("FALSE");
   });

package/tests/examples/pivot.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== PIVOT - Basic 집계 함수 ==========
+//#region ========== PIVOT - Basic Aggregate Functions ==========
 
 export const pivotSum: ExpectedSql = {
   mysql: mysql`
@@ -125,7 +125,7 @@ GROUP BY "T1"."id", "T1"."category"
 
 //#endregion
 
-//#region ========== PIVOT - 다중 피벗 값 ==========
+//#region ========== PIVOT - Multiple Pivot Values ==========
 
 export const pivotMultipleYears: ExpectedSql = {
   mysql: mysql`

package/tests/examples/sampling.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== 랜덤 샘플링 ==========
+//#region ========== Random Sampling ==========
 
 export const samplingBasic: ExpectedSql = {
   mysql: mysql`

package/tests/examples/sampling.spec.ts

@@ -1,9 +1,10 @@
 /**
- * 랜덤 샘플링 예제
+ * Random sampling example
  *
- * sample() 메서드 대신 expr.random()과 orderBy/top을 조합하여 랜덤 샘플링 구현
+ * Implements random sampling using expr.random() combined with orderBy/top
+ * instead of a dedicated sample() method.
  *
- * 사용법: db.user().orderBy(() => expr.random()).top(5)
+ * Usage: db.user().orderBy(() => expr.random()).top(5)
  */
 import { describe, expect, it } from "vitest";
 import { createTestDb } from "../setup/TestDbContext";

package/tests/expr/comparison.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql, DateTime, DateOnly, Time, Uuid } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-// DateTime 값 테스트용
+// For DateTime value tests
 export const testDateTime = new DateTime(2024, 1, 15, 10, 30, 0);
 export const testDateOnly = new DateOnly(2024, 1, 15);
 export const testTime = new Time(10, 30, 0);
@@ -237,7 +237,7 @@ export const inEmpty: ExpectedSql = {
   `,
 };
 
-//#region ========== DateTime/DateOnly/Time 값 테스트 ==========
+//#region ========== DateTime/DateOnly/Time Value Tests ==========
 
 export const eqDateTime: ExpectedSql = {
   mysql: mysql`
@@ -259,7 +259,7 @@ export const eqDateTime: ExpectedSql = {
 
 //#endregion
 
-//#region ========== inQuery 테스트 ==========
+//#region ========== inQuery Tests ==========
 
 export const inQuery: ExpectedSql = {
   mysql: mysql`

package/tests/expr/comparison.spec.ts

@@ -340,7 +340,7 @@ describe("Expr - Comparison operators (null-safe)", () => {
     });
   });
 
-  //#region ========== DateTime 값 테스트 ==========
+  //#region ========== DateTime value tests ==========
 
   describe("eq - DateTime value comparison", () => {
     const db = createTestDb();
@@ -358,7 +358,7 @@ describe("Expr - Comparison operators (null-safe)", () => {
 
   //#endregion
 
-  //#region ========== inQuery 테스트 ==========
+  //#region ========== inQuery tests ==========
 
   describe("inQuery - subquery IN condition", () => {
     const db = createTestDb();

package/tests/expr/conditional.spec.ts

@@ -218,7 +218,7 @@ describe("Expr - Conditional functions", () => {
   });
 
   describe("switch - all case/default are undefined", () => {
-    it("에러를 발생시킨다", () => {
+    it("throws an error", () => {
       const db = createTestDb();
       expect(() => {
         db.user()
@@ -234,7 +234,7 @@ describe("Expr - Conditional functions", () => {
   });
 
   describe("if - both then and else are undefined", () => {
-    it("에러를 발생시킨다", () => {
+    it("throws an error", () => {
       const db = createTestDb();
       expect(() => {
         db.user()

package/tests/expr/utility.expected.ts

@@ -1,5 +1,5 @@
 /**
- * Expr - 유틸리티 함수 test expected SQL
+ * Expr - utility function test expected SQL
  */
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";

package/tests/select/basic.expected.ts

@@ -203,7 +203,7 @@ export const selectGreatest: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 옵션 ==========
+//#region ========== Options ==========
 
 export const selectDistinct: ExpectedSql = {
   mysql: mysql`
@@ -256,7 +256,7 @@ export const selectDistinctLock: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 제한 ==========
+//#region ========== Limit ==========
 
 export const selectTop: ExpectedSql = {
   mysql: mysql`
@@ -317,6 +317,6 @@ export const selectLimitOffset: ExpectedSql = {
   `,
 };
 
-// 랜덤 샘플링은 examples/sampling.spec.ts 참고
+// See examples/sampling.spec.ts for random sampling
 
 //#endregion

package/tests/select/filter.expected.ts

@@ -4,7 +4,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== 비교 연산 ==========
+//#region ========== Comparison Operators ==========
 
 export const whereEq: ExpectedSql = {
   mysql: mysql`
@@ -116,7 +116,7 @@ export const whereLte: ExpectedSql = {
 
 //#endregion
 
-//#region ========== NULL 체크 ==========
+//#region ========== NULL Check ==========
 
 export const whereNull: ExpectedSql = {
   mysql: mysql`
@@ -236,7 +236,7 @@ export const whereNotLike: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 논리 연산 ==========
+//#region ========== Logical Operators ==========
 
 export const whereMultipleAnd: ExpectedSql = {
   mysql: mysql`

package/tests/select/filter.spec.ts

@@ -6,7 +6,7 @@ import { dialects } from "../setup/test-utils";
 import "../setup/test-utils"; // toMatchSql matcher
 import * as expected from "./filter.expected";
 
-//#region ========== 비교 연산 ==========
+//#region ========== comparison operations ==========
 
 describe("SELECT - WHERE - comparison operations", () => {
   describe("eq (equal)", () => {
@@ -183,7 +183,7 @@ describe("SELECT - WHERE - comparison operations", () => {
 
 //#endregion
 
-//#region ========== NULL 체크 ==========
+//#region ========== NULL check ==========
 
 describe("SELECT - WHERE - NULL check", () => {
   describe("null", () => {
@@ -383,10 +383,10 @@ describe("SELECT - WHERE - LIKE", () => {
 
 //#endregion
 
-//#region ========== 논리 연산 ==========
+//#region ========== logical operations ==========
 
 describe("SELECT - WHERE - logical operations", () => {
-  describe("다중 조건 (AND)", () => {
+  describe("multiple conditions (AND)", () => {
     const db = createTestDb();
     const def = db
       .user()
@@ -495,7 +495,7 @@ describe("SELECT - WHERE - logical operations", () => {
     });
   });
 
-  it("연속 where (AND 결합)", () => {
+  it("chained where (AND combination)", () => {
     const db = createTestDb();
     const def = db
       .user()
@@ -601,7 +601,7 @@ describe("SELECT - WHERE - EXISTS / IN subquery", () => {
     });
   });
 
-  it("not exists - QueryDef 검증", () => {
+  it("not exists - verifies QueryDef", () => {
     const db = createTestDb();
     const def = db
       .user()
@@ -683,7 +683,7 @@ describe("SELECT - WHERE - EXISTS / IN subquery", () => {
 //#region ========== SEARCH ==========
 
 describe("SELECT - SEARCH", () => {
-  it("단일 검색어 - 단일 column", () => {
+  it("single keyword - single column", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -717,7 +717,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("다중 검색어 (OR)", () => {
+  it("multiple keywords (OR)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -769,7 +769,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("구문 검색 (따옴표)", () => {
+  it("phrase search (quotes)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -803,7 +803,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("와일드카드 (*)", () => {
+  it("wildcard (*)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -837,7 +837,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("이스케이프 (\\*)", () => {
+  it("escape (\\*)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -871,7 +871,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("다중 column 검색 (OR)", () => {
+  it("multiple column search (OR)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -913,7 +913,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("제외 검색 (-)", () => {
+  it("exclusion search (-)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -963,7 +963,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("복합 검색 (포함, 제외, 구문)", () => {
+  it("complex search (include, exclude, phrase)", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -1050,7 +1050,7 @@ describe("SELECT - SEARCH", () => {
     });
   });
 
-  it("빈 검색어", () => {
+  it("empty search term", () => {
     const db = createTestDb();
     const def = db
       .post()

package/tests/select/join.spec.ts

@@ -213,7 +213,7 @@ describe("SELECT - JOIN", () => {
     });
   });
 
-  describe("다단계 join(Single)", () => {
+  describe("multi-level joinSingle", () => {
     const db = createTestDb();
     const def = db
       .post()
@@ -563,7 +563,7 @@ describe("SELECT - INCLUDE", () => {
       .include((item) => item.user.company)
       .getSelectQueryDef();
 
-    // 중복 include는 자동으로 제거됨 (user 1번, company 1번)
+    // duplicate includes are automatically deduplicated (user once, company once)
     expect(def).toEqual({
       type: "select",
       as: "T1",
@@ -707,7 +707,7 @@ describe("SELECT - INCLUDE", () => {
   });
 
   describe("3 depth include (FK -> FKT -> FK)", () => {
-    // Post → user(FK) → posts(FKT) → user(FK)
+    // Post -> user(FK) -> posts(FKT) -> user(FK)
     const db = createTestDb();
     const def = db
       .post()

package/tests/select/order.expected.ts

@@ -62,7 +62,7 @@ export const orderDesc: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 다중 정렬 ==========
+//#region ========== Multiple Sort ==========
 
 export const orderMultiple: ExpectedSql = {
   mysql: mysql`
@@ -84,7 +84,7 @@ export const orderMultiple: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 표현식 정렬 ==========
+//#region ========== Expression Sort ==========
 
 export const orderExpression: ExpectedSql = {
   mysql: mysql`
@@ -106,7 +106,7 @@ export const orderExpression: ExpectedSql = {
 
 //#endregion
 
-//#region ========== 조합 ==========
+//#region ========== Combination ==========
 
 export const orderSelectCombo: ExpectedSql = {
   mysql: mysql`

package/tests/select/order.spec.ts

@@ -76,7 +76,7 @@ describe("SELECT - ORDER BY", () => {
 
   //#endregion
 
-  //#region ========== 다중 정렬 ==========
+  //#region ========== multiple sorting ==========
 
   describe("multiple sorting", () => {
     const db = createTestDb();
@@ -106,7 +106,7 @@ describe("SELECT - ORDER BY", () => {
 
   //#endregion
 
-  //#region ========== 표현식 정렬 ==========
+  //#region ========== expression sorting ==========
 
   describe("sort by expressions", () => {
     const db = createTestDb();
@@ -132,7 +132,7 @@ describe("SELECT - ORDER BY", () => {
 
   //#endregion
 
-  //#region ========== 조합 ==========
+  //#region ========== combinations ==========
 
   describe("SELECT + ORDER BY combination", () => {
     const db = createTestDb();

package/tests/select/recursive-cte.expected.ts

@@ -4,7 +4,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== Basic 재귀 CTE ==========
+//#region ========== Basic Recursive CTE ==========
 
 export const basicSubordinates: ExpectedSql = {
   mysql: mysql`
@@ -143,7 +143,7 @@ export const upwardManagers: ExpectedSql = {
 
 //#endregion
 
-//#region ========== CTE + 후processing ==========
+//#region ========== CTE + Post Processing ==========
 
 export const cteWithOrderBy: ExpectedSql = {
   mysql: mysql`

package/tests/select/subquery.expected.ts

@@ -1,10 +1,10 @@
 /**
- * SELECT - 서브쿼리/WRAP/UNION test expected SQL
+ * SELECT - Subquery/WRAP/UNION test expected SQL
  */
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-//#region ========== WRAP (서브쿼리) ==========
+//#region ========== WRAP (Subquery) ==========
 
 export const wrapBasic: ExpectedSql = {
   mysql: mysql`

package/tests/select/view.expected.ts

@@ -80,7 +80,7 @@ export const viewSelectOrderByLimit: ExpectedSql = {
 
 //#endregion
 
-//#region ========== View - SELECT가 있는 뷰 ==========
+//#region ========== View - View With SELECT ==========
 
 export const userSummarySelect: ExpectedSql = {
   mysql: mysql`SELECT * FROM \`TestDb\`.\`UserSummary\` AS \`T1\``,

package/tests/setup/MockExecutor.ts

@@ -2,16 +2,16 @@ import type { DbContextExecutor, ResultMeta } from "../../src/types/db";
 import type { QueryDef } from "../../src/types/query-def";
 
 export class MockExecutor implements DbContextExecutor {
-  // 연결 관리 (Mock - 아무것도 안 함)
+  // connection management (Mock - no-op)
   async connect(): Promise<void> {}
   async close(): Promise<void> {}
 
-  // 트랜잭션 (Mock - 아무것도 안 함)
+  // transactions (Mock - no-op)
   async beginTransaction(): Promise<void> {}
   async commitTransaction(): Promise<void> {}
   async rollbackTransaction(): Promise<void> {}
 
-  // 쿼리 실행
+  // query execution
   executeDefs(_defs: QueryDef[], _resultMetas?: (ResultMeta | undefined)[]): Promise<any[][]> {
     return Promise.resolve([[]]);
   }

package/tests/setup/models/Employee.ts

@@ -4,7 +4,7 @@ export const Employee = Table("Employee")
   .columns((c) => ({
     id: c.bigint().autoIncrement(),
     name: c.varchar(100),
-    managerId: c.bigint().nullable(), // 자기 참조 (상위 매니저)
+    managerId: c.bigint().nullable(), // self-referencing (parent manager)
     departmentId: c.bigint().nullable(),
   }))
   .primaryKey("id");

package/tests/setup/views/ActiveUsers.ts

@@ -2,7 +2,7 @@ import { View } from "../../../src/schema/view-builder";
 import { expr } from "../../../src/expr/expr";
 import type { TestDbTablesContext } from "../TestDbContext";
 
-// 활성 사용자만 보여주는 뷰
+// view showing only active users
 export const ActiveUsers = View("ActiveUsers").query((db: TestDbTablesContext) =>
   db.user().where((u) => [expr.eq(u.isActive, true)]),
 );

package/tests/setup/views/UserSummary.ts

@@ -1,7 +1,7 @@
 import { View } from "../../../src/schema/view-builder";
 import type { TestDbTablesContext } from "../TestDbContext";
 
-// 사용자 요약 정보 뷰 (select 포함)
+// view for user summary info (includes select)
 export const UserSummary = View("UserSummary").query((db: TestDbTablesContext) =>
   db.user().select((u) => ({
     id: u.id,

package/tests/utils/result-parser-perf.spec.ts

@@ -3,16 +3,16 @@ import { parseQueryResult } from "../../src/utils/result-parser";
 import type { ResultMeta } from "../../src/types/db";
 
 /**
- * 성능 벤치마크 테스트
+ * Performance benchmark tests
  *
- * 목적: objClone 제거 최적화 효과 측정
- * 측정 항목:
- * - 대용량 단순 레코드 processing 시간
- * - 대용량 JOIN 레코드 processing 시간
- * - 중첩 JOIN processing 시간
+ * Purpose: measure optimization effect of removing objClone
+ * Metrics:
+ * - processing time for large simple records
+ * - processing time for large JOIN records
+ * - processing time for nested JOIN records
  */
 describe("result-parser performance", () => {
-  // 테스트 데이터 생성 헬퍼
+  // test data generation helpers
   function generateSimpleRecords(count: number): Record<string, unknown>[] {
     return Array.from({ length: count }, (_, i) => ({
       id: String(i + 1),
@@ -63,7 +63,7 @@ describe("result-parser performance", () => {
   }
 
   describe("simple record processing", () => {
-    it("10,000개 레코드 processing - 500ms 이내", async () => {
+    it("10,000 records processing - within 500ms", async () => {
       const raw = generateSimpleRecords(10_000);
       const meta: ResultMeta = {
         columns: {
@@ -82,10 +82,10 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(10_000);
       expect(elapsed).toBeLessThan(500);
-      console.log(`  단순 10,000개: ${elapsed.toFixed(2)}ms`);
+      console.log(`  simple 10,000: ${elapsed.toFixed(2)}ms`);
     });
 
-    it("50,000개 레코드 processing - 3000ms 이내", async () => {
+    it("50,000 records processing - within 3000ms", async () => {
       const raw = generateSimpleRecords(50_000);
       const meta: ResultMeta = {
         columns: {
@@ -104,12 +104,12 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(50_000);
       expect(elapsed).toBeLessThan(3000);
-      console.log(`  단순 50,000개: ${elapsed.toFixed(2)}ms`);
+      console.log(`  simple 50,000: ${elapsed.toFixed(2)}ms`);
     });
   });
 
   describe("1-level JOIN processing", () => {
-    it("1,000 users × 10 posts = 10,000개 레코드 - 600ms 이내", async () => {
+    it("1,000 users × 10 posts = 10,000 records - within 600ms", async () => {
       const raw = generateJoinRecords(1_000, 10);
       const meta: ResultMeta = {
         columns: {
@@ -128,10 +128,10 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(1_000);
       expect(elapsed).toBeLessThan(600);
-      console.log(`  JOIN 10,000개 (1000×10): ${elapsed.toFixed(2)}ms`);
+      console.log(`  JOIN 10,000 (1000×10): ${elapsed.toFixed(2)}ms`);
     });
 
-    it("5,000 users × 10 posts = 50,000개 레코드 - 3000ms 이내", async () => {
+    it("5,000 users × 10 posts = 50,000 records - within 3000ms", async () => {
       const raw = generateJoinRecords(5_000, 10);
       const meta: ResultMeta = {
         columns: {
@@ -150,12 +150,12 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(5_000);
       expect(elapsed).toBeLessThan(3000);
-      console.log(`  JOIN 50,000개 (5000×10): ${elapsed.toFixed(2)}ms`);
+      console.log(`  JOIN 50,000 (5000×10): ${elapsed.toFixed(2)}ms`);
     });
   });
 
   describe("2-level nested JOIN processing", () => {
-    it("100 users × 10 posts × 5 comments = 5,000개 레코드 - 500ms 이내", async () => {
+    it("100 users × 10 posts × 5 comments = 5,000 records - within 500ms", async () => {
       const raw = generateNestedJoinRecords(100, 10, 5);
       const meta: ResultMeta = {
         columns: {
@@ -178,10 +178,10 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(100);
       expect(elapsed).toBeLessThan(500);
-      console.log(`  중첩 JOIN 5,000개 (100×10×5): ${elapsed.toFixed(2)}ms`);
+      console.log(`  nested JOIN 5,000 (100×10×5): ${elapsed.toFixed(2)}ms`);
     });
 
-    it("500 users × 10 posts × 5 comments = 25,000개 레코드 - 2000ms 이내", async () => {
+    it("500 users × 10 posts × 5 comments = 25,000 records - within 2000ms", async () => {
       const raw = generateNestedJoinRecords(500, 10, 5);
       const meta: ResultMeta = {
         columns: {
@@ -204,7 +204,7 @@ describe("result-parser performance", () => {
 
       expect(result).toHaveLength(500);
       expect(elapsed).toBeLessThan(2000);
-      console.log(`  중첩 JOIN 25,000개 (500×10×5): ${elapsed.toFixed(2)}ms`);
+      console.log(`  nested JOIN 25,000 (500×10×5): ${elapsed.toFixed(2)}ms`);
     });
   });
 });

package/tests/utils/result-parser.spec.ts

@@ -4,7 +4,7 @@ import { parseQueryResult } from "../../src/utils/result-parser";
 import type { ResultMeta } from "../../src/types/db";
 
 describe("result-parser", () => {
-  //#region ========== 타입 파싱 ==========
+  //#region ========== type parsing ==========
 
   describe("type parsing", () => {
     it("number conversion", async () => {
@@ -51,7 +51,7 @@ describe("result-parser", () => {
       expect(result).toEqual([{ active: true, deleted: false }]);
     });
 
-    it('boolean conversion - "0"/"1" 문자열', async () => {
+    it('boolean conversion - "0"/"1" strings', async () => {
       const raw = [{ active: "1", deleted: "0" }];
       const meta: ResultMeta = {
         columns: { active: "boolean", deleted: "boolean" },
@@ -107,7 +107,7 @@ describe("result-parser", () => {
       expect(result![0].startTime.second).toBe(0);
     });
 
-    it("Uuid conversion - 문자열", async () => {
+    it("Uuid conversion - string", async () => {
       const uuidStr = "550e8400-e29b-41d4-a716-446655440000";
       const raw = [{ id: uuidStr }];
       const meta: ResultMeta = {
@@ -136,7 +136,7 @@ describe("result-parser", () => {
       expect(result![0].id.toString()).toBe(uuidStr);
     });
 
-    it("Bytes conversion - Uint8Array 그대로", async () => {
+    it("Bytes conversion - Uint8Array passthrough", async () => {
       const bytes = new Uint8Array([0x01, 0x02, 0x03]);
       const raw = [{ data: bytes }];
       const meta: ResultMeta = {
@@ -150,8 +150,8 @@ describe("result-parser", () => {
       expect(Array.from(result![0].data)).toEqual([0x01, 0x02, 0x03]);
     });
 
-    it("Bytes conversion - hex 문자열", async () => {
-      // [0x01, 0x02, 0x03]의 hex 표현
+    it("Bytes conversion - hex string", async () => {
+      // hex representation of [0x01, 0x02, 0x03]
       const hexStr = "010203";
       const raw = [{ data: hexStr }];
       const meta: ResultMeta = {
@@ -171,7 +171,7 @@ describe("result-parser", () => {
   //#region ========== null/undefined processing ==========
 
   describe("null/undefined processing", () => {
-    it("null 값은 키가 제거됨", async () => {
+    it("null value removes the key", async () => {
       const raw = [{ id: 1, name: null }];
       const meta: ResultMeta = {
         columns: { id: "number", name: "string" },
@@ -183,7 +183,7 @@ describe("result-parser", () => {
       expect(result![0]).not.toHaveProperty("name");
     });
 
-    it("undefined 값은 키가 제거됨", async () => {
+    it("undefined value removes the key", async () => {
       const raw = [{ id: 1, name: undefined }];
       const meta: ResultMeta = {
         columns: { id: "number", name: "string" },
@@ -195,7 +195,7 @@ describe("result-parser", () => {
       expect(result![0]).not.toHaveProperty("name");
     });
 
-    it("모든 값이 null인 레코드는 제외됨", async () => {
+    it("record with all null values is excluded", async () => {
       const raw = [{ id: null, name: null }];
       const meta: ResultMeta = {
         columns: { id: "number", name: "string" },
@@ -206,7 +206,7 @@ describe("result-parser", () => {
       expect(result).toBeUndefined();
     });
 
-    it("빈 배열은 undefined 반환", async () => {
+    it("empty array returns undefined", async () => {
       const raw: Record<string, unknown>[] = [];
       const meta: ResultMeta = {
         columns: { id: "number" },
@@ -217,8 +217,8 @@ describe("result-parser", () => {
       expect(result).toBeUndefined();
     });
 
-    it("columns에 없는 column은 무시", async () => {
-      const raw = [{ id: 1, name: "Gildong Hong", extra: "무시됨" }];
+    it("columns not in meta are ignored", async () => {
+      const raw = [{ id: 1, name: "Gildong Hong", extra: "ignored" }];
       const meta: ResultMeta = {
         columns: { id: "number", name: "string" },
         joins: {},
@@ -232,7 +232,7 @@ describe("result-parser", () => {
 
   //#endregion
 
-  //#region ========== 에러 processing ==========
+  //#region ========== error processing ==========
 
   describe("error processing", () => {
     it("number throw if parsing fails", async () => {
@@ -266,7 +266,7 @@ describe("result-parser", () => {
     });
 
     it("Bytes throw if parsing fails", async () => {
-      const raw = [{ data: 12345 }]; // Number는 Bytes로 conversion 불가
+      const raw = [{ data: 12345 }]; // Number cannot be converted to Bytes
       const meta: ResultMeta = {
         columns: { data: "Bytes" },
         joins: {},
@@ -278,10 +278,10 @@ describe("result-parser", () => {
 
   //#endregion
 
-  //#region ========== 1레벨 JOIN ==========
+  //#region ========== 1-level JOIN ==========
 
   describe("1-level JOIN", () => {
-    it("isSingle: true - 단일 객체", async () => {
+    it("isSingle: true - single object", async () => {
       const raw = [{ "id": 1, "name": "User1", "company.id": 100, "company.name": "Corp" }];
       const meta: ResultMeta = {
         columns: {
@@ -303,7 +303,7 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("isSingle: false - 배열", async () => {
+    it("isSingle: false - array", async () => {
       const raw = [
         { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" },
         { "id": 1, "name": "User1", "posts.id": 11, "posts.title": "Post2" },
@@ -331,7 +331,7 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("isSingle: true - 여러 개의 다른 결과 시 throw", async () => {
+    it("isSingle: true - throws when multiple different results exist", async () => {
       const raw = [
         { "id": 1, "name": "User1", "company.id": 100, "company.name": "Corp1" },
         { "id": 1, "name": "User1", "company.id": 200, "company.name": "Corp2" },
@@ -351,7 +351,7 @@ describe("result-parser", () => {
       );
     });
 
-    it("빈 JOIN 결과는 키가 N/A", async () => {
+    it("empty JOIN result omits the key", async () => {
       const raw = [{ "id": 1, "name": "User1", "company.id": null, "company.name": null }];
       const meta: ResultMeta = {
         columns: {
@@ -368,7 +368,7 @@ describe("result-parser", () => {
       expect(result![0]).not.toHaveProperty("company");
     });
 
-    it("여러 루트 레코드와 JOIN", async () => {
+    it("multiple root records with JOIN", async () => {
       const raw = [
         { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" },
         { "id": 2, "name": "User2", "posts.id": 20, "posts.title": "Post2" },
@@ -405,10 +405,10 @@ describe("result-parser", () => {
 
   //#endregion
 
-  //#region ========== 다중 레벨 JOIN ==========
+  //#region ========== multi-level JOIN ==========
 
   describe("multi-level JOIN", () => {
-    it("2레벨 중첩", async () => {
+    it("2-level nesting", async () => {
       const raw = [
         {
           "id": 1,
@@ -461,7 +461,7 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("3레벨 중첩", async () => {
+    it("3-level nesting", async () => {
       const raw = [
         {
           "id": 1,
@@ -527,7 +527,7 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("여러 JOIN과 혼합 isSingle", async () => {
+    it("multiple JOINs with mixed isSingle", async () => {
       const raw = [
         {
           "id": 1,
@@ -575,7 +575,7 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("여러 JOIN 중 일부만 NULL - company는 있고 posts는 N/A", async () => {
+    it("partial NULL among multiple JOINs - company present, posts absent", async () => {
       const raw = [
         {
           "id": 1,
@@ -615,10 +615,10 @@ describe("result-parser", () => {
 
   //#endregion
 
-  //#region ========== 에지 케이스 ==========
+  //#region ========== edge cases ==========
 
   describe("edge cases", () => {
-    it("joins가 빈 객체인 경우", async () => {
+    it("joins is an empty object", async () => {
       const raw = [{ id: 1, name: "User1" }];
       const meta: ResultMeta = {
         columns: { id: "number", name: "string" },
@@ -629,10 +629,10 @@ describe("result-parser", () => {
       expect(result).toEqual([{ id: 1, name: "User1" }]);
     });
 
-    it("중복 데이터 제거", async () => {
+    it("deduplicates duplicate data", async () => {
       const raw = [
         { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" },
-        { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" }, // 중복
+        { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" }, // duplicate
       ];
       const meta: ResultMeta = {
         columns: {
@@ -649,15 +649,15 @@ describe("result-parser", () => {
         {
           id: 1,
           name: "User1",
-          posts: [{ id: 10, title: "Post1" }], // 중복 제거됨
+          posts: [{ id: 10, title: "Post1" }], // deduplicated
         },
       ]);
     });
 
-    it("isSingle: true - 동일한 데이터는 에러 N/A", async () => {
+    it("isSingle: true - identical data does not throw", async () => {
       const raw = [
         { "id": 1, "name": "User1", "company.id": 100, "company.name": "Corp" },
-        { "id": 1, "name": "User1", "company.id": 100, "company.name": "Corp" }, // 동일
+        { "id": 1, "name": "User1", "company.id": 100, "company.name": "Corp" }, // identical
       ];
       const meta: ResultMeta = {
         columns: {
@@ -679,8 +679,8 @@ describe("result-parser", () => {
       ]);
     });
 
-    it("대용량 데이터 yield processing", async () => {
-      // 250개 레코드 생성 (yield가 2회 발생: i=100, i=200)
+    it("large dataset yield processing", async () => {
+      // generates 250 records (yield fires twice: at i=100, i=200)
       const raw = Array.from({ length: 250 }, (_, i) => ({
         id: String(i + 1),
         name: `User${i + 1}`,