sonamu 0.2.54 → 0.2.55

package/dist/chunk-6SP5N5ND.mjs

@@ -0,0 +1,1579 @@
+import {
+  DB,
+  EntityManager,
+  ServiceUnavailableException,
+  Sonamu,
+  isBelongsToOneRelationProp,
+  isDecimalProp,
+  isEnumProp,
+  isFloatProp,
+  isHasManyRelationProp,
+  isIntegerProp,
+  isKnexError,
+  isManyToManyRelationProp,
+  isOneToOneRelationProp,
+  isRelationProp,
+  isStringProp,
+  isTextProp,
+  isVirtualProp
+} from "./chunk-ZFLQLW37.mjs";
+
+// src/entity/migrator.ts
+import _ from "lodash";
+import chalk from "chalk";
+import { DateTime } from "luxon";
+import fs from "fs-extra";
+import equal from "fast-deep-equal";
+import inflection from "inflection";
+import prompts from "prompts";
+import { execSync } from "child_process";
+import path from "path";
+var Migrator = class {
+  mode;
+  targets;
+  constructor(options) {
+    this.mode = options.mode;
+    if (this.mode === "dev") {
+      const devDB = DB.getClient("development_master");
+      const testDB = DB.getClient("test");
+      const fixtureLocalDB = DB.getClient("fixture_local");
+      const uniqConfigs = DB.getUniqueConfigs([
+        "development_master",
+        "test",
+        "fixture_local",
+        "fixture_remote"
+      ]);
+      const applyDBs = [devDB, testDB, fixtureLocalDB];
+      if (uniqConfigs.length === 4) {
+        const fixtureRemoteDB = DB.getClient("fixture_remote");
+        applyDBs.push(fixtureRemoteDB);
+      }
+      this.targets = {
+        compare: devDB,
+        pending: devDB,
+        shadow: testDB,
+        apply: applyDBs
+      };
+    } else if (this.mode === "deploy") {
+      const productionDB = DB.getClient("production_master");
+      const testDB = DB.getClient("test");
+      this.targets = {
+        pending: productionDB,
+        shadow: testDB,
+        apply: [productionDB]
+      };
+    } else {
+      throw new Error(`\uC798\uBABB\uB41C \uBAA8\uB4DC ${this.mode} \uC785\uB825`);
+    }
+  }
+  async getMigrationCodes() {
+    const srcMigrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    const distMigrationsDir = `${Sonamu.apiRootPath}/dist/migrations`;
+    if (fs.existsSync(srcMigrationsDir) === false) {
+      fs.mkdirSync(srcMigrationsDir, {
+        recursive: true
+      });
+    }
+    if (fs.existsSync(distMigrationsDir) === false) {
+      fs.mkdirSync(distMigrationsDir, {
+        recursive: true
+      });
+    }
+    const srcMigrations = fs.readdirSync(srcMigrationsDir).filter((f) => f.endsWith(".ts")).map((f) => f.split(".")[0]);
+    const distMigrations = fs.readdirSync(distMigrationsDir).filter((f) => f.endsWith(".js")).map((f) => f.split(".")[0]);
+    const normal = _.intersection(srcMigrations, distMigrations).map((filename) => {
+      return {
+        name: filename,
+        path: path.join(srcMigrationsDir, filename) + ".ts"
+      };
+    }).sort((a, b) => a > b ? 1 : -1);
+    const onlyTs = _.difference(srcMigrations, distMigrations).map(
+      (filename) => {
+        return {
+          name: filename,
+          path: path.join(srcMigrationsDir, filename) + ".ts"
+        };
+      }
+    );
+    const onlyJs = _.difference(distMigrations, srcMigrations).map(
+      (filename) => {
+        return {
+          name: filename,
+          path: path.join(distMigrationsDir, filename) + ".js"
+        };
+      }
+    );
+    return {
+      normal,
+      onlyTs,
+      onlyJs
+    };
+  }
+  async getStatus() {
+    const { normal, onlyTs, onlyJs } = await this.getMigrationCodes();
+    if (onlyTs.length > 0) {
+      console.debug({ onlyTs });
+      throw new ServiceUnavailableException(
+        `There are un-compiled TS migration files.
+Please compile them first.
+
+${onlyTs.map((f) => f.name).join("\n")}`
+      );
+    }
+    if (onlyJs.length > 0) {
+      console.debug({ onlyJs });
+      await Promise.all(
+        onlyJs.map(async (f) => {
+          execSync(
+            `rm -f ${f.path.replace("/src/", "/dist/").replace(".ts", ".js")}`
+          );
+        })
+      );
+    }
+    const connKeys = Object.keys(DB.fullConfig).filter(
+      (key) => key.endsWith("_slave") === false
+    );
+    const statuses = await Promise.all(
+      connKeys.map(async (connKey) => {
+        const tConn = DB.getClient(connKey);
+        const status = await (async () => {
+          try {
+            return await tConn.status();
+          } catch (err) {
+            console.error(err);
+            return "error";
+          }
+        })();
+        const pending = await (async () => {
+          try {
+            return await tConn.getMigrations();
+          } catch (err) {
+            console.error(err);
+            return [];
+          }
+        })();
+        const currentVersion = await (async () => {
+          return "error";
+        })();
+        const info = tConn.connectionInfo;
+        await tConn.destroy();
+        return {
+          name: connKey.replace("_master", ""),
+          connKey,
+          connString: `mysql2://${info.user ?? ""}@${info.host}:${info.port}/${info.database}`,
+          currentVersion,
+          status,
+          pending
+        };
+      })
+    );
+    const preparedCodes = await (async () => {
+      const status0conn = statuses.find((status) => status.status === 0);
+      if (status0conn === void 0) {
+        return [];
+      }
+      const compareDBconn = DB.getClient(status0conn.connKey);
+      const genCodes = await this.compareMigrations(compareDBconn);
+      await compareDBconn.destroy();
+      return genCodes;
+    })();
+    return {
+      conns: statuses,
+      codes: normal,
+      preparedCodes
+    };
+  }
+  async runAction(action, targets) {
+    const configs = DB.getUniqueConfigs(targets);
+    const conns = await Promise.all(
+      configs.map(async (config) => ({
+        connKey: config.connKey,
+        db: DB.getClient(config.connKey)
+      }))
+    );
+    const result = await (async () => {
+      switch (action) {
+        case "latest":
+          return Promise.all(
+            conns.map(async ({ connKey, db }) => {
+              const [batchNo, applied] = await db.migrate();
+              return {
+                connKey,
+                batchNo,
+                applied
+              };
+            })
+          );
+        case "rollback":
+          return Promise.all(
+            conns.map(async ({ connKey, db }) => {
+              const [batchNo, applied] = await db.rollback();
+              return {
+                connKey,
+                batchNo,
+                applied
+              };
+            })
+          );
+      }
+    })();
+    await Promise.all(
+      conns.map(({ db }) => {
+        return db.destroy();
+      })
+    );
+    return result;
+  }
+  async delCodes(codeNames) {
+    const { conns } = await this.getStatus();
+    if (conns.some((conn) => {
+      return codeNames.some(
+        (codeName) => conn.pending.includes(codeName) === false
+      );
+    })) {
+      throw new Error(
+        "You cannot delete a migration file if there is already applied."
+      );
+    }
+    const delFiles = codeNames.map((codeName) => [
+      `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`,
+      `${Sonamu.apiRootPath}/dist/migrations/${codeName}.js`
+    ]).flat();
+    const res = await Promise.all(
+      delFiles.map((delFile) => {
+        if (fs.existsSync(delFile)) {
+          console.log(chalk.red(`DELETE: ${delFile}`));
+          fs.unlinkSync(delFile);
+          return delFiles.includes(".ts") ? 1 : 0;
+        }
+        return 0;
+      })
+    );
+    return _.sum(res);
+  }
+  async generatePreparedCodes() {
+    const { preparedCodes } = await this.getStatus();
+    if (preparedCodes.length === 0) {
+      console.log(chalk.green("\n\uD604\uC7AC \uBAA8\uB450 \uC2F1\uD06C\uB41C \uC0C1\uD0DC\uC785\uB2C8\uB2E4."));
+      return 0;
+    }
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    preparedCodes.filter((pcode) => pcode.formatted).map((pcode, index) => {
+      const dateTag = DateTime.local().plus({ seconds: index }).toFormat("yyyyMMddHHmmss");
+      const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
+      fs.writeFileSync(filePath, pcode.formatted);
+      console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
+    });
+    return preparedCodes.length;
+  }
+  async clearPendingList() {
+    const pendingList = await this.targets.pending.getMigrations();
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    const delList = pendingList.map((df) => {
+      return path.join(migrationsDir, `${df}.ts`);
+    });
+    for (let p of delList) {
+      if (fs.existsSync(p)) {
+        fs.unlinkSync(p);
+      }
+    }
+    await this.cleanUpDist(true);
+  }
+  async check() {
+    const codes = await this.compareMigrations(this.targets.compare);
+    if (codes.length === 0) {
+      console.log(chalk.green("\n\uD604\uC7AC \uBAA8\uB450 \uC2F1\uD06C\uB41C \uC0C1\uD0DC\uC785\uB2C8\uB2E4."));
+      return;
+    }
+    console.table(codes, ["type", "title"]);
+    console.log(codes[0]);
+  }
+  async run() {
+    const pendingList = await this.targets.pending.getMigrations();
+    if (pendingList.length > 0) {
+      console.log(
+        chalk.red("pending \uB41C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uC774 \uC874\uC7AC\uD569\uB2C8\uB2E4."),
+        pendingList.map((pending) => pending.file)
+      );
+      const answer2 = await prompts({
+        type: "confirm",
+        name: "value",
+        message: "Shadow DB \uD14C\uC2A4\uD2B8\uB97C \uC9C4\uD589\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+        initial: true
+      });
+      if (answer2.value === false) {
+        return;
+      }
+      console.time(chalk.blue("Migrator - runShadowTest"));
+      await this.runShadowTest();
+      console.timeEnd(chalk.blue("Migrator - runShadowTest"));
+      await Promise.all(
+        this.targets.apply.map(async (applyDb) => {
+          const info = applyDb.connectionInfo;
+          const label = chalk.green(`APPLIED ${info.host} ${info.database}`);
+          console.time(label);
+          await applyDb.migrate();
+          console.timeEnd(label);
+        })
+      );
+    }
+    const codes = await this.compareMigrations(this.targets.compare);
+    if (codes.length === 0) {
+      console.log(chalk.green("\n\uD604\uC7AC \uBAA8\uB450 \uC2F1\uD06C\uB41C \uC0C1\uD0DC\uC785\uB2C8\uB2E4."));
+      return;
+    }
+    console.table(codes, ["type", "title"]);
+    const answer = await prompts({
+      type: "confirm",
+      name: "value",
+      message: "\uB9C8\uC774\uADF8\uB808\uC774\uC158 \uCF54\uB4DC\uB97C \uC0DD\uC131\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+      initial: false
+    });
+    if (answer.value === false) {
+      return;
+    }
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    codes.filter((code) => code.formatted).map((code, index) => {
+      const dateTag = DateTime.local().plus({ seconds: index }).toFormat("yyyyMMddHHmmss");
+      const filePath = `${migrationsDir}/${dateTag}_${code.title}.ts`;
+      fs.writeFileSync(filePath, code.formatted);
+      console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
+    });
+  }
+  async rollback() {
+    console.time(chalk.red("rollback:"));
+    const rollbackAllResult = await Promise.all(
+      this.targets.apply.map(async (db) => {
+        return db.rollback();
+      })
+    );
+    console.dir({ rollbackAllResult }, { depth: null });
+    console.timeEnd(chalk.red("rollback:"));
+  }
+  async cleanUpDist(force = false) {
+    const files = ["src", "dist"].reduce(
+      (r, which) => {
+        const migrationPath = path.join(
+          Sonamu.apiRootPath,
+          which,
+          "migrations"
+        );
+        if (fs.existsSync(migrationPath) === false) {
+          fs.mkdirSync(migrationPath, {
+            recursive: true
+          });
+        }
+        const files2 = fs.readdirSync(migrationPath).filter((filename) => filename.startsWith(".") === false);
+        r[which] = files2;
+        return r;
+      },
+      {
+        src: [],
+        dist: []
+      }
+    );
+    const diffOnSrc = _.differenceBy(
+      files.src,
+      files.dist,
+      (filename) => filename.split(".")[0]
+    );
+    if (diffOnSrc.length > 0) {
+      throw new Error(
+        "\uCEF4\uD30C\uC77C \uB418\uC9C0 \uC54A\uC740 \uD30C\uC77C\uC774 \uC788\uC2B5\uB2C8\uB2E4.\n" + diffOnSrc.join("\n")
+      );
+    }
+    const diffOnDist = _.differenceBy(
+      files.dist,
+      files.src,
+      (filename) => filename.split(".")[0]
+    );
+    if (diffOnDist.length > 0) {
+      console.log(chalk.red("\uC6D0\uBCF8 ts\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uB294 js\uD30C\uC77C\uC774 \uC788\uC2B5\uB2C8\uB2E4."));
+      console.log(diffOnDist);
+      if (!force) {
+        const answer = await prompts({
+          type: "confirm",
+          name: "value",
+          message: "\uC0AD\uC81C\uB97C \uC9C4\uD589\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+          initial: true
+        });
+        if (answer.value === false) {
+          return;
+        }
+      }
+      const filesToRm = diffOnDist.map((filename) => {
+        return path.join(Sonamu.apiRootPath, "dist", "migrations", filename);
+      });
+      filesToRm.map((filePath) => {
+        fs.unlinkSync(filePath);
+      });
+      console.log(chalk.green(`${filesToRm.length}\uAC74 \uC0AD\uC81C\uB418\uC5C8\uC2B5\uB2C8\uB2E4!`));
+    }
+  }
+  async runShadowTest() {
+    const tdb = DB.getClient("test");
+    const tdbConn = tdb.connectionInfo;
+    const shadowDatabase = tdbConn.database + "__migration_shadow";
+    const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;
+    console.log(
+      chalk.magenta(`${tdbConn.database}\uC758 \uB370\uC774\uD130 ${tmpSqlPath}\uB85C \uB364\uD504`)
+    );
+    execSync(
+      `mysqldump -h${tdbConn.host} -P${tdbConn.port} -u${tdbConn.user} -p'${tdbConn.password}' ${tdbConn.database} --single-transaction --no-create-db --triggers > ${tmpSqlPath};`
+    );
+    execSync(
+      `sed -i'' -e 's/\`${tdbConn.database}\`/\`${shadowDatabase}\`/g' ${tmpSqlPath};`
+    );
+    console.log(chalk.magenta(`${shadowDatabase} \uB9AC\uC14B`));
+    await tdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
+    await tdb.raw(`CREATE DATABASE \`${shadowDatabase}\`;`);
+    console.log(chalk.magenta(`${shadowDatabase} \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uC0DD\uC131`));
+    execSync(
+      `mysql -h${tdbConn.host} -P${tdbConn.port} -u${tdbConn.user} -p'${tdbConn.password}' ${shadowDatabase} < ${tmpSqlPath};`
+    );
+    try {
+      await tdb.raw(`USE \`${shadowDatabase}\`;`);
+      const [batchNo, applied] = await tdb.migrate();
+      console.log(chalk.green("Shadow DB \uD14C\uC2A4\uD2B8\uC5D0 \uC131\uACF5\uD588\uC2B5\uB2C8\uB2E4!"), {
+        batchNo,
+        applied
+      });
+      console.log(chalk.magenta(`${shadowDatabase} \uC0AD\uC81C`));
+      await tdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
+      return [
+        {
+          connKey: "shadow",
+          batchNo,
+          applied
+        }
+      ];
+    } catch (e) {
+      console.error(e);
+      throw new ServiceUnavailableException("Shadow DB \uD14C\uC2A4\uD2B8 \uC9C4\uD589 \uC911 \uC5D0\uB7EC");
+    } finally {
+      await tdb.destroy();
+    }
+  }
+  async resetAll() {
+    const answer = await prompts({
+      type: "confirm",
+      name: "value",
+      message: "\uBAA8\uB4E0 DB\uB97C \uB864\uBC31\uD558\uACE0 \uC804\uCCB4 \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uD30C\uC77C\uC744 \uC0AD\uC81C\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+      initial: false
+    });
+    if (answer.value === false) {
+      return;
+    }
+    console.time(chalk.red("rollback-all:"));
+    const rollbackAllResult = await Promise.all(
+      this.targets.apply.map(async (db) => {
+        return db.rollbackAll();
+      })
+    );
+    console.log({ rollbackAllResult });
+    console.timeEnd(chalk.red("rollback-all:"));
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    console.time(chalk.red("delete migration files"));
+    execSync(`rm -f ${migrationsDir}/*`);
+    execSync(`rm -f ${migrationsDir.replace("/src/", "/dist/")}/*`);
+    console.timeEnd(chalk.red("delete migration files"));
+  }
+  async compareMigrations(compareDB) {
+    const entityIds = EntityManager.getAllIds();
+    const entitySetsWithJoinTable = entityIds.filter((entityId) => {
+      const entity = EntityManager.get(entityId);
+      return entity.props.length > 0;
+    }).map((entityId) => {
+      const entity = EntityManager.get(entityId);
+      return this.getMigrationSetFromEntity(entity);
+    });
+    const joinTablesWithDup = entitySetsWithJoinTable.map((entitySet) => entitySet.joinTables).flat();
+    const joinTables = Object.values(
+      _.groupBy(joinTablesWithDup, (jt) => jt.table)
+    ).map((tables) => {
+      if (tables.length === 1) {
+        return tables[0];
+      }
+      return {
+        ...tables[0],
+        indexes: _.uniqBy(
+          tables.flatMap((t) => t.indexes),
+          (index) => [index.type, ...index.columns.sort()].join("-")
+        )
+      };
+    });
+    const entitySets = [
+      ...entitySetsWithJoinTable,
+      ...joinTables
+    ];
+    const codes = (await Promise.all(
+      entitySets.map(async (entitySet) => {
+        const dbSet = await this.getMigrationSetFromDB(
+          compareDB,
+          entitySet.table
+        );
+        if (dbSet === null) {
+          return [
+            await DB.generator.generateCreateCode_ColumnAndIndexes(
+              entitySet.table,
+              entitySet.columns,
+              entitySet.indexes
+            ),
+            ...await DB.generator.generateCreateCode_Foreign(
+              entitySet.table,
+              entitySet.foreigns
+            )
+          ];
+        }
+        const alterCodes = await Promise.all(
+          ["columnsAndIndexes", "foreigns"].map((key) => {
+            if (key === "columnsAndIndexes") {
+              const replaceColumnDefaultTo = (col) => {
+                if (col.type === "float" && col.defaultTo && String(col.defaultTo).includes('"') === false) {
+                  col.defaultTo = `"${Number(col.defaultTo).toFixed(
+                    col.scale ?? 2
+                  )}"`;
+                }
+                if (col.type === "string" && col.defaultTo === "") {
+                  col.defaultTo = '""';
+                }
+                return col;
+              };
+              const entityColumns = _.sortBy(
+                entitySet.columns,
+                (a) => a.name
+              ).map(replaceColumnDefaultTo);
+              const dbColumns = _.sortBy(dbSet.columns, (a) => a.name).map(
+                replaceColumnDefaultTo
+              );
+              const entityIndexes = _.sortBy(
+                entitySet.indexes,
+                (a) => [
+                  a.type,
+                  ...a.columns.sort((c1, c2) => c1 > c2 ? 1 : -1)
+                ].join("-")
+              );
+              const dbIndexes = _.sortBy(
+                dbSet.indexes,
+                (a) => [
+                  a.type,
+                  ...a.columns.sort((c1, c2) => c1 > c2 ? 1 : -1)
+                ].join("-")
+              );
+              const isEqualColumns = equal(entityColumns, dbColumns);
+              const isEqualIndexes = equal(entityIndexes, dbIndexes);
+              if (isEqualColumns && isEqualIndexes) {
+                return null;
+              } else {
+                return DB.generator.generateAlterCode_ColumnAndIndexes(
+                  entitySet.table,
+                  entityColumns,
+                  entityIndexes,
+                  dbColumns,
+                  dbIndexes
+                );
+              }
+            } else {
+              const replaceNoActionOnMySQL = (f) => {
+                const { onDelete, onUpdate } = f;
+                return {
+                  ...f,
+                  onUpdate: onUpdate === "RESTRICT" ? "NO ACTION" : onUpdate,
+                  onDelete: onDelete === "RESTRICT" ? "NO ACTION" : onDelete
+                };
+              };
+              const entityForeigns = _.sortBy(
+                entitySet.foreigns,
+                (a) => [a.to, ...a.columns].join("-")
+              ).map((f) => replaceNoActionOnMySQL(f));
+              const dbForeigns = _.sortBy(
+                dbSet.foreigns,
+                (a) => [a.to, ...a.columns].join("-")
+              ).map((f) => replaceNoActionOnMySQL(f));
+              if (equal(entityForeigns, dbForeigns) === false) {
+                return DB.generator.generateAlterCode_Foreigns(
+                  entitySet.table,
+                  entityForeigns,
+                  dbForeigns
+                );
+              }
+            }
+            return null;
+          })
+        );
+        if (alterCodes.every((alterCode) => alterCode === null)) {
+          return null;
+        } else {
+          return alterCodes.filter((alterCode) => alterCode !== null).flat();
+        }
+      })
+    )).flat().filter((code) => code !== null);
+    codes.sort((codeA, codeB) => {
+      if (codeA.type === "foreign" && codeB.type == "normal") {
+        return 1;
+      } else if (codeA.type === "normal" && codeB.type === "foreign") {
+        return -1;
+      } else {
+        return 0;
+      }
+    });
+    return codes;
+  }
+  /*
+    기존 테이블 정보 읽어서 MigrationSet 형식으로 리턴
+  */
+  async getMigrationSetFromDB(compareDB, table) {
+    let dbColumns, dbIndexes, dbForeigns;
+    try {
+      [dbColumns, dbIndexes, dbForeigns] = await this.readTable(
+        compareDB,
+        table
+      );
+    } catch (e) {
+      if (isKnexError(e) && e.code === "ER_NO_SUCH_TABLE") {
+        return null;
+      }
+      console.error(e);
+      return null;
+    }
+    const columns = dbColumns.map((dbColumn) => {
+      const dbColType = this.resolveDBColType(dbColumn.Type, dbColumn.Field);
+      return {
+        name: dbColumn.Field,
+        nullable: dbColumn.Null !== "NO",
+        ...dbColType,
+        ...(() => {
+          if (dbColumn.Default !== null) {
+            return {
+              defaultTo: dbColumn.Default
+            };
+          }
+          return {};
+        })()
+      };
+    });
+    const dbIndexesGroup = _.groupBy(
+      dbIndexes.filter(
+        (dbIndex) => dbIndex.Key_name !== "PRIMARY" && !dbForeigns.find(
+          (dbForeign) => dbForeign.keyName === dbIndex.Key_name
+        )
+      ),
+      (dbIndex) => dbIndex.Key_name
+    );
+    const indexes = Object.keys(dbIndexesGroup).map(
+      (keyName) => {
+        const currentIndexes = dbIndexesGroup[keyName];
+        return {
+          type: currentIndexes[0].Non_unique === 1 ? "index" : "unique",
+          columns: currentIndexes.map(
+            (currentIndex) => currentIndex.Column_name
+          )
+        };
+      }
+    );
+    const foreigns = dbForeigns.map((dbForeign) => {
+      return {
+        columns: [dbForeign.from],
+        to: `${dbForeign.referencesTable}.${dbForeign.referencesField}`,
+        onUpdate: dbForeign.onUpdate,
+        onDelete: dbForeign.onDelete
+      };
+    });
+    return {
+      table,
+      columns,
+      indexes,
+      foreigns
+    };
+  }
+  resolveDBColType(colType, colField) {
+    let [rawType, unsigned] = colType.split(" ");
+    const matched = rawType.match(/\(([0-9]+)\)/);
+    let length;
+    if (matched !== null && matched[1]) {
+      rawType = rawType.replace(/\(([0-9]+)\)/, "");
+      length = parseInt(matched[1]);
+    }
+    if (rawType === "char" && colField === "uuid") {
+      return {
+        type: "uuid"
+      };
+    }
+    switch (rawType) {
+      case "int":
+        return {
+          type: "integer",
+          unsigned: unsigned === "unsigned"
+        };
+      case "varchar":
+        return {
+          type: "string",
+          ...length !== void 0 && {
+            length
+          }
+        };
+      case "text":
+      case "mediumtext":
+      case "longtext":
+      case "timestamp":
+      case "json":
+      case "date":
+      case "time":
+        return {
+          type: rawType
+        };
+      case "datetime":
+        return {
+          type: "datetime"
+        };
+      case "tinyint":
+        return {
+          type: "boolean"
+        };
+      default:
+        if (rawType.startsWith("decimal")) {
+          const [, precision, scale] = rawType.match(/decimal\(([0-9]+),([0-9]+)\)/) ?? [];
+          return {
+            type: "decimal",
+            precision: parseInt(precision),
+            scale: parseInt(scale),
+            ...unsigned === "unsigned" && {
+              unsigned: true
+            }
+          };
+        } else if (rawType.startsWith("float")) {
+          const [, precision, scale] = rawType.match(/float\(([0-9]+),([0-9]+)\)/) ?? [];
+          return {
+            type: "float",
+            precision: parseInt(precision),
+            scale: parseInt(scale),
+            ...unsigned === "unsigned" && {
+              unsigned: true
+            }
+          };
+        }
+        throw new Error(`resolve \uBD88\uAC00\uB2A5\uD55C DB\uCEEC\uB7FC \uD0C0\uC785 ${colType} ${rawType}`);
+    }
+  }
+  /*
+    기존 테이블 읽어서 cols, indexes 반환
+  */
+  async readTable(compareDB, tableName) {
+    try {
+      const _cols = await compareDB.raw(
+        `SHOW FIELDS FROM ${tableName}`
+      );
+      const cols = _cols.map((col) => ({
+        ...col,
+        // Default 값은 숫자나 MySQL Expression이 아닌 경우 ""로 감싸줌
+        ...col.Default !== null && {
+          Default: col.Default.replace(/[0-9]+/g, "").length > 0 && col.Extra !== "DEFAULT_GENERATED" ? `"${col.Default}"` : col.Default
+        }
+      }));
+      const indexes = await compareDB.raw(
+        `SHOW INDEX FROM ${tableName}`
+      );
+      const [row] = await compareDB.raw(`SHOW CREATE TABLE ${tableName}`);
+      const ddl = row["Create Table"];
+      const matched = ddl.match(/CONSTRAINT .+/g);
+      const foreignKeys = (matched ?? []).map((line) => {
+        const matched2 = line.match(
+          /CONSTRAINT `(.+)` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)( ON [A-Z ]+)*/
+        );
+        if (!matched2) {
+          throw new Error(`\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 FOREIGN KEY CONSTRAINT ${line}`);
+        }
+        const [, keyName, from, referencesTable, referencesField, onClause] = matched2;
+        const [onUpdateFull, _onUpdate] = (onClause ?? "").match(/ON UPDATE ([A-Z ]+)$/) ?? [];
+        const onUpdate = _onUpdate ?? "NO ACTION";
+        const onDelete = (onClause ?? "").replace(onUpdateFull ?? "", "").match(/ON DELETE ([A-Z ]+)/)?.[1]?.trim() ?? "NO ACTION";
+        return {
+          keyName,
+          from,
+          referencesTable,
+          referencesField,
+          onDelete,
+          onUpdate
+        };
+      });
+      return [cols, indexes, foreignKeys];
+    } catch (e) {
+      throw e;
+    }
+  }
+  /*
+    Entity 내용 읽어서 MigrationSetAndJoinTable 추출
+  */
+  getMigrationSetFromEntity(entity) {
+    const migrationSet = entity.props.reduce(
+      (r, prop) => {
+        if (isVirtualProp(prop)) {
+          return r;
+        }
+        if (isHasManyRelationProp(prop)) {
+          return r;
+        }
+        if (!isRelationProp(prop)) {
+          let type;
+          if (isTextProp(prop)) {
+            type = prop.textType;
+          } else if (isEnumProp(prop)) {
+            type = "string";
+          } else {
+            type = prop.type;
+          }
+          const column = {
+            name: prop.name,
+            type,
+            ...isIntegerProp(prop) && { unsigned: prop.unsigned === true },
+            ...(isStringProp(prop) || isEnumProp(prop)) && {
+              length: prop.length
+            },
+            nullable: prop.nullable === true,
+            ...(() => {
+              if (prop.dbDefault !== void 0) {
+                return {
+                  defaultTo: prop.dbDefault
+                };
+              }
+              return {};
+            })(),
+            // FIXME: float(N, M) deprecated
+            // Decimal, Float 타입의 경우 precision, scale 추가
+            ...(isDecimalProp(prop) || isFloatProp(prop)) && {
+              precision: prop.precision ?? 8,
+              scale: prop.scale ?? 2
+            }
+          };
+          r.columns.push(column);
+        }
+        if (isManyToManyRelationProp(prop)) {
+          const relMd = EntityManager.get(prop.with);
+          const [table1, table2] = prop.joinTable.split("__");
+          const join = {
+            from: `${entity.table}.id`,
+            through: {
+              from: `${prop.joinTable}.${inflection.singularize(table1)}_id`,
+              to: `${prop.joinTable}.${inflection.singularize(table2)}_id`,
+              onUpdate: prop.onUpdate,
+              onDelete: prop.onDelete
+            },
+            to: `${relMd.table}.id`
+          };
+          const through = join.through;
+          const fields = [through.from, through.to];
+          r.joinTables.push({
+            table: through.from.split(".")[0],
+            indexes: [
+              {
+                type: "unique",
+                columns: ["uuid"]
+              },
+              // 조인 테이블에 걸린 인덱스 찾아와서 연결
+              ...entity.indexes.filter(
+                (index) => index.columns.find(
+                  (col) => col.includes(prop.joinTable + ".")
+                )
+              ).map((index) => ({
+                ...index,
+                columns: index.columns.map(
+                  (col) => col.replace(prop.joinTable + ".", "")
+                )
+              }))
+            ],
+            columns: [
+              {
+                name: "id",
+                type: "integer",
+                nullable: false,
+                unsigned: true
+              },
+              ...fields.map((field) => {
+                return {
+                  name: field.split(".")[1],
+                  type: "integer",
+                  nullable: false,
+                  unsigned: true
+                };
+              }),
+              {
+                name: "uuid",
+                nullable: true,
+                type: "uuid"
+              }
+            ],
+            foreigns: fields.map((field) => {
+              const col = field.split(".")[1];
+              const to = (() => {
+                if (inflection.singularize(join.to.split(".")[0]) + "_id" === col) {
+                  return join.to;
+                } else {
+                  return join.from;
+                }
+              })();
+              return {
+                columns: [col],
+                to,
+                onUpdate: through.onUpdate,
+                onDelete: through.onDelete
+              };
+            })
+          });
+          return r;
+        } else if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+          const idColumnName = prop.name + "_id";
+          r.columns.push({
+            name: idColumnName,
+            type: "integer",
+            unsigned: true,
+            nullable: prop.nullable ?? false
+          });
+          r.foreigns.push({
+            columns: [idColumnName],
+            to: `${inflection.underscore(inflection.pluralize(prop.with)).toLowerCase()}.id`,
+            onUpdate: prop.onUpdate,
+            onDelete: prop.onDelete
+          });
+        }
+        return r;
+      },
+      {
+        table: entity.table,
+        columns: [],
+        indexes: [],
+        foreigns: [],
+        joinTables: []
+      }
+    );
+    migrationSet.indexes = entity.indexes.filter(
+      (index) => index.columns.find((col) => col.includes(".") === false)
+    );
+    migrationSet.columns = migrationSet.columns.concat({
+      name: "uuid",
+      nullable: true,
+      type: "uuid"
+    });
+    migrationSet.indexes = migrationSet.indexes.concat({
+      type: "unique",
+      columns: ["uuid"]
+    });
+    return migrationSet;
+  }
+  /*
+    마이그레이션 컬럼 배열 비교용 코드
+  */
+  showMigrationSet(which, migrationSet) {
+    const { columns, indexes, foreigns } = migrationSet;
+    const styledChalk = which === "Entity" ? chalk.bgGreen.black : chalk.bgBlue.black;
+    console.log(
+      styledChalk(
+        `${which} ${migrationSet.table} Columns															`
+      )
+    );
+    console.table(
+      columns.map((column) => {
+        return {
+          ..._.pick(column, [
+            "name",
+            "type",
+            "nullable",
+            "unsigned",
+            "length",
+            "defaultTo",
+            "precision",
+            "scale"
+          ])
+        };
+      }),
+      [
+        "name",
+        "type",
+        "nullable",
+        "unsigned",
+        "length",
+        "defaultTo",
+        "precision",
+        "scale"
+      ]
+    );
+    if (indexes.length > 0) {
+      console.log(
+        styledChalk(
+          `${which} ${migrationSet.table} Indexes															`
+        )
+      );
+      console.table(
+        indexes.map((index) => {
+          return {
+            ..._.pick(index, ["type", "columns", "name"])
+          };
+        })
+      );
+    }
+    if (foreigns.length > 0) {
+      console.log(
+        chalk.bgMagenta.black(
+          `${which} ${migrationSet.table} Foreigns															`
+        )
+      );
+      console.table(
+        foreigns.map((foreign) => {
+          return {
+            ..._.pick(foreign, ["columns", "to", "onUpdate", "onDelete"])
+          };
+        })
+      );
+    }
+  }
+  async destroy() {
+    await Promise.all(
+      this.targets.apply.map((db) => {
+        return db.destroy();
+      })
+    );
+  }
+};
+
+// src/testing/fixture-manager.ts
+import chalk2 from "chalk";
+import _2 from "lodash";
+import inflection2 from "inflection";
+import { readFileSync, writeFileSync } from "fs";
+
+// src/testing/_relation-graph.ts
+var RelationGraph = class {
+  graph = /* @__PURE__ */ new Map();
+  buildGraph(fixtures) {
+    this.graph.clear();
+    for (const fixture of fixtures) {
+      this.graph.set(fixture.fixtureId, {
+        fixtureId: fixture.fixtureId,
+        entityId: fixture.entityId,
+        related: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const fixture of fixtures) {
+      const node = this.graph.get(fixture.fixtureId);
+      for (const [, column] of Object.entries(fixture.columns)) {
+        const prop = column.prop;
+        if (isRelationProp(prop)) {
+          if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+            const relatedFixtureId = `${prop.with}#${column.value}`;
+            if (this.graph.has(relatedFixtureId)) {
+              node.related.add(relatedFixtureId);
+            }
+          } else if (isManyToManyRelationProp(prop)) {
+            const relatedIds = column.value;
+            for (const relatedId of relatedIds) {
+              const relatedFixtureId = `${prop.with}#${relatedId}`;
+              if (this.graph.has(relatedFixtureId)) {
+                node.related.add(relatedFixtureId);
+                this.graph.get(relatedFixtureId).related.add(fixture.fixtureId);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  getInsertionOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const tempVisited = /* @__PURE__ */ new Set();
+    const visit = (fixtureId) => {
+      if (visited.has(fixtureId)) return;
+      if (tempVisited.has(fixtureId)) {
+        console.warn(`Circular dependency detected involving: ${fixtureId}`);
+        return;
+      }
+      tempVisited.add(fixtureId);
+      const node = this.graph.get(fixtureId);
+      const entity = EntityManager.get(node.entityId);
+      for (const depId of node.related) {
+        const depNode = this.graph.get(depId);
+        const relationProp = entity.props.find(
+          (prop) => isRelationProp(prop) && (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) && prop.with === depNode.entityId
+        );
+        if (relationProp && !relationProp.nullable) {
+          visit(depId);
+        }
+      }
+      tempVisited.delete(fixtureId);
+      visited.add(fixtureId);
+      order.push(fixtureId);
+    };
+    for (const fixtureId of this.graph.keys()) {
+      visit(fixtureId);
+    }
+    for (const fixtureId of this.graph.keys()) {
+      if (!visited.has(fixtureId)) {
+        order.push(fixtureId);
+      }
+    }
+    return order;
+  }
+};
+
+// src/testing/fixture-manager.ts
+var FixtureManagerClass = class {
+  relationGraph = new RelationGraph();
+  init() {
+    DB.testInit();
+  }
+  async cleanAndSeed(usingTables) {
+    const tableNames = await (async () => {
+      if (usingTables) {
+        return usingTables;
+      }
+      const tables = await DB.tdb.raw(
+        `SHOW TABLE STATUS WHERE Engine IS NOT NULL`
+      );
+      return tables.map((tableInfo) => tableInfo["Name"]);
+    })();
+    await DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+    for await (let tableName of tableNames) {
+      if (tableName == "migrations") {
+        continue;
+      }
+      const [fdbChecksumRow] = await DB.fdb.raw(
+        `CHECKSUM TABLE ${tableName}`
+      );
+      const fdbChecksum = fdbChecksumRow["Checksum"];
+      const [tdbChecksumRow] = await DB.tdb.raw(
+        `CHECKSUM TABLE ${tableName}`
+      );
+      const tdbChecksum = tdbChecksumRow["Checksum"];
+      if (fdbChecksum !== tdbChecksum) {
+        await DB.tdb.truncate(tableName);
+        const rawQuery = `INSERT INTO ${DB.connectionInfo.test.database}.${tableName}
+            SELECT * FROM ${DB.connectionInfo.fixture_local.database}.${tableName}`;
+        await DB.tdb.raw(rawQuery);
+      }
+    }
+    await DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+  }
+  async getChecksum(db, tableName) {
+    const [checksumRow] = await db.raw(
+      `CHECKSUM TABLE ${tableName}`
+    );
+    return checksumRow.Checksum;
+  }
+  async sync() {
+    const frdb = DB.getClient("fixture_remote");
+    const tables = await DB.fdb.raw(
+      "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
+    );
+    const tableNames = tables.map(
+      (table) => table.Name
+    );
+    console.log(chalk2.magenta("SYNC..."));
+    await Promise.all(
+      tableNames.map(async (tableName) => {
+        if (tableName.startsWith(DB.migrationTable)) {
+          return;
+        }
+        const remoteChecksum = await this.getChecksum(frdb, tableName);
+        const localChecksum = await this.getChecksum(DB.fdb, tableName);
+        if (remoteChecksum !== localChecksum) {
+          await DB.fdb.trx(async (transaction) => {
+            await transaction.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+            await transaction.truncate(tableName);
+            const rows = await frdb.raw(`SELECT * FROM ${tableName}`);
+            if (rows.length === 0) {
+              return;
+            }
+            console.log(chalk2.blue(tableName), rows.length);
+            await transaction.raw(
+              `INSERT INTO ${tableName} (${Object.keys(rows[0]).map((k) => `\`${k}\``).join(",")}) VALUES ?`,
+              [
+                rows.map(
+                  (row) => Object.values(row).map((v) => {
+                    if (v === null) {
+                      return null;
+                    } else if (typeof v === "boolean") {
+                      return v ? 1 : 0;
+                    } else if (typeof v === "object") {
+                      return JSON.stringify(v);
+                    } else {
+                      return v;
+                    }
+                  })
+                )
+              ]
+            );
+            console.log("OK");
+            await transaction.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+          });
+        }
+      })
+    );
+    console.log(chalk2.magenta("DONE!"));
+    await frdb.destroy();
+  }
+  async importFixture(entityId, ids) {
+    const queries = _2.uniq(
+      (await Promise.all(
+        ids.map(async (id) => {
+          return await this.getImportQueries(entityId, "id", id);
+        })
+      )).flat()
+    );
+    const wdb = DB.toClient(DB.getDB("w"));
+    for (let query of queries) {
+      const [rsh] = await wdb.raw(query);
+      console.log({
+        query,
+        info: rsh.info
+      });
+    }
+  }
+  async getImportQueries(entityId, field, id) {
+    console.log({ entityId, field, id });
+    const entity = EntityManager.get(entityId);
+    const wdb = DB.toClient(DB.getDB("w"));
+    const [row] = await wdb.raw(
+      `SELECT * FROM ${entity.table} WHERE ${field} = ${id} LIMIT 1`
+    );
+    if (row === void 0) {
+      throw new Error(`${entityId}#${id} row\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+    }
+    const fixtureDatabase = DB.connectionInfo.fixture_remote.database;
+    const realDatabase = DB.connectionInfo.production_master.database;
+    const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${entity.table}\` (SELECT * FROM \`${realDatabase}\`.\`${entity.table}\` WHERE \`id\` = ${id})`;
+    const args = Object.entries(entity.relations).filter(
+      ([, relation]) => isBelongsToOneRelationProp(relation) || isOneToOneRelationProp(relation) && relation.customJoinClause === void 0
+    ).map(([, relation]) => {
+      let field2;
+      let id2;
+      if (isOneToOneRelationProp(relation) && !relation.hasJoinColumn) {
+        field2 = `${relation.name}_id`;
+        id2 = row["id"];
+      } else {
+        field2 = "id";
+        id2 = row[`${relation.name}_id`];
+      }
+      return {
+        entityId: relation.with,
+        field: field2,
+        id: id2
+      };
+    }).filter((arg) => arg.id !== null);
+    const relQueries = await Promise.all(
+      args.map(async (args2) => {
+        return this.getImportQueries(args2.entityId, args2.field, args2.id);
+      })
+    );
+    return [..._2.uniq(relQueries.reverse().flat()), selfQuery];
+  }
+  async destory() {
+    await DB.testDestroy();
+    await DB.destroy();
+  }
+  async getFixtures(sourceDBName, targetDBName, searchOptions) {
+    const sourceDB = DB.getClient(sourceDBName);
+    const targetDB = DB.getClient(targetDBName);
+    const { entityId, field, value, searchType } = searchOptions;
+    const entity = EntityManager.get(entityId);
+    const column = entity.props.find((prop) => prop.name === field)?.type === "relation" ? `${field}_id` : field;
+    let query = sourceDB.from(entity.table).selectAll();
+    if (searchType === "equals") {
+      query = query.where([column, "=", value]);
+    } else if (searchType === "like") {
+      query = query.where([column, "like", `%${value}%`]);
+    }
+    const rows = await query.execute();
+    if (rows.length === 0) {
+      throw new Error("No records found");
+    }
+    const fixtures = [];
+    for (const row of rows) {
+      const initialRecordsLength = fixtures.length;
+      const newRecords = await this.createFixtureRecord(entity, row);
+      fixtures.push(...newRecords);
+      const currentFixtureRecord = fixtures.find(
+        (r) => r.fixtureId === `${entityId}#${row.id}`
+      );
+      if (currentFixtureRecord) {
+        currentFixtureRecord.fetchedRecords = fixtures.filter((r) => r.fixtureId !== currentFixtureRecord.fixtureId).slice(initialRecordsLength).map((r) => r.fixtureId);
+      }
+    }
+    for await (const fixture of fixtures) {
+      const entity2 = EntityManager.get(fixture.entityId);
+      const [row] = await targetDB.from(entity2.table).selectAll().where(["id", "=", fixture.id]).first().execute();
+      if (row) {
+        const [record] = await this.createFixtureRecord(entity2, row, {
+          singleRecord: true,
+          _db: targetDB
+        });
+        fixture.target = record;
+        continue;
+      }
+      const uniqueRow = await this.checkUniqueViolation(
+        targetDB,
+        entity2,
+        fixture
+      );
+      if (uniqueRow) {
+        const [record] = await this.createFixtureRecord(entity2, uniqueRow, {
+          singleRecord: true,
+          _db: targetDB
+        });
+        fixture.unique = record;
+      }
+    }
+    return _2.uniqBy(fixtures, (f) => f.fixtureId);
+  }
+  async createFixtureRecord(entity, row, options) {
+    const records = [];
+    const visitedEntities = /* @__PURE__ */ new Set();
+    const create = async (entity2, row2) => {
+      const fixtureId = `${entity2.id}#${row2.id}`;
+      if (visitedEntities.has(fixtureId)) {
+        return;
+      }
+      visitedEntities.add(fixtureId);
+      const record = {
+        fixtureId,
+        entityId: entity2.id,
+        id: row2.id,
+        columns: {},
+        fetchedRecords: [],
+        belongsRecords: []
+      };
+      for (const prop of entity2.props) {
+        if (isVirtualProp(prop)) {
+          continue;
+        }
+        record.columns[prop.name] = {
+          prop,
+          value: row2[prop.name]
+        };
+        const db = options?._db ?? DB.toClient(DB.getDB("w"));
+        if (isManyToManyRelationProp(prop)) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const throughTable = prop.joinTable;
+          const fromColumn = `${inflection2.singularize(entity2.table)}_id`;
+          const toColumn = `${inflection2.singularize(relatedEntity.table)}_id`;
+          const _relatedIds = await db.from(throughTable).select(toColumn).where([fromColumn, "=", row2.id]).execute();
+          const relatedIds = _relatedIds.map((r) => parseInt(r[toColumn]));
+          record.columns[prop.name].value = relatedIds;
+        } else if (isHasManyRelationProp(prop)) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedIds = await db.from(relatedEntity.table).select("id").where([prop.joinColumn, "=", row2.id]).pluck("id");
+          record.columns[prop.name].value = relatedIds;
+        } else if (isOneToOneRelationProp(prop) && !prop.hasJoinColumn) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedProp = relatedEntity.props.find(
+            (p) => isRelationProp(p) && p.with === entity2.id
+          );
+          if (relatedProp) {
+            const [relatedRow] = await db.from(relatedEntity.table).select("id").where([relatedProp.name, "=", row2.id]).first().execute();
+            record.columns[prop.name].value = relatedRow?.id;
+          }
+        } else if (isRelationProp(prop)) {
+          const relatedId = row2[`${prop.name}_id`];
+          record.columns[prop.name].value = relatedId;
+          if (relatedId) {
+            record.belongsRecords.push(`${prop.with}#${relatedId}`);
+          }
+          if (!options?.singleRecord && relatedId) {
+            const relatedEntity = EntityManager.get(prop.with);
+            const [relatedRow] = await db.from(relatedEntity.table).selectAll().where(["id", "=", relatedId]).first().execute();
+            if (relatedRow) {
+              await create(relatedEntity, relatedRow);
+            }
+          }
+        }
+      }
+      records.push(record);
+    };
+    await create(entity, row);
+    return records;
+  }
+  async insertFixtures(dbName, _fixtures) {
+    const fixtures = _2.uniqBy(_fixtures, (f) => f.fixtureId);
+    this.relationGraph.buildGraph(fixtures);
+    const insertionOrder = this.relationGraph.getInsertionOrder();
+    const db = DB.getClient(dbName);
+    await db.trx(async (trx) => {
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+      for (const fixtureId of insertionOrder) {
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
+        const result = await this.insertFixture(trx, fixture);
+        if (result.id !== fixture.id) {
+          console.log(
+            chalk2.yellow(
+              `Unique constraint violation: ${fixture.entityId}#${fixture.id} -> ${fixture.entityId}#${result.id}`
+            )
+          );
+          fixtures.forEach((f) => {
+            Object.values(f.columns).forEach((column) => {
+              if (column.prop.type === "relation" && column.prop.with === result.entityId && column.value === fixture.id) {
+                column.value = result.id;
+              }
+            });
+          });
+          fixture.id = result.id;
+        }
+      }
+      for (const fixtureId of insertionOrder) {
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
+        await this.handleManyToManyRelations(trx, fixture, fixtures);
+      }
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    });
+    const records = [];
+    for await (const r of fixtures) {
+      const entity = EntityManager.get(r.entityId);
+      const [record] = await db.from(entity.table).selectAll().where(["id", "=", r.id]).first().execute();
+      records.push({
+        entityId: r.entityId,
+        data: record
+      });
+    }
+    return _2.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
+  }
+  prepareInsertData(fixture) {
+    const insertData = {};
+    for (const [propName, column] of Object.entries(fixture.columns)) {
+      if (isVirtualProp(column.prop)) {
+        continue;
+      }
+      const prop = column.prop;
+      if (!isRelationProp(prop)) {
+        if (prop.type === "json") {
+          insertData[propName] = JSON.stringify(column.value);
+        } else {
+          insertData[propName] = column.value;
+        }
+      } else if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+        insertData[`${propName}_id`] = column.value;
+      }
+    }
+    return insertData;
+  }
+  async insertFixture(db, fixture) {
+    const insertData = this.prepareInsertData(fixture);
+    const entity = EntityManager.get(fixture.entityId);
+    try {
+      const uniqueFound = await this.checkUniqueViolation(db, entity, fixture);
+      if (uniqueFound) {
+        return {
+          entityId: fixture.entityId,
+          id: uniqueFound.id
+        };
+      }
+      const [found] = await db.from(entity.table).select("id").where(["id", "=", fixture.id]).first().execute();
+      if (found && !fixture.override) {
+        return {
+          entityId: fixture.entityId,
+          id: found.id
+        };
+      }
+      await db.upsert(entity.table, [insertData]);
+      return {
+        entityId: fixture.entityId,
+        id: fixture.id
+      };
+    } catch (err) {
+      console.log(err);
+      throw err;
+    }
+  }
+  async handleManyToManyRelations(db, fixture, fixtures) {
+    for (const [, column] of Object.entries(fixture.columns)) {
+      const prop = column.prop;
+      if (isManyToManyRelationProp(prop)) {
+        const joinTable = prop.joinTable;
+        const relatedIds = column.value;
+        for (const relatedId of relatedIds) {
+          if (!fixtures.find((f) => f.fixtureId === `${prop.with}#${relatedId}`)) {
+            continue;
+          }
+          const entity = EntityManager.get(fixture.entityId);
+          const relatedEntity = EntityManager.get(prop.with);
+          if (!entity || !relatedEntity) {
+            throw new Error(
+              `Entity not found: ${fixture.entityId}, ${prop.with}`
+            );
+          }
+          const [found] = await db.from(joinTable).select("id").where([
+            [`${inflection2.singularize(entity.table)}_id`, "=", fixture.id],
+            [
+              `${inflection2.singularize(relatedEntity.table)}_id`,
+              "=",
+              relatedId
+            ]
+          ]).first().execute();
+          if (found) {
+            continue;
+          }
+          const newIds = await db.insert(joinTable, [
+            {
+              [`${inflection2.singularize(entity.table)}_id`]: fixture.id,
+              [`${inflection2.singularize(relatedEntity.table)}_id`]: relatedId
+            }
+          ]);
+          console.log(
+            chalk2.green(
+              `Inserted into ${joinTable}: ${entity.table}(${fixture.id}) - ${relatedEntity.table}(${relatedId}) ID: ${newIds}`
+            )
+          );
+        }
+      }
+    }
+  }
+  async addFixtureLoader(code) {
+    const path2 = Sonamu.apiRootPath + "/src/testing/fixture.ts";
+    let content = readFileSync(path2).toString();
+    const fixtureLoaderStart = content.indexOf("const fixtureLoader = {");
+    const fixtureLoaderEnd = content.indexOf("};", fixtureLoaderStart);
+    if (fixtureLoaderStart !== -1 && fixtureLoaderEnd !== -1) {
+      const newContent = content.slice(0, fixtureLoaderEnd) + "  " + code + "\n" + content.slice(fixtureLoaderEnd);
+      writeFileSync(path2, newContent);
+    } else {
+      throw new Error("Failed to find fixtureLoader in fixture.ts");
+    }
+  }
+  // 해당 픽스쳐의 값으로 유니크 제약에 위배되는 레코드가 있는지 확인
+  async checkUniqueViolation(db, entity, fixture) {
+    const _uniqueIndexes = entity.indexes.filter((i) => i.type === "unique");
+    const uniqueIndexes = _uniqueIndexes.filter(
+      (index) => index.columns.every((column) => !column.startsWith(`${entity.table}__`))
+    );
+    if (uniqueIndexes.length === 0) {
+      return null;
+    }
+    let uniqueQuery = db.from(entity.table).selectAll();
+    const whereClauses = uniqueIndexes.map((index) => {
+      const containsNull = index.columns.some((column) => {
+        const field = column.split("_id")[0];
+        return fixture.columns[field].value === null;
+      });
+      if (containsNull) {
+        return;
+      }
+      return index.columns.map((c) => {
+        const field = c.split("_id")[0];
+        if (Array.isArray(fixture.columns[field].value)) {
+          return [c, "in", fixture.columns[field].value];
+        } else {
+          return [c, "=", fixture.columns[field].value];
+        }
+      });
+    }).filter(Boolean);
+    for (const clauses of whereClauses) {
+      uniqueQuery = uniqueQuery.orWhere(clauses);
+    }
+    const [uniqueFound] = await uniqueQuery.execute();
+    return uniqueFound;
+  }
+};
+var FixtureManager = new FixtureManagerClass();
+
+export {
+  Migrator,
+  FixtureManagerClass,
+  FixtureManager
+};
+//# sourceMappingURL=chunk-6SP5N5ND.mjs.map