sonamu 0.2.47 → 0.2.49

package/dist/{chunk-5VT5JTY4.js → chunk-HATLA54Z.js}

@@ -842,19 +842,19 @@ function globAsync(pathPattern) {
   });
 }
 async function importMultiple(filePaths, doRefresh = false) {
-  return Promise.all(
-    filePaths.map(async (filePath) => {
-      const importPath = "./" + _path2.default.relative(__dirname, filePath);
-      if (doRefresh) {
-        delete __require.cache[__require.resolve(importPath)];
-      }
-      const imported = await Promise.resolve().then(() => _interopRequireWildcard(require(importPath)));
-      return {
-        filePath,
-        imported
-      };
-    })
-  );
+  const results = [];
+  for (const filePath of filePaths) {
+    const importPath = "./" + _path2.default.relative(__dirname, filePath);
+    if (doRefresh) {
+      delete __require.cache[__require.resolve(importPath)];
+    }
+    const imported = await Promise.resolve().then(() => _interopRequireWildcard(require(importPath)));
+    results.push({
+      filePath,
+      imported
+    });
+  }
+  return results;
 }
 async function findAppRootPath() {
   const apiRootPath = await findApiRootPath();
@@ -4215,13 +4215,13 @@ var _uuid = require('uuid');
 
 
 // src/database/_batch_update.ts
-async function batchUpdate(knex5, tableName, id, rows, chunkSize = 50, trx = null) {
+async function batchUpdate(knex5, tableName, ids, rows, chunkSize = 50, trx = null) {
   const chunks = [];
   for (let i = 0; i < rows.length; i += chunkSize) {
     chunks.push(rows.slice(i, i + chunkSize));
   }
   const executeUpdate = async (chunk, transaction) => {
-    const sql = generateBatchUpdateSQL(knex5, tableName, chunk, id);
+    const sql = generateBatchUpdateSQL(knex5, tableName, chunk, ids);
     return knex5.raw(sql).transacting(transaction);
   };
   if (trx) {
@@ -4245,31 +4245,38 @@ function generateKeySetFromData(data) {
   }
   return keySet;
 }
-function generateBatchUpdateSQL(knex5, tableName, data, identifier) {
+function generateBatchUpdateSQL(knex5, tableName, data, identifiers) {
   const keySet = generateKeySetFromData(data);
   const bindings = [];
+  const invalidIdentifiers = identifiers.filter((id) => !keySet.has(id));
+  if (invalidIdentifiers.length > 0) {
+    throw new Error(
+      `Invalid identifiers: ${invalidIdentifiers.join(", ")}. Identifiers must exist in the data`
+    );
+  }
   const cases = [];
   for (const key of keySet) {
-    if (key === identifier) continue;
+    if (identifiers.includes(key)) continue;
     const rows = [];
     for (const row of data) {
       if (Object.hasOwnProperty.call(row, key)) {
-        rows.push(`WHEN \`${identifier}\` = ? THEN ?`);
-        bindings.push(row[identifier], row[key]);
+        const whereClause = identifiers.map((id) => `\`${id}\` = ?`).join(" AND ");
+        rows.push(`WHEN (${whereClause}) THEN ?`);
+        bindings.push(...identifiers.map((i) => row[i]), row[key]);
       }
     }
     const whenThen = rows.join(" ");
     cases.push(`\`${key}\` = CASE ${whenThen} ELSE \`${key}\` END`);
   }
-  const whereInIds = data.map((row) => row[identifier]);
-  const whereInPlaceholders = whereInIds.map(() => "?").join(", ");
+  const whereInClauses = identifiers.map((col) => `${col} IN (${data.map(() => "?").join(", ")})`).join(" AND ");
+  const whereInBindings = identifiers.flatMap(
+    (col) => data.map((row) => row[col])
+  );
   const sql = knex5.raw(
-    `UPDATE \`${tableName}\` SET ${cases.join(
-      ", "
-    )} WHERE ${identifier} IN (${whereInPlaceholders})`,
-    [...bindings, ...whereInIds]
+    `UPDATE \`${tableName}\` SET ${cases.join(", ")} WHERE ${whereInClauses}`,
+    [...bindings, ...whereInBindings]
   );
-  return sql.toString();
+  return sql.toQuery();
 }
 
 // src/database/upsert-builder.ts
@@ -4355,13 +4362,13 @@ var UpsertBuilder = class {
       uuid: _nullishCoalesce(row.uuid, () => ( uuid))
     };
   }
-  async upsert(wdb, tableName) {
-    return this.upsertOrInsert(wdb, tableName, "upsert");
+  async upsert(wdb, tableName, chunkSize) {
+    return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
   }
-  async insertOnly(wdb, tableName) {
-    return this.upsertOrInsert(wdb, tableName, "insert");
+  async insertOnly(wdb, tableName, chunkSize) {
+    return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
   }
-  async upsertOrInsert(wdb, tableName, mode) {
+  async upsertOrInsert(wdb, tableName, mode, chunkSize) {
     if (this.hasTable(tableName) === false) {
       return [];
     }
@@ -4378,17 +4385,6 @@ var UpsertBuilder = class {
     )) {
       throw new Error(`${tableName} \uD574\uACB0\uB418\uC9C0 \uC54A\uC740 \uCC38\uC870\uAC00 \uC788\uC2B5\uB2C8\uB2E4.`);
     }
-    const groups = _lodash2.default.groupBy(
-      table.rows,
-      (row) => Object.entries(row).some(([, value]) => isRefField(value)) ? "selfRef" : "normal"
-    );
-    const targetRows = groups.normal;
-    const q = wdb.insert(targetRows).into(tableName);
-    if (mode === "insert") {
-      await q;
-    } else if (mode === "upsert") {
-      await q.onDuplicateUpdate.apply(q, Object.keys(targetRows[0]));
-    }
     const { references, refTables } = Array.from(this.tables).reduce(
       (r, [, table2]) => {
         const reference = Array.from(table2.references.values()).find(
@@ -4408,11 +4404,27 @@ var UpsertBuilder = class {
     const extractFields = _lodash2.default.uniq(references).map(
       (reference) => reference.split(".")[1]
     );
-    const uuids = table.rows.map((row) => row.uuid);
-    const upsertedRows = await wdb(tableName).select(_lodash2.default.uniq(["uuid", "id", ...extractFields])).whereIn("uuid", uuids);
-    const uuidMap = new Map(
-      upsertedRows.map((row) => [row.uuid, row])
+    const groups = _lodash2.default.groupBy(
+      table.rows,
+      (row) => Object.entries(row).some(([, value]) => isRefField(value)) ? "selfRef" : "normal"
     );
+    const normalRows = _nullishCoalesce(groups.normal, () => ( []));
+    const selfRefRows = _nullishCoalesce(groups.selfRef, () => ( []));
+    const chunks = chunkSize ? _lodash2.default.chunk(normalRows, chunkSize) : [normalRows];
+    const uuidMap = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      const q = wdb.insert(chunk).into(tableName);
+      if (mode === "insert") {
+        await q;
+      } else if (mode === "upsert") {
+        await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
+      }
+      const uuids = chunk.map((row) => row.uuid);
+      const upsertedRows = await wdb(tableName).select(_lodash2.default.uniq(["uuid", "id", ...extractFields])).whereIn("uuid", uuids);
+      upsertedRows.forEach((row) => {
+        uuidMap.set(row.uuid, row);
+      });
+    }
     refTables.map((table2) => {
       table2.rows = table2.rows.map((row) => {
         Object.keys(row).map((key) => {
@@ -4431,12 +4443,13 @@ var UpsertBuilder = class {
         return row;
       });
     });
-    const ids = Array.from(uuidMap.values()).map((val) => val.id);
-    if (groups.selfRef) {
-      const selfRefIds = await this.upsert(wdb, tableName);
-      return [...ids, ...selfRefIds];
+    const allIds = Array.from(uuidMap.values()).map((row) => row.id);
+    if (selfRefRows.length > 0) {
+      table.rows = selfRefRows;
+      const selfRefIds = await this.upsert(wdb, tableName, chunkSize);
+      allIds.push(...selfRefIds);
     }
-    return ids;
+    return allIds;
   }
   async updateBatch(wdb, tableName, options) {
     options = _lodash2.default.defaults(options, {
@@ -4450,17 +4463,12 @@ var UpsertBuilder = class {
     if (table.rows.length === 0) {
       return;
     }
+    const whereColumns = Array.isArray(options.where) ? options.where : [_nullishCoalesce(options.where, () => ( "id"))];
     const rows = table.rows.map((_row) => {
       const { uuid, ...row } = _row;
       return row;
     });
-    await batchUpdate(
-      wdb,
-      tableName,
-      _nullishCoalesce(options.where, () => ( "id")),
-      rows,
-      options.chunkSize
-    );
+    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
   }
 };
 
@@ -4796,6 +4804,7 @@ var SonamuClass = class {
     this._dbConfig = null;
     this._syncer = null;
     this._config = null;
+    this._secrets = null;
   }
   set apiRootPath(apiRootPath) {
     this._apiRootPath = apiRootPath;
@@ -4836,6 +4845,12 @@ var SonamuClass = class {
     }
     return this._config;
   }
+  set secrets(secrets) {
+    this._secrets = secrets;
+  }
+  get secrets() {
+    return this._secrets;
+  }
   async init(doSilent = false, enableSync = true, apiRootPath) {
     if (this.isInitialized) {
       return;
@@ -4843,12 +4858,18 @@ var SonamuClass = class {
     !doSilent && console.time(_chalk2.default.cyan("Sonamu.init"));
     this.apiRootPath = await _asyncNullishCoalesce(apiRootPath, async () => ( await findApiRootPath()));
     const configPath = _path2.default.join(this.apiRootPath, "sonamu.config.json");
+    const secretsPath = _path2.default.join(this.apiRootPath, "sonamu.secrets.json");
     if (_fsextra2.default.existsSync(configPath) === false) {
       throw new Error(`Cannot find sonamu.config.json in ${configPath}`);
     }
     this.config = JSON.parse(
       _fsextra2.default.readFileSync(configPath).toString()
     );
+    if (_fsextra2.default.existsSync(secretsPath)) {
+      this.secrets = JSON.parse(
+        _fsextra2.default.readFileSync(secretsPath).toString()
+      );
+    }
     this.dbConfig = await DB.readKnexfile();
     !doSilent && console.log(_chalk2.default.green("DB Config Loaded!"));
     attachOnDuplicateUpdate();
@@ -4868,9 +4889,9 @@ var SonamuClass = class {
     this.isInitialized = true;
     !doSilent && console.timeEnd(_chalk2.default.cyan("Sonamu.init"));
   }
-  async withFastify(server, config) {
+  async withFastify(server, config, options) {
     if (this.isInitialized === false) {
-      await this.init();
+      await this.init(_optionalChain([options, 'optionalAccess', _83 => _83.doSilent]), _optionalChain([options, 'optionalAccess', _84 => _84.enableSync]));
     }
     server.get(
       `${this.config.route.prefix}/routes`,
@@ -5288,7 +5309,7 @@ var Entity = class {
           const relSubsetQuery = relEntity.resolveSubsetQuery("", relFields);
           let manyJoin;
           if (isHasManyRelationProp(relation)) {
-            const fromCol = _nullishCoalesce(_optionalChain([relation, 'optionalAccess', _83 => _83.fromColumn]), () => ( "id"));
+            const fromCol = _nullishCoalesce(_optionalChain([relation, 'optionalAccess', _85 => _85.fromColumn]), () => ( "id"));
             manyJoin = {
               fromTable: this.table,
               fromCol,
@@ -6493,7 +6514,7 @@ ${onlyTs.map((f) => f.name).join("\n")}`
         const [, keyName, from, referencesTable, referencesField, onClause] = matched2;
         const [onUpdateFull, _onUpdate] = _nullishCoalesce((_nullishCoalesce(onClause, () => ( ""))).match(/ON UPDATE ([A-Z ]+)$/), () => ( []));
         const onUpdate = _nullishCoalesce(_onUpdate, () => ( "NO ACTION"));
-        const onDelete = _nullishCoalesce(_optionalChain([(_nullishCoalesce(onClause, () => ( ""))), 'access', _84 => _84.replace, 'call', _85 => _85(_nullishCoalesce(onUpdateFull, () => ( "")), ""), 'access', _86 => _86.match, 'call', _87 => _87(/ON DELETE ([A-Z ]+) /), 'optionalAccess', _88 => _88[1]]), () => ( "NO ACTION"));
+        const onDelete = _nullishCoalesce(_optionalChain([(_nullishCoalesce(onClause, () => ( ""))), 'access', _86 => _86.replace, 'call', _87 => _87(_nullishCoalesce(onUpdateFull, () => ( "")), ""), 'access', _88 => _88.match, 'call', _89 => _89(/ON DELETE ([A-Z ]+) /), 'optionalAccess', _90 => _90[1]]), () => ( "NO ACTION"));
         return {
           keyName,
           from,
@@ -7177,10 +7198,13 @@ ${onlyTs.map((f) => f.name).join("\n")}`
 
 
 
+
+var _fs = require('fs');
 var FixtureManagerClass = class {
   constructor() {
     this._tdb = null;
     this._fdb = null;
+    this.dependencyGraph = /* @__PURE__ */ new Map();
   }
   set tdb(tdb) {
     this._tdb = tdb;
@@ -7273,6 +7297,9 @@ var FixtureManagerClass = class {
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 0`);
             await transaction(tableName).truncate();
             const rows = await frdb(tableName);
+            if (rows.length === 0) {
+              return;
+            }
             console.log(_chalk2.default.blue(tableName), rows.length);
             await transaction.insert(
               rows.map((row) => {
@@ -7357,6 +7384,364 @@ var FixtureManagerClass = class {
     }
     await BaseModel.destroy();
   }
+  async getFixtures(sourceDBName, targetDBName, searchOptions) {
+    const sourceDB = _knex2.default.call(void 0, Sonamu.dbConfig[sourceDBName]);
+    const targetDB = _knex2.default.call(void 0, Sonamu.dbConfig[targetDBName]);
+    const { entityId, field, value, searchType } = searchOptions;
+    const entity = EntityManager.get(entityId);
+    const column = _optionalChain([entity, 'access', _91 => _91.props, 'access', _92 => _92.find, 'call', _93 => _93((prop) => prop.name === field), 'optionalAccess', _94 => _94.type]) === "relation" ? `${field}_id` : field;
+    let query = sourceDB(entity.table);
+    if (searchType === "equals") {
+      query = query.where(column, value);
+    } else if (searchType === "like") {
+      query = query.where(column, "like", `%${value}%`);
+    }
+    const rows = await query;
+    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(entity2.table).where("id", fixture.id).first();
+      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 fixtures;
+  }
+  async createFixtureRecord(entity, row, options, visitedEntities = /* @__PURE__ */ new Set()) {
+    const fixtureId = `${entity.id}#${row.id}`;
+    if (visitedEntities.has(fixtureId)) {
+      return [];
+    }
+    visitedEntities.add(fixtureId);
+    const records = [];
+    const record = {
+      fixtureId,
+      entityId: entity.id,
+      id: row.id,
+      columns: {},
+      fetchedRecords: [],
+      belongsRecords: []
+    };
+    for (const prop of entity.props) {
+      if (isVirtualProp(prop)) {
+        continue;
+      }
+      record.columns[prop.name] = {
+        prop,
+        value: row[prop.name]
+      };
+      const db = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _95 => _95._db]), () => ( BaseModel.getDB("w")));
+      if (isManyToManyRelationProp(prop)) {
+        const relatedEntity = EntityManager.get(prop.with);
+        const throughTable = prop.joinTable;
+        const fromColumn = `${_inflection2.default.singularize(entity.table)}_id`;
+        const toColumn = `${_inflection2.default.singularize(relatedEntity.table)}_id`;
+        const relatedIds = await db(throughTable).where(fromColumn, row.id).pluck(toColumn);
+        record.columns[prop.name].value = relatedIds;
+      } else if (isHasManyRelationProp(prop)) {
+        const relatedEntity = EntityManager.get(prop.with);
+        const relatedIds = await db(relatedEntity.table).where(prop.joinColumn, row.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) => p.type === "relation" && p.with === entity.id
+        );
+        if (relatedProp) {
+          const relatedRow = await db(relatedEntity.table).where("id", row.id).first();
+          record.columns[prop.name].value = _optionalChain([relatedRow, 'optionalAccess', _96 => _96.id]);
+        }
+      } else if (isRelationProp(prop)) {
+        const relatedId = row[`${prop.name}_id`];
+        record.columns[prop.name].value = relatedId;
+        if (relatedId) {
+          record.belongsRecords.push(`${prop.with}#${relatedId}`);
+        }
+        if (!_optionalChain([options, 'optionalAccess', _97 => _97.singleRecord]) && relatedId) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedRow = await db(relatedEntity.table).where("id", relatedId).first();
+          if (relatedRow) {
+            const newRecords = await this.createFixtureRecord(
+              relatedEntity,
+              relatedRow,
+              options,
+              visitedEntities
+            );
+            records.push(...newRecords);
+          }
+        }
+      }
+    }
+    records.push(record);
+    return records;
+  }
+  async insertFixtures(dbName, _fixtures) {
+    const fixtures = _lodash2.default.uniqBy(_fixtures, (f) => f.fixtureId);
+    this.buildDependencyGraph(fixtures);
+    const insertionOrder = this.getInsertionOrder();
+    const db = _knex2.default.call(void 0, Sonamu.dbConfig[dbName]);
+    await db.transaction(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.default.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(entity.table).where("id", r.id).first();
+      records.push({
+        entityId: r.entityId,
+        data: record
+      });
+    }
+    return _lodash2.default.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
+  }
+  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.dependencyGraph.get(fixtureId);
+      const entity = EntityManager.get(node.entityId);
+      for (const depId of node.dependencies) {
+        const depNode = this.dependencyGraph.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.dependencyGraph.keys()) {
+      visit(fixtureId);
+    }
+    for (const fixtureId of this.dependencyGraph.keys()) {
+      if (!visited.has(fixtureId)) {
+        order.push(fixtureId);
+      }
+    }
+    return order;
+  }
+  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;
+  }
+  buildDependencyGraph(fixtures) {
+    this.dependencyGraph.clear();
+    for (const fixture of fixtures) {
+      this.dependencyGraph.set(fixture.fixtureId, {
+        fixtureId: fixture.fixtureId,
+        entityId: fixture.entityId,
+        dependencies: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const fixture of fixtures) {
+      const node = this.dependencyGraph.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.dependencyGraph.has(relatedFixtureId)) {
+              node.dependencies.add(relatedFixtureId);
+            }
+          } else if (isManyToManyRelationProp(prop)) {
+            const relatedIds = column.value;
+            for (const relatedId of relatedIds) {
+              const relatedFixtureId = `${prop.with}#${relatedId}`;
+              if (this.dependencyGraph.has(relatedFixtureId)) {
+                node.dependencies.add(relatedFixtureId);
+                this.dependencyGraph.get(relatedFixtureId).dependencies.add(fixture.fixtureId);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  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(entity.table).where("id", fixture.id).first();
+      if (found && !fixture.override) {
+        return {
+          entityId: fixture.entityId,
+          id: found.id
+        };
+      }
+      const q = db.insert(insertData).into(entity.table);
+      await q.onDuplicateUpdate.apply(q, Object.keys(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(joinTable).where({
+            [`${_inflection2.default.singularize(entity.table)}_id`]: fixture.id,
+            [`${_inflection2.default.singularize(relatedEntity.table)}_id`]: relatedId
+          }).limit(1);
+          if (found) {
+            continue;
+          }
+          const newIds = await db(joinTable).insert({
+            [`${_inflection2.default.singularize(entity.table)}_id`]: fixture.id,
+            [`${_inflection2.default.singularize(relatedEntity.table)}_id`]: relatedId
+          });
+          console.log(
+            _chalk2.default.green(
+              `Inserted into ${joinTable}: ${entity.table}(${fixture.id}) - ${relatedEntity.table}(${relatedId}) ID: ${newIds}`
+            )
+          );
+        }
+      }
+    }
+  }
+  async addFixtureLoader(code) {
+    const path8 = Sonamu.apiRootPath + "/src/testing/fixture.ts";
+    let content = _fs.readFileSync.call(void 0, path8).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);
+      _fs.writeFileSync.call(void 0, path8, 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");
+    if (uniqueIndexes.length === 0) {
+      return null;
+    }
+    let uniqueQuery = db(entity.table);
+    for (const index of uniqueIndexes) {
+      if (index.columns.some(
+        (column) => fixture.columns[column.split("_id")[0]].value === null
+      )) {
+        continue;
+      }
+      uniqueQuery = uniqueQuery.orWhere((qb) => {
+        for (const column of index.columns) {
+          const field = column.split("_id")[0];
+          if (Array.isArray(fixture.columns[field].value)) {
+            qb.whereIn(column, fixture.columns[field].value);
+          } else {
+            qb.andWhere(column, fixture.columns[field].value);
+          }
+        }
+      });
+    }
+    const [uniqueFound] = await uniqueQuery;
+    return uniqueFound;
+  }
 };
 var FixtureManager = new FixtureManagerClass();
 
@@ -7443,4 +7828,4 @@ var FixtureManager = new FixtureManagerClass();
 
 
 exports.SQLDateTimeString = SQLDateTimeString; exports.zArrayable = zArrayable; exports.isIntegerProp = isIntegerProp; exports.isBigIntegerProp = isBigIntegerProp; exports.isTextProp = isTextProp; exports.isStringProp = isStringProp; exports.isEnumProp = isEnumProp; exports.isFloatProp = isFloatProp; exports.isDoubleProp = isDoubleProp; exports.isDecimalProp = isDecimalProp; exports.isBooleanProp = isBooleanProp; exports.isDateProp = isDateProp; exports.isDateTimeProp = isDateTimeProp; exports.isTimeProp = isTimeProp; exports.isTimestampProp = isTimestampProp; exports.isJsonProp = isJsonProp; exports.isUuidProp = isUuidProp; exports.isVirtualProp = isVirtualProp; exports.isRelationProp = isRelationProp; exports.isOneToOneRelationProp = isOneToOneRelationProp; exports.isBelongsToOneRelationProp = isBelongsToOneRelationProp; exports.isHasManyRelationProp = isHasManyRelationProp; exports.isManyToManyRelationProp = isManyToManyRelationProp; exports.isCustomJoinClause = isCustomJoinClause; exports.SonamuQueryMode = SonamuQueryMode; exports.isKnexError = isKnexError; exports.ApiParamType = ApiParamType; exports.RenderingNode = RenderingNode; exports.TemplateOptions = TemplateOptions; exports.TemplateKey = TemplateKey; exports.GenerateOptions = GenerateOptions; exports.PathAndCode = PathAndCode; exports.getZodObjectFromApi = getZodObjectFromApi; exports.getZodObjectFromApiParams = getZodObjectFromApiParams; exports.getZodTypeFromApiParamType = getZodTypeFromApiParamType; exports.propNodeToZodTypeDef = propNodeToZodTypeDef; exports.getTextTypeLength = getTextTypeLength; exports.propToZodTypeDef = propToZodTypeDef; exports.zodTypeToZodCode = zodTypeToZodCode; exports.apiParamToTsCode = apiParamToTsCode; exports.apiParamTypeToTsType = apiParamTypeToTsType; exports.unwrapPromiseOnce = unwrapPromiseOnce; exports.serializeZodType = serializeZodType; exports.zodTypeToTsTypeDef = zodTypeToTsTypeDef; exports.registeredApis = registeredApis; exports.api = api; exports.SoException = SoException; exports.isSoException = isSoException; exports.BadRequestException = BadRequestException; exports.UnauthorizedException = UnauthorizedException; exports.NotFoundException = NotFoundException; exports.ServiceUnavailableException = ServiceUnavailableException; exports.InternalServerErrorException = InternalServerErrorException; exports.AlreadyProcessedException = AlreadyProcessedException; exports.DuplicateRowException = DuplicateRowException; exports.TargetNotFoundException = TargetNotFoundException; exports.globAsync = globAsync; exports.importMultiple = importMultiple; exports.findAppRootPath = findAppRootPath; exports.findApiRootPath = findApiRootPath; exports.nonNullable = nonNullable; exports.Entity = Entity; exports.EntityManager = EntityManager; exports.Syncer = Syncer; exports.isLocal = isLocal; exports.isRemote = isRemote; exports.isInDocker = isInDocker; exports.isDaemonServer = isDaemonServer; exports.isDevelopment = isDevelopment; exports.isStaging = isStaging; exports.isProduction = isProduction; exports.isTest = isTest; exports.DB = DB; exports.isRefField = isRefField; exports.UpsertBuilder = UpsertBuilder; exports.BaseModelClass = BaseModelClass; exports.BaseModel = BaseModel; exports.Sonamu = Sonamu; exports.Migrator = Migrator; exports.FixtureManagerClass = FixtureManagerClass; exports.FixtureManager = FixtureManager;
-//# sourceMappingURL=chunk-5VT5JTY4.js.map
+//# sourceMappingURL=chunk-HATLA54Z.js.map