@simplysm/orm-common 13.0.68 → 13.0.70

package/dist/schema/factory/column-builder.d.ts

@@ -3,13 +3,13 @@ import type { ColumnMeta, ColumnPrimitive } from "../../types/column";
 import type { ExprInput } from "../../expr/expr-unit";
 import type { DataRecord } from "../../types/db";
 /**
- * 컬럼 정의 빌더
+ * Column definition builder
  *
- * Fluent API를 통해 컬럼의 타입, nullable, autoIncrement, default, 설명을 정의
- * TableBuilder.columns()에서 사용
+ * Fluent API를 통해 column의 type, nullable, autoIncrement, default, description을 definition
+ * TableBuilder.columns()used in
  *
- * @template TValue - 컬럼 값 타입
- * @template TMeta - 컬럼 메타데이터 타입
+ * @template TValue - Column value type
+ * @template TMeta - Column Metadata type
  *
  * @example
  * ```typescript
@@ -18,26 +18,26 @@ import type { DataRecord } from "../../types/db";
  *     id: c.bigint().autoIncrement(),           // bigint, auto increment
  *     name: c.varchar(100),                     // varchar(100), required
  *     email: c.varchar(200).nullable(),         // varchar(200), nullable
- *     status: c.varchar(20).default("active"),  // varchar(20), default 값
+ *     status: c.varchar(20).default("active"),  // varchar(20), default value
  *     createdAt: c.datetime().description("생성일시"),
  *   }));
  * ```
  *
- * @see {@link createColumnFactory} 컬럼 팩토리
- * @see {@link TableBuilder} 테이블 빌더
+ * @see {@link createColumnFactory} column factory
+ * @see {@link TableBuilder} Table builder
  */
 export declare class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnMeta> {
     readonly meta: TMeta;
     /**
-     * @param meta - 컬럼 메타데이터
+     * @param meta - Column Metadata
      */
     constructor(meta: TMeta);
     /**
      * Auto Increment 설정
      *
-     * INSERT 시 자동 증가. INSERT용 타입 추론에서 optional로 처리
+     * INSERT 시 Auto increment. INSERT용 Type inference에서 optional로 processing
      *
-     * @returns 새 ColumnBuilder 인스턴스
+     * @returns new ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -50,9 +50,9 @@ export declare class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends
     /**
      * Nullable 설정
      *
-     * NULL 허용. 값 타입에 undefined 추가
+     * Allow NULL. value 타입에 undefined Add
      *
-     * @returns 새 ColumnBuilder 인스턴스
+     * @returns new ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -63,12 +63,12 @@ export declare class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends
         nullable: true;
     }>;
     /**
-     * 기본값 설정
+     * Default value 설정
      *
-     * INSERT 시 값 미지정 시 사용. INSERT용 타입 추론에서 optional로 처리
+     * INSERT 시 value 미지정 시 사용. INSERT용 Type inference에서 optional로 processing
      *
-     * @param value - 기본값
-     * @returns 새 ColumnBuilder 인스턴스
+     * @param value - Default value
+     * @returns new ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -80,14 +80,14 @@ export declare class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends
         default: typeof value;
     }>;
     /**
-     * 컬럼 설명 설정
+     * column set description
      *
-     * @param desc - 컬럼 설명 (DDL 주석으로 사용)
-     * @returns 새 ColumnBuilder 인스턴스
+     * @param desc - Column description (DDL Comment으로 사용)
+     * @returns new ColumnBuilder instance
      *
      * @example
      * ```typescript
-     * createdAt: c.datetime().description("레코드 생성 일시")
+     * createdAt: c.datetime().description("레코드 Generate 일시")
      * ```
      */
     description(desc: string): ColumnBuilder<TValue, TMeta & {
@@ -95,46 +95,46 @@ export declare class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends
     }>;
 }
 /**
- * 컬럼 빌더 팩토리 생성
+ * Column builder factory Generate
  *
- * TableBuilder.columns()에서 사용하는 컬럼 타입 팩토리
- * 모든 기본 데이터 타입에 대한 빌더 생성 메서드 제공
+ * TableBuilder.columns()used in하는 Column type factory
+ * 모든 Basic data type에 대한 builder Generate method 제공
  *
- * @returns 컬럼 타입별 빌더 생성 메서드를 포함한 객체
+ * @returns Column type별 builder Generate 메서드를 포함한 object
  *
  * @example
  * ```typescript
  * Table("User")
  *   .columns((c) => ({
- *     // 숫자 타입
+ *     // Number type
  *     id: c.bigint().autoIncrement(),
  *     count: c.int(),
  *     price: c.decimal(10, 2),
  *
- *     // 문자열 타입
+ *     // 문자열 type
  *     name: c.varchar(100),
  *     code: c.char(10),
  *     content: c.text(),
  *
- *     // 날짜/시간 타입
+ *     // Date/시간 type
  *     createdAt: c.datetime(),
  *     birthDate: c.date(),
  *     startTime: c.time(),
  *
- *     // 기타 타입
+ *     // Other type
  *     isActive: c.boolean(),
  *     data: c.binary(),
  *     uuid: c.uuid(),
  *   }));
  * ```
  *
- * @see {@link ColumnBuilder} 컬럼 빌더 클래스
+ * @see {@link ColumnBuilder} Column builder class
  */
 export declare function createColumnFactory(): {
     /**
-     * INT 컬럼 (4 bytes, -2^31 ~ 2^31-1)
+     * INT column (4 bytes, -2^31 ~ 2^31-1)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     int(): ColumnBuilder<number, {
         type: "number";
@@ -143,9 +143,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * BIGINT 컬럼 (8 bytes, -2^63 ~ 2^63-1)
+     * BIGINT column (8 bytes, -2^63 ~ 2^63-1)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     bigint(): ColumnBuilder<number, {
         type: "number";
@@ -154,9 +154,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * FLOAT 컬럼 (4 bytes, 단정밀도 부동소수점)
+     * FLOAT column (4 bytes, 단정밀도 부동소수점)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     float(): ColumnBuilder<number, {
         type: "number";
@@ -165,9 +165,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * DOUBLE 컬럼 (8 bytes, 배정밀도 부동소수점)
+     * DOUBLE column (8 bytes, 배정밀도 부동소수점)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     double(): ColumnBuilder<number, {
         type: "number";
@@ -176,11 +176,11 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * DECIMAL 컬럼 (고정 소수점)
+     * DECIMAL column (고정 소수점)
      *
      * @param precision - 전체 자릿수
-     * @param scale - 소수점 이하 자릿수 (선택)
-     * @returns ColumnBuilder 인스턴스
+     * @param scale - 소수점 이하 자릿수 (Select)
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -196,10 +196,10 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * VARCHAR 컬럼 (가변 길이 문자열)
+     * VARCHAR column (가변 길이 문자열)
      *
      * @param length - 최대 길이
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -214,10 +214,10 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * CHAR 컬럼 (고정 길이 문자열)
+     * CHAR column (고정 길이 문자열)
      *
      * @param length - 고정 길이
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -232,9 +232,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * TEXT 컬럼 (대용량 문자열)
+     * TEXT column (대용량 문자열)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     text(): ColumnBuilder<string, {
         type: "string";
@@ -243,11 +243,11 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * BINARY 컬럼 (바이너리 데이터)
+     * BINARY column (바이너리 data)
      *
      * DBMS별: MySQL=LONGBLOB, MSSQL=VARBINARY(MAX), PostgreSQL=BYTEA
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     binary(): ColumnBuilder<Bytes, {
         type: "Bytes";
@@ -256,11 +256,11 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * BOOLEAN 컬럼
+     * BOOLEAN column
      *
      * DBMS별: MySQL=TINYINT(1), MSSQL=BIT, PostgreSQL=BOOLEAN
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     boolean(): ColumnBuilder<boolean, {
         type: "boolean";
@@ -269,9 +269,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * DATETIME 컬럼 (날짜 + 시간)
+     * DATETIME column (Date + 시간)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     datetime(): ColumnBuilder<DateTime, {
         type: "DateTime";
@@ -280,9 +280,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * DATE 컬럼 (날짜만)
+     * DATE column (Date만)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     date(): ColumnBuilder<DateOnly, {
         type: "DateOnly";
@@ -291,9 +291,9 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * TIME 컬럼 (시간만)
+     * TIME column (시간만)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     time(): ColumnBuilder<Time, {
         type: "Time";
@@ -302,11 +302,11 @@ export declare function createColumnFactory(): {
         };
     }>;
     /**
-     * UUID 컬럼
+     * UUID column
      *
      * DBMS별: MySQL=BINARY(16), MSSQL=UNIQUEIDENTIFIER, PostgreSQL=UUID
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     uuid(): ColumnBuilder<Uuid, {
         type: "Uuid";
@@ -316,15 +316,15 @@ export declare function createColumnFactory(): {
     }>;
 };
 /**
- * 컬럼 빌더 레코드 타입
+ * Column builder record type
  *
- * TableBuilder.columns()의 반환 타입으로 사용
+ * TableBuilder.columns()의 return 타입으로 사용
  */
 export type ColumnBuilderRecord = Record<string, ColumnBuilder<ColumnPrimitive, ColumnMeta>>;
 /**
- * 컬럼 빌더 레코드에서 실제 값 타입 추론
+ * Column builder 레코드에서 실제 value Type inference
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  *
  * @example
  * ```typescript
@@ -336,37 +336,37 @@ export type InferColumns<TBuilders extends ColumnBuilderRecord> = {
     [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? V : never;
 };
 /**
- * 컬럼 빌더 레코드에서 표현식 입력 타입 추론
+ * Column builder 레코드에서 expression 입력 Type inference
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  */
 export type InferColumnExprs<TBuilders extends ColumnBuilderRecord> = {
     [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? ExprInput<V> : never;
 };
 /**
- * INSERT 시 필수 컬럼 키 추출
+ * INSERT 시 required column key 추출
  *
- * autoIncrement, nullable, default가 없는 컬럼만 필수
+ * autoIncrement, nullable, default가 없는 column만 required
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  */
 export type RequiredInsertKeys<TBuilders extends ColumnBuilderRecord> = {
     [K in keyof TBuilders]: TBuilders[K]["meta"] extends infer M extends ColumnMeta ? M["autoIncrement"] extends true ? never : M["nullable"] extends true ? never : M["default"] extends undefined ? K : never : never;
 }[keyof TBuilders];
 /**
- * INSERT 시 선택적 컬럼 키 추출
+ * INSERT 시 optional column key 추출
  *
- * autoIncrement, nullable, default가 있는 컬럼은 optional
+ * autoIncrement, nullable, default가 있는 column은 optional
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  */
 export type OptionalInsertKeys<TBuilders extends ColumnBuilderRecord> = Exclude<keyof TBuilders, RequiredInsertKeys<TBuilders>>;
 /**
- * INSERT용 타입 추론
+ * INSERT용 Type inference
  *
- * 필수 컬럼은 required, optional 컬럼은 Partial
+ * required column은 required, optional column은 Partial
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  *
  * @example
  * ```typescript
@@ -376,17 +376,17 @@ export type OptionalInsertKeys<TBuilders extends ColumnBuilderRecord> = Exclude<
  */
 export type InferInsertColumns<TBuilders extends ColumnBuilderRecord> = Pick<InferColumns<TBuilders>, RequiredInsertKeys<TBuilders>> & Partial<Pick<InferColumns<TBuilders>, OptionalInsertKeys<TBuilders>>>;
 /**
- * UPDATE용 타입 추론
+ * UPDATE용 Type inference
  *
- * 모든 컬럼이 optional
+ * 모든 column이 optional
  *
- * @template T - 컬럼 빌더 레코드 타입
+ * @template T - Column builder record type
  */
 export type InferUpdateColumns<TBuilders extends ColumnBuilderRecord> = Partial<InferColumns<TBuilders>>;
 /**
- * 데이터 레코드에서 컬럼 빌더 레코드로 변환
+ * data 레코드에서 Column builder 레코드로 Transform
  *
- * @template TData - 데이터 레코드 타입
+ * @template TData - data record type
  */
 export type DataToColumnBuilderRecord<TData extends DataRecord> = {
     [K in keyof TData as TData[K] extends ColumnPrimitive ? K : never]: ColumnBuilder<TData[K] extends ColumnPrimitive ? TData[K] : never, any>;

package/dist/schema/factory/column-builder.js

@@ -1,6 +1,6 @@
 class ColumnBuilder {
   /**
-   * @param meta - 컬럼 메타데이터
+   * @param meta - Column Metadata
    */
   constructor(meta) {
     this.meta = meta;
@@ -8,9 +8,9 @@ class ColumnBuilder {
   /**
    * Auto Increment 설정
    *
-   * INSERT 시 자동 증가. INSERT용 타입 추론에서 optional로 처리
+   * INSERT 시 Auto increment. INSERT용 Type inference에서 optional로 processing
    *
-   * @returns 새 ColumnBuilder 인스턴스
+   * @returns new ColumnBuilder instance
    *
    * @example
    * ```typescript
@@ -23,9 +23,9 @@ class ColumnBuilder {
   /**
    * Nullable 설정
    *
-   * NULL 허용. 값 타입에 undefined 추가
+   * Allow NULL. value 타입에 undefined Add
    *
-   * @returns 새 ColumnBuilder 인스턴스
+   * @returns new ColumnBuilder instance
    *
    * @example
    * ```typescript
@@ -36,12 +36,12 @@ class ColumnBuilder {
     return new ColumnBuilder({ ...this.meta, nullable: true });
   }
   /**
-   * 기본값 설정
+   * Default value 설정
    *
-   * INSERT 시 값 미지정 시 사용. INSERT용 타입 추론에서 optional로 처리
+   * INSERT 시 value 미지정 시 사용. INSERT용 Type inference에서 optional로 processing
    *
-   * @param value - 기본값
-   * @returns 새 ColumnBuilder 인스턴스
+   * @param value - Default value
+   * @returns new ColumnBuilder instance
    *
    * @example
    * ```typescript
@@ -53,14 +53,14 @@ class ColumnBuilder {
     return new ColumnBuilder({ ...this.meta, default: value });
   }
   /**
-   * 컬럼 설명 설정
+   * column set description
    *
-   * @param desc - 컬럼 설명 (DDL 주석으로 사용)
-   * @returns 새 ColumnBuilder 인스턴스
+   * @param desc - Column description (DDL Comment으로 사용)
+   * @returns new ColumnBuilder instance
    *
    * @example
    * ```typescript
-   * createdAt: c.datetime().description("레코드 생성 일시")
+   * createdAt: c.datetime().description("레코드 Generate 일시")
    * ```
    */
   description(desc) {
@@ -70,43 +70,43 @@ class ColumnBuilder {
 function createColumnFactory() {
   return {
     /**
-     * INT 컬럼 (4 bytes, -2^31 ~ 2^31-1)
+     * INT column (4 bytes, -2^31 ~ 2^31-1)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     int() {
       return new ColumnBuilder({ type: "number", dataType: { type: "int" } });
     },
     /**
-     * BIGINT 컬럼 (8 bytes, -2^63 ~ 2^63-1)
+     * BIGINT column (8 bytes, -2^63 ~ 2^63-1)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     bigint() {
       return new ColumnBuilder({ type: "number", dataType: { type: "bigint" } });
     },
     /**
-     * FLOAT 컬럼 (4 bytes, 단정밀도 부동소수점)
+     * FLOAT column (4 bytes, 단정밀도 부동소수점)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     float() {
       return new ColumnBuilder({ type: "number", dataType: { type: "float" } });
     },
     /**
-     * DOUBLE 컬럼 (8 bytes, 배정밀도 부동소수점)
+     * DOUBLE column (8 bytes, 배정밀도 부동소수점)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     double() {
       return new ColumnBuilder({ type: "number", dataType: { type: "double" } });
     },
     /**
-     * DECIMAL 컬럼 (고정 소수점)
+     * DECIMAL column (고정 소수점)
      *
      * @param precision - 전체 자릿수
-     * @param scale - 소수점 이하 자릿수 (선택)
-     * @returns ColumnBuilder 인스턴스
+     * @param scale - 소수점 이하 자릿수 (Select)
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -117,10 +117,10 @@ function createColumnFactory() {
       return new ColumnBuilder({ type: "number", dataType: { type: "decimal", precision, scale } });
     },
     /**
-     * VARCHAR 컬럼 (가변 길이 문자열)
+     * VARCHAR column (가변 길이 문자열)
      *
      * @param length - 최대 길이
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -131,10 +131,10 @@ function createColumnFactory() {
       return new ColumnBuilder({ type: "string", dataType: { type: "varchar", length } });
     },
     /**
-     * CHAR 컬럼 (고정 길이 문자열)
+     * CHAR column (고정 길이 문자열)
      *
      * @param length - 고정 길이
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      *
      * @example
      * ```typescript
@@ -145,63 +145,63 @@ function createColumnFactory() {
       return new ColumnBuilder({ type: "string", dataType: { type: "char", length } });
     },
     /**
-     * TEXT 컬럼 (대용량 문자열)
+     * TEXT column (대용량 문자열)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     text() {
       return new ColumnBuilder({ type: "string", dataType: { type: "text" } });
     },
     /**
-     * BINARY 컬럼 (바이너리 데이터)
+     * BINARY column (바이너리 data)
      *
      * DBMS별: MySQL=LONGBLOB, MSSQL=VARBINARY(MAX), PostgreSQL=BYTEA
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     binary() {
       return new ColumnBuilder({ type: "Bytes", dataType: { type: "binary" } });
     },
     /**
-     * BOOLEAN 컬럼
+     * BOOLEAN column
      *
      * DBMS별: MySQL=TINYINT(1), MSSQL=BIT, PostgreSQL=BOOLEAN
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     boolean() {
       return new ColumnBuilder({ type: "boolean", dataType: { type: "boolean" } });
     },
     /**
-     * DATETIME 컬럼 (날짜 + 시간)
+     * DATETIME column (Date + 시간)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     datetime() {
       return new ColumnBuilder({ type: "DateTime", dataType: { type: "datetime" } });
     },
     /**
-     * DATE 컬럼 (날짜만)
+     * DATE column (Date만)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     date() {
       return new ColumnBuilder({ type: "DateOnly", dataType: { type: "date" } });
     },
     /**
-     * TIME 컬럼 (시간만)
+     * TIME column (시간만)
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     time() {
       return new ColumnBuilder({ type: "Time", dataType: { type: "time" } });
     },
     /**
-     * UUID 컬럼
+     * UUID column
      *
      * DBMS별: MySQL=BINARY(16), MSSQL=UNIQUEIDENTIFIER, PostgreSQL=UUID
      *
-     * @returns ColumnBuilder 인스턴스
+     * @returns ColumnBuilder instance
      */
     uuid() {
       return new ColumnBuilder({ type: "Uuid", dataType: { type: "uuid" } });