@simplysm/orm-node 13.0.100 → 14.0.4

package/src/create-orm.ts

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

package/src/index.ts

@@ -1,12 +1,12 @@
-// Types
+// 타입
 export * from "./types/db-conn";
 
-// Connections
+// 연결
 export * from "./connections/mssql-db-conn";
 export * from "./connections/mysql-db-conn";
 export * from "./connections/postgresql-db-conn";
 
-// Core
+// 코어
 export * from "./create-db-conn";
 export * from "./node-db-context-executor";
 export * from "./create-orm";

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";
 
 /**
- * DbContextExecutor for Node.js environment
+ * Node.js 환경용 DbContextExecutor
  *
- * Executor used by DbContext that handles actual DB connections.
+ * DbContext에서 사용하는 실제 DB 연결을 처리하는 실행자.
  */
 export class NodeDbContextExecutor implements DbContextExecutor {
   private _conn?: DbConn;
@@ -27,7 +27,7 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Establish DB connection
+   * DB 연결을 수립한다
    */
   async connect(): Promise<void> {
     this._conn = await createDbConn(this._config);
@@ -35,9 +35,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Close DB connection
+   * DB 연결을 종료한다
    *
-   * @throws {Error} When not connected
+   * @throws {Error} 연결되지 않은 경우
    */
   async close(): Promise<void> {
     const conn = this._requireConn();
@@ -46,10 +46,10 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Begin transaction
+   * 트랜잭션을 시작한다
    *
-   * @param isolationLevel - Transaction isolation level
-   * @throws {Error} When not connected
+   * @param isolationLevel - 트랜잭션 격리 수준
+   * @throws {Error} 연결되지 않은 경우
    */
   async beginTransaction(isolationLevel?: IsolationLevel): Promise<void> {
     const conn = this._requireConn();
@@ -57,9 +57,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Commit transaction
+   * 트랜잭션을 커밋한다
    *
-   * @throws {Error} When not connected
+   * @throws {Error} 연결되지 않은 경우
    */
   async commitTransaction(): Promise<void> {
     const conn = this._requireConn();
@@ -67,9 +67,9 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Rollback transaction
+   * 트랜잭션을 롤백한다
    *
-   * @throws {Error} When not connected
+   * @throws {Error} 연결되지 않은 경우
    */
   async rollbackTransaction(): Promise<void> {
     const conn = this._requireConn();
@@ -77,12 +77,12 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Execute parameterized query
+   * 파라미터화된 쿼리를 실행한다
    *
-   * @param query - SQL query string
-   * @param params - Query parameter array
-   * @returns Query result array
-   * @throws {Error} When not connected
+   * @param query - SQL 쿼리 문자열
+   * @param params - 쿼리 파라미터 배열
+   * @returns 쿼리 결과 배열
+   * @throws {Error} 연결되지 않은 경우
    */
   async executeParametrized(
     query: string,
@@ -93,12 +93,12 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Bulk insert data (using native bulk API)
+   * 대량 데이터 삽입 (네이티브 bulk API 사용)
    *
-   * @param tableName - Target table name
-   * @param columnMetas - Column metadata
-   * @param records - Record array to insert
-   * @throws {Error} When not connected
+   * @param tableName - 대상 테이블 이름
+   * @param columnMetas - 컬럼 메타데이터
+   * @param records - 삽입할 레코드 배열
+   * @throws {Error} 연결되지 않은 경우
    */
   async bulkInsert(
     tableName: string,
@@ -110,14 +110,14 @@ export class NodeDbContextExecutor implements DbContextExecutor {
   }
 
   /**
-   * Execute QueryDef array
+   * QueryDef 배열을 실행한다
    *
-   * Converts QueryDef to SQL and executes, parses results using ResultMeta.
+   * QueryDef를 SQL로 변환하여 실행하고, ResultMeta를 사용하여 결과를 파싱한다.
    *
-   * @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
+   * @param defs - 실행할 QueryDef 배열
+   * @param resultMetas - 결과 파싱 메타데이터 배열 (타입 변환에 사용)
+   * @returns 각 QueryDef의 실행 결과 배열
+   * @throws {Error} 연결되지 않은 경우
    */
   async executeDefs<T = DataRecord>(
     defs: QueryDef[],
@@ -127,15 +127,15 @@ export class NodeDbContextExecutor implements DbContextExecutor {
 
     const builder = createQueryBuilder(this._dialect);
 
-    // 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
+    // 데이터를 가져올 필요가 없도록 설정된 경우, 단일 쿼리로 한 번의 요청을 보낸다
+    // 결과가 필요 없으므로 인터페이스 계약을 유지하기 위해 defs.length에 맞는 빈 배열을 반환
     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[][];
     }
 
-    // Execute each def individually
+    // 각 def를 개별적으로 실행
     const results: T[][] = [];
     for (let i = 0; i < defs.length; i++) {
       const def = defs[i];
@@ -144,7 +144,7 @@ export class NodeDbContextExecutor implements DbContextExecutor {
 
       const rawResults = await conn.execute([buildResult.sql]);
 
-      // Use result set at specified index if resultSetIndex is specified
+      // resultSetIndex가 지정된 경우 해당 인덱스의 결과 집합을 사용
       const targetResultSet =
         buildResult.resultSetIndex != null ? rawResults[buildResult.resultSetIndex] : rawResults[0];
 

package/src/types/db-conn.ts

@@ -2,112 +2,112 @@ import type { EventEmitter } from "@simplysm/core-common";
 import type { ColumnMeta, Dialect, IsolationLevel } from "@simplysm/orm-common";
 
 // ============================================
-// Common constants
+// 공통 상수
 // ============================================
 
 /**
- * DB connection establishment timeout (10 seconds)
+ * DB 연결 수립 타임아웃 (10초)
  */
 export const DB_CONN_CONNECT_TIMEOUT = 10 * 1000;
 
 /**
- * DB query default timeout (10 minutes)
+ * DB 쿼리 기본 타임아웃 (10분)
  */
 export const DB_CONN_DEFAULT_TIMEOUT = 10 * 60 * 1000;
 
 /**
- * DB connection error messages
+ * DB 연결 오류 메시지
  */
 export const DB_CONN_ERRORS = {
-  NOT_CONNECTED: "'Connection' is not connected.",
-  ALREADY_CONNECTED: "'Connection' is already connected.",
+  NOT_CONNECTED: "'Connection'이 연결되어 있지 않습니다.",
+  ALREADY_CONNECTED: "'Connection'이 이미 연결되어 있습니다.",
 } as const;
 
 // ============================================
-// IDbConn Interface
+// IDbConn 인터페이스
 // ============================================
 
 /**
- * Low-level DB connection interface
+ * 저수준 DB 연결 인터페이스
  *
- * Implementations for each DBMS implement this interface.
- * - {@link MysqlDbConn} - MySQL connection
- * - {@link MssqlDbConn} - MSSQL connection
- * - {@link PostgresqlDbConn} - PostgreSQL connection
+ * 각 DBMS 구현체가 이 인터페이스를 구현한다.
+ * - {@link MysqlDbConn} - MySQL 연결
+ * - {@link MssqlDbConn} - MSSQL 연결
+ * - {@link PostgresqlDbConn} - PostgreSQL 연결
  *
  * @remarks
- * Inherits from EventEmitter and emits 'close' events.
+ * EventEmitter를 상속하며 'close' 이벤트를 발생시킨다.
  */
 export interface DbConn extends EventEmitter<{ close: void }> {
   /**
-   * Connection configuration
+   * 연결 설정
    */
   config: DbConnConfig;
 
   /**
-   * Whether connected
+   * 연결 여부
    */
   isConnected: boolean;
 
   /**
-   * Whether transaction is in progress
+   * 트랜잭션 진행 여부
    */
   isInTransaction: boolean;
 
   /**
-   * Establish DB connection
+   * DB 연결을 수립한다
    */
   connect(): Promise<void>;
 
   /**
-   * Close DB connection
+   * DB 연결을 종료한다
    */
   close(): Promise<void>;
 
   /**
-   * Begin transaction
+   * 트랜잭션을 시작한다
    *
-   * @param isolationLevel - Isolation level (optional)
+   * @param isolationLevel - 격리 수준 (선택사항)
    */
   beginTransaction(isolationLevel?: IsolationLevel): Promise<void>;
 
   /**
-   * Commit transaction
+   * 트랜잭션을 커밋한다
    */
   commitTransaction(): Promise<void>;
 
   /**
-   * Rollback transaction
+   * 트랜잭션을 롤백한다
    */
   rollbackTransaction(): Promise<void>;
 
   /**
-   * Execute SQL query array
+   * SQL 쿼리 배열을 실행한다
    *
-   * @param queries - SQL string array to execute
-   * @returns Array of result arrays for each query
+   * @param queries - 실행할 SQL 문자열 배열
+   * @returns 각 쿼리의 결과 배열
    */
   execute(queries: string[]): Promise<Record<string, unknown>[][]>;
 
   /**
-   * Execute parameterized query
+   * 파라미터화된 쿼리를 실행한다
    *
-   * @param query - SQL query string
-   * @param params - Binding parameters (optional)
-   * @returns Array of result arrays
+   * @param query - SQL 쿼리 문자열
+   * @param params - 바인딩 파라미터 (선택사항)
+   * @returns 결과 배열
    */
   executeParametrized(query: string, params?: unknown[]): Promise<Record<string, unknown>[][]>;
 
   /**
-   * Bulk INSERT (using native bulk API)
+   * Bulk INSERT (네이티브 bulk API 사용)
    *
    * - MSSQL: tedious BulkLoad
-   * - MySQL: LOAD DATA LOCAL INFILE (temporary file)
+   * - MySQL: LOAD DATA LOCAL INFILE (임시 파일)
    * - PostgreSQL: COPY FROM STDIN
    *
-   * @param tableName - Table name (database.table or database.schema.table)
-   * @param columnMetas - Column name → ColumnMeta mapping
-   * @param records - Record array to insert
+   * @param tableName - 테이블 이름 (database.table 또는 database.schema.table)
+   * @param columnMetas - 컬럼 이름 → ColumnMeta 매핑
+   * @param records - 삽입할 레코드 배열
    */
   bulkInsert(
     tableName: string,
@@ -117,16 +117,16 @@ export interface DbConn extends EventEmitter<{ close: void }> {
 }
 
 // ============================================
-// DbConnConfig Types
+// DbConnConfig 타입
 // ============================================
 
 /**
- * DB connection configuration type (branching by dialect)
+ * DB 연결 설정 타입 (dialect별 분기)
  */
 export type DbConnConfig = MysqlDbConnConfig | MssqlDbConnConfig | PostgresqlDbConnConfig;
 
 /**
- * MySQL connection configuration
+ * MySQL 연결 설정
  */
 export interface MysqlDbConnConfig {
   dialect: "mysql";
@@ -139,7 +139,7 @@ export interface MysqlDbConnConfig {
 }
 
 /**
- * MSSQL connection configuration
+ * MSSQL 연결 설정
  */
 export interface MssqlDbConnConfig {
   dialect: "mssql" | "mssql-azure";
@@ -153,7 +153,7 @@ export interface MssqlDbConnConfig {
 }
 
 /**
- * PostgreSQL connection configuration
+ * PostgreSQL 연결 설정
  */
 export interface PostgresqlDbConnConfig {
   dialect: "postgresql";
@@ -167,7 +167,7 @@ export interface PostgresqlDbConnConfig {
 }
 
 /**
- * Extract Dialect from DbConnConfig
+ * DbConnConfig에서 Dialect를 추출한다
  */
 export function getDialectFromConfig(config: DbConnConfig): Dialect {
   if (config.dialect === "mssql-azure") {