sonamu 0.5.7 → 0.7.0

package/src/database/puri.types.ts

@@ -1,23 +1,41 @@
-// 메타데이터 컬럼 제외
-type ExcludeMetadataColumns<T> = T extends {
-  __fulltext__: readonly (infer _Col)[];
-}
-  ? Omit<T, "__fulltext__">
-  : T;
+/** biome-ignore-all lint/suspicious/noExplicitAny: Puri.types.ts는 다양한 타입을 사용하고 있습니다. */
+
+import type { QueryResult } from "pg";
+import type { DatabaseSchemaExtend } from "../types/types";
+import type { Puri } from "./puri";
+import type { PuriWrapper } from "./puri-wrapper";
+
+// 메타데이터 컬럼 유틸
+type MetadataColumns = "__fulltext__" | "__virtual__";
+
+// virtual 컬럼 타입 추출
+type VirtualKeys<T> = T extends { __virtual__: readonly (infer V)[] } ? V & string : never;
+
+// virtual 컬럼 제거
+type StripVirtual<T> = Omit<T, VirtualKeys<T>>;
+
+// 메타데이터 필드 제외한 실제 엔티티 컬럼
+export type ColumnKeys<T> = Exclude<keyof StripVirtual<T>, MetadataColumns> & string;
+
+// virtual 컬럼 제거 후 __fulltext__ 메타데이터 유지
+export type PuriTable<T> = Omit<StripVirtual<T>, "__virtual__">;
+
+// 메타데이터 컬럼 제외 타입 정의
+export type OmitMetadataColumns<T> = Omit<T, MetadataColumns>;
 
 // TTables의 모든 테이블에서 사용 가능한 컬럼 경로
 export type AvailableColumns<TTables extends Record<string, any>> =
   | {
-      [TAlias in keyof TTables]: `${TAlias & string}.${ExcludeMetadataColumns<keyof TTables[TAlias]> & string}`;
+      [TAlias in keyof TTables]: `${TAlias & string}.${ColumnKeys<TTables[TAlias]>}`;
     }[keyof TTables]
   | (IsSingleKey<TTables> extends true
-      ? ExcludeMetadataColumns<keyof TTables[keyof TTables]> // 단일 테이블이면 컬럼명만도 허용
+      ? ColumnKeys<TTables[keyof TTables]> // 단일 테이블이면 컬럼명만도 허용
       : never);
+
 // Group By, Order By, Having 등에서 선택 가능한 컬럼
-export type ResultAvailableColumns<
-  TTables extends Record<string, any>,
-  TResult = any,
-> = AvailableColumns<TTables> | `${keyof TResult & string}`;
+export type ResultAvailableColumns<TTables extends Record<string, any>, TResult = any> =
+  | AvailableColumns<TTables>
+  | `${keyof TResult & string}`;
 
 // Select 값 타입 확장
 export type SelectValue<TTables extends Record<string, any>> =
@@ -84,12 +102,11 @@ export type FulltextColumns<TTables extends Record<string, any>> = {
 export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
 
 // SQL Expression 타입 정의
-export type SqlExpression<T extends "string" | "number" | "boolean" | "date"> =
-  {
-    _type: "sql_expression"; // 또는 "computed_value"
-    _return: T;
-    _sql: string;
-  };
+export type SqlExpression<T extends "string" | "number" | "boolean" | "date"> = {
+  _type: "sql_expression"; // 또는 "computed_value"
+  _return: T;
+  _sql: string;
+};
 
 // 결과 타입 가독성을 위한 타입 확장
 export type Expand<T> = T extends any[]
@@ -98,29 +115,58 @@ export type Expand<T> = T extends any[]
     ? { [K in keyof T]: T[K] }
     : T;
 
-type IsSingleKey<TTables extends Record<string, any>> =
-  keyof TTables extends infer K
-    ? K extends keyof TTables
-      ? keyof TTables extends K // 역방향 체크로 단일 키 확인
-        ? true
-        : false
+type IsSingleKey<TTables extends Record<string, any>> = keyof TTables extends infer K
+  ? K extends keyof TTables
+    ? keyof TTables extends K // 역방향 체크로 단일 키 확인
+      ? true
       : false
-    : false;
+    : false
+  : false;
 
 export type SingleTableValue<TTables extends Record<string, any>> =
   IsSingleKey<TTables> extends true ? TTables[keyof TTables] : never;
 
 // Nullable을 Optional로 변환
 type NullableToOptional<T> = {
-  [K in keyof T as T[K] extends null | undefined ? K : never]?: Exclude<
-    T[K],
-    null | undefined
-  >;
+  [K in keyof T as T[K] extends null | undefined ? K : never]?: Exclude<T[K], null | undefined>;
 } & Partial<{
   [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
 }>;
 
 // Insert 타입: id, created_at 제외
 export type InsertData<T> = NullableToOptional<
-  Omit<T, "id" | "created_at" | "__fulltext__">
+  Omit<PuriTable<T>, "id" | "created_at" | MetadataColumns>
 >;
+
+// Insert Result 타입
+export type InsertResult = Pick<QueryResult<any>, "command" | "rowCount" | "rows" | "oid">;
+
+// SubsetQuery를 위한 타입 유틸리티
+type ExtractTTables<T extends Puri<any, any, any>> = T extends Puri<any, infer TTables, any>
+  ? TTables
+  : never;
+export type UnionExtractedTTables<
+  SubsetKey extends string,
+  SubsetQueries extends Record<
+    SubsetKey,
+    (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => Puri<any, any, any>
+  >,
+> = {
+  [K in SubsetKey]: ExtractTTables<ReturnType<SubsetQueries[K]>>;
+}[SubsetKey];
+
+// ON CONFLICT 대상 타입
+// - 단일 컬럼: "email"
+// - 복수 컬럼: ["user_id", "product_id"]
+export type OnConflictTarget = string | string[];
+
+// ON CONFLICT 액션 타입
+// - "nothing": DO NOTHING
+// - { update: [...] }: DO UPDATE
+export type OnConflictAction<TTables extends Record<string, unknown>> =
+  | "nothing"
+  | {
+      update:
+        | AvailableColumns<TTables>[] // 배열 형태 - ["name", "email"]
+        | WhereCondition<TTables>; // 객체 형태 - { name: "John", count: Puri.rawNumber(...) }
+    };

package/src/database/transaction-context.ts

@@ -1,5 +1,5 @@
-import type { PuriTransactionWrapper } from "./puri-wrapper";
 import type { DBPreset } from "./db";
+import type { PuriTransactionWrapper } from "./puri-wrapper";
 
 export class TransactionContext {
   private transactions: Map<DBPreset, PuriTransactionWrapper> = new Map();

package/src/database/upsert-builder.ts

@@ -1,13 +1,14 @@
 import { randomUUID } from "crypto";
-import _ from "lodash";
-import { Knex } from "knex";
+import type { Knex } from "knex";
+import { unique } from "radashi";
 import { EntityManager } from "../entity/entity-manager";
-import { nonNullable } from "../utils/utils";
-import { RowWithId, batchUpdate } from "./_batch_update";
+import { Naite } from "../naite/naite";
+import { assertDefined, chunk, nonNullable } from "../utils/utils";
+import { batchUpdate, type RowWithId } from "./_batch_update";
 
 type TableData = {
   references: Set<string>;
-  rows: any[];
+  rows: Record<string, unknown>[];
   uniqueIndexes: { name?: string; columns: string[] }[];
   uniquesMap: Map<string, string>;
 };
@@ -16,12 +17,12 @@ export type UBRef = {
   of: string;
   use?: string;
 };
-export function isRefField(field: any): field is UBRef {
+export function isRefField(field: unknown): field is UBRef {
   return (
     field !== undefined &&
     field !== null &&
-    field.of !== undefined &&
-    field.uuid !== undefined
+    (field as UBRef)?.of !== undefined &&
+    (field as UBRef)?.uuid !== undefined
   );
 }
 
@@ -33,24 +34,26 @@ export class UpsertBuilder {
 
   getTable(tableName: string): TableData {
     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<string, string>(),
-      });
+    if (table) {
+      return table;
     }
 
-    return this.tables.get(tableName)!;
+    const tableSpec = (() => {
+      try {
+        return EntityManager.getTableSpec(tableName);
+      } catch {
+        return null;
+      }
+    })();
+
+    const tableData = {
+      references: new Set<string>(),
+      rows: [],
+      uniqueIndexes: tableSpec?.uniqueIndexes ?? [],
+      uniquesMap: new Map<string, string>(),
+    };
+    this.tables.set(tableName, tableData);
+    return tableData;
   }
 
   hasTable(tableName: string): boolean {
@@ -60,16 +63,8 @@ export class UpsertBuilder {
   register<T extends string>(
     tableName: string,
     row: {
-      [key in T]?:
-        | UBRef
-        | string
-        | number
-        | boolean
-        | bigint
-        | null
-        | object
-        | unknown;
-    }
+      [key in T]?: UBRef | string | number | boolean | bigint | null | object | unknown;
+    },
   ): UBRef {
     const table = this.getTable(tableName);
 
@@ -94,18 +89,21 @@ export class UpsertBuilder {
       .filter(nonNullable);
 
     // uuid 생성 로직
-    const uuid: string = (() => {
+    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 저장
@@ -117,45 +115,45 @@ export class UpsertBuilder {
 
     // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가
     // 이 정보를 나중에 치환할 때 사용
-    row = Object.keys(row).reduce((r, rowKey) => {
-      const rowValue = row[rowKey as keyof typeof row];
-
-      if (isRefField(rowValue)) {
-        rowValue.use ??= "id";
-        table.references.add(rowValue.of + "." + rowValue.use);
-        r[rowKey] = rowValue;
-      } else if (typeof rowValue === "object" && !(rowValue instanceof Date)) {
-        // object인 경우 JSON으로 변환
-        r[rowKey] = rowValue === null ? null : JSON.stringify(rowValue);
-      } else {
-        r[rowKey] = rowValue;
-      }
-      return r;
-    }, {} as any);
+    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 (typeof rowValue === "object" && !(rowValue instanceof Date)) {
+          // object인 경우 JSON으로 변환
+          return [rowKey, rowValue === null ? null : JSON.stringify(rowValue)];
+        } else {
+          return [rowKey, rowValue];
+        }
+      }),
+    ) as { [key in T]?: unknown };
 
     table.rows.push({
       uuid,
       ...row,
     });
 
-    return {
+    const result: UBRef = {
       of: tableName,
       uuid: (row as { uuid?: string }).uuid ?? uuid,
     };
+
+    Naite.t("puri:ub-register", {
+      tableName,
+      uuid: result.uuid,
+      isUuidReused: isReused,
+      row,
+    });
+
+    return result;
   }
 
-  async upsert(
-    wdb: Knex,
-    tableName: string,
-    chunkSize?: number
-  ): Promise<number[]> {
+  async upsert(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
   }
-  async insertOnly(
-    wdb: Knex,
-    tableName: string,
-    chunkSize?: number
-  ): Promise<number[]> {
+  async insertOnly(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
   }
 
@@ -163,7 +161,7 @@ export class UpsertBuilder {
     wdb: Knex,
     tableName: string,
     mode: "upsert" | "insert",
-    chunkSize?: number
+    chunkSize?: number,
   ): Promise<number[]> {
     if (this.hasTable(tableName) === false) {
       return [];
@@ -178,9 +176,7 @@ export class UpsertBuilder {
 
     if (
       table.rows.some((row) =>
-        Object.entries(row).some(
-          ([, value]) => isRefField(value) && value.of !== tableName
-        )
+        Object.entries(row).some(([, value]) => isRefField(value) && value.of !== tableName),
       )
     ) {
       throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
@@ -190,7 +186,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 + ".")
+          ref.includes(`${tableName}.`),
         );
         if (reference) {
           r.references.push(reference);
@@ -202,77 +198,132 @@ export class UpsertBuilder {
       {
         references: [] as string[],
         refTables: [] as TableData[],
-      }
-    );
-    const extractFields = _.uniq(references).map(
-      (reference) => reference.split(".")[1]
+      },
     );
+    const extractFields = unique(references)
+      .map((reference) => reference.split(".")[1])
+      .filter((field): field is string => field !== undefined);
 
-    // 내부 참조 있는 경우 필터하여 분리
-    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 uuidMap = new Map<string, any>();
-
-    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]));
-      }
+    // 의존성 순서에 따라 레벨별 그룹화 (자기 참조가 없으면 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<string, unknown>();
+    const allIds: number[] = [];
 
-      // upsert된 row들을 다시 조회하여 uuidMap에 저장
-      const uuids = chunk.map((row) => row.uuid);
-      const upsertedRows = await wdb(tableName)
-        .select(_.uniq(["uuid", "id", ...extractFields]))
-        .whereIn("uuid", uuids);
-      upsertedRows.forEach((row: any) => {
-        uuidMap.set(row.uuid, row);
+    // 레벨별로 순차 처리
+    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 as Record<string, unknown>)[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]);
+
+      for (const dataChunk of levelChunks) {
+        if (dataChunk.length === 0) continue;
+
+        let resultRows: { uuid: string; id: number; [key: string]: unknown }[];
+
+        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 as readonly string[]);
+        } 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}`
-              );
+              throw new Error(`존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`);
             }
-            row[key] = parent[prop.use ?? "id"];
+            const resolvedValue = (parent as Record<string, unknown>)[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;
   }
 
@@ -282,34 +333,113 @@ export class UpsertBuilder {
     options?: {
       chunkSize?: number;
       where?: string | string[];
-    }
+    },
   ): Promise<void> {
-    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) {
+    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 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 as RowWithId<string>;
     });
 
     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
+   * - 자기 참조 있는 경우 : 자기 참조 관계를 위상 정렬하여 레벨별로 그룹화
+   */
+  private buildInsertLevels(
+    rows: Record<string, unknown>[],
+    tableName: string,
+  ): { levels: Record<string, unknown>[][]; hasCircular: boolean } {
+    // 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<string, Record<string, unknown>>();
+    for (const row of rows) {
+      const uuid = row.uuid as string | undefined;
+      if (!uuid) throw new Error(`buildInsertLevels: uuid가 없는 row -- in ${tableName}`);
+      rowByUuid.set(uuid, row);
+    }
+
+    let pending = Array.from(rowByUuid.values());
+    const levels: Record<string, unknown>[][] = [];
+    const inserted = new Set<string>();
+
+    // 3. 레벨별 분류
+    while (pending.length > 0) {
+      const currentLevel: Record<string, unknown>[] = [];
+      const nextPending: Record<string, unknown>[] = [];
+
+      for (const row of pending) {
+        // 이 row가 참조하는 자기 참조들
+        const selfRefs = Object.values(row).filter(
+          (value) => isRefField(value) && value.of === tableName,
+        ) as UBRef[];
+
+        // 참조하는 모든 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 as string);
+      }
+
+      pending = nextPending;
+    }
+
+    return { levels, hasCircular: false };
+  }
 }