sonamu 0.2.48 → 0.2.50

package/src/database/_batch_update.ts

@@ -13,7 +13,7 @@ export type RowWithId<Id extends string> = {
  * Batch update rows in a table. Technically its a patch since it only updates the specified columns. Any omitted columns will not be affected
  * @param knex
  * @param tableName
- * @param id
+ * @param ids
  * @param rows
  * @param chunkSize
  * @param trx
@@ -21,7 +21,7 @@ export type RowWithId<Id extends string> = {
 export async function batchUpdate<Id extends string>(
   knex: Knex,
   tableName: string,
-  id: Id,
+  ids: Id[],
   rows: RowWithId<Id>[],
   chunkSize = 50,
   trx: Knex.Transaction | null = null
@@ -35,7 +35,7 @@ export async function batchUpdate<Id extends string>(
     chunk: RowWithId<Id>[],
     transaction: Knex.Transaction
   ) => {
-    const sql = generateBatchUpdateSQL(knex, tableName, chunk, id);
+    const sql = generateBatchUpdateSQL(knex, tableName, chunk, ids);
     return knex.raw(sql).transacting(transaction);
   };
 
@@ -73,20 +73,30 @@ function generateBatchUpdateSQL<Id extends string>(
   knex: Knex,
   tableName: string,
   data: Record<string, any>[],
-  identifier: Id
+  identifiers: Id[]
 ) {
   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 as Id)) 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]);
       }
     }
 
@@ -94,13 +104,18 @@ function generateBatchUpdateSQL<Id extends string>(
     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 = knex.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();
 }

package/src/database/upsert-builder.ts

@@ -144,17 +144,26 @@ export class UpsertBuilder {
     };
   }
 
-  async upsert(wdb: Knex, tableName: string): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "upsert");
+  async upsert(
+    wdb: Knex,
+    tableName: string,
+    chunkSize?: number
+  ): Promise<number[]> {
+    return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
   }
-  async insertOnly(wdb: Knex, tableName: string): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "insert");
+  async insertOnly(
+    wdb: Knex,
+    tableName: string,
+    chunkSize?: number
+  ): Promise<number[]> {
+    return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
   }
 
   async upsertOrInsert(
     wdb: Knex,
     tableName: string,
-    mode: "upsert" | "insert"
+    mode: "upsert" | "insert",
+    chunkSize?: number
   ): Promise<number[]> {
     if (this.hasTable(tableName) === false) {
       return [];
@@ -177,22 +186,6 @@ export class UpsertBuilder {
       throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
     }
 
-    // 내부 참조 있는 경우 필터하여 분리
-    const groups = _.groupBy(table.rows, (row) =>
-      Object.entries(row).some(([, value]) => isRefField(value))
-        ? "selfRef"
-        : "normal"
-    );
-    const targetRows = groups.normal;
-
-    // Insert On Duplicate Update
-    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, [, table]) => {
@@ -211,19 +204,39 @@ export class UpsertBuilder {
         refTables: [] as TableData[],
       }
     );
-
     const extractFields = _.uniq(references).map(
       (reference) => reference.split(".")[1]
     );
 
-    // UUID 기준으로 id 추출
-    const uuids = table.rows.map((row) => row.uuid);
-    const upsertedRows = await wdb(tableName)
-      .select(_.uniq(["uuid", "id", ...extractFields]))
-      .whereIn("uuid", uuids);
-    const uuidMap = new Map<string, any>(
-      upsertedRows.map((row: any) => [row.uuid, row])
+    // 내부 참조 있는 경우 필터하여 분리
+    const groups = _.groupBy(table.rows, (row) =>
+      Object.entries(row).some(([, value]) => isRefField(value))
+        ? "selfRef"
+        : "normal"
     );
+    const normalRows = groups.normal ?? [];
+    const selfRefRows = groups.selfRef ?? [];
+
+    const chunks = chunkSize ? _.chunk(normalRows, chunkSize) : [normalRows];
+    const uuidMap = new Map<string, any>();
+
+    for (const chunk of chunks) {
+      const q = wdb.insert(chunk).into(tableName);
+      if (mode === "insert") {
+        await q;
+      } else if (mode === "upsert") {
+        await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
+      }
+
+      // upsert된 row들을 다시 조회하여 uuidMap에 저장
+      const uuids = chunk.map((row) => row.uuid);
+      const upsertedRows = await wdb(tableName)
+        .select(_.uniq(["uuid", "id", ...extractFields]))
+        .whereIn("uuid", uuids);
+      upsertedRows.forEach((row: any) => {
+        uuidMap.set(row.uuid, row);
+      });
+    }
 
     // 해당 테이블 참조를 실제 밸류로 변경
     refTables.map((table) => {
@@ -245,14 +258,17 @@ export class UpsertBuilder {
       });
     });
 
-    const ids = Array.from(uuidMap.values()).map((val) => val.id);
+    const allIds = Array.from(uuidMap.values()).map((row) => row.id);
 
-    if (groups.selfRef) {
-      const selfRefIds = await this.upsert(wdb, tableName);
-      return [...ids, ...selfRefIds];
+    // 자기 참조가 있는 경우 재귀적으로 upsert
+    if (selfRefRows.length > 0) {
+      // 처리된 데이터를 제외하고 다시 upsert
+      table.rows = selfRefRows;
+      const selfRefIds = await this.upsert(wdb, tableName, chunkSize);
+      allIds.push(...selfRefIds);
     }
 
-    return ids;
+    return allIds;
   }
 
   async updateBatch(
@@ -260,7 +276,7 @@ export class UpsertBuilder {
     tableName: string,
     options?: {
       chunkSize?: number;
-      where?: string;
+      where?: string | string[];
     }
   ): Promise<void> {
     options = _.defaults(options, {
@@ -276,16 +292,14 @@ export class UpsertBuilder {
       return;
     }
 
+    const whereColumns = Array.isArray(options.where)
+      ? options.where
+      : [options.where ?? "id"];
     const rows = table.rows.map((_row) => {
       const { uuid, ...row } = _row;
       return row as RowWithId<string>;
     });
-    await batchUpdate(
-      wdb,
-      tableName,
-      options.where ?? "id",
-      rows,
-      options.chunkSize
-    );
+
+    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
   }
 }

package/src/templates/service.template.ts

@@ -30,6 +30,11 @@ export class Template__service extends Template {
     // 서비스 TypeSource
     const { lines, importKeys } = this.getTypeSource(apis);
 
+    // AxiosProgressEvent 있는지 확인
+    const hasAxiosProgressEvent = apis.find((api) =>
+      (api.options.clients ?? []).includes("axios-multipart")
+    );
+
     return {
       ...this.getTargetAndPath(names),
       body: lines.join("\n"),
@@ -41,6 +46,9 @@ export class Template__service extends Template {
         `import qs from "qs";`,
         `import useSWR, { SWRResponse } from "swr";`,
         `import { fetch, ListResult, SWRError, SwrOptions, handleConditional, swrPostFetcher } from '../sonamu.shared';`,
+        ...(hasAxiosProgressEvent
+          ? [`import { AxiosProgressEvent } from 'axios';`]
+          : []),
       ],
     };
   }
@@ -210,7 +218,7 @@ export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<
 export async function ${api.methodName}${typeParamsDef}(
   ${paramsDef}${paramsDefComma}
   file: File,
-  onUploadProgress?: (pe:ProgressEvent) => void
+  onUploadProgress?: (pe:AxiosProgressEvent) => void
   ): Promise<${returnTypeDef}> {
     const formData = new FormData();
     ${formDataDef}

package/src/testing/fixture-manager.ts

@@ -158,6 +158,10 @@ export class FixtureManagerClass {
             await transaction(tableName).truncate();
 
             const rows = await frdb(tableName);
+            if (rows.length === 0) {
+              return;
+            }
+
             console.log(chalk.blue(tableName), rows.length);
             await transaction
               .insert(
@@ -307,58 +311,72 @@ export class FixtureManagerClass {
       throw new Error("No records found");
     }
 
-    const visitedEntities = new Set<string>();
-    const records: FixtureRecord[] = [];
+    const fixtures: FixtureRecord[] = [];
     for (const row of rows) {
-      const initialRecordsLength = records.length;
-      await this.createFixtureRecord(entity, row, visitedEntities, records);
-      const currentFixtureRecord = records.find(
+      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) {
         // 현재 fixture로부터 생성된 fetchedRecords 설정
-        currentFixtureRecord.fetchedRecords = records
+        currentFixtureRecord.fetchedRecords = fixtures
           .filter((r) => r.fixtureId !== currentFixtureRecord.fixtureId)
           .slice(initialRecordsLength)
           .map((r) => r.fixtureId);
       }
     }
 
-    for await (const record of records) {
-      const entity = EntityManager.get(record.entityId);
-      const rows: FixtureRecord[] = [];
-      const row = await targetDB(entity.table).where("id", record.id).first();
+    for await (const fixture of fixtures) {
+      const entity = EntityManager.get(fixture.entityId);
+
+      // targetDB에 해당 레코드가 존재하는지 확인
+      const row = await targetDB(entity.table).where("id", fixture.id).first();
       if (row) {
-        await this.createFixtureRecord(
-          entity,
-          row,
-          new Set(),
-          rows,
-          true,
-          targetDB
-        );
-        record.target = rows[0];
+        const [record] = await this.createFixtureRecord(entity, row, {
+          singleRecord: true,
+          _db: targetDB,
+        });
+        fixture.target = record;
+        continue;
+      }
+
+      // targetDB에 해당 레코드가 존재하지 않는 경우, unique 제약을 위반하는지 확인
+      const uniqueRow = await this.checkUniqueViolation(
+        targetDB,
+        entity,
+        fixture
+      );
+      if (uniqueRow) {
+        const [record] = await this.createFixtureRecord(entity, uniqueRow, {
+          singleRecord: true,
+          _db: targetDB,
+        });
+        fixture.unique = record;
       }
     }
 
-    return records;
+    return fixtures;
   }
 
   async createFixtureRecord(
     entity: Entity,
     row: any,
-    visitedEntities: Set<string>,
-    records: FixtureRecord[],
-    singleRecord = false,
-    _db?: Knex
-  ) {
+    options?: {
+      singleRecord?: boolean;
+      _db?: Knex;
+    },
+    visitedEntities = new Set<string>()
+  ): Promise<FixtureRecord[]> {
     const fixtureId = `${entity.id}#${row.id}`;
     if (visitedEntities.has(fixtureId)) {
-      return;
+      return [];
     }
     visitedEntities.add(fixtureId);
 
+    const records: FixtureRecord[] = [];
     const record: FixtureRecord = {
       fixtureId,
       entityId: entity.id,
@@ -378,7 +396,7 @@ export class FixtureManagerClass {
         value: row[prop.name],
       };
 
-      const db = _db ?? BaseModel.getDB("w");
+      const db = options?._db ?? BaseModel.getDB("w");
       if (isManyToManyRelationProp(prop)) {
         const relatedEntity = EntityManager.get(prop.with);
         const throughTable = prop.joinTable;
@@ -412,32 +430,34 @@ export class FixtureManagerClass {
         if (relatedId) {
           record.belongsRecords.push(`${prop.with}#${relatedId}`);
         }
-        if (!singleRecord && relatedId) {
+        if (!options?.singleRecord && relatedId) {
           const relatedEntity = EntityManager.get(prop.with);
           const relatedRow = await db(relatedEntity.table)
             .where("id", relatedId)
             .first();
           if (relatedRow) {
-            await this.createFixtureRecord(
+            const newRecords = await this.createFixtureRecord(
               relatedEntity,
               relatedRow,
-              visitedEntities,
-              records,
-              singleRecord,
-              _db
+              options,
+              visitedEntities
             );
+            records.push(...newRecords);
           }
         }
       }
     }
 
     records.push(record);
+    return records;
   }
 
   async insertFixtures(
     dbName: keyof SonamuDBConfig,
-    fixtures: FixtureRecord[]
+    _fixtures: FixtureRecord[]
   ) {
+    const fixtures = _.uniqBy(_fixtures, (f) => f.fixtureId);
+
     this.buildDependencyGraph(fixtures);
     const insertionOrder = this.getInsertionOrder();
     const db = knex(Sonamu.dbConfig[dbName]);
@@ -447,7 +467,27 @@ export class FixtureManagerClass {
 
       for (const fixtureId of insertionOrder) {
         const fixture = fixtures.find((f) => f.fixtureId === fixtureId)!;
-        await this.insertFixture(trx, fixture);
+        const result = await this.insertFixture(trx, fixture);
+        if (result.id !== fixture.id) {
+          // ID가 변경된 경우, 다른 fixture에서 참조하는 경우가 찾아서 수정
+          console.log(
+            chalk.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) {
@@ -468,7 +508,7 @@ export class FixtureManagerClass {
       });
     }
 
-    return records;
+    return _.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
   }
 
   private getInsertionOrder() {
@@ -598,6 +638,14 @@ export class FixtureManagerClass {
     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 {
@@ -688,5 +736,43 @@ export class FixtureManagerClass {
       throw new Error("Failed to find fixtureLoader in fixture.ts");
     }
   }
+
+  // 해당 픽스쳐의 값으로 유니크 제약에 위배되는 레코드가 있는지 확인
+  private async checkUniqueViolation(
+    db: Knex,
+    entity: Entity,
+    fixture: FixtureRecord
+  ) {
+    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) {
+      // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
+      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;
+  }
 }
 export const FixtureManager = new FixtureManagerClass();

package/src/types/types.ts

@@ -738,8 +738,9 @@ export type FixtureRecord = {
     };
   };
   fetchedRecords: string[];
-  belongsRecords: string[]; //
-  target?: FixtureRecord; // Import 대상 DB 레코드
+  belongsRecords: string[];
+  target?: FixtureRecord; // Import 대상 DB 레코드(id가 같은)
+  unique?: FixtureRecord; // Import 대상 DB 레코드(unique key가 같은)
   override?: boolean;
 };
 

package/src/utils/utils.ts

@@ -17,19 +17,21 @@ export async function importMultiple(
   filePaths: string[],
   doRefresh: boolean = false
 ): Promise<{ filePath: string; imported: any }[]> {
-  return Promise.all(
-    filePaths.map(async (filePath) => {
-      const importPath = "./" + path.relative(__dirname, filePath);
-      if (doRefresh) {
-        delete require.cache[require.resolve(importPath)];
-      }
-      const imported = await import(importPath);
-      return {
-        filePath,
-        imported,
-      };
-    })
-  );
+  const results: { filePath: string; imported: any }[] = [];
+
+  for (const filePath of filePaths) {
+    const importPath = "./" + path.relative(__dirname, filePath);
+    if (doRefresh) {
+      delete require.cache[require.resolve(importPath)];
+    }
+    const imported = await import(importPath);
+    results.push({
+      filePath,
+      imported,
+    });
+  }
+
+  return results;
 }
 export async function findAppRootPath() {
   const apiRootPath = await findApiRootPath();

package/tsup.config.js

@@ -4,10 +4,7 @@ import { defineConfig } from "tsup";
 export default defineConfig({
   entry: ["src/index.ts", "src/bin/cli.ts", "src/bin/cli-wrapper.ts"],
   dts: true,
-  format: [
-    // "esm",
-    "cjs",
-  ],
+  format: ["esm", "cjs"],
   target: "es2020",
   clean: true,
   sourcemap: true,