sonamu 0.8.26 → 0.9.0

package/dist/database/upsert-builder.js

@@ -1,469 +1,409 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { assertDefined, init_utils, nonNullable } from "../utils/utils.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { Naite, init_naite } from "../naite/naite.js";
+import { batchUpdate, init__batch_update } from "./_batch_update.js";
 import { getLogger } from "@logtape/logtape";
+import { cluster, isArray, unique } from "radashi";
 import { randomUUID } from "crypto";
-import { isArray, unique } from "radashi";
-import { EntityManager } from "../entity/entity-manager.js";
-import { Naite } from "../naite/naite.js";
-import { assertDefined, chunk, nonNullable } from "../utils/utils.js";
-import { batchUpdate } from "./_batch_update.js";
-const logger = getLogger([
-    "sonamu",
-    "internal",
-    "upsert-builder"
-]);
-export function isRefField(field) {
-    return field !== undefined && field !== null && field?.of !== undefined && field?.uuid !== undefined;
-}
-export class UpsertBuilder {
-    tables;
-    constructor(){
-        this.tables = new Map();
-    }
-    getTable(tableName) {
-        const table = this.tables.get(tableName);
-        if (table) {
-            return table;
-        }
-        const tableSpec = (()=>{
-            try {
-                return EntityManager.getTableSpec(tableName);
-            } catch  {
-                return null;
-            }
-        })();
-        const tableData = {
-            references: new Set(),
-            rows: [],
-            uniqueIndexes: tableSpec?.uniqueIndexes ?? [],
-            uniquesMap: new Map(),
-            jsonColumns: tableSpec?.jsonColumns ?? []
-        };
-        this.tables.set(tableName, tableData);
-        return tableData;
-    }
-    hasTable(tableName) {
-        return this.tables.has(tableName);
-    }
-    register(tableName, row) {
-        const table = this.getTable(tableName);
-        // 해당 테이블의 unique 인덱스를 순회하며 키 생성
-        const uniqueKeys = table.uniqueIndexes.map((unqIndex)=>{
-            const uniqueKeyArray = unqIndex.columns.map((unqCol)=>{
-                const val = row[unqCol.name];
-                if (isRefField(val)) {
-                    return val.uuid;
-                } else {
-                    return row[unqCol.name] ?? randomUUID(); // nullable인 경우 uuid로 랜덤값 삽입
-                }
-            });
-            // 값이 모두 null인 경우 키 생성 패스
-            if (uniqueKeyArray.length === 0) {
-                return null;
-            }
-            return uniqueKeyArray.join("---delimiter--");
-        }).filter(nonNullable);
-        // uuid 생성 로직
-        const { uuid, isReused } = (()=>{
-            // 키를 순회하여 이미 존재하는 키가 있는지 확인
-            if (uniqueKeys.length > 0) {
-                for (const uniqueKey of uniqueKeys){
-                    if (table.uniquesMap.has(uniqueKey)) {
-                        return {
-                            uuid: assertDefined(table.uniquesMap.get(uniqueKey), "Unique key not found"),
-                            isReused: true
-                        };
-                    }
-                }
-            }
-            // 찾을 수 없는 경우 생성
-            return {
-                uuid: randomUUID(),
-                isReused: false
-            };
-        })();
-        // 모든 유니크키에 대해 유니크맵에 uuid 저장
-        if (uniqueKeys.length > 0) {
-            for (const uniqueKey of uniqueKeys){
-                table.uniquesMap.set(uniqueKey, uuid);
-            }
-        }
-        // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가
-        // 이 정보를 나중에 치환할 때 사용
-        row = Object.fromEntries(Object.entries(row).map(([rowKey, rowValue])=>{
-            if (isRefField(rowValue)) {
-                rowValue.use ??= "id";
-                table.references.add(`${rowValue.of}.${rowValue.use}`);
-                return [
-                    rowKey,
-                    rowValue
-                ];
-            } else if (table.jsonColumns.includes(rowKey) && rowValue !== null) {
-                // JSON 컬럼인 경우 JSON.stringify 처리 (Knex는 JSON 타입을 지원하지 않음)
-                return [
-                    rowKey,
-                    JSON.stringify(rowValue)
-                ];
-            } else if (isArray(rowValue)) {
-                // 배열은 그대로 저장
-                return [
-                    rowKey,
-                    rowValue
-                ];
-            } else {
-                return [
-                    rowKey,
-                    rowValue
-                ];
-            }
-        }));
-        table.rows.push({
-            uuid,
-            ...row
-        });
-        const result = {
-            of: tableName,
-            uuid: row.uuid ?? uuid
-        };
-        Naite.t("puri:ub-register", {
-            tableName,
-            uuid: result.uuid,
-            isUuidReused: isReused,
-            row
-        });
-        return result;
-    }
-    async upsert(wdb, tableName, options) {
-        return this.upsertOrInsert(wdb, tableName, "upsert", options);
-    }
-    async insertOnly(wdb, tableName, options) {
-        return this.upsertOrInsert(wdb, tableName, "insert", options);
-    }
-    async upsertOrInsert(wdb, tableName, mode, options) {
-        if (this.hasTable(tableName) === false) {
-            return [];
-        }
-        const table = this.tables.get(tableName);
-        if (table === undefined) {
-            throw new Error(`존재하지 않는 테이블 ${tableName}에 upsert 요청`);
-        } else if (table.rows.length === 0) {
-            throw new Error(`${tableName}에 upsert 할 데이터가 없습니다.`);
-        }
-        if (table.rows.some((row)=>Object.entries(row).some(([, value])=>isRefField(value) && value.of !== tableName))) {
-            throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
-        }
-        // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출
-        const { references, refTables } = Array.from(this.tables).reduce((r, [, table])=>{
-            const reference = Array.from(table.references.values()).find((ref)=>ref.includes(`${tableName}.`));
-            if (reference) {
-                r.references.push(reference);
-                r.refTables.push(table);
-            }
-            return r;
-        }, {
-            references: [],
-            refTables: []
-        });
-        const extractFields = unique(references).map((reference)=>reference.split(".")[1]).filter((field)=>field !== undefined);
-        // 의존성 순서에 따라 레벨별 그룹화 (자기 참조가 없으면 Level 0 하나)
-        const { levels, hasCircular } = this.buildInsertLevels(table.rows, tableName);
-        if (hasCircular) {
-            throw new Error(`${tableName}에 순환 자기 참조가 있습니다.`);
-        }
-        const uuidMap = new Map();
-        const allIds = [];
-        // 레벨별로 순차 처리
-        for(let levelIdx = 0; levelIdx < levels.length; levelIdx++){
-            const levelRows = levels[levelIdx];
-            logger.debug("Processing Query Level: {current} / {total}", {
-                current: levelIdx + 1,
-                total: levels.length
-            });
-            // 이전 레벨에서 얻은 ID로 자기 참조 해결
-            const resolvedRows = levelRows.map((row)=>{
-                const resolved = {
-                    ...row
-                };
-                for (const [key, value] of Object.entries(row)){
-                    if (isRefField(value) && value.of === tableName) {
-                        const parent = uuidMap.get(value.uuid);
-                        if (!parent) throw new Error(`존재하지 않는 uuid ${value.uuid} -- in ${tableName}`);
-                        resolved[key] = parent[value.use ?? "id"];
-                        Naite.t("puri:ub-ref-resolved", {
-                            tableName,
-                            field: key,
-                            from: {
-                                of: value.of,
-                                uuid: value.uuid,
-                                use: value.use ?? "id"
-                            },
-                            to: resolved[key]
-                        });
-                    }
-                }
-                return resolved;
-            });
-            // 현재 레벨 upsert
-            const chunkSize = options?.chunkSize;
-            const levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [
-                resolvedRows
-            ];
-            const selectFields = unique([
-                "id",
-                ...extractFields
-            ]);
-            for(let index = 0; index < levelChunks.length; index++){
-                const dataChunk = levelChunks[index];
-                if (dataChunk.length === 0) continue;
-                logger.debug("Processing Chunk: {current} / {total}", {
-                    current: index + 1,
-                    total: levelChunks.length
-                });
-                // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거
-                const originalUuids = dataChunk.map((r)=>r.uuid);
-                const dataForDb = dataChunk.map(({ uuid, ...rest })=>rest);
-                let resultRows;
-                if (mode === "insert") {
-                    // INSERT 모드 - RETURNING 사용
-                    resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
-                } else {
-                    // UPSERT 모드 - id 없는 row들의 id를 사전 조회로 채우기
-                    const rowsWithoutId = dataForDb.filter((row)=>!row.id);
-                    if (rowsWithoutId.length > 0 && table.uniqueIndexes.length > 0) {
-                        // 모든 uniqueIndexes로 기존 레코드 조회
-                        for (const uniqueIndex of table.uniqueIndexes){
-                            const columns = uniqueIndex.columns.map((c)=>c.name);
-                            // 조회할 조건들 추출 (각 row의 unique 컬럼 값들)
-                            const conditions = [];
-                            for (const row of rowsWithoutId){
-                                const values = columns.map((col)=>row[col]);
-                                // null이 포함된 조건은 제외 (PostgreSQL UNIQUE는 NULL 무시)
-                                if (!values.some((v)=>v == null)) {
-                                    conditions.push(values);
-                                }
-                            }
-                            if (conditions.length === 0) continue;
-                            // 배치 SELECT
-                            const existingRows = await wdb(tableName).whereIn(columns, conditions).select("id", ...columns);
-                            // Map 생성: unique 컬럼 조합 → id
-                            const existingMap = new Map();
-                            for (const existing of existingRows){
-                                const key = columns.map((col)=>String(existing[col] ?? "")).join("---delimiter---");
-                                const id = existing.id;
-                                if (typeof id === "number" || typeof id === "string") {
-                                    existingMap.set(key, id);
-                                }
-                            }
-                            // id 없는 row들에 매칭되는 id 채우기
-                            for (const row of rowsWithoutId){
-                                if (row.id) continue; // 이미 다른 uniqueIndex에서 채워진 경우 스킵
-                                const key = columns.map((col)=>String(row[col] ?? "")).join("---delimiter---");
-                                const existingId = existingMap.get(key);
-                                if (existingId) {
-                                    row.id = existingId;
-                                }
-                            }
-                        }
-                    }
-                    // onConflict는 id만 사용 (모든 uniqueIndexes는 이미 사전 조회로 처리됨)
-                    const conflictColumns = [
-                        "id"
-                    ];
-                    const allColumns = Object.keys(dataForDb[0]);
-                    let updateColumns = allColumns.filter((c)=>c !== "id");
-                    // inherit 옵션 처리 - inherit 컬럼은 update 대상에서 제외
-                    if (options?.inherit?.length) {
-                        const inheritColumns = options.inherit;
-                        const excludedFromUpdate = updateColumns.filter((c)=>inheritColumns.includes(c));
-                        updateColumns = updateColumns.filter((c)=>!inheritColumns.includes(c));
-                        // 실제로 제외된 컬럼 로깅
-                        if (excludedFromUpdate.length) {
-                            Naite.t("puri:ub-inherit", {
-                                tableName,
-                                inheritColumns,
-                                excludedFromUpdate
-                            });
-                        }
-                    }
-                    // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장
-                    const mergeColumns = updateColumns.length ? updateColumns : conflictColumns;
-                    resultRows = await wdb.insert(dataForDb).into(tableName).onConflict(conflictColumns).merge(mergeColumns).returning(selectFields);
-                }
-                if (originalUuids.length !== resultRows.length) {
-                    throw new Error(`${tableName}: register/returning 불일치`);
-                }
-                for(let i = 0; i < resultRows.length; i++){
-                    uuidMap.set(originalUuids[i], resultRows[i]);
-                    allIds.push(resultRows[i].id);
-                }
-            }
-        }
-        // 해당 테이블 참조를 실제 밸류로 변경
-        for (const table of refTables){
-            table.rows = table.rows.map((row)=>{
-                for (const key of Object.keys(row)){
-                    const prop = row[key];
-                    if (isRefField(prop) && prop.of === tableName) {
-                        const parent = uuidMap.get(prop.uuid);
-                        if (!parent) {
-                            console.error(prop);
-                            throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);
-                        }
-                        const resolvedValue = parent[prop.use ?? "id"];
-                        row[key] = resolvedValue;
-                        Naite.t("puri:ub-ref-resolved", {
-                            tableName,
-                            field: key,
-                            from: {
-                                of: prop.of,
-                                uuid: prop.uuid,
-                                use: prop.use ?? "id"
-                            },
-                            to: resolvedValue
-                        });
-                    }
-                }
-                return row;
-            });
-        }
-        if (options?.cleanOrphans) {
-            const cleanOrphans = options.cleanOrphans;
-            const fkColumns = isArray(cleanOrphans) ? cleanOrphans : [
-                cleanOrphans
-            ];
-            // 현재 register된 레코드들의 FK 값들 추출
-            const fkConditions = fkColumns.map((fkCol)=>{
-                const fkValues = [
-                    ...new Set(table.rows.map((row)=>row[fkCol]).filter((v)=>v != null))
-                ];
-                return {
-                    column: fkCol,
-                    values: fkValues
-                };
-            });
-            // 모든 FK 컬럼에 값이 있는 경우에만 삭제 실행
-            if (fkConditions.every((fc)=>fc.values.length > 0)) {
-                let deleteQuery = wdb(tableName);
-                // 각 FK 컬럼에 대한 WHERE IN 조건 추가
-                for (const { column, values } of fkConditions){
-                    deleteQuery = deleteQuery.whereIn(column, values);
-                }
-                // 방금 upsert한 ID는 제외
-                deleteQuery = deleteQuery.whereNotIn("id", allIds);
-                const deletedCount = await deleteQuery.delete();
-                Naite.t("puri:ub-clean-orphans", {
-                    tableName,
-                    cleanOrphans: fkColumns,
-                    deletedCount
-                });
-            }
-        }
-        // 해당 테이블의 데이터 초기화
-        table.rows = [];
-        table.references.clear();
-        table.uniquesMap.clear();
-        Naite.t("puri:ub-upserted", {
-            tableName,
-            mode,
-            rowCount: allIds.length,
-            returnedIds: allIds
-        });
-        return allIds;
-    }
-    async updateBatch(wdb, tableName, options) {
-        options = {
-            ...options,
-            chunkSize: options?.chunkSize ?? 500,
-            where: options?.where ?? "id"
-        };
-        if (this.hasTable(tableName) === false) {
-            return;
-        }
-        const table = this.tables.get(tableName);
-        if (!table) {
-            throw new Error(`등록되지 않은 테이블 ${tableName}에 updateBatch 요청`);
-        } else if (table.rows.length === 0) {
-            return;
-        }
-        const whereColumns = Array.isArray(options.where) ? options.where : [
-            options.where ?? "id"
-        ];
-        const rows = table.rows.map((_row)=>{
-            const { uuid: _, ...row } = _row; // uuid 제외
-            return row;
-        });
-        await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
-        Naite.t("puri:ub-batch-updated", {
-            tableName,
-            rowCount: rows.length,
-            whereColumns
-        });
-        // updateBatch 완료 후 처리된 데이터 제거
-        table.rows = [];
-        table.references.clear();
-        table.uniquesMap.clear();
-    }
-    // ============================================================================
-    // Private Helper Methods
-    // ============================================================================
-    /**
-   * rows를 의존성 순서에 따라 레벨별로 그룹화
-   * - 자기 참조 없는 경우 : 모든 rows가 Level 0
-   * - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화
-   */ buildInsertLevels(rows, tableName) {
-        // 1. 자기 참조가 없으면 한 레벨로 처리
-        const hasSelfRef = rows.flatMap((row)=>Object.values(row)).some((value)=>isRefField(value) && value.of === tableName);
-        if (!hasSelfRef) return {
-            levels: [
-                rows
-            ],
-            hasCircular: false
-        };
-        // 2. uuid → row 매핑 (중복 uuid 방지)
-        const rowByUuid = new Map();
-        for (const row of rows){
-            const uuid = row.uuid;
-            if (!uuid) throw new Error(`buildInsertLevels: uuid가 없는 row -- in ${tableName}`);
-            rowByUuid.set(uuid, row);
-        }
-        let pending = Array.from(rowByUuid.values());
-        const levels = [];
-        const inserted = new Set();
-        // 3. 레벨별 분류
-        while(pending.length > 0){
-            const currentLevel = [];
-            const nextPending = [];
-            for (const row of pending){
-                // 이 row가 참조하는 자기 참조들
-                const selfRefs = Object.values(row).filter((value)=>isRefField(value) && value.of === tableName);
-                // 참조하는 모든 uuid가 이미 inserted에 있어야 이번 레벨에 포함
-                const canInsert = selfRefs.every((ref)=>{
-                    if (!rowByUuid.has(ref.uuid)) {
-                        throw new Error(`존재하지 않는 uuid ${ref.uuid} -- in ${tableName}`);
-                    }
-                    return inserted.has(ref.uuid);
-                });
-                if (canInsert) {
-                    currentLevel.push(row);
-                } else {
-                    nextPending.push(row);
-                }
-            }
-            // 순환 참조 감지
-            if (currentLevel.length === 0) return {
-                levels: [],
-                hasCircular: true
-            };
-            // 레벨 확정 + inserted 갱신
-            levels.push(currentLevel);
-            for (const row of currentLevel){
-                inserted.add(row.uuid);
-            }
-            pending = nextPending;
-        }
-        return {
-            levels,
-            hasCircular: false
-        };
-    }
+
+//#region src/database/upsert-builder.ts
+function isRefField(field) {
+	return field !== undefined && field !== null && field?.of !== undefined && field?.uuid !== undefined;
 }
+var logger, UpsertBuilder;
+var init_upsert_builder = __esmMin((() => {
+	init_entity_manager();
+	init_naite();
+	init_utils();
+	init__batch_update();
+	logger = getLogger([
+		"sonamu",
+		"internal",
+		"upsert-builder"
+	]);
+	UpsertBuilder = class {
+		tables;
+		constructor() {
+			this.tables = new Map();
+		}
+		getTable(tableName) {
+			const table = this.tables.get(tableName);
+			if (table) {
+				return table;
+			}
+			const tableSpec = (() => {
+				try {
+					return EntityManager.getTableSpec(tableName);
+				} catch {
+					return null;
+				}
+			})();
+			const tableData = {
+				references: new Set(),
+				rows: [],
+				uniqueIndexes: tableSpec?.uniqueIndexes ?? [],
+				uniquesMap: new Map(),
+				jsonColumns: tableSpec?.jsonColumns ?? []
+			};
+			this.tables.set(tableName, tableData);
+			return tableData;
+		}
+		hasTable(tableName) {
+			return this.tables.has(tableName);
+		}
+		register(tableName, row) {
+			const table = this.getTable(tableName);
+			const uniqueKeys = table.uniqueIndexes.map((unqIndex) => {
+				const uniqueKeyArray = unqIndex.columns.map((unqCol) => {
+					const val = row[unqCol.name];
+					if (isRefField(val)) {
+						return val.uuid;
+					} else {
+						return row[unqCol.name] ?? randomUUID();
+					}
+				});
+				if (uniqueKeyArray.length === 0) {
+					return null;
+				}
+				return uniqueKeyArray.join("---delimiter--");
+			}).filter(nonNullable);
+			const { uuid, isReused } = (() => {
+				if (uniqueKeys.length > 0) {
+					for (const uniqueKey of uniqueKeys) {
+						if (table.uniquesMap.has(uniqueKey)) {
+							return {
+								uuid: assertDefined(table.uniquesMap.get(uniqueKey), "Unique key not found"),
+								isReused: true
+							};
+						}
+					}
+				}
+				return {
+					uuid: randomUUID(),
+					isReused: false
+				};
+			})();
+			if (uniqueKeys.length > 0) {
+				for (const uniqueKey of uniqueKeys) {
+					table.uniquesMap.set(uniqueKey, uuid);
+				}
+			}
+			row = Object.fromEntries(Object.entries(row).map(([rowKey, rowValue]) => {
+				if (isRefField(rowValue)) {
+					rowValue.use ??= "id";
+					table.references.add(`${rowValue.of}.${rowValue.use}`);
+					return [rowKey, rowValue];
+				} else if (table.jsonColumns.includes(rowKey) && rowValue !== null) {
+					return [rowKey, JSON.stringify(rowValue)];
+				} else if (isArray(rowValue)) {
+					return [rowKey, rowValue];
+				} else {
+					return [rowKey, rowValue];
+				}
+			}));
+			table.rows.push({
+				uuid,
+				...row
+			});
+			const result = {
+				of: tableName,
+				uuid: row.uuid ?? uuid
+			};
+			Naite.t("puri:ub-register", {
+				tableName,
+				uuid: result.uuid,
+				isUuidReused: isReused,
+				row
+			});
+			return result;
+		}
+		async upsert(wdb, tableName, options) {
+			return this.upsertOrInsert(wdb, tableName, "upsert", options);
+		}
+		async insertOnly(wdb, tableName, options) {
+			return this.upsertOrInsert(wdb, tableName, "insert", options);
+		}
+		async upsertOrInsert(wdb, tableName, mode, options) {
+			if (!this.hasTable(tableName)) {
+				return [];
+			}
+			const table = this.tables.get(tableName);
+			if (table === undefined) {
+				throw new Error(`존재하지 않는 테이블 ${tableName}에 upsert 요청`);
+			} else if (table.rows.length === 0) {
+				throw new Error(`${tableName}에 upsert 할 데이터가 없습니다.`);
+			}
+			if (table.rows.some((row) => Object.entries(row).some(([, value]) => isRefField(value) && value.of !== tableName))) {
+				throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
+			}
+			const { references, refTables } = Array.from(this.tables).reduce((r, [, table$1]) => {
+				const reference = Array.from(table$1.references.values()).find((ref) => ref.includes(`${tableName}.`));
+				if (reference) {
+					r.references.push(reference);
+					r.refTables.push(table$1);
+				}
+				return r;
+			}, {
+				references: [],
+				refTables: []
+			});
+			const extractFields = unique(references).map((reference) => reference.split(".")[1]).filter((field) => field !== undefined);
+			const { levels, hasCircular } = this.buildInsertLevels(table.rows, tableName);
+			if (hasCircular) {
+				throw new Error(`${tableName}에 순환 자기 참조가 있습니다.`);
+			}
+			const uuidMap = new Map();
+			const allIds = [];
+			for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {
+				const levelRows = levels[levelIdx];
+				logger.debug("Processing Query Level: {current} / {total}", {
+					current: levelIdx + 1,
+					total: levels.length
+				});
+				const resolvedRows = levelRows.map((row) => {
+					const resolved = { ...row };
+					for (const [key, value] of Object.entries(row)) {
+						if (isRefField(value) && value.of === tableName) {
+							const parent = uuidMap.get(value.uuid);
+							if (!parent) throw new Error(`존재하지 않는 uuid ${value.uuid} -- in ${tableName}`);
+							resolved[key] = parent[value.use ?? "id"];
+							Naite.t("puri:ub-ref-resolved", {
+								tableName,
+								field: key,
+								from: {
+									of: value.of,
+									uuid: value.uuid,
+									use: value.use ?? "id"
+								},
+								to: resolved[key]
+							});
+						}
+					}
+					return resolved;
+				});
+				const chunkSize = options?.chunkSize;
+				const levelChunks = chunkSize ? cluster(resolvedRows, chunkSize) : [resolvedRows];
+				const selectFields = unique(["id", ...extractFields]);
+				for (let index = 0; index < levelChunks.length; index++) {
+					const dataChunk = levelChunks[index];
+					if (dataChunk.length === 0) continue;
+					logger.debug("Processing Chunk: {current} / {total}", {
+						current: index + 1,
+						total: levelChunks.length
+					});
+					const originalUuids = dataChunk.map((r) => r.uuid);
+					const dataForDb = dataChunk.map(({ uuid, ...rest }) => rest);
+					let resultRows;
+					if (mode === "insert") {
+						resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
+					} else {
+						const rowsWithoutId = dataForDb.filter((row) => !row.id);
+						if (rowsWithoutId.length > 0 && table.uniqueIndexes.length > 0) {
+							for (const uniqueIndex of table.uniqueIndexes) {
+								const columns = uniqueIndex.columns.map((c) => c.name);
+								const conditions = [];
+								for (const row of rowsWithoutId) {
+									const values = columns.map((col) => row[col]);
+									if (!values.some((v) => v == null)) {
+										conditions.push(values);
+									}
+								}
+								if (conditions.length === 0) continue;
+								const existingRows = await wdb(tableName).whereIn(columns, conditions).select("id", ...columns);
+								const existingMap = new Map();
+								for (const existing of existingRows) {
+									const key = columns.map((col) => String(existing[col] ?? "")).join("---delimiter---");
+									const id = existing.id;
+									if (typeof id === "number" || typeof id === "string") {
+										existingMap.set(key, id);
+									}
+								}
+								for (const row of rowsWithoutId) {
+									if (row.id) continue;
+									const key = columns.map((col) => String(row[col] ?? "")).join("---delimiter---");
+									const existingId = existingMap.get(key);
+									if (existingId) {
+										row.id = existingId;
+									}
+								}
+							}
+						}
+						const conflictColumns = ["id"];
+						const allColumns = Object.keys(dataForDb[0]);
+						let updateColumns = allColumns.filter((c) => c !== "id");
+						if (options?.inherit?.length) {
+							const inheritColumns = options.inherit;
+							const excludedFromUpdate = updateColumns.filter((c) => inheritColumns.includes(c));
+							updateColumns = updateColumns.filter((c) => !inheritColumns.includes(c));
+							if (excludedFromUpdate.length) {
+								Naite.t("puri:ub-inherit", {
+									tableName,
+									inheritColumns,
+									excludedFromUpdate
+								});
+							}
+						}
+						const mergeColumns = updateColumns.length ? updateColumns : conflictColumns;
+						resultRows = await wdb.insert(dataForDb).into(tableName).onConflict(conflictColumns).merge(mergeColumns).returning(selectFields);
+					}
+					if (originalUuids.length !== resultRows.length) {
+						throw new Error(`${tableName}: register/returning 불일치`);
+					}
+					for (let i = 0; i < resultRows.length; i++) {
+						uuidMap.set(originalUuids[i], resultRows[i]);
+						allIds.push(resultRows[i].id);
+					}
+				}
+			}
+			for (const table$1 of refTables) {
+				table$1.rows = table$1.rows.map((row) => {
+					for (const key of Object.keys(row)) {
+						const prop = row[key];
+						if (isRefField(prop) && prop.of === tableName) {
+							const parent = uuidMap.get(prop.uuid);
+							if (!parent) {
+								console.error(prop);
+								throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);
+							}
+							const resolvedValue = parent[prop.use ?? "id"];
+							row[key] = resolvedValue;
+							Naite.t("puri:ub-ref-resolved", {
+								tableName,
+								field: key,
+								from: {
+									of: prop.of,
+									uuid: prop.uuid,
+									use: prop.use ?? "id"
+								},
+								to: resolvedValue
+							});
+						}
+					}
+					return row;
+				});
+			}
+			if (options?.cleanOrphans) {
+				const cleanOrphans = options.cleanOrphans;
+				const fkColumns = isArray(cleanOrphans) ? cleanOrphans : [cleanOrphans];
+				const fkConditions = fkColumns.map((fkCol) => {
+					const fkValues = [...new Set(table.rows.map((row) => row[fkCol]).filter((v) => v != null))];
+					return {
+						column: fkCol,
+						values: fkValues
+					};
+				});
+				if (fkConditions.every((fc) => fc.values.length > 0)) {
+					let deleteQuery = wdb(tableName);
+					for (const { column, values } of fkConditions) {
+						deleteQuery = deleteQuery.whereIn(column, values);
+					}
+					deleteQuery = deleteQuery.whereNotIn("id", allIds);
+					const deletedCount = await deleteQuery.delete();
+					Naite.t("puri:ub-clean-orphans", {
+						tableName,
+						cleanOrphans: fkColumns,
+						deletedCount
+					});
+				}
+			}
+			table.rows = [];
+			table.references.clear();
+			table.uniquesMap.clear();
+			Naite.t("puri:ub-upserted", {
+				tableName,
+				mode,
+				rowCount: allIds.length,
+				returnedIds: allIds
+			});
+			return allIds;
+		}
+		async updateBatch(wdb, tableName, options) {
+			options = {
+				...options,
+				chunkSize: options?.chunkSize ?? 500,
+				where: options?.where ?? "id"
+			};
+			if (!this.hasTable(tableName)) {
+				return;
+			}
+			const table = this.tables.get(tableName);
+			if (!table) {
+				throw new Error(`등록되지 않은 테이블 ${tableName}에 updateBatch 요청`);
+			} else if (table.rows.length === 0) {
+				return;
+			}
+			const whereColumns = Array.isArray(options.where) ? options.where : [options.where ?? "id"];
+			const rows = table.rows.map((_row) => {
+				const { uuid: _, ...row } = _row;
+				return row;
+			});
+			await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
+			Naite.t("puri:ub-batch-updated", {
+				tableName,
+				rowCount: rows.length,
+				whereColumns
+			});
+			table.rows = [];
+			table.references.clear();
+			table.uniquesMap.clear();
+		}
+		/**
+		* rows를 의존성 순서에 따라 레벨별로 그룹화
+		* - 자기 참조 없는 경우 : 모든 rows가 Level 0
+		* - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화
+		*/
+		buildInsertLevels(rows, tableName) {
+			const hasSelfRef = rows.flatMap((row) => Object.values(row)).some((value) => isRefField(value) && value.of === tableName);
+			if (!hasSelfRef) return {
+				levels: [rows],
+				hasCircular: false
+			};
+			const rowByUuid = new Map();
+			for (const row of rows) {
+				const uuid = row.uuid;
+				if (!uuid) throw new Error(`buildInsertLevels: uuid가 없는 row -- in ${tableName}`);
+				rowByUuid.set(uuid, row);
+			}
+			let pending = Array.from(rowByUuid.values());
+			const levels = [];
+			const inserted = new Set();
+			while (pending.length > 0) {
+				const currentLevel = [];
+				const nextPending = [];
+				for (const row of pending) {
+					const selfRefs = Object.values(row).filter((value) => isRefField(value) && value.of === tableName);
+					const canInsert = selfRefs.every((ref) => {
+						if (!rowByUuid.has(ref.uuid)) {
+							throw new Error(`존재하지 않는 uuid ${ref.uuid} -- in ${tableName}`);
+						}
+						return inserted.has(ref.uuid);
+					});
+					if (canInsert) {
+						currentLevel.push(row);
+					} else {
+						nextPending.push(row);
+					}
+				}
+				if (currentLevel.length === 0) return {
+					levels: [],
+					hasCircular: true
+				};
+				levels.push(currentLevel);
+				for (const row of currentLevel) {
+					inserted.add(row.uuid);
+				}
+				pending = nextPending;
+			}
+			return {
+				levels,
+				hasCircular: false
+			};
+		}
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/upsert-builder.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport { randomUUID } from \"crypto\";\nimport type { Knex } from \"knex\";\nimport { isArray, unique } from \"radashi\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport type { DatabaseForeignKeys, DatabaseSchemaExtend, EntityIndex } from \"../types/types\";\nimport { assertDefined, chunk, nonNullable } from \"../utils/utils\";\nimport { batchUpdate, type RowWithId } from \"./_batch_update\";\nimport type { ColumnKeys, ForeignKeyColumns, IdType, TableName } from \"./puri.types\";\n\nconst logger = getLogger([\"sonamu\", \"internal\", \"upsert-builder\"]);\n\n/**\n * FK 타입 추론을 위해 DatabaseForeignKeys export\n * (module augmentation 자동 로드 보장)\n */\nexport type { DatabaseForeignKeys };\n\ntype InheritableColumns<TTable extends TableName<DatabaseSchemaExtend>> =\n  TTable extends keyof DatabaseSchemaExtend ? ColumnKeys<DatabaseSchemaExtend[TTable]> : never;\n\n// 테이블 데이터 타입\ntype TableData = {\n  references: Set<string>;\n  rows: Record<string, unknown>[];\n  uniqueIndexes: EntityIndex[];\n  uniquesMap: Map<string, string>;\n  jsonColumns: string[];\n};\n\n// 참조 필드 타입\nexport type UBRef = {\n  uuid: string;\n  of: string;\n  use?: string;\n};\n\n// upsert 옵션\nexport type UpsertOptions<TTable extends TableName<DatabaseSchemaExtend>> = {\n  chunkSize?: number;\n  cleanOrphans?: ForeignKeyColumns<TTable> | ForeignKeyColumns<TTable>[];\n  inherit?: InheritableColumns<TTable>[];\n};\n\n// insertOnly 옵션\nexport type InsertOnlyOptions = {\n  chunkSize?: number;\n};\n\nexport function isRefField(field: unknown): field is UBRef {\n  return (\n    field !== undefined &&\n    field !== null &&\n    (field as UBRef)?.of !== undefined &&\n    (field as UBRef)?.uuid !== undefined\n  );\n}\n\nexport class UpsertBuilder {\n  tables: Map<string, TableData>;\n  constructor() {\n    this.tables = new Map();\n  }\n\n  getTable(tableName: string): TableData {\n    const table = this.tables.get(tableName);\n    if (table) {\n      return table;\n    }\n\n    const tableSpec = (() => {\n      try {\n        return EntityManager.getTableSpec(tableName);\n      } catch {\n        return null;\n      }\n    })();\n\n    const tableData = {\n      references: new Set<string>(),\n      rows: [],\n      uniqueIndexes: tableSpec?.uniqueIndexes ?? [],\n      uniquesMap: new Map<string, string>(),\n      jsonColumns: tableSpec?.jsonColumns ?? [],\n    };\n    this.tables.set(tableName, tableData);\n    return tableData;\n  }\n\n  hasTable(tableName: string): boolean {\n    return this.tables.has(tableName);\n  }\n\n  register<T extends string>(\n    tableName: string,\n    row: {\n      [key in T]?: UBRef | string | number | boolean | bigint | null | object | unknown;\n    },\n  ): UBRef {\n    const table = this.getTable(tableName);\n\n    // 해당 테이블의 unique 인덱스를 순회하며 키 생성\n    const uniqueKeys = table.uniqueIndexes\n      .map((unqIndex) => {\n        const uniqueKeyArray = unqIndex.columns.map((unqCol) => {\n          const val = row[unqCol.name as keyof typeof row];\n          if (isRefField(val)) {\n            return val.uuid;\n          } else {\n            return row[unqCol.name as keyof typeof row] ?? randomUUID(); // nullable인 경우 uuid로 랜덤값 삽입\n          }\n        });\n\n        // 값이 모두 null인 경우 키 생성 패스\n        if (uniqueKeyArray.length === 0) {\n          return null;\n        }\n        return uniqueKeyArray.join(\"---delimiter--\");\n      })\n      .filter(nonNullable);\n\n    // uuid 생성 로직\n    const { uuid, isReused } = (() => {\n      // 키를 순회하여 이미 존재하는 키가 있는지 확인\n      if (uniqueKeys.length > 0) {\n        for (const uniqueKey of uniqueKeys) {\n          if (table.uniquesMap.has(uniqueKey)) {\n            return {\n              uuid: assertDefined(table.uniquesMap.get(uniqueKey), \"Unique key not found\"),\n              isReused: true,\n            };\n          }\n        }\n      }\n\n      // 찾을 수 없는 경우 생성\n      return { uuid: randomUUID(), isReused: false };\n    })();\n\n    // 모든 유니크키에 대해 유니크맵에 uuid 저장\n    if (uniqueKeys.length > 0) {\n      for (const uniqueKey of uniqueKeys) {\n        table.uniquesMap.set(uniqueKey, uuid);\n      }\n    }\n\n    // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가\n    // 이 정보를 나중에 치환할 때 사용\n    row = Object.fromEntries(\n      Object.entries(row).map(([rowKey, rowValue]) => {\n        if (isRefField(rowValue)) {\n          rowValue.use ??= \"id\";\n          table.references.add(`${rowValue.of}.${rowValue.use}`);\n          return [rowKey, rowValue];\n        } else if (table.jsonColumns.includes(rowKey) && rowValue !== null) {\n          // JSON 컬럼인 경우 JSON.stringify 처리 (Knex는 JSON 타입을 지원하지 않음)\n          return [rowKey, JSON.stringify(rowValue)];\n        } else if (isArray(rowValue)) {\n          // 배열은 그대로 저장\n          return [rowKey, rowValue];\n        } else {\n          return [rowKey, rowValue];\n        }\n      }),\n    ) as { [key in T]?: unknown };\n\n    table.rows.push({\n      uuid,\n      ...row,\n    });\n\n    const result: UBRef = {\n      of: tableName,\n      uuid: (row as { uuid?: string }).uuid ?? uuid,\n    };\n\n    Naite.t(\"puri:ub-register\", {\n      tableName,\n      uuid: result.uuid,\n      isUuidReused: isReused,\n      row,\n    });\n\n    return result;\n  }\n\n  async upsert<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    options?: UpsertOptions<TTable>,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    return this.upsertOrInsert(wdb, tableName, \"upsert\", options);\n  }\n\n  async insertOnly<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    options?: InsertOnlyOptions,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    return this.upsertOrInsert(wdb, tableName, \"insert\", options);\n  }\n\n  async upsertOrInsert<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    mode: \"upsert\" | \"insert\",\n    options?: UpsertOptions<TTable>,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    if (this.hasTable(tableName) === false) {\n      return [];\n    }\n\n    const table = this.tables.get(tableName);\n    if (table === undefined) {\n      throw new Error(`존재하지 않는 테이블 ${tableName}에 upsert 요청`);\n    } else if (table.rows.length === 0) {\n      throw new Error(`${tableName}에 upsert 할 데이터가 없습니다.`);\n    }\n\n    if (\n      table.rows.some((row) =>\n        Object.entries(row).some(([, value]) => isRefField(value) && value.of !== tableName),\n      )\n    ) {\n      throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);\n    }\n\n    // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출\n    const { references, refTables } = Array.from(this.tables).reduce(\n      (r, [, table]) => {\n        const reference = Array.from(table.references.values()).find((ref) =>\n          ref.includes(`${tableName}.`),\n        );\n        if (reference) {\n          r.references.push(reference);\n          r.refTables.push(table);\n        }\n\n        return r;\n      },\n      {\n        references: [] as string[],\n        refTables: [] as TableData[],\n      },\n    );\n    const extractFields = unique(references)\n      .map((reference) => reference.split(\".\")[1])\n      .filter((field): field is string => field !== undefined);\n\n    // 의존성 순서에 따라 레벨별 그룹화 (자기 참조가 없으면 Level 0 하나)\n    const { levels, hasCircular } = this.buildInsertLevels(table.rows, tableName);\n\n    if (hasCircular) {\n      throw new Error(`${tableName}에 순환 자기 참조가 있습니다.`);\n    }\n\n    const uuidMap = new Map<string, unknown>();\n    const allIds: (number | string)[] = [];\n\n    // 레벨별로 순차 처리\n    for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {\n      const levelRows = levels[levelIdx];\n      logger.debug(\"Processing Query Level: {current} / {total}\", {\n        current: levelIdx + 1,\n        total: levels.length,\n      });\n\n      // 이전 레벨에서 얻은 ID로 자기 참조 해결\n      const resolvedRows = levelRows.map((row) => {\n        const resolved = { ...row };\n        for (const [key, value] of Object.entries(row)) {\n          if (isRefField(value) && value.of === tableName) {\n            const parent = uuidMap.get(value.uuid);\n\n            if (!parent) throw new Error(`존재하지 않는 uuid ${value.uuid} -- in ${tableName}`);\n\n            resolved[key] = (parent as Record<string, unknown>)[value.use ?? \"id\"];\n\n            Naite.t(\"puri:ub-ref-resolved\", {\n              tableName,\n              field: key,\n              from: { of: value.of, uuid: value.uuid, use: value.use ?? \"id\" },\n              to: resolved[key],\n            });\n          }\n        }\n        return resolved;\n      });\n\n      // 현재 레벨 upsert\n      const chunkSize = options?.chunkSize;\n      const levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [resolvedRows];\n      const selectFields = unique([\"id\", ...extractFields]);\n\n      for (let index = 0; index < levelChunks.length; index++) {\n        const dataChunk = levelChunks[index];\n        if (dataChunk.length === 0) continue;\n        logger.debug(\"Processing Chunk: {current} / {total}\", {\n          current: index + 1,\n          total: levelChunks.length,\n        });\n\n        // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거\n        const originalUuids = dataChunk.map((r) => r.uuid as string);\n        const dataForDb = dataChunk.map(({ uuid, ...rest }) => rest);\n\n        let resultRows: { id: number | string; [key: string]: unknown }[];\n\n        if (mode === \"insert\") {\n          // INSERT 모드 - RETURNING 사용\n          resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);\n        } else {\n          // UPSERT 모드 - id 없는 row들의 id를 사전 조회로 채우기\n          const rowsWithoutId = dataForDb.filter((row) => !row.id);\n\n          if (rowsWithoutId.length > 0 && table.uniqueIndexes.length > 0) {\n            // 모든 uniqueIndexes로 기존 레코드 조회\n            for (const uniqueIndex of table.uniqueIndexes) {\n              const columns = uniqueIndex.columns.map((c) => c.name);\n\n              // 조회할 조건들 추출 (각 row의 unique 컬럼 값들)\n              const conditions: unknown[][] = [];\n              for (const row of rowsWithoutId) {\n                const values = columns.map((col) => row[col]);\n                // null이 포함된 조건은 제외 (PostgreSQL UNIQUE는 NULL 무시)\n                if (!values.some((v) => v == null)) {\n                  conditions.push(values);\n                }\n              }\n\n              if (conditions.length === 0) continue;\n\n              // 배치 SELECT\n              const existingRows = (await wdb(tableName)\n                .whereIn(columns, conditions as Record<string, unknown>[][])\n                .select(\"id\", ...columns)) as Record<string, unknown>[];\n\n              // Map 생성: unique 컬럼 조합 → id\n              const existingMap = new Map<string, number | string>();\n              for (const existing of existingRows) {\n                const key = columns\n                  .map((col) => String(existing[col] ?? \"\"))\n                  .join(\"---delimiter---\");\n                const id = existing.id;\n                if (typeof id === \"number\" || typeof id === \"string\") {\n                  existingMap.set(key, id);\n                }\n              }\n\n              // id 없는 row들에 매칭되는 id 채우기\n              for (const row of rowsWithoutId) {\n                if (row.id) continue; // 이미 다른 uniqueIndex에서 채워진 경우 스킵\n\n                const key = columns.map((col) => String(row[col] ?? \"\")).join(\"---delimiter---\");\n                const existingId = existingMap.get(key);\n\n                if (existingId) {\n                  row.id = existingId;\n                }\n              }\n            }\n          }\n\n          // onConflict는 id만 사용 (모든 uniqueIndexes는 이미 사전 조회로 처리됨)\n          const conflictColumns = [\"id\"];\n\n          const allColumns = Object.keys(dataForDb[0]);\n          let updateColumns = allColumns.filter((c) => c !== \"id\");\n\n          // inherit 옵션 처리 - inherit 컬럼은 update 대상에서 제외\n          if (options?.inherit?.length) {\n            const inheritColumns = options.inherit as string[];\n\n            const excludedFromUpdate = updateColumns.filter((c) => inheritColumns.includes(c));\n            updateColumns = updateColumns.filter((c) => !inheritColumns.includes(c));\n\n            // 실제로 제외된 컬럼 로깅\n            if (excludedFromUpdate.length) {\n              Naite.t(\"puri:ub-inherit\", {\n                tableName,\n                inheritColumns,\n                excludedFromUpdate,\n              });\n            }\n          }\n\n          // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장\n          const mergeColumns = updateColumns.length ? updateColumns : conflictColumns;\n\n          resultRows = await wdb\n            .insert(dataForDb)\n            .into(tableName)\n            .onConflict(conflictColumns)\n            .merge(mergeColumns)\n            .returning(selectFields);\n        }\n\n        if (originalUuids.length !== resultRows.length) {\n          throw new Error(`${tableName}: register/returning 불일치`);\n        }\n\n        for (let i = 0; i < resultRows.length; i++) {\n          uuidMap.set(originalUuids[i], resultRows[i]);\n          allIds.push(resultRows[i].id);\n        }\n      }\n    }\n\n    // 해당 테이블 참조를 실제 밸류로 변경\n    for (const table of refTables) {\n      table.rows = table.rows.map((row) => {\n        for (const key of Object.keys(row)) {\n          const prop = row[key];\n          if (isRefField(prop) && prop.of === tableName) {\n            const parent = uuidMap.get(prop.uuid);\n            if (!parent) {\n              console.error(prop);\n              throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);\n            }\n            const resolvedValue = (parent as Record<string, unknown>)[prop.use ?? \"id\"];\n            row[key] = resolvedValue;\n\n            Naite.t(\"puri:ub-ref-resolved\", {\n              tableName,\n              field: key,\n              from: { of: prop.of, uuid: prop.uuid, use: prop.use ?? \"id\" },\n              to: resolvedValue,\n            });\n          }\n        }\n        return row;\n      });\n    }\n\n    if (options?.cleanOrphans) {\n      const cleanOrphans = options.cleanOrphans;\n      const fkColumns = isArray(cleanOrphans)\n        ? (cleanOrphans as ForeignKeyColumns<TTable>[])\n        : [cleanOrphans as ForeignKeyColumns<TTable>];\n\n      // 현재 register된 레코드들의 FK 값들 추출\n      const fkConditions = fkColumns.map((fkCol) => {\n        const fkValues = [...new Set(table.rows.map((row) => row[fkCol]).filter((v) => v != null))];\n        return { column: fkCol, values: fkValues };\n      });\n\n      // 모든 FK 컬럼에 값이 있는 경우에만 삭제 실행\n      if (fkConditions.every((fc) => fc.values.length > 0)) {\n        let deleteQuery = wdb(tableName);\n\n        // 각 FK 컬럼에 대한 WHERE IN 조건 추가\n        for (const { column, values } of fkConditions) {\n          deleteQuery = deleteQuery.whereIn(column, values);\n        }\n\n        // 방금 upsert한 ID는 제외\n        deleteQuery = deleteQuery.whereNotIn(\"id\", allIds);\n\n        const deletedCount = await deleteQuery.delete();\n\n        Naite.t(\"puri:ub-clean-orphans\", {\n          tableName,\n          cleanOrphans: fkColumns,\n          deletedCount,\n        });\n      }\n    }\n\n    // 해당 테이블의 데이터 초기화\n    table.rows = [];\n    table.references.clear();\n    table.uniquesMap.clear();\n\n    Naite.t(\"puri:ub-upserted\", {\n      tableName,\n      mode,\n      rowCount: allIds.length,\n      returnedIds: allIds,\n    });\n\n    return allIds as IdType<DatabaseSchemaExtend, TTable>[];\n  }\n\n  async updateBatch(\n    wdb: Knex,\n    tableName: string,\n    options?: {\n      chunkSize?: number;\n      where?: string | string[];\n    },\n  ): Promise<void> {\n    options = {\n      ...options,\n      chunkSize: options?.chunkSize ?? 500,\n      where: options?.where ?? \"id\",\n    };\n\n    if (this.hasTable(tableName) === false) {\n      return;\n    }\n    const table = this.tables.get(tableName);\n    if (!table) {\n      throw new Error(`등록되지 않은 테이블 ${tableName}에 updateBatch 요청`);\n    } else if (table.rows.length === 0) {\n      return;\n    }\n\n    const whereColumns = Array.isArray(options.where) ? options.where : [options.where ?? \"id\"];\n    const rows = table.rows.map((_row) => {\n      const { uuid: _, ...row } = _row; // uuid 제외\n      return row as RowWithId<string>;\n    });\n\n    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);\n\n    Naite.t(\"puri:ub-batch-updated\", {\n      tableName,\n      rowCount: rows.length,\n      whereColumns,\n    });\n\n    // updateBatch 완료 후 처리된 데이터 제거\n    table.rows = [];\n    table.references.clear();\n    table.uniquesMap.clear();\n  }\n\n  // ============================================================================\n  // Private Helper Methods\n  // ============================================================================\n\n  /**\n   * rows를 의존성 순서에 따라 레벨별로 그룹화\n   * - 자기 참조 없는 경우 : 모든 rows가 Level 0\n   * - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화\n   */\n  private buildInsertLevels(\n    rows: Record<string, unknown>[],\n    tableName: string,\n  ): { levels: Record<string, unknown>[][]; hasCircular: boolean } {\n    // 1. 자기 참조가 없으면 한 레벨로 처리\n    const hasSelfRef = rows\n      .flatMap((row) => Object.values(row))\n      .some((value) => isRefField(value) && value.of === tableName);\n    if (!hasSelfRef) return { levels: [rows], hasCircular: false };\n\n    // 2. uuid → row 매핑 (중복 uuid 방지)\n    const rowByUuid = new Map<string, Record<string, unknown>>();\n    for (const row of rows) {\n      const uuid = row.uuid as string | undefined;\n      if (!uuid) throw new Error(`buildInsertLevels: uuid가 없는 row -- in ${tableName}`);\n      rowByUuid.set(uuid, row);\n    }\n\n    let pending = Array.from(rowByUuid.values());\n    const levels: Record<string, unknown>[][] = [];\n    const inserted = new Set<string>();\n\n    // 3. 레벨별 분류\n    while (pending.length > 0) {\n      const currentLevel: Record<string, unknown>[] = [];\n      const nextPending: Record<string, unknown>[] = [];\n\n      for (const row of pending) {\n        // 이 row가 참조하는 자기 참조들\n        const selfRefs = Object.values(row).filter(\n          (value) => isRefField(value) && value.of === tableName,\n        ) as UBRef[];\n\n        // 참조하는 모든 uuid가 이미 inserted에 있어야 이번 레벨에 포함\n        const canInsert = selfRefs.every((ref) => {\n          if (!rowByUuid.has(ref.uuid)) {\n            throw new Error(`존재하지 않는 uuid ${ref.uuid} -- in ${tableName}`);\n          }\n          return inserted.has(ref.uuid);\n        });\n\n        if (canInsert) {\n          currentLevel.push(row);\n        } else {\n          nextPending.push(row);\n        }\n      }\n\n      // 순환 참조 감지\n      if (currentLevel.length === 0) return { levels: [], hasCircular: true };\n\n      // 레벨 확정 + inserted 갱신\n      levels.push(currentLevel);\n      for (const row of currentLevel) {\n        inserted.add(row.uuid as string);\n      }\n\n      pending = nextPending;\n    }\n\n    return { levels, hasCircular: false };\n  }\n}\n"],"names":["getLogger","randomUUID","isArray","unique","EntityManager","Naite","assertDefined","chunk","nonNullable","batchUpdate","logger","isRefField","field","undefined","of","uuid","UpsertBuilder","tables","Map","getTable","tableName","table","get","tableSpec","getTableSpec","tableData","references","Set","rows","uniqueIndexes","uniquesMap","jsonColumns","set","hasTable","has","register","row","uniqueKeys","map","unqIndex","uniqueKeyArray","columns","unqCol","val","name","length","join","filter","isReused","uniqueKey","Object","fromEntries","entries","rowKey","rowValue","use","add","includes","JSON","stringify","push","result","t","isUuidReused","upsert","wdb","options","upsertOrInsert","insertOnly","mode","Error","some","value","refTables","Array","from","reduce","r","reference","values","find","ref","extractFields","split","levels","hasCircular","buildInsertLevels","uuidMap","allIds","levelIdx","levelRows","debug","current","total","resolvedRows","resolved","key","parent","to","chunkSize","levelChunks","selectFields","index","dataChunk","originalUuids","dataForDb","rest","resultRows","insert","into","returning","rowsWithoutId","id","uniqueIndex","c","conditions","col","v","existingRows","whereIn","select","existingMap","existing","String","existingId","conflictColumns","allColumns","keys","updateColumns","inherit","inheritColumns","excludedFromUpdate","mergeColumns","onConflict","merge","i","prop","console","error","resolvedValue","cleanOrphans","fkColumns","fkConditions","fkCol","fkValues","column","every","fc","deleteQuery","whereNotIn","deletedCount","delete","clear","rowCount","returnedIds","updateBatch","where","whereColumns","_row","_","hasSelfRef","flatMap","rowByUuid","pending","inserted","currentLevel","nextPending","selfRefs","canInsert"],"mappings":"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"}
+//#endregion
+init_upsert_builder();
+export { UpsertBuilder, init_upsert_builder, isRefField };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"upsert-builder.js","names":["result: UBRef","table","allIds: (number | string)[]","resultRows: { id: number | string; [key: string]: unknown }[]","conditions: unknown[][]","levels: Record<string, unknown>[][]","currentLevel: Record<string, unknown>[]","nextPending: Record<string, unknown>[]"],"sources":["../../src/database/upsert-builder.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { type Knex } from \"knex\";\nimport { cluster, isArray, unique } from \"radashi\";\n\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport {\n  type DatabaseForeignKeys,\n  type DatabaseSchemaExtend,\n  type EntityIndex,\n} from \"../types/types\";\nimport { assertDefined, nonNullable } from \"../utils/utils\";\nimport { batchUpdate } from \"./_batch_update\";\nimport { type RowWithId } from \"./_batch_update\";\nimport { type ColumnKeys, type ForeignKeyColumns, type IdType, type TableName } from \"./puri.types\";\n\nconst logger = getLogger([\"sonamu\", \"internal\", \"upsert-builder\"]);\n\n/**\n * FK 타입 추론을 위해 DatabaseForeignKeys export\n * (module augmentation 자동 로드 보장)\n */\nexport type { DatabaseForeignKeys };\n\ntype InheritableColumns<TTable extends TableName<DatabaseSchemaExtend>> =\n  TTable extends keyof DatabaseSchemaExtend ? ColumnKeys<DatabaseSchemaExtend[TTable]> : never;\n\n// 테이블 데이터 타입\ntype TableData = {\n  references: Set<string>;\n  rows: Record<string, unknown>[];\n  uniqueIndexes: EntityIndex[];\n  uniquesMap: Map<string, string>;\n  jsonColumns: string[];\n};\n\n// 참조 필드 타입\nexport type UBRef = {\n  uuid: string;\n  of: string;\n  use?: string;\n};\n\n// upsert 옵션\nexport type UpsertOptions<TTable extends TableName<DatabaseSchemaExtend>> = {\n  chunkSize?: number;\n  cleanOrphans?: ForeignKeyColumns<TTable> | ForeignKeyColumns<TTable>[];\n  inherit?: InheritableColumns<TTable>[];\n};\n\n// insertOnly 옵션\nexport type InsertOnlyOptions = {\n  chunkSize?: number;\n};\n\nexport function isRefField(field: unknown): field is UBRef {\n  return (\n    field !== undefined &&\n    field !== null &&\n    (field as UBRef)?.of !== undefined &&\n    (field as UBRef)?.uuid !== undefined\n  );\n}\n\nexport class UpsertBuilder {\n  tables: Map<string, TableData>;\n  constructor() {\n    this.tables = new Map();\n  }\n\n  getTable(tableName: string): TableData {\n    const table = this.tables.get(tableName);\n    if (table) {\n      return table;\n    }\n\n    const tableSpec = (() => {\n      try {\n        return EntityManager.getTableSpec(tableName);\n      } catch {\n        return null;\n      }\n    })();\n\n    const tableData = {\n      references: new Set<string>(),\n      rows: [],\n      uniqueIndexes: tableSpec?.uniqueIndexes ?? [],\n      uniquesMap: new Map<string, string>(),\n      jsonColumns: tableSpec?.jsonColumns ?? [],\n    };\n    this.tables.set(tableName, tableData);\n    return tableData;\n  }\n\n  hasTable(tableName: string): boolean {\n    return this.tables.has(tableName);\n  }\n\n  register<T extends string>(\n    tableName: string,\n    row: {\n      [key in T]?: UBRef | string | number | boolean | bigint | null | object | unknown;\n    },\n  ): UBRef {\n    const table = this.getTable(tableName);\n\n    // 해당 테이블의 unique 인덱스를 순회하며 키 생성\n    const uniqueKeys = table.uniqueIndexes\n      .map((unqIndex) => {\n        const uniqueKeyArray = unqIndex.columns.map((unqCol) => {\n          const val = row[unqCol.name as keyof typeof row];\n          if (isRefField(val)) {\n            return val.uuid;\n          } else {\n            return row[unqCol.name as keyof typeof row] ?? randomUUID(); // nullable인 경우 uuid로 랜덤값 삽입\n          }\n        });\n\n        // 값이 모두 null인 경우 키 생성 패스\n        if (uniqueKeyArray.length === 0) {\n          return null;\n        }\n        return uniqueKeyArray.join(\"---delimiter--\");\n      })\n      .filter(nonNullable);\n\n    // uuid 생성 로직\n    const { uuid, isReused } = (() => {\n      // 키를 순회하여 이미 존재하는 키가 있는지 확인\n      if (uniqueKeys.length > 0) {\n        for (const uniqueKey of uniqueKeys) {\n          if (table.uniquesMap.has(uniqueKey)) {\n            return {\n              uuid: assertDefined(table.uniquesMap.get(uniqueKey), \"Unique key not found\"),\n              isReused: true,\n            };\n          }\n        }\n      }\n\n      // 찾을 수 없는 경우 생성\n      return { uuid: randomUUID(), isReused: false };\n    })();\n\n    // 모든 유니크키에 대해 유니크맵에 uuid 저장\n    if (uniqueKeys.length > 0) {\n      for (const uniqueKey of uniqueKeys) {\n        table.uniquesMap.set(uniqueKey, uuid);\n      }\n    }\n\n    // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가\n    // 이 정보를 나중에 치환할 때 사용\n    row = Object.fromEntries(\n      Object.entries(row).map(([rowKey, rowValue]) => {\n        if (isRefField(rowValue)) {\n          rowValue.use ??= \"id\";\n          table.references.add(`${rowValue.of}.${rowValue.use}`);\n          return [rowKey, rowValue];\n        } else if (table.jsonColumns.includes(rowKey) && rowValue !== null) {\n          // JSON 컬럼인 경우 JSON.stringify 처리 (Knex는 JSON 타입을 지원하지 않음)\n          return [rowKey, JSON.stringify(rowValue)];\n        } else if (isArray(rowValue)) {\n          // 배열은 그대로 저장\n          return [rowKey, rowValue];\n        } else {\n          return [rowKey, rowValue];\n        }\n      }),\n    ) as { [key in T]?: unknown };\n\n    table.rows.push({\n      uuid,\n      ...row,\n    });\n\n    const result: UBRef = {\n      of: tableName,\n      uuid: (row as { uuid?: string }).uuid ?? uuid,\n    };\n\n    Naite.t(\"puri:ub-register\", {\n      tableName,\n      uuid: result.uuid,\n      isUuidReused: isReused,\n      row,\n    });\n\n    return result;\n  }\n\n  async upsert<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    options?: UpsertOptions<TTable>,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    return this.upsertOrInsert(wdb, tableName, \"upsert\", options);\n  }\n\n  async insertOnly<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    options?: InsertOnlyOptions,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    return this.upsertOrInsert(wdb, tableName, \"insert\", options);\n  }\n\n  async upsertOrInsert<TTable extends TableName<DatabaseSchemaExtend>>(\n    wdb: Knex,\n    tableName: TTable,\n    mode: \"upsert\" | \"insert\",\n    options?: UpsertOptions<TTable>,\n  ): Promise<IdType<DatabaseSchemaExtend, TTable>[]> {\n    if (!this.hasTable(tableName)) {\n      return [];\n    }\n\n    const table = this.tables.get(tableName);\n    if (table === undefined) {\n      throw new Error(`존재하지 않는 테이블 ${tableName}에 upsert 요청`);\n    } else if (table.rows.length === 0) {\n      throw new Error(`${tableName}에 upsert 할 데이터가 없습니다.`);\n    }\n\n    if (\n      table.rows.some((row) =>\n        Object.entries(row).some(([, value]) => isRefField(value) && value.of !== tableName),\n      )\n    ) {\n      throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);\n    }\n\n    // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출\n    const { references, refTables } = Array.from(this.tables).reduce(\n      (r, [, table]) => {\n        const reference = Array.from(table.references.values()).find((ref) =>\n          ref.includes(`${tableName}.`),\n        );\n        if (reference) {\n          r.references.push(reference);\n          r.refTables.push(table);\n        }\n\n        return r;\n      },\n      {\n        references: [] as string[],\n        refTables: [] as TableData[],\n      },\n    );\n    const extractFields = unique(references)\n      .map((reference) => reference.split(\".\")[1])\n      .filter((field): field is string => field !== undefined);\n\n    // 의존성 순서에 따라 레벨별 그룹화 (자기 참조가 없으면 Level 0 하나)\n    const { levels, hasCircular } = this.buildInsertLevels(table.rows, tableName);\n\n    if (hasCircular) {\n      throw new Error(`${tableName}에 순환 자기 참조가 있습니다.`);\n    }\n\n    const uuidMap = new Map<string, unknown>();\n    const allIds: (number | string)[] = [];\n\n    // 레벨별로 순차 처리\n    for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {\n      const levelRows = levels[levelIdx];\n      logger.debug(\"Processing Query Level: {current} / {total}\", {\n        current: levelIdx + 1,\n        total: levels.length,\n      });\n\n      // 이전 레벨에서 얻은 ID로 자기 참조 해결\n      const resolvedRows = levelRows.map((row) => {\n        const resolved = { ...row };\n        for (const [key, value] of Object.entries(row)) {\n          if (isRefField(value) && value.of === tableName) {\n            const parent = uuidMap.get(value.uuid);\n\n            if (!parent) throw new Error(`존재하지 않는 uuid ${value.uuid} -- in ${tableName}`);\n\n            resolved[key] = (parent as Record<string, unknown>)[value.use ?? \"id\"];\n\n            Naite.t(\"puri:ub-ref-resolved\", {\n              tableName,\n              field: key,\n              from: { of: value.of, uuid: value.uuid, use: value.use ?? \"id\" },\n              to: resolved[key],\n            });\n          }\n        }\n        return resolved;\n      });\n\n      // 현재 레벨 upsert\n      const chunkSize = options?.chunkSize;\n      const levelChunks = chunkSize ? cluster(resolvedRows, chunkSize) : [resolvedRows];\n      const selectFields = unique([\"id\", ...extractFields]);\n\n      for (let index = 0; index < levelChunks.length; index++) {\n        const dataChunk = levelChunks[index];\n        if (dataChunk.length === 0) continue;\n        logger.debug(\"Processing Chunk: {current} / {total}\", {\n          current: index + 1,\n          total: levelChunks.length,\n        });\n\n        // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거\n        const originalUuids = dataChunk.map((r) => r.uuid as string);\n        const dataForDb = dataChunk.map(({ uuid, ...rest }) => rest);\n\n        let resultRows: { id: number | string; [key: string]: unknown }[];\n\n        if (mode === \"insert\") {\n          // INSERT 모드 - RETURNING 사용\n          resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);\n        } else {\n          // UPSERT 모드 - id 없는 row들의 id를 사전 조회로 채우기\n          const rowsWithoutId = dataForDb.filter((row) => !row.id);\n\n          if (rowsWithoutId.length > 0 && table.uniqueIndexes.length > 0) {\n            // 모든 uniqueIndexes로 기존 레코드 조회\n            for (const uniqueIndex of table.uniqueIndexes) {\n              const columns = uniqueIndex.columns.map((c) => c.name);\n\n              // 조회할 조건들 추출 (각 row의 unique 컬럼 값들)\n              const conditions: unknown[][] = [];\n              for (const row of rowsWithoutId) {\n                const values = columns.map((col) => row[col]);\n                // null이 포함된 조건은 제외 (PostgreSQL UNIQUE는 NULL 무시)\n                if (!values.some((v) => v == null)) {\n                  conditions.push(values);\n                }\n              }\n\n              if (conditions.length === 0) continue;\n\n              // 배치 SELECT\n              const existingRows = (await wdb(tableName)\n                .whereIn(columns, conditions as Record<string, unknown>[][])\n                .select(\"id\", ...columns)) as Record<string, unknown>[];\n\n              // Map 생성: unique 컬럼 조합 → id\n              const existingMap = new Map<string, number | string>();\n              for (const existing of existingRows) {\n                const key = columns\n                  .map((col) => String(existing[col] ?? \"\"))\n                  .join(\"---delimiter---\");\n                const id = existing.id;\n                if (typeof id === \"number\" || typeof id === \"string\") {\n                  existingMap.set(key, id);\n                }\n              }\n\n              // id 없는 row들에 매칭되는 id 채우기\n              for (const row of rowsWithoutId) {\n                if (row.id) continue; // 이미 다른 uniqueIndex에서 채워진 경우 스킵\n\n                const key = columns.map((col) => String(row[col] ?? \"\")).join(\"---delimiter---\");\n                const existingId = existingMap.get(key);\n\n                if (existingId) {\n                  row.id = existingId;\n                }\n              }\n            }\n          }\n\n          // onConflict는 id만 사용 (모든 uniqueIndexes는 이미 사전 조회로 처리됨)\n          const conflictColumns = [\"id\"];\n\n          const allColumns = Object.keys(dataForDb[0]);\n          let updateColumns = allColumns.filter((c) => c !== \"id\");\n\n          // inherit 옵션 처리 - inherit 컬럼은 update 대상에서 제외\n          if (options?.inherit?.length) {\n            const inheritColumns = options.inherit as string[];\n\n            const excludedFromUpdate = updateColumns.filter((c) => inheritColumns.includes(c));\n            updateColumns = updateColumns.filter((c) => !inheritColumns.includes(c));\n\n            // 실제로 제외된 컬럼 로깅\n            if (excludedFromUpdate.length) {\n              Naite.t(\"puri:ub-inherit\", {\n                tableName,\n                inheritColumns,\n                excludedFromUpdate,\n              });\n            }\n          }\n\n          // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장\n          const mergeColumns = updateColumns.length ? updateColumns : conflictColumns;\n\n          resultRows = await wdb\n            .insert(dataForDb)\n            .into(tableName)\n            .onConflict(conflictColumns)\n            .merge(mergeColumns)\n            .returning(selectFields);\n        }\n\n        if (originalUuids.length !== resultRows.length) {\n          throw new Error(`${tableName}: register/returning 불일치`);\n        }\n\n        for (let i = 0; i < resultRows.length; i++) {\n          uuidMap.set(originalUuids[i], resultRows[i]);\n          allIds.push(resultRows[i].id);\n        }\n      }\n    }\n\n    // 해당 테이블 참조를 실제 밸류로 변경\n    for (const table of refTables) {\n      table.rows = table.rows.map((row) => {\n        for (const key of Object.keys(row)) {\n          const prop = row[key];\n          if (isRefField(prop) && prop.of === tableName) {\n            const parent = uuidMap.get(prop.uuid);\n            if (!parent) {\n              console.error(prop);\n              throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);\n            }\n            const resolvedValue = (parent as Record<string, unknown>)[prop.use ?? \"id\"];\n            row[key] = resolvedValue;\n\n            Naite.t(\"puri:ub-ref-resolved\", {\n              tableName,\n              field: key,\n              from: { of: prop.of, uuid: prop.uuid, use: prop.use ?? \"id\" },\n              to: resolvedValue,\n            });\n          }\n        }\n        return row;\n      });\n    }\n\n    if (options?.cleanOrphans) {\n      const cleanOrphans = options.cleanOrphans;\n      const fkColumns = isArray(cleanOrphans)\n        ? (cleanOrphans as ForeignKeyColumns<TTable>[])\n        : [cleanOrphans as ForeignKeyColumns<TTable>];\n\n      // 현재 register된 레코드들의 FK 값들 추출\n      const fkConditions = fkColumns.map((fkCol) => {\n        const fkValues = [...new Set(table.rows.map((row) => row[fkCol]).filter((v) => v != null))];\n        return { column: fkCol, values: fkValues };\n      });\n\n      // 모든 FK 컬럼에 값이 있는 경우에만 삭제 실행\n      if (fkConditions.every((fc) => fc.values.length > 0)) {\n        let deleteQuery = wdb(tableName);\n\n        // 각 FK 컬럼에 대한 WHERE IN 조건 추가\n        for (const { column, values } of fkConditions) {\n          deleteQuery = deleteQuery.whereIn(column, values);\n        }\n\n        // 방금 upsert한 ID는 제외\n        deleteQuery = deleteQuery.whereNotIn(\"id\", allIds);\n\n        const deletedCount = await deleteQuery.delete();\n\n        Naite.t(\"puri:ub-clean-orphans\", {\n          tableName,\n          cleanOrphans: fkColumns,\n          deletedCount,\n        });\n      }\n    }\n\n    // 해당 테이블의 데이터 초기화\n    table.rows = [];\n    table.references.clear();\n    table.uniquesMap.clear();\n\n    Naite.t(\"puri:ub-upserted\", {\n      tableName,\n      mode,\n      rowCount: allIds.length,\n      returnedIds: allIds,\n    });\n\n    return allIds as IdType<DatabaseSchemaExtend, TTable>[];\n  }\n\n  async updateBatch(\n    wdb: Knex,\n    tableName: string,\n    options?: {\n      chunkSize?: number;\n      where?: string | string[];\n    },\n  ): Promise<void> {\n    options = {\n      ...options,\n      chunkSize: options?.chunkSize ?? 500,\n      where: options?.where ?? \"id\",\n    };\n\n    if (!this.hasTable(tableName)) {\n      return;\n    }\n    const table = this.tables.get(tableName);\n    if (!table) {\n      throw new Error(`등록되지 않은 테이블 ${tableName}에 updateBatch 요청`);\n    } else if (table.rows.length === 0) {\n      return;\n    }\n\n    const whereColumns = Array.isArray(options.where) ? options.where : [options.where ?? \"id\"];\n    const rows = table.rows.map((_row) => {\n      const { uuid: _, ...row } = _row; // uuid 제외\n      return row as RowWithId<string>;\n    });\n\n    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);\n\n    Naite.t(\"puri:ub-batch-updated\", {\n      tableName,\n      rowCount: rows.length,\n      whereColumns,\n    });\n\n    // updateBatch 완료 후 처리된 데이터 제거\n    table.rows = [];\n    table.references.clear();\n    table.uniquesMap.clear();\n  }\n\n  // ============================================================================\n  // Private Helper Methods\n  // ============================================================================\n\n  /**\n   * rows를 의존성 순서에 따라 레벨별로 그룹화\n   * - 자기 참조 없는 경우 : 모든 rows가 Level 0\n   * - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화\n   */\n  private buildInsertLevels(\n    rows: Record<string, unknown>[],\n    tableName: string,\n  ): { levels: Record<string, unknown>[][]; hasCircular: boolean } {\n    // 1. 자기 참조가 없으면 한 레벨로 처리\n    const hasSelfRef = rows\n      .flatMap((row) => Object.values(row))\n      .some((value) => isRefField(value) && value.of === tableName);\n    if (!hasSelfRef) return { levels: [rows], hasCircular: false };\n\n    // 2. uuid → row 매핑 (중복 uuid 방지)\n    const rowByUuid = new Map<string, Record<string, unknown>>();\n    for (const row of rows) {\n      const uuid = row.uuid as string | undefined;\n      if (!uuid) throw new Error(`buildInsertLevels: uuid가 없는 row -- in ${tableName}`);\n      rowByUuid.set(uuid, row);\n    }\n\n    let pending = Array.from(rowByUuid.values());\n    const levels: Record<string, unknown>[][] = [];\n    const inserted = new Set<string>();\n\n    // 3. 레벨별 분류\n    while (pending.length > 0) {\n      const currentLevel: Record<string, unknown>[] = [];\n      const nextPending: Record<string, unknown>[] = [];\n\n      for (const row of pending) {\n        // 이 row가 참조하는 자기 참조들\n        const selfRefs = Object.values(row).filter(\n          (value) => isRefField(value) && value.of === tableName,\n        ) as UBRef[];\n\n        // 참조하는 모든 uuid가 이미 inserted에 있어야 이번 레벨에 포함\n        const canInsert = selfRefs.every((ref) => {\n          if (!rowByUuid.has(ref.uuid)) {\n            throw new Error(`존재하지 않는 uuid ${ref.uuid} -- in ${tableName}`);\n          }\n          return inserted.has(ref.uuid);\n        });\n\n        if (canInsert) {\n          currentLevel.push(row);\n        } else {\n          nextPending.push(row);\n        }\n      }\n\n      // 순환 참조 감지\n      if (currentLevel.length === 0) return { levels: [], hasCircular: true };\n\n      // 레벨 확정 + inserted 갱신\n      levels.push(currentLevel);\n      for (const row of currentLevel) {\n        inserted.add(row.uuid as string);\n      }\n\n      pending = nextPending;\n    }\n\n    return { levels, hasCircular: false };\n  }\n}\n"],"mappings":"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"}