@simplysm/orm-common 13.0.100 → 14.0.4

package/src/errors/db-transaction-error.ts

@@ -1,27 +1,27 @@
 /**
- * Transaction-related error codes
+ * 트랜잭션 관련 에러 코드
  *
- * Abstracts DBMS-specific native error codes for DBMS-independent error handling
+ * DBMS별 네이티브 에러 코드를 추상화하여 DBMS 독립적인 에러 처리를 지원한다
  */
 export enum DbErrorCode {
-  /** No active transaction (no transaction during ROLLBACK) */
+  /** 활성 트랜잭션 없음 (ROLLBACK 시 트랜잭션 없음) */
   NO_ACTIVE_TRANSACTION = "NO_ACTIVE_TRANSACTION",
 
-  /** Transaction already started */
+  /** 트랜잭션 이미 시작됨 */
   TRANSACTION_ALREADY_STARTED = "TRANSACTION_ALREADY_STARTED",
 
-  /** Deadlock occurred */
+  /** 데드락 발생 */
   DEADLOCK = "DEADLOCK",
 
-  /** Lock timeout */
+  /** 잠금 타임아웃 */
   LOCK_TIMEOUT = "LOCK_TIMEOUT",
 }
 
 /**
- * Database transaction error
+ * 데이터베이스 트랜잭션 에러
  *
- * Wraps DBMS-specific native errors with standardized error codes for
- * DBMS-independent error handling
+ * DBMS별 네이티브 에러를 표준화된 에러 코드로 래핑하여
+ * DBMS 독립적인 에러 처리를 지원한다
  *
  * @example
  * ```typescript
@@ -30,7 +30,7 @@ export enum DbErrorCode {
  * } catch (err) {
  *   if (err instanceof DbTransactionError) {
  *     if (err.code === DbErrorCode.NO_ACTIVE_TRANSACTION) {
- *       // Ignore if already rolled back
+ *       // 이미 롤백된 경우 무시
  *       return;
  *     }
  *   }
@@ -42,11 +42,11 @@ export class DbTransactionError extends Error {
   override readonly name = "DbTransactionError";
 
   constructor(
-    /** Standardized error code */
+    /** 표준화된 에러 코드 */
     public readonly code: DbErrorCode,
-    /** Error message */
+    /** 에러 메시지 */
     message: string,
-    /** Original DBMS error (for debugging) */
+    /** 원본 DBMS 에러 (디버깅용) */
     public readonly originalError?: unknown,
   ) {
     super(message);

package/src/exec/executable.ts

@@ -5,22 +5,22 @@ import { ExprUnit } from "../expr/expr-unit";
 import { expr } from "../expr/expr";
 
 /**
- * Stored procedure execution wrapper class
+ * 저장 프로시저 실행 래퍼 클래스
  *
- * Class for executing procedures defined by ProcedureBuilder.
- * Created and used through the executable() factory function in DbContext.
+ * ProcedureBuilder로 정의된 프로시저를 실행하기 위한 클래스.
+ * DbContext에서 executable() 팩토리 함수를 통해 생성 및 사용된다.
  *
- * @template TParams - Procedure parameter type
- * @template TReturns - Procedure return type
+ * @template TParams - 프로시저 파라미터 타입
+ * @template TReturns - 프로시저 반환 타입
  *
  * @example
  * ```typescript
- * // Execute procedure
+ * // 프로시저 실행
  * const result = await db.getUserById().execute({ userId: 1n });
  * ```
  *
- * @see {@link executable} Factory function
- * @see {@link ProcedureBuilder} Procedure definition
+ * @see {@link executable} 팩토리 함수
+ * @see {@link ProcedureBuilder} 프로시저 정의
  */
 export class Executable<TParams extends ColumnBuilderRecord, TReturns extends ColumnBuilderRecord> {
   constructor(
@@ -29,12 +29,12 @@ export class Executable<TParams extends ColumnBuilderRecord, TReturns extends Co
   ) {}
 
   /**
-   * Generate procedure execution QueryDef
+   * 프로시저 실행 QueryDef 생성
    */
   getExecProcQueryDef(params?: InferColumnExprs<TParams>) {
     const meta = this._builder.meta;
     if (params && !meta.params) {
-      throw new Error(`Procedure '${meta.name}' has no parameters.`);
+      throw new Error(`Procedure '${meta.name}'에 파라미터가 없습니다.`);
     }
 
     return {
@@ -59,7 +59,7 @@ export class Executable<TParams extends ColumnBuilderRecord, TReturns extends Co
   }
 
   /**
-   * Execute procedure
+   * 프로시저 실행
    */
   async execute(params: InferColumnExprs<TParams>): Promise<InferColumnExprs<TReturns>[][]> {
     return this._db.executeDefs<InferColumnExprs<TReturns>>([this.getExecProcQueryDef(params)]);
@@ -67,41 +67,41 @@ export class Executable<TParams extends ColumnBuilderRecord, TReturns extends Co
 }
 
 // ============================================
-// executable function
+// executable 함수
 // ============================================
 
 /**
- * Factory function to create Executable
+ * Executable 생성 팩토리 함수
  *
- * Used when registering procedures in DbContext.
- * Wraps procedures defined by ProcedureBuilder and returns them as Executable.
+ * DbContext에 프로시저를 등록할 때 사용한다.
+ * ProcedureBuilder로 정의된 프로시저를 Executable로 래핑하여 반환한다.
  *
- * @template TParams - Procedure parameter type
- * @template TReturns - Procedure return type
- * @param db - DbContext instance
- * @param builder - ProcedureBuilder instance
- * @returns Executable factory function
+ * @template TParams - 프로시저 파라미터 타입
+ * @template TReturns - 프로시저 반환 타입
+ * @param db - DbContext 인스턴스
+ * @param builder - ProcedureBuilder 인스턴스
+ * @returns Executable 팩토리 함수
  *
  * @example
  * ```typescript
- * // Define procedure
+ * // 프로시저 정의
  * const GetUserById = Procedure("GetUserById")
  *   .database("mydb")
  *   .params((c) => ({ userId: c.bigint() }))
  *   .returns((c) => ({ id: c.bigint(), name: c.varchar(100) }))
  *   .body("SELECT id, name FROM User WHERE id = userId");
  *
- * // Register in DbContext
+ * // DbContext에 등록
  * class MyDb extends DbContext {
  *   getUserById = executable(this, GetUserById);
  * }
  *
- * // Use
+ * // 사용
  * const result = await db.getUserById().execute({ userId: 1n });
  * ```
  *
- * @see {@link Executable} Execution class
- * @see {@link ProcedureBuilder} Procedure definition
+ * @see {@link Executable} 실행 클래스
+ * @see {@link ProcedureBuilder} 프로시저 정의
  */
 export function executable<
   TParams extends ColumnBuilderRecord,