npm - sonamu - Versions diffs - 0.7.39 → 0.7.41 - Mend

sonamu 0.7.39 → 0.7.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/dist/ui-web/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/sonamu-ui/setting.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>{{projectName}}: Sonamu UI</title>
-    <script type="module" crossorigin src="/sonamu-ui/assets/index-DCf469Xl.js"></script>
-    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-Bfv7V57v.css">
+    <script type="module" crossorigin src="/sonamu-ui/assets/index-DoZuAOiq.js"></script>
+    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-CWExqVO5.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.7.39",
+  "version": "0.7.41",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -113,9 +113,9 @@
     "exceljs": "^4.4.0",
     "zod": "^4.1.12",
     "@sonamu-kit/hmr-hook": "^0.4.1",
+    "@sonamu-kit/ts-loader": "^2.1.3",
     "@sonamu-kit/hmr-runner": "^0.1.1",
-    "@sonamu-kit/tasks": "^0.1.3",
-    "@sonamu-kit/ts-loader": "^2.1.3"
+    "@sonamu-kit/tasks": "^0.1.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.10",

package/src/tasks/workflow-manager.ts CHANGED Viewed

@@ -198,6 +198,11 @@ export class WorkflowManager {
     workflow: Pick<WorkflowMetadata, "id" | "name" | "version">,
     schedule: WorkflowMetadata["schedules"][number],
   ) {
+    // Worker가 활성화된 노드에서만 처리
+    if (!this.#worker) {
+      return;
+    }
     const task = cronSchedule(
       schedule.expression,
       (async (
@@ -227,6 +232,11 @@ export class WorkflowManager {
   // cron task를 중지
   async unscheduleTask(name: string) {
+    // Worker가 활성화된 노드에서만 처리
+    if (!this.#worker) {
+      return;
+    }
     const taskItem = this.#scheduledTasks.get(name);
     if (!taskItem) {
       console.error("scheduled task not found", name);

package/src/template/implementations/generated_http.template.ts CHANGED Viewed

@@ -75,7 +75,8 @@ export class Template__generated_http extends Template {
       );
     } else if (zodType instanceof z.ZodArray) {
       return [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];
-    } else if (zodType instanceof z.ZodString) {
+    } else if (zodType instanceof z.core.$ZodString) {
+      // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함
       if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
         return "2000-01-01";
       } else {

package/src/template/implementations/queries.template.ts CHANGED Viewed

@@ -90,22 +90,33 @@ ${functions.join("\n\n")}
       );
     }
+    // tanstack-query API가 없으면 헬퍼 함수와 import를 포함하지 않습니다.
+    // 새 프로젝트에서 첫 빌드 시 sync가 아직 안 되어 namespace가 비어있을 수 있고,
+    // 이때 createSSRQuery가 unused로 빌드 에러가 발생하는 것을 방지합니다.
+    const hasQueries = namespaces.length > 0;
     return {
       ...this.getTargetAndPath(),
       body: namespaces.join("\n\n"),
       importKeys: diff(unique(importKeys), typeParamNames),
-      customHeaders: [
-        "/** biome-ignore-all lint: generated는 무시 */",
-        "/** biome-ignore-all assist: generated는 무시 */",
-        "",
-        `import type { SSRQuery } from 'sonamu/ssr';`,
-        "",
-        `// SSRQuery 헬퍼 함수`,
-        `function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,
-        `  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,
-        `}`,
-        "",
-      ],
+      customHeaders: hasQueries
+        ? [
+            "/** biome-ignore-all lint: generated는 무시 */",
+            "/** biome-ignore-all assist: generated는 무시 */",
+            "",
+            `import type { SSRQuery } from 'sonamu/ssr';`,
+            "",
+            `// SSRQuery 헬퍼 함수`,
+            `function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,
+            `  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,
+            `}`,
+            "",
+          ]
+        : [
+            "/** biome-ignore-all lint: generated는 무시 */",
+            "/** biome-ignore-all assist: generated는 무시 */",
+            "",
+          ],
     };
   }
 }

package/src/template/implementations/sd.template.ts CHANGED Viewed

@@ -38,27 +38,27 @@ export class Template__sd extends Template {
         ? `
 import { Sonamu } from "sonamu";
-const DEFAULT_LOCALE = "${defaultLocale}";
-const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)};
-function getCurrentLocale(): string {
+const DEFAULT_LOCALE = "${defaultLocale}" as const;
+const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;
+function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {
   try {
     const ctx = Sonamu.getContext();
-    return ctx.locale ?? DEFAULT_LOCALE;
+    return ctx.locale as (typeof SUPPORTED_LOCALES)[number] ?? DEFAULT_LOCALE;
   } catch (_) {
     return DEFAULT_LOCALE;
   }
 }
 `.trim()
         : `
-const DEFAULT_LOCALE = "${defaultLocale}";
-const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)};
-let _currentLocale = DEFAULT_LOCALE;
+const DEFAULT_LOCALE = "${defaultLocale}" as const;
+const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;
+let _currentLocale: (typeof SUPPORTED_LOCALES)[number] = DEFAULT_LOCALE;
-export function setLocale(locale: string) {
+export function setLocale(locale: (typeof SUPPORTED_LOCALES)[number]) {
   _currentLocale = locale;
 }
-export function getCurrentLocale(): string {
+export function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {
   return _currentLocale;
 }
 `.trim();
@@ -136,33 +136,46 @@ export function SD<K extends DictKey>(key: K): SDReturnType<K> {
  * const EN = SD.locale("en");
  * EN("common.save")  // → "Save"
  */
-SD.locale = (locale: string) => <K extends DictKey>(key: K): SDReturnType<K> => {
+SD.locale = (locale: (typeof SUPPORTED_LOCALES)[number]) => <K extends DictKey>(key: K): SDReturnType<K> => {
   return getDictValue(key, locale);
 };
+// Localized 가능한 Column 타입 계산
+type LocalizedBaseColumn<T> = {
+  [K in keyof T & string]: K extends \`\${infer Base}_\${(typeof SUPPORTED_LOCALES)[number]}\` ? Base : K;
+}[keyof T & string];
 /**
  * locale에 따라 적절한 컬럼 값을 반환합니다.
  * DB에 name, name_ko, name_en처럼 localized column이 있을 때 사용합니다.
- *
- * 우선순위 (ko locale): column_ko → column → column_en
- * 우선순위 (en locale): column_en → column → column_ko
+ *
+ * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 ko, 사용자의 로케일은 jp일 때): column_jp → column → column_ko → column_en
+ * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 en, 사용자의 로케일은 ko일 때): column_ko → column → column_en → column_jp
  *
  * @example
  * localizedColumn(tag, "name")
  */
-export function localizedColumn<T extends Record<string, unknown>, K extends keyof T & string>(
+export function localizedColumn<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(
   row: T,
   column: K,
 ): string | undefined {
   const locale = getCurrentLocale();
-  const otherLocales = SUPPORTED_LOCALES.filter((l: string) => l !== locale);
-  const localizedKey = (column: K, locale: string) => \`\${String(column)}_\${locale}\`;
-  const keys = [localizedKey(column, locale), column, ...otherLocales.map((l) => localizedKey(column, l))];
+  const otherLocales = SUPPORTED_LOCALES.filter((l: string) => l !== locale && l !== DEFAULT_LOCALE);
+  const localizedKey = (column: K, locale: (typeof SUPPORTED_LOCALES)[number]) => \`\${column}_\${locale}\`;
+  const keys = [
+    localizedKey(column, locale),
+    column,
+    localizedKey(column, DEFAULT_LOCALE),
+    ...otherLocales.map((l) => localizedKey(column, l)),
+  ];
   for (const key of keys) {
-    const value = row[key];
-    if (value != null && value !== "") {
-      return String(value);
+    if (!(key in row)) {
+      continue;
+    }
+    if (row[key] !== null && row[key] !== undefined && row[key] !== "") {
+      return String(row[key]);
     }
   }

package/src/template/implementations/view_form.template.ts CHANGED Viewed

@@ -138,7 +138,9 @@ export class Template__view_form extends Template {
           value = Object.keys(col.zodType.enum)[0];
         } else if (col.zodType instanceof z.ZodBoolean) {
           value = false;
-        } else if (col.zodType instanceof z.ZodString) {
+        } else if (col.zodType instanceof z.core.$ZodString) {
+          // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함
+          // FIXME: email이나 url 타입 등에 대한 처리가 필요함
           if (col.renderType === "string-datetime") {
             value = "now()";
           } else {

package/src/template/implementations/view_id_async_select.template.ts CHANGED Viewed

@@ -147,8 +147,8 @@ export function ${names.capital}IdAsyncSelect<T extends ${names.capital}SubsetKe
     return (
       <MultiSelect
         options={options}
+        value={multiValue}
         onValueChange={handleMultiChange}
-        defaultValue={multiValue}
         placeholder={placeholder}
         disabled={disabled}
         className={className}

package/src/template/zod-converter.ts CHANGED Viewed

@@ -627,7 +627,9 @@ export function zodTypeToRenderingNode(
 function resolveRenderType(key: string, zodType: z.ZodTypeAny): RenderingNode["renderType"] {
   if (zodType instanceof z.ZodDate) {
     return "datetime";
-  } else if (zodType instanceof z.ZodString) {
+  } else if (zodType instanceof z.core.$ZodString) {
+    // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함
+    // FIXME: email이나 url 타입 등에 대한 처리가 필요함
     if (zodType.description === "SQLDateTimeString") {
       return "string-datetime";
     } else if (key.endsWith("date")) {

package/src/testing/fixture-manager.ts CHANGED Viewed

@@ -14,6 +14,7 @@ import { type UBRef, UpsertBuilder } from "../database/upsert-builder";
 import type { Entity } from "../entity/entity";
 import { EntityManager } from "../entity/entity-manager";
 import {
+  type BelongsToOneRelationProp,
   type DatabaseSchemaExtend,
   type EntityProp,
   type FixtureImportResult,
@@ -26,6 +27,7 @@ import {
   isRelationProp,
   isVirtualProp,
   type ManyToManyRelationProp,
+  type OneToOneRelationProp,
 } from "../types/types";
 import { RelationGraph } from "./_relation-graph";
@@ -65,7 +67,6 @@ export class FixtureManagerClass {
   // UpsertBuilder 기반 import를 위한 상태
   private builder: UpsertBuilder = new UpsertBuilder();
   private fixtureRefMap: Map<string, UBRef> = new Map();
-  private uuidToFixtureId: Map<string, string> = new Map();
   private skippedFixtures: Map<string, { entityId: string; existingId: number }> = new Map();
   init() {
@@ -422,8 +423,13 @@ export class FixtureManagerClass {
   /**
    * 1. RelationGraph로 fixture 단위 삽입 순서 계산 (self-reference 포함)
-   * 2. 순서대로 UpsertBuilder에 등록 (UBRef로 참조 관계 표현)
-   * 3. 테이블별 upsert 실행 (ID는 DB가 자동 할당)
+   * 2. 테이블별 레벨별로 UpsertBuilder에 등록 및 upsert 실행
+   * 3. 순서 기반 uuid→id 매핑 (UpsertBuilder가 uuid를 DB에 저장하지 않으므로)
+   *
+   * UpsertBuilder는 self-reference가 있으면 buildInsertLevels()로 재정렬하여
+   * 등록 순서와 반환 순서가 달라질 수 있습니다. 이를 방지하기 위해
+   * FixtureManager가 레벨별로 나눠서 처리하여 각 upsert 호출에서는
+   * self-reference가 없도록 합니다.
    */
   async insertFixtures(
     dbName: keyof SonamuDBConfig,
@@ -434,7 +440,6 @@ export class FixtureManagerClass {
     // 초기화
     this.builder = new UpsertBuilder();
     this.fixtureRefMap = new Map();
-    this.uuidToFixtureId = new Map();
     this.skippedFixtures = new Map();
     const db = createKnexInstance(Sonamu.dbConfig[dbName]);
@@ -445,7 +450,7 @@ export class FixtureManagerClass {
       this.relationGraph.buildGraph(fixtures);
       const insertionOrder = this.relationGraph.getInsertionOrder();
-      // 2. 순서대로 UpsertBuilder에 등록 (override 체크)
+      // 2. 스킵할 fixture 먼저 처리 (override 체크)
       for (const fixtureId of insertionOrder) {
         const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
         if (!fixture) continue;
@@ -469,52 +474,82 @@ export class FixtureManagerClass {
               `Skipped ${fixture.entityId}#${fixture.id} (existing: #${existingId}, override: false)`,
             ),
           );
-          continue;
         }
-        this.registerFixture(fixture);
-        console.log(
-          chalk.blue(
-            `Registered ${fixture.entityId}#${fixture.id}${fixture.override ? ` (override existing: #${fixture.target?.id})` : ""}`,
-          ),
-        );
       }
-      // 3. 테이블별 upsert 실행
-      const tableOrder = this.getTableOrder(fixtures);
+      // 3. 테이블별 fixture 그룹화 (insertionOrder 순서 기반)
+      const fixturesByTable = new Map<string, FixtureRecord[]>();
+      const tableOrder: string[] = [];
-      await db.transaction(async (trx) => {
-        const insertedIdsByTable = new Map<string, Map<string, number>>();
+      for (const fixtureId of insertionOrder) {
+        // 스킵된 fixture 제외
+        if (this.skippedFixtures.has(fixtureId)) continue;
-        for (const tableName of tableOrder) {
-          if (!this.builder.hasTable(tableName)) continue;
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
+        if (!fixture) continue;
+        const entity = EntityManager.get(fixture.entityId);
+        const tableName = entity.table;
-          // upsert 실행 전 uuid 목록 저장
-          const table = this.builder.getTable(tableName);
-          const uuids = table.rows.map((row) => row.uuid as string);
+        if (!fixturesByTable.has(tableName)) {
+          fixturesByTable.set(tableName, []);
+          tableOrder.push(tableName);
+        }
+        fixturesByTable.get(tableName)?.push(fixture);
+      }
-          console.log(chalk.blue(`Upserting ${tableName} with ${uuids.length} rows`));
-          await this.builder.upsert(trx, tableName);
+      await db.transaction(async (trx) => {
+        const insertedIdsByTable = new Map<string, Map<string, number>>();
-          // upsert된 row들의 uuid -> id 매핑 구축
-          if (uuids.length > 0) {
-            const uuidToId = new Map<string, number>();
-            const rows = await trx(tableName as string)
-              .select("uuid", "id")
-              .whereIn("uuid", uuids);
+        // 4. 테이블별 레벨별 처리
+        for (const tableName of tableOrder) {
+          const tableFixtures = fixturesByTable.get(tableName) ?? [];
+          const levels = this.groupFixturesByLevel(tableFixtures);
-            for (const row of rows) {
-              uuidToId.set(row.uuid, row.id);
+          for (const levelFixtures of levels) {
+            // 해당 레벨의 fixture들 register
+            for (const fixture of levelFixtures) {
+              this.registerFixture(fixture, insertedIdsByTable);
+              console.log(
+                chalk.blue(
+                  `Registered ${fixture.entityId}#${fixture.id}${fixture.override ? ` (override)` : ""}`,
+                ),
+              );
             }
-            insertedIdsByTable.set(tableName, uuidToId);
+            // upsert 실행 전 uuid 목록 저장
+            const table = this.builder.getTable(tableName);
+            const uuids = table.rows.map((row) => row.uuid as string);
+            console.log(
+              chalk.blue(
+                `Upserting ${tableName} with ${uuids.length} rows (level ${levels.indexOf(levelFixtures) + 1}/${levels.length})`,
+              ),
+            );
+            const ids = await this.builder.upsert(trx, tableName as keyof DatabaseSchemaExtend);
+            // 순서 기반 uuid -> id 매핑
+            // self-reference가 없으므로 등록 순서 = 반환 순서 보장
+            if (uuids.length > 0 && uuids.length === ids.length) {
+              const existingMap = insertedIdsByTable.get(tableName) ?? new Map<string, number>();
+              for (let i = 0; i < uuids.length; i++) {
+                existingMap.set(uuids[i], ids[i]);
+              }
+              insertedIdsByTable.set(tableName, existingMap);
+            } else if (uuids.length !== ids.length) {
+              console.warn(
+                chalk.yellow(
+                  `Warning: uuid count (${uuids.length}) != id count (${ids.length}) for ${tableName}`,
+                ),
+              );
+            }
           }
         }
-        // 4. ManyToMany 관계 처리
+        // 5. ManyToMany 관계 처리
         await this.processManyToManyRelations(trx, fixtures, insertedIdsByTable);
-        // 5. 결과 수집
+        // 6. 결과 수집
         for (const fixture of fixtures) {
           const entity = EntityManager.get(fixture.entityId);
@@ -555,8 +590,12 @@ export class FixtureManagerClass {
   /**
    * FixtureRecord를 UpsertBuilder에 등록
+   * @param insertedIdsByTable 이미 upsert된 테이블의 uuid→id 매핑 (레벨별 처리 시 사용)
    */
-  private registerFixture(fixture: FixtureRecord): UBRef {
+  private registerFixture(
+    fixture: FixtureRecord,
+    insertedIdsByTable?: Map<string, Map<string, number>>,
+  ): UBRef {
     const entity = EntityManager.get(fixture.entityId);
     const row: Record<string, unknown> = {};
@@ -571,8 +610,13 @@ export class FixtureManagerClass {
         continue;
       }
-      // id/uuid 처리: Override 모드일 때만 기존 값 사용
-      if (propName === "id" || propName === "uuid") {
+      // Generated column은 INSERT에서 제외 (DB가 자동 생성)
+      if ("generated" in prop && prop.generated) {
+        continue;
+      }
+      // id 처리: Override 모드일 때만 기존 값 사용
+      if (propName === "id") {
         if (isOverrideMode && existingRecord) {
           // Override: 기존 레코드의 값 사용 → UPDATE
           row[propName] = existingRecord.columns[propName]?.value;
@@ -598,8 +642,18 @@ export class FixtureManagerClass {
             } else {
               const relatedRef = this.fixtureRefMap.get(relatedFixtureId);
               if (relatedRef) {
-                // 이미 등록된 fixture 참조 → UBRef 사용
-                row[`${propName}_id`] = relatedRef;
+                // 이미 upsert된 같은 테이블 fixture 확인
+                const relatedEntity = EntityManager.get(prop.with);
+                const relatedInsertedIds = insertedIdsByTable?.get(relatedEntity.table);
+                const actualId = relatedInsertedIds?.get(relatedRef.uuid);
+                if (actualId !== undefined) {
+                  // 이미 upsert됨 → 실제 ID 사용
+                  row[`${propName}_id`] = actualId;
+                } else {
+                  // 아직 upsert 안됨 → UBRef 사용
+                  row[`${propName}_id`] = relatedRef;
+                }
               } else {
                 // fixtures에 포함되지 않은 레코드 → ID 그대로 사용
                 row[`${propName}_id`] = relatedId;
@@ -619,7 +673,6 @@ export class FixtureManagerClass {
     console.log(chalk.blue(`Registering ${entity.table} - ${inspect(row, false, null, true)}`));
     const ref = this.builder.register(entity.table, row);
     this.fixtureRefMap.set(fixture.fixtureId, ref);
-    this.uuidToFixtureId.set(ref.uuid, fixture.fixtureId);
     return ref;
   }
@@ -648,24 +701,6 @@ export class FixtureManagerClass {
     }
   }
-  /**
-   * 테이블 순서 추출 (fixtures에 포함된 테이블만)
-   */
-  private getTableOrder(fixtures: FixtureRecord[]): (keyof DatabaseSchemaExtend)[] {
-    const tables: string[] = [];
-    const seen = new Set<string>();
-    for (const fixture of fixtures) {
-      const entity = EntityManager.get(fixture.entityId);
-      if (!seen.has(entity.table)) {
-        seen.add(entity.table);
-        tables.push(entity.table);
-      }
-    }
-    return tables as (keyof DatabaseSchemaExtend)[];
-  }
   private async processManyToManyRelations(
     trx: Knex.Transaction,
     fixtures: FixtureRecord[],
@@ -746,6 +781,79 @@ export class FixtureManagerClass {
     }
   }
+  /**
+   * 같은 테이블 내 fixture들을 self-reference 레벨별로 분할
+   * - self-reference가 없는 fixture들: Level 0
+   * - Level 0을 참조하는 fixture들: Level 1
+   * - 반복
+   *
+   * UpsertBuilder가 self-reference가 있으면 buildInsertLevels()로 재정렬하여
+   * 등록 순서와 반환 순서가 달라질 수 있습니다.
+   * 이를 방지하기 위해 FixtureManager가 레벨별로 나눠서 처리합니다.
+   */
+  private groupFixturesByLevel(fixtures: FixtureRecord[]): FixtureRecord[][] {
+    if (fixtures.length === 0) {
+      return [];
+    }
+    const entity = EntityManager.get(fixtures[0].entityId);
+    // self-reference relation prop 찾기
+    const selfRefProps = entity.props.filter(
+      (p): p is BelongsToOneRelationProp | OneToOneRelationProp =>
+        isRelationProp(p) &&
+        (isBelongsToOneRelationProp(p) || (isOneToOneRelationProp(p) && p.hasJoinColumn)) &&
+        p.with === entity.id,
+    );
+    if (selfRefProps.length === 0) {
+      // self-reference 없음 → 단일 레벨
+      return [fixtures];
+    }
+    // 레벨별 분할 (topological sort)
+    const levels: FixtureRecord[][] = [];
+    const remaining = new Set(fixtures.map((f) => f.fixtureId));
+    const processed = new Set<string>();
+    while (remaining.size > 0) {
+      const currentLevel: FixtureRecord[] = [];
+      for (const fixture of fixtures) {
+        if (!remaining.has(fixture.fixtureId)) continue;
+        // self-reference가 모두 이미 처리됐거나 null인 경우
+        const canProcess = selfRefProps.every((prop) => {
+          const refId = fixture.columns[prop.name]?.value as number | null;
+          if (refId === null || refId === undefined) return true;
+          const refFixtureId = `${prop.with}#${refId}`;
+          // 이미 처리됐거나, 현재 fixtures에 포함되지 않은 경우 (외부 참조)
+          return processed.has(refFixtureId) || !remaining.has(refFixtureId);
+        });
+        if (canProcess) {
+          currentLevel.push(fixture);
+        }
+      }
+      if (currentLevel.length === 0) {
+        const remainingIds = Array.from(remaining).join(", ");
+        throw new Error(
+          `Circular self-reference detected in ${entity.table}. Remaining fixtures: ${remainingIds}`,
+        );
+      }
+      for (const fixture of currentLevel) {
+        remaining.delete(fixture.fixtureId);
+        processed.add(fixture.fixtureId);
+      }
+      levels.push(currentLevel);
+    }
+    return levels;
+  }
   private async checkUniqueViolation(db: Knex, entity: Entity, fixture: FixtureRecord) {
     const _uniqueIndexes = entity.indexes?.filter((i) => i.type === "unique") ?? [];