@simplysm/orm-common 13.0.83 → 13.0.85

package/src/schema/procedure-builder.ts

@@ -5,13 +5,13 @@ import { type ColumnBuilderRecord, createColumnFactory } from "./factory/column-
 // ============================================
 
 /**
- * 저장 Procedure definition builder
+ * Stored Procedure definition builder
  *
- * Fluent API를 통해 Procedure의 파라미터, return type, 본문을 definition
- * DbContext의 executable()과 함께 사용하여 type 안전한 Procedure 호출
+ * Define Procedure parameters, return type, and body via Fluent API
+ * Use with DbContext's executable() for type-safe Procedure invocation
  *
- * @template TParams - 파라미터 Column definition type
- * @template TReturns - return Column definition type
+ * @template TParams - Parameter Column definition type
+ * @template TReturns - Return Column definition type
  *
  * @example
  * ```typescript
@@ -28,12 +28,12 @@ import { type ColumnBuilderRecord, createColumnFactory } from "./factory/column-
  *   }))
  *   .body("SELECT id, name, email FROM User WHERE id = userId");
  *
- * // DbContextused in
+ * // Used in DbContext
  * class MyDb extends DbContext {
  *   readonly getUserById = executable(this, GetUserById);
  * }
  *
- * // 호출
+ * // Invocation
  * const users = await db.getUserById({ userId: 1n }).execute();
  * ```
  *
@@ -44,20 +44,20 @@ export class ProcedureBuilder<
   TParams extends ColumnBuilderRecord,
   TReturns extends ColumnBuilderRecord,
 > {
-  /** 파라미터 definition (type for inference) */
+  /** Parameter definition (type for inference) */
   readonly $params!: TParams;
   /** return type definition (type for inference) */
   readonly $returns!: TReturns;
 
   /**
    * @param meta - Procedure Metadata
-   * @param meta.name - Procedure 이름
-   * @param meta.description - Procedure description (주석)
-   * @param meta.database - Database 이름
-   * @param meta.schema - Schema 이름 (MSSQL/PostgreSQL)
-   * @param meta.params - 파라미터 definition
-   * @param meta.returns - return type definition
-   * @param meta.query - Procedure 본문 SQL
+   * @param meta.name - Procedure name
+   * @param meta.description - Procedure description (comment)
+   * @param meta.database - Database name
+   * @param meta.schema - Schema name (MSSQL/PostgreSQL)
+   * @param meta.params - Parameter definition
+   * @param meta.returns - Return type definition
+   * @param meta.query - Procedure body SQL
    */
   constructor(
     readonly meta: {
@@ -74,7 +74,7 @@ export class ProcedureBuilder<
   /**
    * Procedure set description
    *
-   * @param desc - Procedure description (DDL Comment으로 사용)
+   * @param desc - Procedure description (used as DDL Comment)
    * @returns new ProcedureBuilder instance
    */
   description(desc: string): ProcedureBuilder<TParams, TReturns> {
@@ -84,7 +84,7 @@ export class ProcedureBuilder<
   /**
    * Database set name
    *
-   * @param db - Database 이름
+   * @param db - Database name
    * @returns new ProcedureBuilder instance
    *
    * @example
@@ -101,7 +101,7 @@ export class ProcedureBuilder<
    *
    * MSSQL, PostgreSQLused in
    *
-   * @param schema - Schema 이름 (MSSQL: dbo, PostgreSQL: public)
+   * @param schema - Schema name (MSSQL: dbo, PostgreSQL: public)
    * @returns new ProcedureBuilder instance
    */
   schema(schema: string): ProcedureBuilder<TParams, TReturns> {
@@ -109,13 +109,13 @@ export class ProcedureBuilder<
   }
 
   /**
-   * 파라미터 definition
+   * Parameter definition
    *
-   * Procedure 입력 파라미터 definition
-   * DBMS별 파라미터 문법 차이 주의 (MSSQL: @param, MySQL/PostgreSQL: param)
+   * Define Procedure input parameters
+   * Note DBMS-specific parameter syntax differences (MSSQL: @param, MySQL/PostgreSQL: param)
    *
-   * @template T - 새 파라미터 definition type
-   * @param fn - Column factory를 받아 파라미터 정의를 반환하는 function
+   * @template T - New parameter definition type
+   * @param fn - Function that receives a Column factory and returns parameter definitions
    * @returns new ProcedureBuilder instance
    *
    * @example
@@ -134,12 +134,12 @@ export class ProcedureBuilder<
   }
 
   /**
-   * return type definition
+   * Return type definition
    *
-   * Procedure return result Column definition
+   * Define Procedure return result columns
    *
-   * @template T - 새 return type definition
-   * @param fn - Column factory를 받아 return Column definition를 반환하는 function
+   * @template T - New return type definition
+   * @param fn - Function that receives a Column factory and returns Column definitions
    * @returns new ProcedureBuilder instance
    *
    * @example
@@ -160,14 +160,14 @@ export class ProcedureBuilder<
   }
 
   /**
-   * Procedure 본문 SQL 설정
+   * Set Procedure body SQL
    *
-   * DBMS별 SQL 문법 차이 주의:
-   * - MySQL: 파라미터명 그대로 (userId)
-   * - MSSQL: @ 접두사 (@userId)
-   * - PostgreSQL: RETURN QUERY 필요
+   * Note DBMS-specific SQL syntax differences:
+   * - MySQL: parameter name as-is (userId)
+   * - MSSQL: @ prefix (@userId)
+   * - PostgreSQL: RETURN QUERY required
    *
-   * @param sql - Procedure 본문 SQL
+   * @param sql - Procedure body SQL
    * @returns new ProcedureBuilder instance
    *
    * @example
@@ -193,16 +193,16 @@ export class ProcedureBuilder<
 // ============================================
 
 /**
- * Procedure builder Generate factory function
+ * Procedure builder factory function
  *
- * ProcedureBuilder를 생성하여 Fluent API로 저장 Procedure schema definition
+ * Creates a ProcedureBuilder for defining stored Procedure schema via Fluent API
  *
- * @param name - Procedure 이름
+ * @param name - Procedure name
  * @returns ProcedureBuilder instance
  *
  * @example
  * ```typescript
- * // Basic 사용
+ * // Basic usage
  * const GetUserById = Procedure("GetUserById")
  *   .database("mydb")
  *   .params((c) => ({
@@ -215,7 +215,7 @@ export class ProcedureBuilder<
  *   }))
  *   .body("SELECT id, name, email FROM User WHERE id = userId");
  *
- * // 파라미터 없는 Procedure
+ * // Procedure without parameters
  * const GetAllActiveUsers = Procedure("GetAllActiveUsers")
  *   .database("mydb")
  *   .returns((c) => ({

package/src/schema/table-builder.ts

@@ -19,11 +19,11 @@ import {
 /**
  * Database Table definition builder
  *
- * Fluent API를 통해 Table의 column, PK, Index, 관계를 definition
- * DbContext에서 queryable()과 함께 사용하여 type 안전한 query 작성
+ * Define Table columns, PK, indexes, and relations via Fluent API
+ * Use with DbContext's queryable() for type-safe query composition
  *
  * @template TColumns - Column definition record type
- * @template TRelations - relationship definition record type
+ * @template TRelations - Relation definition record type
  *
  * @example
  * ```typescript
@@ -39,7 +39,7 @@ import {
  *   .primaryKey("id")
  *   .indexes((i) => [i.index("email").unique()]);
  *
- * // DbContextused in
+ * // Used in DbContext
  * class MyDb extends DbContext {
  *   readonly user = queryable(this, User);
  * }
@@ -54,27 +54,27 @@ export class TableBuilder<
 > {
   /** Column definition (type for inference) */
   readonly $columns!: TColumns;
-  /** relationship definition (type for inference) */
+  /** Relation definition (type for inference) */
   readonly $relations!: TRelations;
 
-  /** 전체 Type inference (column + relationship) */
+  /** Full Type inference (column + relation) */
   readonly $inferSelect!: InferColumns<TColumns> & InferDeepRelations<TRelations>;
-  /** column만 Type inference */
+  /** Column-only Type inference */
   readonly $inferColumns!: InferColumns<TColumns>;
-  /** INSERT용 Type inference (autoIncrement exclude, nullable/default는 optional) */
+  /** INSERT Type inference (autoIncrement excluded, nullable/default are optional) */
   readonly $inferInsert!: InferInsertColumns<TColumns>;
-  /** UPDATE용 Type inference (모든 field optional) */
+  /** UPDATE Type inference (all fields optional) */
   readonly $inferUpdate!: InferUpdateColumns<TColumns>;
 
   /**
    * @param meta - Table Metadata
-   * @param meta.name - Table 이름
-   * @param meta.description - Table description (주석)
-   * @param meta.database - Database 이름
-   * @param meta.schema - Schema 이름 (MSSQL/PostgreSQL)
+   * @param meta.name - Table name
+   * @param meta.description - Table description (comment)
+   * @param meta.database - Database name
+   * @param meta.schema - Schema name (MSSQL/PostgreSQL)
    * @param meta.columns - Column definition
    * @param meta.primaryKey - PK column array
-   * @param meta.relations - relationship definition
+   * @param meta.relations - Relation definition
    * @param meta.indexes - Index definition
    */
   constructor(
@@ -94,7 +94,7 @@ export class TableBuilder<
   /**
    * Table set description
    *
-   * @param desc - Table description (DDL Comment으로 사용)
+   * @param desc - Table description (used as DDL Comment)
    * @returns new TableBuilder instance
    */
   description(desc: string) {
@@ -104,7 +104,7 @@ export class TableBuilder<
   /**
    * Database set name
    *
-   * @param db - Database 이름
+   * @param db - Database name
    * @returns new TableBuilder instance
    *
    * @example
@@ -119,9 +119,9 @@ export class TableBuilder<
   /**
    * schema set name
    *
-   * MSSQL, PostgreSQLused in
+   * Used in MSSQL, PostgreSQL
    *
-   * @param schema - Schema 이름 (MSSQL: dbo, PostgreSQL: public)
+   * @param schema - Schema name (MSSQL: dbo, PostgreSQL: public)
    * @returns new TableBuilder instance
    *
    * @example
@@ -138,10 +138,10 @@ export class TableBuilder<
   /**
    * Column definition
    *
-   * column factory를 통해 type 안전한 Column definition
+   * Type-safe Column definition through column factory
    *
-   * @template TNewColumnDefs - 새 Column definition type
-   * @param fn - Column factory를 받아 Column definition를 반환하는 function
+   * @template TNewColumnDefs - New Column definition type
+   * @param fn - Function that receives a Column factory and returns Column definitions
    * @returns new TableBuilder instance
    *
    * @example
@@ -165,19 +165,19 @@ export class TableBuilder<
   }
 
   /**
-   * Primary Key 설정
+   * Primary Key configuration
    *
-   * @param columns - PK를 구성할 column name들 (복합 PK 가능)
+   * @param columns - Column names composing the PK (composite PK supported)
    * @returns new TableBuilder instance
    *
    * @example
    * ```typescript
-   * // 단일 PK
+   * // Single PK
    * const User = Table("User")
    *   .columns((c) => ({ id: c.bigint() }))
    *   .primaryKey("id");
    *
-   * // 복합 PK
+   * // Composite PK
    * const UserRole = Table("UserRole")
    *   .columns((c) => ({
    *     userId: c.bigint(),
@@ -196,7 +196,7 @@ export class TableBuilder<
   /**
    * Index definition
    *
-   * @param fn - Index factory를 받아 Index 배열을 반환하는 function
+   * @param fn - Function that receives an Index factory and returns an Index array
    * @returns new TableBuilder instance
    *
    * @example
@@ -225,12 +225,12 @@ export class TableBuilder<
   }
 
   /**
-   * relationship definition
+   * Relation definition
    *
-   * FK, 역참조 등 Table 간 relationship 설정
+   * Set up FK, reverse-references, and other inter-Table relations
    *
-   * @template T - relationship definition type
-   * @param fn - relationship factory를 받아 relationship 정의를 반환하는 function
+   * @template T - Relation definition type
+   * @param fn - Function that receives a relation factory and returns relation definitions
    * @returns new TableBuilder instance
    *
    * @example
@@ -243,7 +243,7 @@ export class TableBuilder<
    *   }))
    *   .primaryKey("id")
    *   .relations((r) => ({
-   *     // FK relationship (N:1)
+   *     // FK relation (N:1)
    *     author: r.foreignKey(["authorId"], () => User),
    *   }));
    *
@@ -254,13 +254,13 @@ export class TableBuilder<
    *   }))
    *   .primaryKey("id")
    *   .relations((r) => ({
-   *     // 역참조 (1:N)
+   *     // Reverse-reference (1:N)
    *     posts: r.foreignKeyTarget(() => Post, "author"),
    *   }));
    * ```
    *
    * @see {@link ForeignKeyBuilder} FK builder
-   * @see {@link ForeignKeyTargetBuilder} FK 역참조 builder
+   * @see {@link ForeignKeyTargetBuilder} FK reverse-reference builder
    */
   relations<T extends RelationBuilderRecord>(
     fn: (r: ReturnType<typeof createRelationFactory<this, keyof TColumns & string>>) => T,
@@ -277,16 +277,16 @@ export class TableBuilder<
 // ============================================
 
 /**
- * Table builder Generate factory function
+ * Table builder factory function
  *
- * TableBuilder를 생성하여 Fluent API로 Table schema definition
+ * Creates a TableBuilder for defining Table schema via Fluent API
  *
- * @param name - Table 이름
+ * @param name - Table name
  * @returns TableBuilder instance
  *
  * @example
  * ```typescript
- * // Basic 사용
+ * // Basic usage
  * const User = Table("User")
  *   .database("mydb")
  *   .columns((c) => ({
@@ -297,7 +297,7 @@ export class TableBuilder<
  *   .primaryKey("id")
  *   .indexes((i) => [i.index("email").unique()]);
  *
- * // relationship include
+ * // With relations
  * const Post = Table("Post")
  *   .database("mydb")
  *   .columns((c) => ({

package/src/schema/view-builder.ts

@@ -14,12 +14,12 @@ import {
 /**
  * Database View definition builder
  *
- * Fluent API를 통해 View의 query, 관계를 definition
- * DbContext에서 queryable()과 함께 사용하여 type 안전한 query 작성
+ * Define View query and relations via Fluent API
+ * Use with DbContext's queryable() for type-safe query composition
  *
  * @template TDbContext - DbContext type
  * @template TData - View data record type
- * @template TRelations - relationship definition record type
+ * @template TRelations - Relation definition record type
  *
  * @example
  * ```typescript
@@ -38,7 +38,7 @@ import {
  *       }))
  *   );
  *
- * // DbContextused in
+ * // Used in DbContext
  * class MyDb extends DbContext {
  *   readonly userSummary = queryable(this, UserSummary);
  * }
@@ -52,19 +52,19 @@ export class ViewBuilder<
   TData extends DataRecord,
   TRelations extends RelationBuilderRecord,
 > {
-  /** relationship definition (type for inference) */
+  /** Relation definition (type for inference) */
   readonly $relations!: TRelations;
-  /** 전체 Type inference */
+  /** Full Type inference */
   readonly $inferSelect!: TData;
 
   /**
    * @param meta - View Metadata
-   * @param meta.name - View 이름
-   * @param meta.description - View description (주석)
-   * @param meta.database - Database 이름
-   * @param meta.schema - Schema 이름 (MSSQL/PostgreSQL)
+   * @param meta.name - View name
+   * @param meta.description - View description (comment)
+   * @param meta.database - Database name
+   * @param meta.schema - Schema name (MSSQL/PostgreSQL)
    * @param meta.viewFn - View Query definition function
-   * @param meta.relations - relationship definition
+   * @param meta.relations - Relation definition
    */
   constructor(
     readonly meta: {
@@ -80,7 +80,7 @@ export class ViewBuilder<
   /**
    * View set description
    *
-   * @param desc - View description (DDL Comment으로 사용)
+   * @param desc - View description (used as DDL Comment)
    * @returns new ViewBuilder instance
    */
   description(desc: string): ViewBuilder<TDbContext, TData, TRelations> {
@@ -90,7 +90,7 @@ export class ViewBuilder<
   /**
    * Database set name
    *
-   * @param db - Database 이름
+   * @param db - Database name
    * @returns new ViewBuilder instance
    *
    * @example
@@ -105,9 +105,9 @@ export class ViewBuilder<
   /**
    * schema set name
    *
-   * MSSQL, PostgreSQLused in
+   * Used in MSSQL, PostgreSQL
    *
-   * @param schema - Schema 이름 (MSSQL: dbo, PostgreSQL: public)
+   * @param schema - Schema name (MSSQL: dbo, PostgreSQL: public)
    * @returns new ViewBuilder instance
    */
   schema(schema: string): ViewBuilder<TDbContext, TData, TRelations> {
@@ -117,11 +117,11 @@ export class ViewBuilder<
   /**
    * View Query definition
    *
-   * SELECT query를 통해 View의 data 소스 definition
+   * Define the View's data source through a SELECT query
    *
    * @template TViewData - View data type
    * @template TDb - DbContext type
-   * @param viewFn - DbContext를 받아 Queryable을 반환하는 function
+   * @param viewFn - Function that receives a DbContext and returns a Queryable
    * @returns new ViewBuilder instance
    *
    * @example
@@ -146,12 +146,12 @@ export class ViewBuilder<
   }
 
   /**
-   * relationship definition
+   * Relation definition
    *
-   * 다른 Table/View와의 relationship 설정
+   * Set up relations with other Tables/Views
    *
-   * @template T - relationship definition type
-   * @param fn - relationship factory를 받아 relationship 정의를 반환하는 function
+   * @template T - Relation definition type
+   * @param fn - Function that receives a relation factory and returns relation definitions
    * @returns new ViewBuilder instance
    *
    * @example
@@ -164,13 +164,13 @@ export class ViewBuilder<
    * ```
    *
    * @see {@link ForeignKeyBuilder} FK builder
-   * @see {@link ForeignKeyTargetBuilder} FK 역참조 builder
+   * @see {@link ForeignKeyTargetBuilder} FK reverse-reference builder
    */
   relations<T extends RelationBuilderRecord>(
     fn: (r: ReturnType<typeof createRelationFactory<this, keyof TData & string>>) => T,
   ): ViewBuilder<TDbContext, TData & InferDeepRelations<T>, TRelations> {
-    // TypeScript의 generic Type inference 한계로 인해 캐스팅 불가피
-    // TRelations type 파라미터와 새로 생성되는 relationship type T 간의 type 불일치 해결
+    // Casting is unavoidable due to TypeScript generic type inference limitations
+    // Resolves type mismatch between TRelations type parameter and newly created relation type T
     return new ViewBuilder({
       ...this.meta,
       relations: fn(createRelationFactory<this, keyof TData & string>(() => this)),
@@ -183,16 +183,16 @@ export class ViewBuilder<
 // ============================================
 
 /**
- * View builder Generate factory function
+ * View builder factory function
  *
- * ViewBuilder를 생성하여 Fluent API로 View schema definition
+ * Creates a ViewBuilder for defining View schema via Fluent API
  *
- * @param name - View 이름
+ * @param name - View name
  * @returns ViewBuilder instance
  *
  * @example
  * ```typescript
- * // Basic 사용
+ * // Basic usage
  * const ActiveUsers = View("ActiveUsers")
  *   .database("mydb")
  *   .query((db: MyDb) =>