@simplysm/orm-common 14.0.100 → 14.0.102

package/src/schema/factory/column-builder.ts

@@ -16,18 +16,6 @@ import type { DataRecord } from "../../types/db";
  * @template TValue - Column 값 타입
  * @template TMeta - Column 메타데이터 타입
  *
- * @example
- * ```typescript
- * Table("User")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),           // bigint, 자동 증가
- *     name: c.varchar(100),                     // varchar(100), 필수
- *     email: c.varchar(200).nullable(),         // varchar(200), nullable
- *     status: c.varchar(20).default("active"),  // varchar(20), 기본값
- *     createdAt: c.datetime().description("created datetime"),
- *   }));
- * ```
- *
  * @see {@link createColumnFactory} column factory
  * @see {@link TableBuilder} Table builder
  */
@@ -43,11 +31,6 @@ export class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnM
    * INSERT 시 자동 증가. INSERT 타입 추론에서 선택적(optional)으로 처리됨
    *
    * @returns 새 ColumnBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * id: c.bigint().autoIncrement()
-   * ```
    */
   autoIncrement(): ColumnBuilder<TValue, Omit<TMeta, "autoIncrement"> & { autoIncrement: true }> {
     return new ColumnBuilder({ ...this.meta, autoIncrement: true });
@@ -59,11 +42,6 @@ export class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnM
    * NULL 허용. 값 타입에 undefined가 추가됨
    *
    * @returns 새 ColumnBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * email: c.varchar(200).nullable()  // string | undefined
-   * ```
    */
   nullable(): ColumnBuilder<TValue | undefined, Omit<TMeta, "nullable"> & { nullable: true }> {
     return new ColumnBuilder({ ...this.meta, nullable: true });
@@ -76,12 +54,6 @@ export class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnM
    *
    * @param value - 기본값
    * @returns 새 ColumnBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * status: c.varchar(20).default("active")
-   * createdAt: c.datetime().default("CURRENT_TIMESTAMP")
-   * ```
    */
   default(
     value: TValue,
@@ -94,11 +66,6 @@ export class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnM
    *
    * @param desc - Column 설명 (DDL Comment로 사용됨)
    * @returns 새 ColumnBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * createdAt: c.datetime().description("record creation datetime")
-   * ```
    */
   description(desc: string): ColumnBuilder<TValue, TMeta & { description: string }> {
     return new ColumnBuilder({ ...this.meta, description: desc });
@@ -117,32 +84,6 @@ export class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnM
  *
  * @returns 각 Column 타입별 builder 생성 메서드를 포함하는 객체
  *
- * @example
- * ```typescript
- * Table("User")
- *   .columns((c) => ({
- *     // 숫자 타입
- *     id: c.bigint().autoIncrement(),
- *     count: c.int(),
- *     price: c.decimal(10, 2),
- *
- *     // 문자열 타입
- *     name: c.varchar(100),
- *     code: c.char(10),
- *     content: c.text(),
- *
- *     // 날짜/시간 타입
- *     createdAt: c.datetime(),
- *     birthDate: c.date(),
- *     startTime: c.time(),
- *
- *     // 기타 타입
- *     isActive: c.boolean(),
- *     data: c.binary(),
- *     uuid: c.uuid(),
- *   }));
- * ```
- *
  * @see {@link ColumnBuilder} Column builder 클래스
  */
 export function createColumnFactory() {
@@ -189,11 +130,6 @@ export function createColumnFactory() {
      * @param precision - 전체 자릿수
      * @param scale - 소수점 이하 자릿수 (선택)
      * @returns ColumnBuilder 인스턴스
-     *
-     * @example
-     * ```typescript
-     * price: c.decimal(10, 2)  // DECIMAL(10, 2)
-     * ```
      */
     decimal(
       precision: number,
@@ -210,11 +146,6 @@ export function createColumnFactory() {
      *
      * @param length - 최대 길이
      * @returns ColumnBuilder 인스턴스
-     *
-     * @example
-     * ```typescript
-     * name: c.varchar(100)  // VARCHAR(100)
-     * ```
      */
     varchar(
       length: number,
@@ -227,11 +158,6 @@ export function createColumnFactory() {
      *
      * @param length - 고정 길이
      * @returns ColumnBuilder 인스턴스
-     *
-     * @example
-     * ```typescript
-     * countryCode: c.char(2)  // CHAR(2)
-     * ```
      */
     char(
       length: number,
@@ -329,12 +255,6 @@ export type ColumnBuilderRecord = Record<string, ColumnBuilder<ColumnPrimitive,
  * Column builder 레코드에서 실제 값 타입을 추론
  *
  * @template T - Column builder 레코드 타입
- *
- * @example
- * ```typescript
- * type UserColumns = InferColumns<typeof User.$columns>;
- * // { id: number; name: string; email: string | undefined; }
- * ```
  */
 export type InferColumns<TBuilders extends ColumnBuilderRecord> = {
   [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? V : never;
@@ -386,12 +306,6 @@ export type OptionalInsertKeys<TBuilders extends ColumnBuilderRecord> = Exclude<
  * 필수 column은 필수, 선택적 column은 Partial
  *
  * @template T - Column builder 레코드 타입
- *
- * @example
- * ```typescript
- * type UserInsert = InferInsertColumns<typeof User.$columns>;
- * // { name: string; } & { id?: number; email?: string; status?: string; }
- * ```
  */
 export type InferInsertColumns<TBuilders extends ColumnBuilderRecord> = Pick<
   InferColumns<TBuilders>,

package/src/schema/factory/index-builder.ts

@@ -10,27 +10,6 @@
  *
  * @template TKeys - Index column key 배열 타입
  *
- * @example
- * ```typescript
- * Table("User")
- *   .columns((c) => ({
- *     id: c.bigint(),
- *     email: c.varchar(200),
- *     name: c.varchar(100),
- *     createdAt: c.datetime(),
- *   }))
- *   .indexes((i) => [
- *     // 유니크 index
- *     i.index("email").unique(),
- *
- *     // 복합 index + 정렬 순서
- *     i.index("name", "createdAt").orderBy("ASC", "DESC"),
- *
- *     // 커스텀 이름
- *     i.index("createdAt").name("IX_User_CreatedAt"),
- *   ]);
- * ```
- *
  * @see {@link createIndexFactory} Index factory
  * @see {@link TableBuilder} Table builder
  */
@@ -58,11 +37,6 @@ export class IndexBuilder<TKeys extends string[]> {
    *
    * @param name - Index 이름
    * @returns 새 IndexBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * i.index("email").name("IX_User_Email")
-   * ```
    */
   name(name: string): IndexBuilder<TKeys> {
     return new IndexBuilder({ ...this.meta, name });
@@ -72,11 +46,6 @@ export class IndexBuilder<TKeys extends string[]> {
    * 유니크 index 설정
    *
    * @returns 새 IndexBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * i.index("email").unique()
-   * ```
    */
   unique(): IndexBuilder<TKeys> {
     return new IndexBuilder({ ...this.meta, unique: true });
@@ -89,15 +58,6 @@ export class IndexBuilder<TKeys extends string[]> {
    *
    * @param orderBy - column별 정렬 순서 (column 수와 일치해야 함)
    * @returns 새 IndexBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * // 단일 column
-   * i.index("createdAt").orderBy("DESC")
-   *
-   * // 복합 column
-   * i.index("status", "createdAt").orderBy("ASC", "DESC")
-   * ```
    */
   orderBy(...orderBy: { [K in keyof TKeys]: "ASC" | "DESC" }): IndexBuilder<TKeys> {
     return new IndexBuilder({ ...this.meta, orderBy });
@@ -126,20 +86,6 @@ export class IndexBuilder<TKeys extends string[]> {
  * @template TColumnKey - Table column key 타입
  * @returns Index 생성 메서드를 포함하는 객체
  *
- * @example
- * ```typescript
- * Table("User")
- *   .columns((c) => ({
- *     id: c.bigint(),
- *     email: c.varchar(200),
- *     name: c.varchar(100),
- *   }))
- *   .indexes((i) => [
- *     i.index("email").unique(),
- *     i.index("name"),
- *   ]);
- * ```
- *
  * @see {@link IndexBuilder} Index builder 클래스
  */
 export function createIndexFactory<TColumnKey extends string>() {
@@ -150,12 +96,6 @@ export function createIndexFactory<TColumnKey extends string>() {
      * @template TKeys - Index column key 배열 타입
      * @param columns - Index column 이름들
      * @returns IndexBuilder 인스턴스
-     *
-     * @example
-     * ```typescript
-     * i.index("email")          // 단일 column
-     * i.index("name", "email")  // 복합 column
-     * ```
      */
     index<TKeys extends TColumnKey[]>(...columns: [...TKeys]): IndexBuilder<TKeys> {
       return new IndexBuilder({ columns });

package/src/schema/factory/relation-builder.ts

@@ -18,20 +18,6 @@ import type { ViewBuilder } from "../view-builder";
  * @template TOwner - 소유 Table builder 타입
  * @template TTargetFn - 대상 Table builder factory 타입
  *
- * @example
- * ```typescript
- * const Post = Table("Post")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),
- *     authorId: c.bigint(),  // FK column
- *   }))
- *   .primaryKey("id")
- *   .relations((r) => ({
- *     // N:1 relationship - Post → User
- *     author: r.foreignKey(["authorId"], () => User, { description: "작성자" }),
- *   }));
- * ```
- *
  * @see {@link ForeignKeyTargetBuilder} 역참조 builder
  * @see {@link RelationKeyBuilder} DB FK 없는 관계
  */
@@ -68,26 +54,6 @@ export class ForeignKeyBuilder<
  * @template TTargetTableFn - 참조하는 Table builder factory 타입
  * @template TIsSingle - 단일 객체 여부
  *
- * @example
- * ```typescript
- * const User = Table("User")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),
- *     name: c.varchar(100),
- *   }))
- *   .primaryKey("id")
- *   .relations((r) => ({
- *     // 1:N relationship - User ← Post.author
- *     posts: r.foreignKeyTarget(() => Post, "author"),
- *
- *     // 1:1 relation (single object)
- *     profile: r.foreignKeyTarget(() => Profile, "user", { single: true }),
- *
- *     // with description
- *     comments: r.foreignKeyTarget(() => Comment, "user", { description: "댓글목록" }),
- *   }));
- * ```
- *
  * @see {@link ForeignKeyBuilder} FK builder
  */
 export class ForeignKeyTargetBuilder<
@@ -126,17 +92,6 @@ export class ForeignKeyTargetBuilder<
  * @template TOwner - 소유 Table/View builder 타입
  * @template TTargetFn - 대상 Table/View builder factory 타입
  *
- * @example
- * ```typescript
- * // View에서 Table로의 관계 정의
- * const UserSummary = View("UserSummary")
- *   .query((db: MyDb) => db.user().select(...))
- *   .relations((r) => ({
- *     // View → Table (FK 미생성)
- *     company: r.relationKey(["companyId"], () => Company, { description: "소속회사" }),
- *   }));
- * ```
- *
  * @see {@link ForeignKeyBuilder} DB FK 생성 버전
  */
 export class RelationKeyBuilder<
@@ -171,18 +126,6 @@ export class RelationKeyBuilder<
  * @template TTargetTableFn - 참조하는 Table/View builder factory 타입
  * @template TIsSingle - 단일 객체 여부
  *
- * @example
- * ```typescript
- * const Company = Table("Company")
- *   .columns((c) => ({ id: c.bigint() }))
- *   .relations((r) => ({
- *     // 역참조 (FK 미생성)
- *     employees: r.relationKeyTarget(() => UserSummary, "company"),
- *     // 단일 객체 + 설명
- *     ceo: r.relationKeyTarget(() => UserSummary, "company", { single: true, description: "대표" }),
- *   }));
- * ```
- *
  * @see {@link ForeignKeyTargetBuilder} DB FK 생성 버전
  */
 export class RelationKeyTargetBuilder<
@@ -275,26 +218,6 @@ type RelationRkFactory<
  * @template TColumnKey - Column key 타입
  * @param ownerFn - 소유 Table/View factory 함수
  * @returns 관계 builder factory
- *
- * @example
- * ```typescript
- * // Table - FK와 RelationKey 모두 사용 가능
- * const Post = Table("Post")
- *   .columns((c) => ({
- *     id: c.bigint(),
- *     authorId: c.bigint(),
- *   }))
- *   .relations((r) => ({
- *     author: r.foreignKey(["authorId"], () => User),  // FK 생성
- *   }));
- *
- * // View - RelationKey만 사용 가능
- * const UserSummary = View("UserSummary")
- *   .query(...)
- *   .relations((r) => ({
- *     posts: r.relationKeyTarget(() => Post, "author"),  // FK 미생성
- *   }));
- * ```
  */
 export function createRelationFactory<
   TOwner extends TableBuilder<any, any, any> | ViewBuilder<any, any, any>,
@@ -415,12 +338,6 @@ export type ExtractRelationTargetResult<TRelation, TVisited extends string = nev
  * include() 없이 접근 시 undefined가 되도록 모든 관계를 optional로 설정
  *
  * @template TRelations - 관계 builder 레코드 타입
- *
- * @example
- * ```typescript
- * type UserRelations = InferDeepRelations<typeof User.$relations>;
- * // { posts?: Post[]; profile?: Profile; }
- * ```
  */
 export type InferDeepRelations<TRelations extends RelationBuilderRecord, TVisited extends string = never> = {
   [K in keyof TRelations]?:

package/src/schema/procedure-builder.ts

@@ -13,30 +13,6 @@ import { type ColumnBuilderRecord, createColumnFactory } from "./factory/column-
  * @template TParams - 파라미터 Column 정의 타입
  * @template TReturns - 반환 Column 정의 타입
  *
- * @example
- * ```typescript
- * // Procedure definition
- * const GetUserById = Procedure("GetUserById")
- *   .database("mydb")
- *   .params((c) => ({
- *     userId: c.bigint(),
- *   }))
- *   .returns((c) => ({
- *     id: c.bigint(),
- *     name: c.varchar(100),
- *     email: c.varchar(200),
- *   }))
- *   .body("SELECT id, name, email FROM User WHERE id = userId");
- *
- * // Used in DbContext
- * class MyDb extends DbContext {
- *   readonly getUserById = executable(this, GetUserById);
- * }
- *
- * // Invocation
- * const users = await db.getUserById({ userId: 1n }).execute();
- * ```
- *
  * @see {@link Procedure} factory 함수
  * @see {@link executable} Executable 생성
  */
@@ -86,11 +62,6 @@ export class ProcedureBuilder<
    *
    * @param db - Database 이름
    * @returns 새 ProcedureBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const GetUser = Procedure("GetUser").database("mydb");
-   * ```
    */
   database(db: string): ProcedureBuilder<TParams, TReturns> {
     return new ProcedureBuilder({ ...this.meta, database: db });
@@ -117,15 +88,6 @@ export class ProcedureBuilder<
    * @template T - 새 파라미터 정의 타입
    * @param fn - Column factory를 받아 파라미터 정의를 반환하는 함수
    * @returns 새 ProcedureBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const GetUserById = Procedure("GetUserById")
-   *   .params((c) => ({
-   *     userId: c.bigint(),
-   *     includeDeleted: c.boolean().default(false),
-   *   }));
-   * ```
    */
   params<T extends ColumnBuilderRecord>(
     fn: (c: ReturnType<typeof createColumnFactory>) => T,
@@ -141,17 +103,6 @@ export class ProcedureBuilder<
    * @template T - 새 반환 타입 정의
    * @param fn - Column factory를 받아 column 정의를 반환하는 함수
    * @returns 새 ProcedureBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const GetUserById = Procedure("GetUserById")
-   *   .params((c) => ({ userId: c.bigint() }))
-   *   .returns((c) => ({
-   *     id: c.bigint(),
-   *     name: c.varchar(100),
-   *     email: c.varchar(200).nullable(),
-   *   }));
-   * ```
    */
   returns<T extends ColumnBuilderRecord>(
     fn: (c: ReturnType<typeof createColumnFactory>) => T,
@@ -169,19 +120,6 @@ export class ProcedureBuilder<
    *
    * @param sql - Procedure 본문 SQL
    * @returns 새 ProcedureBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * // MySQL/PostgreSQL
-   * const GetUser = Procedure("GetUser")
-   *   .params((c) => ({ userId: c.bigint() }))
-   *   .body("SELECT * FROM User WHERE id = userId");
-   *
-   * // MSSQL
-   * const GetUser = Procedure("GetUser")
-   *   .params((c) => ({ userId: c.bigint() }))
-   *   .body("SELECT * FROM [User] WHERE id = @userId");
-   * ```
    */
   body(sql: string): ProcedureBuilder<TParams, TReturns> {
     return new ProcedureBuilder({ ...this.meta, query: sql });
@@ -200,31 +138,6 @@ export class ProcedureBuilder<
  * @param name - Procedure 이름
  * @returns ProcedureBuilder 인스턴스
  *
- * @example
- * ```typescript
- * // Basic usage
- * const GetUserById = Procedure("GetUserById")
- *   .database("mydb")
- *   .params((c) => ({
- *     userId: c.bigint(),
- *   }))
- *   .returns((c) => ({
- *     id: c.bigint(),
- *     name: c.varchar(100),
- *     email: c.varchar(200),
- *   }))
- *   .body("SELECT id, name, email FROM User WHERE id = userId");
- *
- * // 파라미터 없는 Procedure
- * const GetAllActiveUsers = Procedure("GetAllActiveUsers")
- *   .database("mydb")
- *   .returns((c) => ({
- *     id: c.bigint(),
- *     name: c.varchar(100),
- *   }))
- *   .body("SELECT id, name FROM User WHERE status = 'active'");
- * ```
- *
  * @see {@link ProcedureBuilder} builder 클래스
  */
 export function Procedure(name: string): ProcedureBuilder<never, never> {

package/src/schema/table-builder.ts

@@ -25,26 +25,6 @@ import {
  * @template TColumns - Column 정의 레코드 타입
  * @template TRelations - 관계 정의 레코드 타입
  *
- * @example
- * ```typescript
- * // Table definition
- * const User = Table("User")
- *   .database("mydb")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),
- *     name: c.varchar(100),
- *     email: c.varchar(200).nullable(),
- *     status: c.varchar(20).default("active"),
- *   }))
- *   .primaryKey("id")
- *   .indexes((i) => [i.index("email").unique()]);
- *
- * // Used in DbContext
- * class MyDb extends DbContext {
- *   readonly user = queryable(this, User);
- * }
- * ```
- *
  * @see {@link Table} factory 함수
  * @see {@link queryable} Queryable 생성
  */
@@ -107,11 +87,6 @@ export class TableBuilder<
    *
    * @param db - Database 이름
    * @returns 새 TableBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const User = Table("User").database("mydb");
-   * ```
    */
   database(db: string): TableBuilder<TName, TColumns, TRelations> {
     return new TableBuilder({ ...this.meta, database: db });
@@ -124,13 +99,6 @@ export class TableBuilder<
    *
    * @param schema - Schema 이름 (MSSQL: dbo, PostgreSQL: public)
    * @returns 새 TableBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const User = Table("User")
-   *   .database("mydb")
-   *   .schema("custom_schema");
-   * ```
    */
   schema(schema: string): TableBuilder<TName, TColumns, TRelations> {
     return new TableBuilder({ ...this.meta, schema });
@@ -144,17 +112,6 @@ export class TableBuilder<
    * @template TNewColumnDefs - 새 Column 정의 타입
    * @param fn - Column factory를 받아 column 정의를 반환하는 함수
    * @returns 새 TableBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const User = Table("User")
-   *   .columns((c) => ({
-   *     id: c.bigint().autoIncrement(),
-   *     name: c.varchar(100),
-   *     email: c.varchar(200).nullable(),
-   *     createdAt: c.datetime().default("CURRENT_TIMESTAMP"),
-   *   }));
-   * ```
    */
   columns<TNewColumnDefs extends ColumnBuilderRecord>(
     fn: (c: ReturnType<typeof createColumnFactory>) => TNewColumnDefs,
@@ -170,22 +127,6 @@ export class TableBuilder<
    *
    * @param columns - PK를 구성하는 column 이름 (복합 PK 지원)
    * @returns 새 TableBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * // 단일 PK
-   * const User = Table("User")
-   *   .columns((c) => ({ id: c.bigint() }))
-   *   .primaryKey("id");
-   *
-   * // 복합 PK
-   * const UserRole = Table("UserRole")
-   *   .columns((c) => ({
-   *     userId: c.bigint(),
-   *     roleId: c.bigint(),
-   *   }))
-   *   .primaryKey("userId", "roleId");
-   * ```
    */
   primaryKey(...columns: (keyof TColumns & string)[]): TableBuilder<TName, TColumns, TRelations> {
     return new TableBuilder({
@@ -199,20 +140,6 @@ export class TableBuilder<
    *
    * @param fn - Index factory를 받아 index 배열을 반환하는 함수
    * @returns 새 TableBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const User = Table("User")
-   *   .columns((c) => ({
-   *     id: c.bigint(),
-   *     email: c.varchar(200),
-   *     name: c.varchar(100),
-   *   }))
-   *   .indexes((i) => [
-   *     i.index("email").unique(),
-   *     i.index("name").orderBy("ASC"),
-   *   ]);
-   * ```
    */
   indexes(
     fn: (
@@ -234,32 +161,6 @@ export class TableBuilder<
    * @param fn - 관계 factory를 받아 관계 정의를 반환하는 함수
    * @returns 새 TableBuilder 인스턴스
    *
-   * @example
-   * ```typescript
-   * const Post = Table("Post")
-   *   .columns((c) => ({
-   *     id: c.bigint().autoIncrement(),
-   *     authorId: c.bigint(),
-   *     title: c.varchar(200),
-   *   }))
-   *   .primaryKey("id")
-   *   .relations((r) => ({
-   *     // FK relation (N:1)
-   *     author: r.foreignKey(["authorId"], () => User),
-   *   }));
-   *
-   * const User = Table("User")
-   *   .columns((c) => ({
-   *     id: c.bigint().autoIncrement(),
-   *     name: c.varchar(100),
-   *   }))
-   *   .primaryKey("id")
-   *   .relations((r) => ({
-   *     // Reverse-reference (1:N)
-   *     posts: r.foreignKeyTarget(() => Post, "author"),
-   *   }));
-   * ```
-   *
    * @see {@link ForeignKeyBuilder} FK builder
    * @see {@link ForeignKeyTargetBuilder} FK reverse-reference builder
    */
@@ -285,34 +186,6 @@ export class TableBuilder<
  * @param name - Table 이름
  * @returns TableBuilder 인스턴스
  *
- * @example
- * ```typescript
- * // Basic usage
- * const User = Table("User")
- *   .database("mydb")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),
- *     name: c.varchar(100),
- *     email: c.varchar(200).nullable(),
- *   }))
- *   .primaryKey("id")
- *   .indexes((i) => [i.index("email").unique()]);
- *
- * // With relations
- * const Post = Table("Post")
- *   .database("mydb")
- *   .columns((c) => ({
- *     id: c.bigint().autoIncrement(),
- *     authorId: c.bigint(),
- *     title: c.varchar(200),
- *     content: c.text(),
- *   }))
- *   .primaryKey("id")
- *   .relations((r) => ({
- *     author: r.foreignKey(["authorId"], () => User),
- *   }));
- * ```
- *
  * @see {@link TableBuilder} builder 클래스
  */
 export function Table<TName extends string>(name: TName) {