@simplysm/orm-common 14.0.99 → 14.0.101

package/src/schema/view-builder.ts

@@ -21,29 +21,6 @@ import {
  * @template TData - View 데이터 레코드 타입
  * @template TRelations - 관계 정의 레코드 타입
  *
- * @example
- * ```typescript
- * // View definition
- * const UserSummary = View("UserSummary")
- *   .database("mydb")
- *   .query((db: MyDb) =>
- *     db.user()
- *       .select(u => ({
- *         id: u.id,
- *         name: u.name,
- *         postCount: expr.subquery(
- *           db.post().where(p => [expr.eq(p.authorId, u.id)]),
- *           q => expr.count(q.id)
- *         ),
- *       }))
- *   );
- *
- * // Used in DbContext
- * class MyDb extends DbContext {
- *   readonly userSummary = queryable(this, UserSummary);
- * }
- * ```
- *
  * @see {@link View} factory 함수
  * @see {@link queryable} Queryable 생성
  */
@@ -92,11 +69,6 @@ export class ViewBuilder<
    *
    * @param db - Database 이름
    * @returns 새 ViewBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const UserSummary = View("UserSummary").database("mydb");
-   * ```
    */
   database(db: string): ViewBuilder<TDbContext, TData, TRelations> {
     return new ViewBuilder({ ...this.meta, database: db });
@@ -123,21 +95,6 @@ export class ViewBuilder<
    * @template TDb - DbContext 타입
    * @param viewFn - DbContext를 받아 Queryable을 반환하는 함수
    * @returns 새 ViewBuilder 인스턴스
-   *
-   * @example
-   * ```typescript
-   * const ActiveUsers = View("ActiveUsers")
-   *   .database("mydb")
-   *   .query((db: MyDb) =>
-   *     db.user()
-   *       .where(u => [expr.eq(u.status, "active")])
-   *       .select(u => ({
-   *         id: u.id,
-   *         name: u.name,
-   *         email: u.email,
-   *       }))
-   *   );
-   * ```
    */
   query<TViewData extends DataRecord, TDb extends DbContextBase>(
     viewFn: (db: TDb) => Queryable<TViewData, any>,
@@ -154,15 +111,6 @@ export class ViewBuilder<
    * @param fn - 관계 factory를 받아 관계 정의를 반환하는 함수
    * @returns 새 ViewBuilder 인스턴스
    *
-   * @example
-   * ```typescript
-   * const UserSummary = View("UserSummary")
-   *   .query((db: MyDb) => db.user().select(...))
-   *   .relations((r) => ({
-   *     posts: r.foreignKeyTarget(Post, "author"),
-   *   }));
-   * ```
-   *
    * @see {@link ForeignKeyBuilder} FK builder
    * @see {@link ForeignKeyTargetBuilder} FK reverse-reference builder
    */
@@ -188,30 +136,6 @@ export class ViewBuilder<
  * @param name - View 이름
  * @returns ViewBuilder 인스턴스
  *
- * @example
- * ```typescript
- * // Basic usage
- * const ActiveUsers = View("ActiveUsers")
- *   .database("mydb")
- *   .query((db: MyDb) =>
- *     db.user()
- *       .where(u => [expr.eq(u.status, "active")])
- *       .select(u => ({ id: u.id, name: u.name }))
- *   );
- *
- * // 집계 View
- * const UserStats = View("UserStats")
- *   .database("mydb")
- *   .query((db: MyDb) =>
- *     db.user()
- *       .groupBy(u => ({ status: u.status }))
- *       .select(u => ({
- *         status: u.status,
- *         count: expr.count(u.id),
- *       }))
- *   );
- * ```
- *
  * @see {@link ViewBuilder} builder 클래스
  */
 export function View(name: string) {

package/src/types/column.ts

@@ -22,13 +22,6 @@ import { DateOnly, DateTime, Time, Uuid, type Bytes } from "@simplysm/core-commo
  * - `date`: DATE
  * - `time`: TIME
  * - `uuid`: BINARY(16)/UNIQUEIDENTIFIER/UUID
- *
- * @example
- * ```typescript
- * const intType: DataType = { type: "int" };
- * const decimalType: DataType = { type: "decimal", precision: 10, scale: 2 };
- * const varcharType: DataType = { type: "varchar", length: 100 };
- * ```
  */
 export type DataType =
   | { type: "int" }
@@ -54,12 +47,6 @@ export type DataType =
  * Column 원시 타입 매핑
  *
  * TypeScript 타입 이름 (문자열) → 실제 TypeScript 타입 매핑
- *
- * @example
- * ```typescript
- * type StringType = ColumnPrimitiveMap["string"];  // string
- * type DateTimeType = ColumnPrimitiveMap["DateTime"];  // DateTime
- * ```
  */
 export type ColumnPrimitiveMap = {
   string: string;
@@ -74,12 +61,6 @@ export type ColumnPrimitiveMap = {
 
 /**
  * Column 원시 타입 이름 (문자열)
- *
- * @example
- * ```typescript
- * const typeStr: ColumnPrimitiveStr = "string";  // OK
- * const typeStr2: ColumnPrimitiveStr = "invalid";  // Error
- * ```
  */
 export type ColumnPrimitiveStr = keyof ColumnPrimitiveMap;
 
@@ -96,12 +77,6 @@ export type ColumnPrimitive = ColumnPrimitiveMap[ColumnPrimitiveStr] | undefined
 
 /**
  * SQL DataType → TypeScript 타입 이름 매핑
- *
- * @example
- * ```typescript
- * const tsType = dataTypeStrToColumnPrimitiveStr["int"];  // "number"
- * const tsType2 = dataTypeStrToColumnPrimitiveStr["datetime"];  // "DateTime"
- * ```
  */
 export const dataTypeStrToColumnPrimitiveStr = {
   int: "number" as const,
@@ -124,12 +99,6 @@ export const dataTypeStrToColumnPrimitiveStr = {
  * DataType으로부터 TypeScript 타입 추론
  *
  * @template T - DataType
- *
- * @example
- * ```typescript
- * type IntType = InferColumnPrimitiveFromDataType<{ type: "int" }>;  // number
- * type VarcharType = InferColumnPrimitiveFromDataType<{ type: "varchar"; length: 100 }>;  // string
- * ```
  */
 export type InferColumnPrimitiveFromDataType<TDataType extends DataType> =
   ColumnPrimitiveMap[(typeof dataTypeStrToColumnPrimitiveStr)[TDataType["type"]]];
@@ -140,13 +109,6 @@ export type InferColumnPrimitiveFromDataType<TDataType extends DataType> =
  * @param value - Column 값
  * @returns ColumnPrimitiveStr 타입 이름
  * @throws 값 타입이 알 수 없을 때 Error
- *
- * @example
- * ```typescript
- * inferColumnPrimitiveStr("hello");  // "string"
- * inferColumnPrimitiveStr(123);  // "number"
- * inferColumnPrimitiveStr(new DateTime());  // "DateTime"
- * ```
  */
 export function inferColumnPrimitiveStr(value: ColumnPrimitive): ColumnPrimitiveStr {
   if (typeof value === "string") return "string";

package/src/types/db.ts

@@ -19,14 +19,6 @@ export type Dialect = "mysql" | "mssql" | "postgresql";
  * 지원하는 모든 Database dialect 목록
  *
  * 테스트에서 dialect별 검증에 사용
- *
- * @example
- * ```typescript
- * it.each(dialects)("[%s] SQL Validation", (dialect) => {
- *   const builder = createQueryBuilder(dialect);
- *   expect(builder.build(def)).toMatchSql(expected[dialect]);
- * });
- * ```
  */
 export const dialects: Dialect[] = ["mysql", "mssql", "postgresql"];
 
@@ -70,20 +62,6 @@ export type IsolationLevel =
  * Query 결과 데이터 레코드 타입
  *
  * 재귀적 구조로 중첩 관계(include) 결과를 표현
- *
- * @example
- * ```typescript
- * // 단순 레코드
- * type User = { id: number; name: string; }
- *
- * // 중첩 관계 include
- * type UserWithPosts = {
- *   id: number;
- *   name: string;
- *   posts: { id: number; title: string; }[]  // 1:N 관계
- *   company: { id: number; name: string; }   // N:1 관계
- * }
- * ```
  */
 export type DataRecord = {
   [key: string]: ColumnPrimitive | DataRecord | DataRecord[];
@@ -99,17 +77,6 @@ export type DataRecord = {
  * 실제 DB 연결과 query 실행을 담당
  * NodeDbContextExecutor(서버) 또는 SdOrmServiceClientDbContextExecutor(클라이언트)로 구현
  *
- * @example
- * ```typescript
- * // 서버 측 구현 예시
- * class NodeDbContextExecutor implements IDbContextExecutor {
- *   async connect(): Promise<void> {
- *     await this.connection.connect();
- *   }
- *   // ...
- * }
- * ```
- *
  * @see {@link DbContext} DbContext에서 사용
  */
 export interface DbContextExecutor {
@@ -179,27 +146,6 @@ export interface ResultMeta {
  * @property name - 고유 Migration 이름 (타임스탬프 권장)
  * @property up - Migration 실행 함수
  *
- * @example
- * ```typescript
- * const migrations: Migration[] = [
- *   {
- *     name: "20260105_001_create_user_table",
- *     up: async (db) => {
- *       await db.createTable(User);
- *     },
- *   },
- *   {
- *     name: "20260105_002_add_email_column",
- *     up: async (db) => {
- *       await db.addColumn(User, "email", {
- *         type: "varchar",
- *         length: 200,
- *       });
- *     },
- *   },
- * ];
- * ```
- *
  * @see {@link DbContext.initialize} migration 실행
  */
 export interface Migration {

package/src/utils/result-parser.ts

@@ -82,9 +82,6 @@ function buildColumnInfos(columns: Record<string, ColumnPrimitiveStr>): ColumnIn
 
 /**
  * 플랫 레코드를 중첩 객체로 변환
- *
- * @example
- * { "posts.id": 1, "posts.title": "Hi" } → { posts: { id: 1, title: "Hi" } }
  */
 function flatToNested(
   record: Record<string, unknown>,
@@ -186,27 +183,6 @@ const yieldToEventLoop: () => Promise<void> =
  * - async 전용: 대규모 처리 시 외부 인터럽트 허용을 위해 동기 버전 미제공
  * - 브라우저/Node 호환: setTimeout(resolve, 0)으로 양보
  * - 빈 결과 처리: 입력 배열이 비어있거나 파싱 후 모든 레코드가 빈 객체이면 undefined 반환
- *
- * @example
- * ```typescript
- * // 1. 단순 타입 파싱
- * const raw = [{ id: "1", createdAt: "2026-01-07T10:00:00.000Z" }];
- * const meta = { columns: { id: "number", createdAt: "DateTime" }, joins: {} };
- * const result = await parseQueryResult(raw, meta);
- * // [{ id: 1, createdAt: DateTime(...) }]
- *
- * // 2. JOIN 결과 중첩
- * const raw = [
- *   { id: 1, name: "User1", "posts.id": 10, "posts.title": "Post1" },
- *   { id: 1, name: "User1", "posts.id": 11, "posts.title": "Post2" },
- * ];
- * const meta = {
- *   columns: { id: "number", name: "string", "posts.id": "number", "posts.title": "string" },
- *   joins: { posts: { isSingle: false } }
- * };
- * const result = await parseQueryResult(raw, meta);
- * // [{ id: 1, name: "User1", posts: [{ id: 10, title: "Post1" }, { id: 11, title: "Post2" }] }]
- * ```
  */
 export async function parseQueryResult<TRecord>(
   rawResults: Record<string, unknown>[],