sonamu 0.7.2 → 0.7.3

package/src/database/upsert-builder.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "crypto";
 import type { Knex } from "knex";
-import { unique } from "radashi";
+import { isArray, unique } from "radashi";
 import { EntityManager } from "../entity/entity-manager";
 import { Naite } from "../naite/naite";
 import { assertDefined, chunk, nonNullable } from "../utils/utils";
@@ -17,6 +17,10 @@ export type UBRef = {
   of: string;
   use?: string;
 };
+type UpsertOptions = {
+  chunkSize?: number;
+  cleanOrphans?: string | string[]; // FK 컬럼명(들)
+};
 export function isRefField(field: unknown): field is UBRef {
   return (
     field !== undefined &&
@@ -150,18 +154,37 @@ export class UpsertBuilder {
     return result;
   }
 
-  async upsert(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
+  async upsert(
+    wdb: Knex,
+    tableName: string,
+    optionsOrChunkSize?: UpsertOptions,
+  ): Promise<number[]> {
+    // 숫자면 { chunkSize: n } 으로 변환
+    const options =
+      typeof optionsOrChunkSize === "number"
+        ? { chunkSize: optionsOrChunkSize }
+        : optionsOrChunkSize;
+
+    return this.upsertOrInsert(wdb, tableName, "upsert", options);
   }
-  async insertOnly(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
+  async insertOnly(
+    wdb: Knex,
+    tableName: string,
+    optionsOrChunkSize?: UpsertOptions | number,
+  ): Promise<number[]> {
+    const options =
+      typeof optionsOrChunkSize === "number"
+        ? { chunkSize: optionsOrChunkSize }
+        : optionsOrChunkSize;
+
+    return this.upsertOrInsert(wdb, tableName, "insert", options);
   }
 
   async upsertOrInsert(
     wdb: Knex,
     tableName: string,
     mode: "upsert" | "insert",
-    chunkSize?: number,
+    options?: UpsertOptions,
   ): Promise<number[]> {
     if (this.hasTable(tableName) === false) {
       return [];
@@ -244,43 +267,47 @@ export class UpsertBuilder {
       });
 
       // 현재 레벨 upsert
+      const chunkSize = options?.chunkSize;
       const levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [resolvedRows];
-      const selectFields = unique(["uuid", "id", ...extractFields]);
+      const selectFields = unique(["id", ...extractFields]);
 
       for (const dataChunk of levelChunks) {
         if (dataChunk.length === 0) continue;
 
-        let resultRows: { uuid: string; id: number; [key: string]: unknown }[];
+        // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거
+        const originalUuids = dataChunk.map((r) => r.uuid as string);
+        const dataForDb = dataChunk.map(({ uuid, ...rest }) => rest);
 
-        if (mode === "insert") {
-          // INSERT 모드
-          await wdb.insert(dataChunk).into(tableName);
+        let resultRows: { id: number; [key: string]: unknown }[];
 
-          const uuids = dataChunk.map((r) => r.uuid);
-          resultRows = await wdb(tableName)
-            .select(selectFields)
-            .whereIn("uuid", uuids as readonly string[]);
+        if (mode === "insert") {
+          // INSERT 모드 - RETURNING 사용
+          resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
         } else {
-          // UPSERT 모드: onConflict로 중복 처리
+          // UPSERT 모드 - onConflict 사용
           const conflictColumns = table.uniqueIndexes[0].columns;
-          const updateColumns = Object.keys(dataChunk[0]).filter(
-            (col) => col !== "uuid" && !conflictColumns.includes(col),
+          const updateColumns = Object.keys(dataForDb[0]).filter(
+            (col) => !conflictColumns.includes(col),
           );
 
-          const query = wdb.insert(dataChunk).into(tableName).onConflict(conflictColumns);
+          // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장
+          const mergeColumns = updateColumns.length > 0 ? updateColumns : conflictColumns;
 
-          // updateColumns 유무에 따라 ignore/merge 선택하고 RETURNING으로 결과 받기
-          if (updateColumns.length === 0) {
-            resultRows = await query.ignore().returning(selectFields);
-          } else {
-            resultRows = await query.merge(updateColumns).returning(selectFields);
-          }
+          resultRows = await wdb
+            .insert(dataForDb)
+            .into(tableName)
+            .onConflict(conflictColumns)
+            .merge(mergeColumns)
+            .returning(selectFields);
         }
 
-        // 양쪽 모드 공통 처리
-        for (const row of resultRows) {
-          uuidMap.set(row.uuid, row);
-          allIds.push(row.id);
+        if (originalUuids.length !== resultRows.length) {
+          throw new Error(`${tableName}: register/returning 불일치`);
+        }
+
+        for (let i = 0; i < resultRows.length; i++) {
+          uuidMap.set(originalUuids[i], resultRows[i]);
+          allIds.push(resultRows[i].id);
         }
       }
     }
@@ -311,6 +338,38 @@ export class UpsertBuilder {
       });
     }
 
+    if (options?.cleanOrphans) {
+      const cleanOrphans = options.cleanOrphans;
+      const fkColumns = isArray(cleanOrphans) ? cleanOrphans : [cleanOrphans];
+
+      // 현재 register된 레코드들의 FK 값들 추출
+      const fkConditions = fkColumns.map((fkCol) => {
+        const fkValues = [...new Set(table.rows.map((row) => row[fkCol]).filter((v) => v != null))];
+        return { column: fkCol, values: fkValues };
+      });
+
+      // 모든 FK 컬럼에 값이 있는 경우에만 삭제 실행
+      if (fkConditions.every((fc) => fc.values.length > 0)) {
+        let deleteQuery = wdb(tableName);
+
+        // 각 FK 컬럼에 대한 WHERE IN 조건 추가
+        for (const { column, values } of fkConditions) {
+          deleteQuery = deleteQuery.whereIn(column, values);
+        }
+
+        // 방금 upsert한 ID는 제외
+        deleteQuery = deleteQuery.whereNotIn("id", allIds);
+
+        const deletedCount = await deleteQuery.delete();
+
+        Naite.t("puri:ub-clean-orphans", {
+          tableName,
+          cleanOrphans: fkColumns,
+          deletedCount,
+        });
+      }
+    }
+
     // 해당 테이블의 데이터 초기화
     table.rows = [];
     table.references.clear();

package/src/entity/entity.ts

@@ -524,8 +524,8 @@ export class Entity {
       // 일반 prop 처리
       if (key === "") {
         return group.map((propName) => {
-          // uuid 개별 처리
-          if (propName === "uuid") {
+          // FIXME: 이거 나중에 없애야함
+          if (propName === "말도안되는프롭명__이거왜타입처리가꼬여서이러지?") {
             return {
               nodeType: "plain" as const,
               prop: {

package/src/migration/code-generation.ts

@@ -146,15 +146,15 @@ function genIndexDefinition(index: MigrationIndex, table: string) {
   };
 
   if (index.type === "fulltext" && index.parser === "ngram") {
-    const indexName = `${table}_${index.columns.join("_")}_index`;
-    return `await knex.raw(\`ALTER TABLE ${table} ADD FULLTEXT INDEX ${indexName} (${index.columns.join(
+    return `await knex.raw(\`ALTER TABLE ${table} ADD FULLTEXT INDEX ${index.name} (${index.columns.join(
       ", ",
     )}) WITH PARSER ngram\`);`;
   }
 
   return `table.${methodMap[index.type]}([${index.columns
     .map((col) => `'${col}'`)
-    .join(",")}]${index.type === "fulltext" ? ", undefined, 'FULLTEXT'" : ""})`;
+    .join(",")}], '${index.name}'${index.type === "fulltext" ? ", 'FULLTEXT'" : ""}
+  );`;
 }
 
 /**
@@ -309,6 +309,8 @@ async function generateAlterCode_ColumnAndIndexes(
   });
   // Naite.t("migrator:generateAlterCode_ColumnAndIndexes:alterColumnsTo", alterColumnsTo);
 
+  // TODO: 인덱스명 변경된 경우 처리
+
   const lines: string[] = [
     'import { Knex } from "knex";',
     "",
@@ -536,7 +538,7 @@ function genIndexDropDefinition(index: MigrationIndex) {
 
   return `table.drop${methodMap[index.type]}([${index.columns
     .map((columnName) => `'${columnName}'`)
-    .join(",")}])`;
+    .join(",")}], '${index.name}')`;
 }
 
 /**
@@ -723,10 +725,10 @@ export async function generateAlterCode(
          */
 
   const entityIndexes = alphabetical(entitySet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
+    [a.type, ...a.columns].join("-"),
   );
   const dbIndexes = alphabetical(dbSet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
+    [a.type, ...a.columns].join("-"),
   );
 
   const replaceNoActionOnMySQL = (f: MigrationForeign) => {

package/src/migration/migration-set.ts

@@ -88,10 +88,6 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
         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}.`)))
@@ -113,11 +109,6 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
                 nullable: false,
               } as MigrationColumn;
             }),
-            {
-              name: "uuid",
-              nullable: true,
-              type: "uuid",
-            },
           ],
           foreigns: fields.map((field) => {
             // 현재 필드가 어떤 테이블에 속하는지 판단
@@ -175,17 +166,6 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
     index.columns.find((col) => col.includes(".") === false),
   );
 
-  // uuid
-  migrationSet.columns = migrationSet.columns.concat({
-    name: "uuid",
-    nullable: true,
-    type: "uuid",
-  } as MigrationColumn);
-  migrationSet.indexes = migrationSet.indexes.concat({
-    type: "unique",
-    columns: ["uuid"],
-  } as MigrationIndex);
-
   return migrationSet;
 }
 

package/src/migration/migrator.ts

@@ -341,7 +341,7 @@ export class Migrator {
         ...tables[0],
         indexes: unique(
           tables.flatMap((t) => t.indexes),
-          (index) => [index.type, ...index.columns.sort()].join("-"),
+          (index) => [index.type, ...index.columns].join("-"),
         ),
       };
     });

package/src/migration/postgresql-schema-reader.ts

@@ -109,6 +109,7 @@ class PostgreSQLSchemaReaderClass {
 
       return {
         type,
+        name: indexName,
         columns: currentIndexes.map((idx) => idx.column_name),
       };
     });

package/src/shared/web.shared.ts.txt

@@ -86,10 +86,12 @@ export function defaultCatch(e: any) {
 /*
   Isomorphic Types
 */
-export type ListResult<T> = {
-  rows: T[];
-  total?: number;
-};
+export type ListResult<LP extends { queryMode?: SonamuQueryMode }, T> = LP["queryMode"] extends "list"
+  ? { rows: T[] }
+  : LP["queryMode"] extends "count"
+    ? { total: number }
+    : { rows: T[]; total: number };
+
 export const SonamuQueryMode = z.enum(["both", "list", "count"]);
 export type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
 

package/src/syncer/file-patterns.ts

@@ -30,7 +30,7 @@ export const checksumPatternGroup: GlobPattern<ApiRelativePath> = {
   model: "src/application/**/*.model.ts",
   frame: "src/application/**/*.frame.ts",
   functions: "src/application/**/*.functions.ts",
-  config: "sonamu.config.ts",
+  config: "src/sonamu.config.ts",
 };
 
 /**

package/src/template/implementations/service.template.ts

@@ -85,11 +85,12 @@ export class Template__service extends Template {
             );
 
             // 파라미터 타입 정의
-            const typeParamsDef = api.typeParameters
+            const typeParametersAsTsType = api.typeParameters
               .map((typeParam) => {
                 return apiParamTypeToTsType(typeParam, importKeys);
               })
               .join(", ");
+            const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : "";
             typeParamNames = typeParamNames.concat(
               api.typeParameters.map((typeParam) => typeParam.id),
             );

package/src/types/types.ts

@@ -175,7 +175,7 @@ export type EntityProp =
 export type EntityIndex = {
   type: "index" | "unique" | "fulltext";
   columns: string[];
-  name?: string;
+  name: string;
   parser?: "built-in" | "ngram";
 };
 export type EntityJson = {
@@ -451,6 +451,7 @@ export type MigrationColumn = {
   scale?: number;
 };
 export type MigrationIndex = {
+  name: string;
   columns: string[];
   type: "unique" | "index" | "fulltext";
   parser?: "built-in" | "ngram";
@@ -942,7 +943,7 @@ const EntityIndexSchema = z
   .object({
     type: z.enum(["index", "unique", "fulltext"]),
     columns: z.array(z.string()),
-    name: z.string().optional(),
+    name: z.string().min(1).max(63),
     parser: z.enum(["built-in", "ngram"]).optional(),
   })
   .strict();

package/src/utils/model.ts

@@ -1,7 +1,13 @@
-export type ListResult<T> = {
-  rows: T[];
-  total?: number;
-};
+import type { SonamuQueryMode } from "..";
+
+export type ListResult<
+  LP extends { queryMode?: SonamuQueryMode },
+  T,
+> = LP["queryMode"] extends "list"
+  ? { rows: T[] }
+  : LP["queryMode"] extends "count"
+    ? { total: number }
+    : { rows: T[]; total: number };
 
 export type ArrayOr<T> = T | T[];
 

package/src/utils/path-utils.ts

@@ -10,7 +10,7 @@ import { isHotReloadServer, isTest } from "./controller.js";
  *
  * **기준점**: `Sonamu.apiRootPath` (일반적으로 프로젝트의 `/api` 디렉토리)
  */
-export type ApiRelativePath = `${"src" | "dist"}/${string}` | "sonamu.config.ts";
+export type ApiRelativePath = `${"src" | "dist"}/${string}`;
 
 /**
  * 앱 루트 기준 상대 경로 (api/, web/ 등 타겟 디렉토리로 시작)
@@ -90,7 +90,10 @@ export type AbsolutePath = `/${string}`;
  * @param anyPath
  * @returns
  */
-export function runtimePath(anyPath: string, isDev: boolean = isHotReloadServer() || isTest()): string {
+export function runtimePath(
+  anyPath: string,
+  isDev: boolean = isHotReloadServer() || isTest(),
+): string {
   if (isDev) {
     return anyPath.replace(/dist\//, "src/").replace(/\.js/, ".ts");
   } else {