@simplysm/orm-common 13.0.68 → 13.0.70

package/src/ddl/relation-ddl.ts

@@ -1,89 +1,89 @@
-import type { ForeignKeyBuilder } from "../schema/factory/relation-builder";
-import type { IndexBuilder } from "../schema/factory/index-builder";
-import type {
-  QueryDef,
-  QueryDefObjectName,
-  AddPkQueryDef,
-  DropPkQueryDef,
-  DropFkQueryDef,
-  DropIdxQueryDef,
-} from "../types/query-def";
-import type { DbContextBase } from "../types/db-context-def";
-import { getMatchedPrimaryKeys } from "../exec/queryable";
-import { getQueryDefObjectName } from "./table-ddl";
-
-/**
- * DROP PRIMARY KEY QueryDef 생성
- */
-export function getDropPkQueryDef(table: QueryDefObjectName): DropPkQueryDef {
-  return { type: "dropPk", table };
-}
-
-/**
- * ADD PRIMARY KEY QueryDef 생성
- */
-export function getAddPkQueryDef(table: QueryDefObjectName, columns: string[]): AddPkQueryDef {
-  return { type: "addPk", table, columns };
-}
-
-/**
- * ADD FOREIGN KEY QueryDef 생성
- */
-export function getAddFkQueryDef(
-  db: DbContextBase,
-  table: QueryDefObjectName,
-  relationName: string,
-  relationDef: ForeignKeyBuilder<any, any>,
-): QueryDef {
-  const targetTable = relationDef.meta.targetFn();
-  const fkColumns = relationDef.meta.columns;
-  const pk = getMatchedPrimaryKeys(fkColumns, targetTable);
-
-  return {
-    type: "addFk",
-    table,
-    foreignKey: {
-      name: `FK_${table.name}_${relationName}`,
-      fkColumns,
-      targetTable: getQueryDefObjectName(db, targetTable),
-      targetPkColumns: pk,
-    },
-  };
-}
-
-/**
- * ADD INDEX QueryDef 생성
- */
-export function getAddIdxQueryDef(
-  table: QueryDefObjectName,
-  indexBuilder: IndexBuilder<string[]>,
-): QueryDef {
-  const indexMeta = indexBuilder.meta;
-
-  return {
-    type: "addIdx",
-    table,
-    index: {
-      name: indexBuilder.meta.name ?? `IDX_${table.name}_${indexMeta.columns.join("_")}`,
-      columns: indexMeta.columns.map((col, i) => ({
-        name: col,
-        orderBy: indexMeta.orderBy?.[i] ?? "ASC",
-      })),
-      unique: indexMeta.unique,
-    },
-  };
-}
-
-/**
- * DROP FOREIGN KEY QueryDef 생성
- */
-export function getDropFkQueryDef(table: QueryDefObjectName, relationName: string): DropFkQueryDef {
-  return { type: "dropFk", table, foreignKey: `FK_${table.name}_${relationName}` };
-}
-
-/**
- * DROP INDEX QueryDef 생성
- */
-export function getDropIdxQueryDef(table: QueryDefObjectName, columns: string[]): DropIdxQueryDef {
-  return { type: "dropIdx", table, index: `IDX_${table.name}_${columns.join("_")}` };
-}
+import type { ForeignKeyBuilder } from "../schema/factory/relation-builder";
+import type { IndexBuilder } from "../schema/factory/index-builder";
+import type {
+  QueryDef,
+  QueryDefObjectName,
+  AddPkQueryDef,
+  DropPkQueryDef,
+  DropFkQueryDef,
+  DropIdxQueryDef,
+} from "../types/query-def";
+import type { DbContextBase } from "../types/db-context-def";
+import { getMatchedPrimaryKeys } from "../exec/queryable";
+import { getQueryDefObjectName } from "./table-ddl";
+
+/**
+ * Generate DROP PRIMARY KEY QueryDef
+ */
+export function getDropPkQueryDef(table: QueryDefObjectName): DropPkQueryDef {
+  return { type: "dropPk", table };
+}
+
+/**
+ * Generate ADD PRIMARY KEY QueryDef
+ */
+export function getAddPkQueryDef(table: QueryDefObjectName, columns: string[]): AddPkQueryDef {
+  return { type: "addPk", table, columns };
+}
+
+/**
+ * Generate ADD FOREIGN KEY QueryDef
+ */
+export function getAddFkQueryDef(
+  db: DbContextBase,
+  table: QueryDefObjectName,
+  relationName: string,
+  relationDef: ForeignKeyBuilder<any, any>,
+): QueryDef {
+  const targetTable = relationDef.meta.targetFn();
+  const fkColumns = relationDef.meta.columns;
+  const pk = getMatchedPrimaryKeys(fkColumns, targetTable);
+
+  return {
+    type: "addFk",
+    table,
+    foreignKey: {
+      name: `FK_${table.name}_${relationName}`,
+      fkColumns,
+      targetTable: getQueryDefObjectName(db, targetTable),
+      targetPkColumns: pk,
+    },
+  };
+}
+
+/**
+ * ADD INDEX QueryDef Generate
+ */
+export function getAddIdxQueryDef(
+  table: QueryDefObjectName,
+  indexBuilder: IndexBuilder<string[]>,
+): QueryDef {
+  const indexMeta = indexBuilder.meta;
+
+  return {
+    type: "addIdx",
+    table,
+    index: {
+      name: indexBuilder.meta.name ?? `IDX_${table.name}_${indexMeta.columns.join("_")}`,
+      columns: indexMeta.columns.map((col, i) => ({
+        name: col,
+        orderBy: indexMeta.orderBy?.[i] ?? "ASC",
+      })),
+      unique: indexMeta.unique,
+    },
+  };
+}
+
+/**
+ * DROP FOREIGN KEY QueryDef Generate
+ */
+export function getDropFkQueryDef(table: QueryDefObjectName, relationName: string): DropFkQueryDef {
+  return { type: "dropFk", table, foreignKey: `FK_${table.name}_${relationName}` };
+}
+
+/**
+ * DROP INDEX QueryDef Generate
+ */
+export function getDropIdxQueryDef(table: QueryDefObjectName, columns: string[]): DropIdxQueryDef {
+  return { type: "dropIdx", table, index: `IDX_${table.name}_${columns.join("_")}` };
+}

package/src/ddl/schema-ddl.ts

@@ -7,7 +7,7 @@ import type {
 } from "../types/query-def";
 
 /**
- * CLEAR SCHEMA QueryDef 생성
+ * Generate CLEAR SCHEMA QueryDef
  */
 export function getClearSchemaQueryDef(params: {
   database: string;
@@ -17,21 +17,21 @@ export function getClearSchemaQueryDef(params: {
 }
 
 /**
- * SCHEMA EXISTS QueryDef 생성
+ * Generate SCHEMA EXISTS QueryDef
  */
 export function getSchemaExistsQueryDef(database: string, schema?: string): SchemaExistsQueryDef {
   return { type: "schemaExists", database, schema };
 }
 
 /**
- * TRUNCATE TABLE QueryDef 생성
+ * Generate TRUNCATE TABLE QueryDef
  */
 export function getTruncateQueryDef(table: QueryDefObjectName): TruncateQueryDef {
   return { type: "truncate", table };
 }
 
 /**
- * SWITCH FK QueryDef 생성
+ * Generate SWITCH FK QueryDef
  */
 export function getSwitchFkQueryDef(
   table: QueryDefObjectName,

package/src/ddl/table-ddl.ts

@@ -1,189 +1,189 @@
-import { TableBuilder } from "../schema/table-builder";
-import { ViewBuilder } from "../schema/view-builder";
-import { ProcedureBuilder } from "../schema/procedure-builder";
-import type { ColumnBuilderRecord } from "../schema/factory/column-builder";
-import type {
-  QueryDef,
-  QueryDefObjectName,
-  DropTableQueryDef,
-  RenameTableQueryDef,
-  DropViewQueryDef,
-  DropProcQueryDef,
-} from "../types/query-def";
-import type { DbContextBase } from "../types/db-context-def";
-import { objClearUndefined } from "@simplysm/core-common";
-
-/**
- * Builder를 CREATE QueryDef로 변환
- *
- * @param db - DbContext 인스턴스
- * @param builder - Table/View/Procedure 빌더
- * @returns CREATE TABLE/VIEW/PROCEDURE QueryDef
- * @throws {Error} 알 수 없는 빌더 타입일 때
- */
-export function getCreateObjectQueryDef(
-  db: DbContextBase,
-  builder: TableBuilder<any, any> | ViewBuilder<any, any, any> | ProcedureBuilder<any, any>,
-): QueryDef {
-  if (builder instanceof TableBuilder) {
-    return getCreateTableQueryDef(db, builder);
-  } else if (builder instanceof ViewBuilder) {
-    return getCreateViewQueryDef(db, builder);
-  } else if (builder instanceof ProcedureBuilder) {
-    return getCreateProcQueryDef(db, builder);
-  }
-
-  throw new Error(`알 수 없는 빌더 타입: ${typeof builder}`);
-}
-
-/**
- * CREATE TABLE QueryDef 생성
- *
- * @param db - DbContext 인스턴스
- * @param table - 테이블 빌더
- * @returns CREATE TABLE QueryDef
- * @throws {Error} 테이블에 컬럼이 없을 때
- */
-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.meta.name}'에 컬럼이 없습니다.`);
-  }
-
-  return {
-    type: "createTable",
-    table: getQueryDefObjectName(db, table),
-    columns: Object.entries(columns).map(([key, col]) => ({
-      name: key,
-      dataType: col.meta.dataType,
-      autoIncrement: col.meta.autoIncrement,
-      nullable: col.meta.nullable,
-      default: col.meta.default,
-    })),
-    primaryKey: table.meta.primaryKey,
-  };
-}
-
-/**
- * CREATE VIEW QueryDef 생성
- *
- * @param db - DbContext 인스턴스
- * @param view - 뷰 빌더
- * @returns CREATE VIEW QueryDef
- * @throws {Error} 뷰에 viewFn이 없을 때
- */
-export function getCreateViewQueryDef(
-  db: DbContextBase,
-  view: ViewBuilder<any, any, any>,
-): QueryDef {
-  if (view.meta.viewFn == null) {
-    throw new Error(`뷰 '${view.meta.name}'에 viewFn이 없습니다.`);
-  }
-
-  const qr = view.meta.viewFn(db);
-  const selectDef = qr.getSelectQueryDef();
-
-  return {
-    type: "createView",
-    view: {
-      database: view.meta.database ?? db.database,
-      schema: view.meta.schema ?? db.schema,
-      name: view.meta.name,
-    },
-    queryDef: selectDef,
-  };
-}
-
-/**
- * CREATE PROCEDURE QueryDef 생성
- *
- * @param db - DbContext 인스턴스
- * @param procedure - 프로시저 빌더
- * @returns CREATE PROCEDURE QueryDef
- * @throws {Error} 프로시저에 본문이 없을 때
- */
-export function getCreateProcQueryDef(
-  db: DbContextBase,
-  procedure: ProcedureBuilder<any, any>,
-): QueryDef {
-  if (procedure.meta.query == null) {
-    throw new Error(`프로시저 '${procedure.meta.name}'에 본문이 없습니다.`);
-  }
-
-  const params = procedure.meta.params as ColumnBuilderRecord | undefined;
-  const returns = procedure.meta.returns as ColumnBuilderRecord | undefined;
-
-  return {
-    type: "createProc",
-    procedure: {
-      database: procedure.meta.database ?? db.database,
-      schema: procedure.meta.schema ?? db.schema,
-      name: procedure.meta.name,
-    },
-    params: params
-      ? Object.entries(params).map(([key, col]) => ({
-          name: key,
-          dataType: col.meta.dataType,
-          nullable: col.meta.nullable,
-          default: col.meta.default,
-        }))
-      : undefined,
-    returns: returns
-      ? Object.entries(returns).map(([key, col]) => ({
-          name: key,
-          dataType: col.meta.dataType,
-          nullable: col.meta.nullable,
-        }))
-      : undefined,
-    query: procedure.meta.query,
-  };
-}
-
-/**
- * DROP TABLE QueryDef 생성
- */
-export function getDropTableQueryDef(table: QueryDefObjectName): DropTableQueryDef {
-  return { type: "dropTable", table };
-}
-
-/**
- * RENAME TABLE QueryDef 생성
- */
-export function getRenameTableQueryDef(
-  table: QueryDefObjectName,
-  newName: string,
-): RenameTableQueryDef {
-  return { type: "renameTable", table, newName };
-}
-
-/**
- * DROP VIEW QueryDef 생성
- */
-export function getDropViewQueryDef(view: QueryDefObjectName): DropViewQueryDef {
-  return { type: "dropView", view };
-}
-
-/**
- * DROP PROCEDURE QueryDef 생성
- */
-export function getDropProcQueryDef(procedure: QueryDefObjectName): DropProcQueryDef {
-  return { type: "dropProc", procedure };
-}
-
-/**
- * TableBuilder/ViewBuilder를 QueryDefObjectName으로 변환
- *
- * @param db - DbContext 인스턴스
- * @param tableOrView - 테이블 또는 뷰 빌더
- * @returns QueryDef에서 사용할 객체 이름 정보
- */
-export function getQueryDefObjectName(
-  db: DbContextBase,
-  tableOrView: TableBuilder<any, any> | ViewBuilder<any, any, any>,
-): QueryDefObjectName {
-  return objClearUndefined({
-    database: tableOrView.meta.database ?? db.database,
-    schema: tableOrView.meta.schema ?? db.schema,
-    name: tableOrView.meta.name,
-  });
-}
+import { TableBuilder } from "../schema/table-builder";
+import { ViewBuilder } from "../schema/view-builder";
+import { ProcedureBuilder } from "../schema/procedure-builder";
+import type { ColumnBuilderRecord } from "../schema/factory/column-builder";
+import type {
+  QueryDef,
+  QueryDefObjectName,
+  DropTableQueryDef,
+  RenameTableQueryDef,
+  DropViewQueryDef,
+  DropProcQueryDef,
+} from "../types/query-def";
+import type { DbContextBase } from "../types/db-context-def";
+import { objClearUndefined } from "@simplysm/core-common";
+
+/**
+ * Builder를 CREATE QueryDef로 Transform
+ *
+ * @param db - DbContext instance
+ * @param builder - Table/View/Procedure builder
+ * @returns CREATE TABLE/VIEW/PROCEDURE QueryDef
+ * @throws {Error} When unknown builder type
+ */
+export function getCreateObjectQueryDef(
+  db: DbContextBase,
+  builder: TableBuilder<any, any> | ViewBuilder<any, any, any> | ProcedureBuilder<any, any>,
+): QueryDef {
+  if (builder instanceof TableBuilder) {
+    return getCreateTableQueryDef(db, builder);
+  } else if (builder instanceof ViewBuilder) {
+    return getCreateViewQueryDef(db, builder);
+  } else if (builder instanceof ProcedureBuilder) {
+    return getCreateProcQueryDef(db, builder);
+  }
+
+  throw new Error(`Unknown builder type: ${typeof builder}`);
+}
+
+/**
+ * CREATE TABLE QueryDef Generate
+ *
+ * @param db - DbContext instance
+ * @param table - Table builder
+ * @returns CREATE TABLE QueryDef
+ * @throws {Error} When table has no columns
+ */
+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.`);
+  }
+
+  return {
+    type: "createTable",
+    table: getQueryDefObjectName(db, table),
+    columns: Object.entries(columns).map(([key, col]) => ({
+      name: key,
+      dataType: col.meta.dataType,
+      autoIncrement: col.meta.autoIncrement,
+      nullable: col.meta.nullable,
+      default: col.meta.default,
+    })),
+    primaryKey: table.meta.primaryKey,
+  };
+}
+
+/**
+ * CREATE VIEW QueryDef Generate
+ *
+ * @param db - DbContext instance
+ * @param view - View builder
+ * @returns CREATE VIEW QueryDef
+ * @throws {Error} When view has no 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.`);
+  }
+
+  const qr = view.meta.viewFn(db);
+  const selectDef = qr.getSelectQueryDef();
+
+  return {
+    type: "createView",
+    view: {
+      database: view.meta.database ?? db.database,
+      schema: view.meta.schema ?? db.schema,
+      name: view.meta.name,
+    },
+    queryDef: selectDef,
+  };
+}
+
+/**
+ * CREATE PROCEDURE QueryDef Generate
+ *
+ * @param db - DbContext instance
+ * @param procedure - Procedure builder
+ * @returns CREATE PROCEDURE QueryDef
+ * @throws {Error} When procedure has no 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.`);
+  }
+
+  const params = procedure.meta.params as ColumnBuilderRecord | undefined;
+  const returns = procedure.meta.returns as ColumnBuilderRecord | undefined;
+
+  return {
+    type: "createProc",
+    procedure: {
+      database: procedure.meta.database ?? db.database,
+      schema: procedure.meta.schema ?? db.schema,
+      name: procedure.meta.name,
+    },
+    params: params
+      ? Object.entries(params).map(([key, col]) => ({
+          name: key,
+          dataType: col.meta.dataType,
+          nullable: col.meta.nullable,
+          default: col.meta.default,
+        }))
+      : undefined,
+    returns: returns
+      ? Object.entries(returns).map(([key, col]) => ({
+          name: key,
+          dataType: col.meta.dataType,
+          nullable: col.meta.nullable,
+        }))
+      : undefined,
+    query: procedure.meta.query,
+  };
+}
+
+/**
+ * DROP TABLE QueryDef Generate
+ */
+export function getDropTableQueryDef(table: QueryDefObjectName): DropTableQueryDef {
+  return { type: "dropTable", table };
+}
+
+/**
+ * RENAME TABLE QueryDef Generate
+ */
+export function getRenameTableQueryDef(
+  table: QueryDefObjectName,
+  newName: string,
+): RenameTableQueryDef {
+  return { type: "renameTable", table, newName };
+}
+
+/**
+ * DROP VIEW QueryDef Generate
+ */
+export function getDropViewQueryDef(view: QueryDefObjectName): DropViewQueryDef {
+  return { type: "dropView", view };
+}
+
+/**
+ * DROP PROCEDURE QueryDef Generate
+ */
+export function getDropProcQueryDef(procedure: QueryDefObjectName): DropProcQueryDef {
+  return { type: "dropProc", procedure };
+}
+
+/**
+ * Transform TableBuilder/ViewBuilder to QueryDefObjectName
+ *
+ * @param db - DbContext instance
+ * @param tableOrView - Table or View builder
+ * @returns Object name information for use in QueryDef
+ */
+export function getQueryDefObjectName(
+  db: DbContextBase,
+  tableOrView: TableBuilder<any, any> | ViewBuilder<any, any, any>,
+): QueryDefObjectName {
+  return objClearUndefined({
+    database: tableOrView.meta.database ?? db.database,
+    schema: tableOrView.meta.schema ?? db.schema,
+    name: tableOrView.meta.name,
+  });
+}

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

@@ -1,27 +1,27 @@
 /**
- * 트랜잭션 관련 에러 코드
+ * Transaction-related error codes
  *
- * DBMS별 native 에러 코드를 추상화하여 DBMS 독립적인 에러 처리 가능
+ * Abstracts DBMS-specific native error codes for DBMS-independent error handling
  */
 export enum DbErrorCode {
-  /** 활성 트랜잭션이 없음 (ROLLBACK 시 트랜잭션 없음) */
+  /** No active transaction (no transaction during 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
  *
- * DBMS별 native 에러를 표준화된 에러 코드로 래핑하여
- * DBMS 독립적인 에러 처리 가능
+ * Wraps DBMS-specific native errors with standardized error codes for
+ * DBMS-independent error handling
  *
  * @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,
-    /** 원본 DBMS 에러 (디버깅용) */
+    /** Original DBMS error (for debugging) */
     public readonly originalError?: unknown,
   ) {
     super(message);