sonamu 0.6.0 → 0.7.0

package/dist/database/upsert-builder.d.ts

@@ -1,7 +1,7 @@
-import { Knex } from "knex";
+import type { Knex } from "knex";
 type TableData = {
     references: Set<string>;
-    rows: any[];
+    rows: Record<string, unknown>[];
     uniqueIndexes: {
         name?: string;
         columns: string[];
@@ -13,7 +13,7 @@ export type UBRef = {
     of: string;
     use?: string;
 };
-export declare function isRefField(field: any): field is UBRef;
+export declare function isRefField(field: unknown): field is UBRef;
 export declare class UpsertBuilder {
     tables: Map<string, TableData>;
     constructor();
@@ -29,6 +29,12 @@ export declare class UpsertBuilder {
         chunkSize?: number;
         where?: string | string[];
     }): Promise<void>;
+    /**
+     * rows를 의존성 순서에 따라 레벨별로 그룹화
+     * - 자기 참조 없는 경우 : 모든 rows가 Level 0
+     * - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화
+     */
+    private buildInsertLevels;
 }
 export {};
 //# sourceMappingURL=upsert-builder.d.ts.map

package/dist/database/upsert-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert-builder.d.ts","sourceRoot":"","sources":["../../src/database/upsert-builder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAK5B,KAAK,SAAS,GAAG;IACf,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACxB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,aAAa,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACtD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AACF,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AACF,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,KAAK,CAOrD;AAED,qBAAa,aAAa;IACxB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;IAK/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;IAsBtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIpC,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE;SACF,GAAG,IAAI,CAAC,CAAC,CAAC,EACP,KAAK,GACL,MAAM,GACN,MAAM,GACN,OAAO,GACP,MAAM,GACN,IAAI,GACJ,MAAM,GACN,OAAO;KACZ,GACA,KAAK;IA0EF,MAAM,CACV,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC;IAGd,UAAU,CACd,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC;IAId,cAAc,CAClB,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC;IAgHd,WAAW,CACf,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;KAC3B,GACA,OAAO,CAAC,IAAI,CAAC;CA6BjB"}
+{"version":3,"file":"upsert-builder.d.ts","sourceRoot":"","sources":["../../src/database/upsert-builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAOjC,KAAK,SAAS,GAAG;IACf,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,aAAa,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACtD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AACF,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AACF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAOzD;AAED,qBAAa,aAAa;IACxB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;IAK/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;IAwBtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIpC,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE;SACF,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO;KAClF,GACA,KAAK;IAqFF,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAG3E,UAAU,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAI/E,cAAc,CAClB,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC;IAqKd,WAAW,CACf,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;KAC3B,GACA,OAAO,CAAC,IAAI,CAAC;IAyChB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CA8D1B"}

package/dist/database/upsert-builder.js

@@ -1,10 +1,11 @@
 import { randomUUID } from "crypto";
-import * as _ from "lodash-es";
+import { unique } from "radashi";
 import { EntityManager } from "../entity/entity-manager.js";
-import { nonNullable } from "../utils/utils.js";
+import { Naite } from "../naite/naite.js";
+import { assertDefined, chunk, nonNullable } from "../utils/utils.js";
 import { batchUpdate } from "./_batch_update.js";
 export function isRefField(field) {
-    return field !== undefined && field !== null && field.of !== undefined && field.uuid !== undefined;
+    return field !== undefined && field !== null && field?.of !== undefined && field?.uuid !== undefined;
 }
 export class UpsertBuilder {
     tables;
@@ -13,22 +14,24 @@ export class UpsertBuilder {
     }
     getTable(tableName) {
         const table = this.tables.get(tableName);
-        if (table === undefined) {
-            const tableSpec = (()=>{
-                try {
-                    return EntityManager.getTableSpec(tableName);
-                } catch  {
-                    return null;
-                }
-            })();
-            this.tables.set(tableName, {
-                references: new Set(),
-                rows: [],
-                uniqueIndexes: tableSpec?.uniqueIndexes ?? [],
-                uniquesMap: new Map()
-            });
+        if (table) {
+            return table;
         }
-        return this.tables.get(tableName);
+        const tableSpec = (()=>{
+            try {
+                return EntityManager.getTableSpec(tableName);
+            } catch  {
+                return null;
+            }
+        })();
+        const tableData = {
+            references: new Set(),
+            rows: [],
+            uniqueIndexes: tableSpec?.uniqueIndexes ?? [],
+            uniquesMap: new Map()
+        };
+        this.tables.set(tableName, tableData);
+        return tableData;
     }
     hasTable(tableName) {
         return this.tables.has(tableName);
@@ -52,17 +55,23 @@ export class UpsertBuilder {
             return uniqueKeyArray.join("---delimiter--");
         }).filter(nonNullable);
         // uuid 생성 로직
-        const uuid = (()=>{
+        const { uuid, isReused } = (()=>{
             // 키를 순회하여 이미 존재하는 키가 있는지 확인
             if (uniqueKeys.length > 0) {
                 for (const uniqueKey of uniqueKeys){
                     if (table.uniquesMap.has(uniqueKey)) {
-                        return table.uniquesMap.get(uniqueKey); // 이미 has 체크를 했으므로 undefined 불가능
+                        return {
+                            uuid: assertDefined(table.uniquesMap.get(uniqueKey), "Unique key not found"),
+                            isReused: true
+                        };
                     }
                 }
             }
             // 찾을 수 없는 경우 생성
-            return randomUUID();
+            return {
+                uuid: randomUUID(),
+                isReused: false
+            };
         })();
         // 모든 유니크키에 대해 유니크맵에 uuid 저장
         if (uniqueKeys.length > 0) {
@@ -72,28 +81,42 @@ export class UpsertBuilder {
         }
         // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가
         // 이 정보를 나중에 치환할 때 사용
-        row = Object.keys(row).reduce((r, rowKey)=>{
-            const rowValue = row[rowKey];
+        row = Object.fromEntries(Object.entries(row).map(([rowKey, rowValue])=>{
             if (isRefField(rowValue)) {
                 rowValue.use ??= "id";
-                table.references.add(rowValue.of + "." + rowValue.use);
-                r[rowKey] = rowValue;
+                table.references.add(`${rowValue.of}.${rowValue.use}`);
+                return [
+                    rowKey,
+                    rowValue
+                ];
             } else if (typeof rowValue === "object" && !(rowValue instanceof Date)) {
                 // object인 경우 JSON으로 변환
-                r[rowKey] = rowValue === null ? null : JSON.stringify(rowValue);
+                return [
+                    rowKey,
+                    rowValue === null ? null : JSON.stringify(rowValue)
+                ];
             } else {
-                r[rowKey] = rowValue;
+                return [
+                    rowKey,
+                    rowValue
+                ];
             }
-            return r;
-        }, {});
+        }));
         table.rows.push({
             uuid,
             ...row
         });
-        return {
+        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, chunkSize) {
         return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
@@ -116,7 +139,7 @@ export class UpsertBuilder {
         }
         // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출
         const { references, refTables } = Array.from(this.tables).reduce((r, [, table])=>{
-            const reference = Array.from(table.references.values()).find((ref)=>ref.includes(tableName + "."));
+            const reference = Array.from(table.references.values()).find((ref)=>ref.includes(`${tableName}.`));
             if (reference) {
                 r.references.push(reference);
                 r.refTables.push(table);
@@ -126,90 +149,217 @@ export class UpsertBuilder {
             references: [],
             refTables: []
         });
-        const extractFields = _.uniq(references).map((reference)=>reference.split(".")[1]);
-        // 내부 참조 있는 경우 필터하여 분리
-        const groups = _.groupBy(table.rows, (row)=>Object.entries(row).some(([, value])=>isRefField(value)) ? "selfRef" : "normal");
-        const normalRows = groups.normal ?? [];
-        const selfRefRows = groups.selfRef ?? [];
-        const chunks = chunkSize ? _.chunk(normalRows, chunkSize) : [
-            normalRows
-        ];
+        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}에 순환 자기 참조가 있습니다.`);
+        }
+        // upsert 모드일 때 유니크 인덱스가 없으면 에러
+        if (mode === "upsert" && table.uniqueIndexes.length === 0) {
+            throw new Error(`${tableName}에 unique index가 정의되지 않아 upsert를 할 수 없습니다.`);
+        }
         const uuidMap = new Map();
-        for (const chunk of chunks){
-            const q = wdb.insert(chunk).into(tableName);
-            if (mode === "insert") {
-                await q;
-            } else if (mode === "upsert") {
-                await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
-            }
-            // upsert된 row들을 다시 조회하여 uuidMap에 저장
-            const uuids = chunk.map((row)=>row.uuid);
-            const upsertedRows = await wdb(tableName).select(_.uniq([
+        const allIds = [];
+        // 레벨별로 순차 처리
+        for (const levelRows of levels){
+            // 이전 레벨에서 얻은 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 levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [
+                resolvedRows
+            ];
+            const selectFields = unique([
                 "uuid",
                 "id",
                 ...extractFields
-            ])).whereIn("uuid", uuids);
-            upsertedRows.forEach((row)=>{
-                uuidMap.set(row.uuid, row);
-            });
+            ]);
+            for (const dataChunk of levelChunks){
+                if (dataChunk.length === 0) continue;
+                let resultRows;
+                if (mode === "insert") {
+                    // INSERT 모드
+                    await wdb.insert(dataChunk).into(tableName);
+                    const uuids = dataChunk.map((r)=>r.uuid);
+                    resultRows = await wdb(tableName).select(selectFields).whereIn("uuid", uuids);
+                } else {
+                    // UPSERT 모드 (uniqueIndexes 이미 체크됨)
+                    const conflictColumns = table.uniqueIndexes[0].columns;
+                    const updateColumns = Object.keys(dataChunk[0]).filter((col)=>col !== "uuid" && !conflictColumns.includes(col));
+                    // RETURNING으로 결과 받기
+                    const query = wdb.insert(dataChunk).into(tableName).onConflict(conflictColumns);
+                    // updateColumns가 비어있으면 ignore(), 아니면 merge()
+                    if (updateColumns.length === 0) {
+                        resultRows = await query.ignore().returning(selectFields);
+                    } else {
+                        resultRows = await query.merge(updateColumns).returning(selectFields);
+                    }
+                }
+                // 양쪽 모드 공통 처리
+                for (const row of resultRows){
+                    uuidMap.set(row.uuid, row);
+                    allIds.push(row.id);
+                }
+            }
         }
         // 해당 테이블 참조를 실제 밸류로 변경
-        refTables.map((table)=>{
+        for (const table of refTables){
             table.rows = table.rows.map((row)=>{
-                Object.keys(row).map((key)=>{
+                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 === undefined) {
+                        if (!parent) {
                             console.error(prop);
                             throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);
                         }
-                        row[key] = parent[prop.use ?? "id"];
+                        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;
             });
-        });
-        const allIds = Array.from(uuidMap.values()).map((row)=>row.id);
-        // 자기 참조가 있는 경우 재귀적으로 upsert
-        if (selfRefRows.length > 0) {
-            // 처리된 데이터를 제외하고 다시 upsert
-            table.rows = selfRefRows;
-            const selfRefIds = await this.upsert(wdb, tableName, chunkSize);
-            allIds.push(...selfRefIds);
-        } else {
-            // 자기 참조가 없으면 해당 테이블의 데이터 초기화
-            table.rows = [];
-            table.references.clear();
-            table.uniquesMap.clear();
         }
+        // 해당 테이블의 데이터 초기화
+        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 = _.defaults(options, {
-            chunkSize: 500,
-            where: "id"
-        });
+        options = {
+            ...options,
+            chunkSize: options?.chunkSize ?? 500,
+            where: options?.where ?? "id"
+        };
         if (this.hasTable(tableName) === false) {
             return;
         }
         const table = this.tables.get(tableName);
-        if (table.rows.length === 0) {
+        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;
+            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 Helpers
+    // ============================================================================
+    /**
+   * 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
+        };
+    }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/upsert-builder.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\nimport * as _ from \"lodash-es\";\nimport { Knex } from \"knex\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { nonNullable } from \"../utils/utils\";\nimport { RowWithId, batchUpdate } from \"./_batch_update\";\n\ntype TableData = {\n  references: Set<string>;\n  rows: any[];\n  uniqueIndexes: { name?: string; columns: string[] }[];\n  uniquesMap: Map<string, string>;\n};\nexport type UBRef = {\n  uuid: string;\n  of: string;\n  use?: string;\n};\nexport function isRefField(field: any): field is UBRef {\n  return (\n    field !== undefined &&\n    field !== null &&\n    field.of !== undefined &&\n    field.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 === undefined) {\n      const tableSpec = (() => {\n        try {\n          return EntityManager.getTableSpec(tableName);\n        } catch {\n          return null;\n        }\n      })();\n\n      this.tables.set(tableName, {\n        references: new Set(),\n        rows: [],\n        uniqueIndexes: tableSpec?.uniqueIndexes ?? [],\n        uniquesMap: new Map<string, string>(),\n      });\n    }\n\n    return this.tables.get(tableName)!;\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]?:\n        | UBRef\n        | string\n        | number\n        | boolean\n        | bigint\n        | null\n        | object\n        | 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 as keyof typeof row];\n          if (isRefField(val)) {\n            return val.uuid;\n          } else {\n            return row[unqCol 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: string = (() => {\n      // 키를 순회하여 이미 존재하는 키가 있는지 확인\n      if (uniqueKeys.length > 0) {\n        for (const uniqueKey of uniqueKeys) {\n          if (table.uniquesMap.has(uniqueKey)) {\n            return table.uniquesMap.get(uniqueKey)!; // 이미 has 체크를 했으므로 undefined 불가능\n          }\n        }\n      }\n\n      // 찾을 수 없는 경우 생성\n      return randomUUID();\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.keys(row).reduce((r, rowKey) => {\n      const rowValue = row[rowKey as keyof typeof row];\n\n      if (isRefField(rowValue)) {\n        rowValue.use ??= \"id\";\n        table.references.add(rowValue.of + \".\" + rowValue.use);\n        r[rowKey] = rowValue;\n      } else if (typeof rowValue === \"object\" && !(rowValue instanceof Date)) {\n        // object인 경우 JSON으로 변환\n        r[rowKey] = rowValue === null ? null : JSON.stringify(rowValue);\n      } else {\n        r[rowKey] = rowValue;\n      }\n      return r;\n    }, {} as any);\n\n    table.rows.push({\n      uuid,\n      ...row,\n    });\n\n    return {\n      of: tableName,\n      uuid: (row as { uuid?: string }).uuid ?? uuid,\n    };\n  }\n\n  async upsert(\n    wdb: Knex,\n    tableName: string,\n    chunkSize?: number\n  ): Promise<number[]> {\n    return this.upsertOrInsert(wdb, tableName, \"upsert\", chunkSize);\n  }\n  async insertOnly(\n    wdb: Knex,\n    tableName: string,\n    chunkSize?: number\n  ): Promise<number[]> {\n    return this.upsertOrInsert(wdb, tableName, \"insert\", chunkSize);\n  }\n\n  async upsertOrInsert(\n    wdb: Knex,\n    tableName: string,\n    mode: \"upsert\" | \"insert\",\n    chunkSize?: number\n  ): Promise<number[]> {\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(\n          ([, value]) => isRefField(value) && value.of !== tableName\n        )\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 = _.uniq(references).map(\n      (reference) => reference.split(\".\")[1]\n    );\n\n    // 내부 참조 있는 경우 필터하여 분리\n    const groups = _.groupBy(table.rows, (row) =>\n      Object.entries(row).some(([, value]) => isRefField(value))\n        ? \"selfRef\"\n        : \"normal\"\n    );\n    const normalRows = groups.normal ?? [];\n    const selfRefRows = groups.selfRef ?? [];\n\n    const chunks = chunkSize ? _.chunk(normalRows, chunkSize) : [normalRows];\n    const uuidMap = new Map<string, any>();\n\n    for (const chunk of chunks) {\n      const q = wdb.insert(chunk).into(tableName);\n      if (mode === \"insert\") {\n        await q;\n      } else if (mode === \"upsert\") {\n        await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));\n      }\n\n      // upsert된 row들을 다시 조회하여 uuidMap에 저장\n      const uuids = chunk.map((row) => row.uuid);\n      const upsertedRows = await wdb(tableName)\n        .select(_.uniq([\"uuid\", \"id\", ...extractFields]))\n        .whereIn(\"uuid\", uuids);\n      upsertedRows.forEach((row: any) => {\n        uuidMap.set(row.uuid, row);\n      });\n    }\n\n    // 해당 테이블 참조를 실제 밸류로 변경\n    refTables.map((table) => {\n      table.rows = table.rows.map((row) => {\n        Object.keys(row).map((key) => {\n          const prop = row[key];\n          if (isRefField(prop) && prop.of === tableName) {\n            const parent = uuidMap.get(prop.uuid);\n            if (parent === undefined) {\n              console.error(prop);\n              throw new Error(\n                `존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`\n              );\n            }\n            row[key] = parent[prop.use ?? \"id\"];\n          }\n        });\n        return row;\n      });\n    });\n\n    const allIds = Array.from(uuidMap.values()).map((row) => row.id);\n\n    // 자기 참조가 있는 경우 재귀적으로 upsert\n    if (selfRefRows.length > 0) {\n      // 처리된 데이터를 제외하고 다시 upsert\n      table.rows = selfRefRows;\n      const selfRefIds = await this.upsert(wdb, tableName, chunkSize);\n      allIds.push(...selfRefIds);\n    } else {\n      // 자기 참조가 없으면 해당 테이블의 데이터 초기화\n      table.rows = [];\n      table.references.clear();\n      table.uniquesMap.clear();\n    }\n\n    return allIds;\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 = _.defaults(options, {\n      chunkSize: 500,\n      where: \"id\",\n    });\n\n    if (this.hasTable(tableName) === false) {\n      return;\n    }\n    const table = this.tables.get(tableName)!;\n    if (table.rows.length === 0) {\n      return;\n    }\n\n    const whereColumns = Array.isArray(options.where)\n      ? options.where\n      : [options.where ?? \"id\"];\n    const rows = table.rows.map((_row) => {\n      const { uuid, ...row } = _row;\n      return row as RowWithId<string>;\n    });\n\n    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);\n\n    // updateBatch 완료 후 처리된 데이터 제거\n    table.rows = [];\n    table.references.clear();\n    table.uniquesMap.clear();\n  }\n}\n"],"names":["randomUUID","_","EntityManager","nonNullable","batchUpdate","isRefField","field","undefined","of","uuid","UpsertBuilder","tables","Map","getTable","tableName","table","get","tableSpec","getTableSpec","set","references","Set","rows","uniqueIndexes","uniquesMap","hasTable","has","register","row","uniqueKeys","map","unqIndex","uniqueKeyArray","columns","unqCol","val","length","join","filter","uniqueKey","Object","keys","reduce","r","rowKey","rowValue","use","add","Date","JSON","stringify","push","upsert","wdb","chunkSize","upsertOrInsert","insertOnly","mode","Error","some","entries","value","refTables","Array","from","reference","values","find","ref","includes","extractFields","uniq","split","groups","groupBy","normalRows","normal","selfRefRows","selfRef","chunks","chunk","uuidMap","q","insert","into","onDuplicateUpdate","apply","uuids","upsertedRows","select","whereIn","forEach","key","prop","parent","console","error","allIds","id","selfRefIds","clear","updateBatch","options","defaults","where","whereColumns","isArray","_row"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/upsert-builder.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\nimport type { Knex } from \"knex\";\nimport { unique } from \"radashi\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { assertDefined, chunk, nonNullable } from \"../utils/utils\";\nimport { batchUpdate, type RowWithId } from \"./_batch_update\";\n\ntype TableData = {\n  references: Set<string>;\n  rows: Record<string, unknown>[];\n  uniqueIndexes: { name?: string; columns: string[] }[];\n  uniquesMap: Map<string, string>;\n};\nexport type UBRef = {\n  uuid: string;\n  of: string;\n  use?: string;\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    };\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 as keyof typeof row];\n          if (isRefField(val)) {\n            return val.uuid;\n          } else {\n            return row[unqCol 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 (typeof rowValue === \"object\" && !(rowValue instanceof Date)) {\n          // object인 경우 JSON으로 변환\n          return [rowKey, rowValue === null ? null : JSON.stringify(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(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {\n    return this.upsertOrInsert(wdb, tableName, \"upsert\", chunkSize);\n  }\n  async insertOnly(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {\n    return this.upsertOrInsert(wdb, tableName, \"insert\", chunkSize);\n  }\n\n  async upsertOrInsert(\n    wdb: Knex,\n    tableName: string,\n    mode: \"upsert\" | \"insert\",\n    chunkSize?: number,\n  ): Promise<number[]> {\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    // upsert 모드일 때 유니크 인덱스가 없으면 에러\n    if (mode === \"upsert\" && table.uniqueIndexes.length === 0) {\n      throw new Error(`${tableName}에 unique index가 정의되지 않아 upsert를 할 수 없습니다.`);\n    }\n\n    const uuidMap = new Map<string, unknown>();\n    const allIds: number[] = [];\n\n    // 레벨별로 순차 처리\n    for (const levelRows of levels) {\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 levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [resolvedRows];\n      const selectFields = unique([\"uuid\", \"id\", ...extractFields]);\n\n      for (const dataChunk of levelChunks) {\n        if (dataChunk.length === 0) continue;\n\n        let resultRows: { uuid: string; id: number; [key: string]: unknown }[];\n\n        if (mode === \"insert\") {\n          // INSERT 모드\n          await wdb.insert(dataChunk).into(tableName);\n\n          const uuids = dataChunk.map((r) => r.uuid);\n          resultRows = await wdb(tableName)\n            .select(selectFields)\n            .whereIn(\"uuid\", uuids as readonly string[]);\n        } else {\n          // UPSERT 모드 (uniqueIndexes 이미 체크됨)\n          const conflictColumns = table.uniqueIndexes[0].columns;\n          const updateColumns = Object.keys(dataChunk[0]).filter(\n            (col) => col !== \"uuid\" && !conflictColumns.includes(col),\n          );\n\n          // RETURNING으로 결과 받기\n          const query = wdb.insert(dataChunk).into(tableName).onConflict(conflictColumns);\n\n          // updateColumns가 비어있으면 ignore(), 아니면 merge()\n          if (updateColumns.length === 0) {\n            resultRows = await query.ignore().returning(selectFields);\n          } else {\n            resultRows = await query.merge(updateColumns).returning(selectFields);\n          }\n        }\n\n        // 양쪽 모드 공통 처리\n        for (const row of resultRows) {\n          uuidMap.set(row.uuid, row);\n          allIds.push(row.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    // 해당 테이블의 데이터 초기화\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;\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 Helpers\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":["randomUUID","unique","EntityManager","Naite","assertDefined","chunk","nonNullable","batchUpdate","isRefField","field","undefined","of","uuid","UpsertBuilder","tables","Map","getTable","tableName","table","get","tableSpec","getTableSpec","tableData","references","Set","rows","uniqueIndexes","uniquesMap","set","hasTable","has","register","row","uniqueKeys","map","unqIndex","uniqueKeyArray","columns","unqCol","val","length","join","filter","isReused","uniqueKey","Object","fromEntries","entries","rowKey","rowValue","use","add","Date","JSON","stringify","push","result","t","isUuidReused","upsert","wdb","chunkSize","upsertOrInsert","insertOnly","mode","Error","some","value","refTables","Array","from","reduce","r","reference","values","find","ref","includes","extractFields","split","levels","hasCircular","buildInsertLevels","uuidMap","allIds","levelRows","resolvedRows","resolved","key","parent","to","levelChunks","selectFields","dataChunk","resultRows","insert","into","uuids","select","whereIn","conflictColumns","updateColumns","keys","col","query","onConflict","ignore","returning","merge","id","prop","console","error","resolvedValue","clear","rowCount","returnedIds","updateBatch","options","where","whereColumns","isArray","_row","_","hasSelfRef","flatMap","rowByUuid","pending","inserted","currentLevel","nextPending","selfRefs","canInsert","every"],"mappings":"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"}