@simplysm/orm-common 13.0.99 → 14.0.1

package/src/ddl/table-ddl.ts

@@ -14,12 +14,12 @@ import type { DbContextBase } from "../types/db-context-def";
 import { obj } from "@simplysm/core-common";
 
 /**
- * Transform Builder to CREATE QueryDef
+ * Builder를 CREATE QueryDef로 변환
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param builder - Table/View/Procedure builder
  * @returns CREATE TABLE/VIEW/PROCEDURE QueryDef
- * @throws {Error} When unknown builder type
+ * @throws {Error} 알 수 없는 builder 타입일 때
  */
 export function getCreateObjectQueryDef(
   db: DbContextBase,
@@ -33,21 +33,21 @@ export function getCreateObjectQueryDef(
     return getCreateProcQueryDef(db, builder);
   }
 
-  throw new Error(`Unknown builder type: ${typeof builder}`);
+  throw new Error(`알 수 없는 builder 타입: ${typeof builder}`);
 }
 
 /**
- * CREATE TABLE QueryDef Generate
+ * CREATE TABLE QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param table - Table builder
  * @returns CREATE TABLE QueryDef
- * @throws {Error} When table has no columns
+ * @throws {Error} 테이블에 column이 없을 때
  */
 export function getCreateTableQueryDef(db: DbContextBase, table: TableBuilder<any, any>): QueryDef {
   const columns = table.meta.columns as ColumnBuilderRecord | undefined;
   if (columns == null) {
-    throw new Error(`Table '${table.meta.name}' has no columns.`);
+    throw new Error(`테이블 '${table.meta.name}'에 column이 없습니다.`);
   }
 
   return {
@@ -65,19 +65,19 @@ export function getCreateTableQueryDef(db: DbContextBase, table: TableBuilder<an
 }
 
 /**
- * CREATE VIEW QueryDef Generate
+ * CREATE VIEW QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param view - View builder
  * @returns CREATE VIEW QueryDef
- * @throws {Error} When view has no viewFn
+ * @throws {Error} View에 viewFn이 없을 때
  */
 export function getCreateViewQueryDef(
   db: DbContextBase,
   view: ViewBuilder<any, any, any>,
 ): QueryDef {
   if (view.meta.viewFn == null) {
-    throw new Error(`View '${view.meta.name}' has no viewFn.`);
+    throw new Error(`View '${view.meta.name}'에 viewFn이 없습니다.`);
   }
 
   const qr = view.meta.viewFn(db);
@@ -95,19 +95,19 @@ export function getCreateViewQueryDef(
 }
 
 /**
- * CREATE PROCEDURE QueryDef Generate
+ * CREATE PROCEDURE QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param procedure - Procedure builder
  * @returns CREATE PROCEDURE QueryDef
- * @throws {Error} When procedure has no body
+ * @throws {Error} Procedure에 body가 없을 때
  */
 export function getCreateProcQueryDef(
   db: DbContextBase,
   procedure: ProcedureBuilder<any, any>,
 ): QueryDef {
   if (procedure.meta.query == null) {
-    throw new Error(`Procedure '${procedure.meta.name}' has no body.`);
+    throw new Error(`Procedure '${procedure.meta.name}'에 body가 없습니다.`);
   }
 
   const params = procedure.meta.params as ColumnBuilderRecord | undefined;
@@ -140,14 +140,14 @@ export function getCreateProcQueryDef(
 }
 
 /**
- * DROP TABLE QueryDef Generate
+ * DROP TABLE QueryDef 생성
  */
 export function getDropTableQueryDef(table: QueryDefObjectName): DropTableQueryDef {
   return { type: "dropTable", table };
 }
 
 /**
- * RENAME TABLE QueryDef Generate
+ * RENAME TABLE QueryDef 생성
  */
 export function getRenameTableQueryDef(
   table: QueryDefObjectName,
@@ -157,25 +157,25 @@ export function getRenameTableQueryDef(
 }
 
 /**
- * DROP VIEW QueryDef Generate
+ * DROP VIEW QueryDef 생성
  */
 export function getDropViewQueryDef(view: QueryDefObjectName): DropViewQueryDef {
   return { type: "dropView", view };
 }
 
 /**
- * DROP PROCEDURE QueryDef Generate
+ * DROP PROCEDURE QueryDef 생성
  */
 export function getDropProcQueryDef(procedure: QueryDefObjectName): DropProcQueryDef {
   return { type: "dropProc", procedure };
 }
 
 /**
- * Transform TableBuilder/ViewBuilder to QueryDefObjectName
+ * TableBuilder/ViewBuilder를 QueryDefObjectName으로 변환
  *
- * @param db - DbContext instance
- * @param tableOrView - Table or View builder
- * @returns Object name information for use in QueryDef
+ * @param db - DbContext 인스턴스
+ * @param tableOrView - Table 또는 View builder
+ * @returns QueryDef에서 사용할 객체 이름 정보
  */
 export function getQueryDefObjectName(
   db: DbContextBase,

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,