sonamu 0.7.53 → 0.8.0

package/src/testing/fixture-manager.ts

@@ -67,7 +67,8 @@ export class FixtureManagerClass {
   // UpsertBuilder 기반 import를 위한 상태
   private builder: UpsertBuilder = new UpsertBuilder();
   private fixtureRefMap: Map<string, UBRef> = new Map();
-  private skippedFixtures: Map<string, { entityId: string; existingId: number }> = new Map();
+  private skippedFixtures: Map<string, { entityId: string; existingId: number | string }> =
+    new Map();
 
   init() {
     if (this._tdb !== null) {
@@ -132,6 +133,45 @@ export class FixtureManagerClass {
       env: { ...process.env, ...fixturePgEnv } as NodeJS.ProcessEnv,
       shell: "/bin/bash",
     });
+
+    // 3. 시퀀스 리셋 (데이터 복사 후 시퀀스를 MAX(id)로 정렬)
+    await this.resetSequences(Sonamu.dbConfig.test);
+  }
+
+  /**
+   * 모든 테이블의 시퀀스를 현재 MAX(id)로 리셋합니다.
+   * fixture sync 후 시퀀스가 실제 데이터와 맞지 않는 문제를 해결합니다.
+   */
+  private async resetSequences(dbConfig: SonamuDBConfig["test"]) {
+    const testDb = createKnexInstance(dbConfig);
+    const entities = EntityManager.getAllEntities();
+
+    try {
+      for (const entity of entities) {
+        const tableName = entity.table || entity.id.toLowerCase();
+
+        // id 필드의 타입을 확인합니다
+        const idProp = entity.props.find((p) => p.name === "id");
+        const idType = idProp?.type;
+
+        // integer나 bigInteger가 아닌 경우 sequence reset을 스킵합니다 (text, uuid 등)
+        if (!idType || (idType !== "integer" && idType !== "bigInteger")) {
+          console.log(`Skipping sequence reset for ${tableName} (id type: ${idType || "unknown"})`);
+          continue;
+        }
+
+        // PostgreSQL 시퀀스를 현재 테이블의 MAX(id)로 리셋합니다.
+        // 세 번째 인자를 생략하면 기본값 true가 적용되어, 다음 INSERT 시 MAX(id)+1부터 시작합니다.
+        await testDb.raw(`
+          SELECT setval(
+            pg_get_serial_sequence('public.${tableName}', 'id'),
+            COALESCE((SELECT MAX(id) FROM ${tableName}), 1)
+          )
+        `);
+      }
+    } finally {
+      await testDb.destroy();
+    }
   }
 
   private visitedRecords = new Set<string>();
@@ -330,7 +370,7 @@ export class FixtureManagerClass {
   async createFixtureRecord(
     entity: Entity,
     row: {
-      id: number;
+      id: number | string;
       [key: string]: string | number | boolean | null;
     },
     options?: {
@@ -344,7 +384,7 @@ export class FixtureManagerClass {
     const create = async (
       entity: Entity,
       row: {
-        id: number;
+        id: number | string;
         [key: string]: string | number | boolean | null;
       },
     ) => {
@@ -389,12 +429,16 @@ export class FixtureManagerClass {
             .pluck("id");
           record.columns[prop.name].value = relatedIds;
         } else if (isOneToOneRelationProp(prop) && !prop.hasJoinColumn) {
+          // 역방향 OneToOne: FK를 가진 관련 엔티티를 찾습니다
+          // 예시: User OneToOne Employee (Employee가 user_id FK를 가짐)
           const relatedEntity = EntityManager.get(prop.with);
           const relatedProp = relatedEntity.props.find(
             (p) => isRelationProp(p) && p.with === entity.id,
           );
-          if (relatedProp) {
-            const relatedRow = await db(relatedEntity.table).where("id", row.id).first();
+          if (relatedProp && isRelationProp(relatedProp)) {
+            // 관련 엔티티에서 FK 컬럼으로 쿼리합니다 (id가 아님)
+            const fkColumn = `${relatedProp.name}_id`;
+            const relatedRow = await db(relatedEntity.table).where(fkColumn, row.id).first();
             record.columns[prop.name].value = relatedRow?.id;
           }
         } else if (isRelationProp(prop)) {
@@ -553,7 +597,48 @@ export class FixtureManagerClass {
         // 5. ManyToMany 관계 처리
         await this.processManyToManyRelations(trx, fixtures, insertedIdsByTable);
 
-        // 6. 결과 수집
+        // 6. PostgreSQL 시퀀스 리셋
+        // Fixture 삽입 후 각 테이블의 ID 시퀀스를 최대 ID 값으로 업데이트합니다.
+        // 이렇게 하지 않으면 다음 INSERT 시 ID가 2000번대로 생성될 수 있습니다.
+        console.log(chalk.blue("Resetting sequences..."));
+        for (const tableName of tableOrder) {
+          try {
+            // Entity를 찾아서 id 타입 확인
+            const entity = EntityManager.getAllEntities().find(
+              (e) => e.table === tableName || e.id.toLowerCase() === tableName,
+            );
+
+            if (entity) {
+              const idProp = entity.props.find((p) => p.name === "id");
+              const idType = idProp?.type;
+
+              // integer나 bigInteger가 아닌 경우 sequence reset을 스킵합니다
+              if (!idType || (idType !== "integer" && idType !== "bigInteger")) {
+                console.log(
+                  chalk.gray(
+                    `Skipped sequence reset for ${tableName} (id type: ${idType || "unknown"})`,
+                  ),
+                );
+                continue;
+              }
+            }
+
+            // 테이블의 최대 ID 조회
+            const maxIdResult = await trx(tableName).max("id as max_id").first();
+            const maxId = maxIdResult?.max_id;
+
+            if (maxId !== null && maxId !== undefined) {
+              // 시퀀스를 최대 ID로 설정
+              await trx.raw(`SELECT setval('${tableName}_id_seq', ?)`, [maxId]);
+              console.log(chalk.green(`Reset sequence for ${tableName}: ${maxId}`));
+            }
+          } catch (_err) {
+            // 시퀀스가 없는 테이블(join table 등)은 무시
+            console.log(chalk.gray(`Skipped sequence reset for ${tableName}`));
+          }
+        }
+
+        // 7. 결과 수집
         for (const fixture of fixtures) {
           const entity = EntityManager.get(fixture.entityId);
 

package/src/testing/index.ts

@@ -1,5 +1,8 @@
 export * from "./bootstrap";
+export * from "./data-explorer";
+export * from "./fixture-generator";
 export * from "./fixture-loader";
+export * from "./fixture-manager";
 export * from "./global-setup";
 export * from "./naite-vitest-reporter";
 export * from "./parallel-db-manager";

package/src/types/types.ts

@@ -16,6 +16,34 @@ export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K
 /*
   Model-Definition
 */
+
+/**
+ * cone: 범용 메타데이터 시스템
+ *
+ * Entity, Prop, Enum, Subset에 추가할 수 있는 범용 메타데이터입니다.
+ * Fixture 생성, UI 라벨, 문서화 등 다양한 용도로 활용할 수 있습니다.
+ */
+export type Cone = {
+  // 일반 정보
+  desc?: string; // 짧은 설명 (UI 라벨용)
+  note?: string; // 자유로운 메모 (무제한 길이)
+  tags?: string[]; // 분류/검색용 태그
+
+  // Fixture 생성 관련
+  fixtureHint?: string; // 생성 힌트 (무제한 길이, 짧은 패턴 또는 긴 설명 가능)
+  fixtureGenerator?: string; // Faker.js 코드 또는 커스텀 함수
+  fixtureDefault?: unknown; // 기본값
+
+  // 참조 데이터 관련
+  dataSource?: {
+    strategy: "sample" | "ids" | "query" | "file" | "recent" | "random";
+    config?: unknown; // 전략별 설정
+  };
+
+  // 확장성
+  [key: string]: unknown; // 사용자 정의 메타데이터
+};
+
 export type GeneratedColumnType = "STORED" | "VIRTUAL";
 export type GeneratedColumn = {
   type: GeneratedColumnType;
@@ -28,7 +56,18 @@ export type CommonProp = {
   desc?: string;
   dbDefault?: string;
   generated?: GeneratedColumn;
+  cone?: Cone; // cone 메타데이터
 };
+
+/**
+ * 하위 호환성을 위한 헬퍼 함수
+ *
+ * desc 필드와 cone.desc 둘 다 지원합니다.
+ * cone.desc가 있으면 우선적으로 사용하고, 없으면 desc를 사용합니다.
+ */
+export function getDescription(item: { desc?: string; cone?: Cone }): string | undefined {
+  return item.cone?.desc || item.desc;
+}
 export type IntegerProp = CommonProp & {
   type: "integer";
 }; // PG: integer / TS: number / JSON: number
@@ -41,13 +80,56 @@ export type BigIntegerProp = CommonProp & {
 export type BigIntegerArrayProp = CommonProp & {
   type: "bigInteger[]";
 }; // PG: bigint[] / TS: bigint[] / JSON: bigint[]
+
+/**
+ * Zod 4 String Format 타입
+ * entity.json에서 string 타입의 prop에 zodFormat 옵션을 지정하여
+ * BaseSchema 생성 시 Zod의 string format validation을 적용합니다.
+ */
+export const ZodStringFormat = z.enum([
+  // 기본 포맷
+  "email",
+  "uuid",
+  "url",
+  "httpUrl",
+  "hostname",
+  "emoji",
+  "base64",
+  "base64url",
+  "hex",
+  "jwt",
+  "nanoid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "ipv4",
+  "ipv6",
+  "mac",
+  "cidrv4",
+  "cidrv6",
+  // hash 포맷 (알고리즘별)
+  "hashMd5",
+  "hashSha1",
+  "hashSha256",
+  "hashSha384",
+  "hashSha512",
+  // ISO 포맷
+  "isoDate",
+  "isoTime",
+  "isoDatetime",
+  "isoDuration",
+]);
+export type ZodStringFormat = z.infer<typeof ZodStringFormat>;
+
 export type StringProp = CommonProp & {
   type: "string";
   length?: number; // PG: varchar(n), text / TS: string / JSON: string
+  zodFormat?: ZodStringFormat;
 }; // PG: text / TS: string / JSON: string
 export type StringArrayProp = CommonProp & {
   type: "string[]";
   length?: number; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]
+  zodFormat?: ZodStringFormat;
 }; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]
 export type EnumProp = CommonProp & {
   type: "enum";
@@ -131,6 +213,7 @@ type _RelationProp = {
   nullable?: boolean; // DEFAULT: false
   toFilter?: true; // DEFAULT: false
   desc?: string;
+  cone?: Cone; // cone 메타데이터
 };
 export type OneToOneRelationProp = _RelationProp & {
   relationType: "OneToOne";
@@ -312,20 +395,77 @@ export function isInternalSubsetField(f: SubsetField): boolean {
   return typeof f !== "string" && f.internal === true;
 }
 
+/**
+ * SubsetDef: Subset 정의
+ *
+ * 하위 호환성을 위해 SubsetField[] 배열 형태도 지원합니다.
+ */
+export type SubsetDef =
+  | SubsetField[] // 기존 배열 형태
+  | {
+      // 새로운 객체 형태
+      fields: SubsetField[];
+      cone?: Cone;
+    };
+
+/**
+ * EnumDef: Enum 정의
+ *
+ * 하위 호환성을 위해 Record<string, string> 형태도 지원합니다.
+ */
+export type EnumDef =
+  | Record<string, string> // 기존 Record 형태
+  | {
+      // 새로운 객체 형태
+      values: Record<string, string>;
+      cone?: Cone;
+    };
+
+/**
+ * SubsetDef가 새로운 객체 형태인지 확인
+ */
+export function isSubsetDefWithCone(def: SubsetDef): def is { fields: SubsetField[]; cone?: Cone } {
+  return !Array.isArray(def) && "fields" in def;
+}
+
+/**
+ * EnumDef가 새로운 객체 형태인지 확인
+ */
+export function isEnumDefWithCone(
+  def: EnumDef,
+): def is { values: Record<string, string>; cone?: Cone } {
+  return (
+    "values" in def && !("cone" in def && def.cone === undefined && Object.keys(def).length > 1)
+  );
+}
+
+/**
+ * SubsetDef에서 fields 추출
+ */
+export function getSubsetFields(def: SubsetDef): SubsetField[] {
+  return Array.isArray(def) ? def : def.fields;
+}
+
+/**
+ * EnumDef에서 values 추출
+ */
+export function getEnumDefValues(def: EnumDef): Record<string, string> {
+  return isEnumDefWithCone(def) ? def.values : def;
+}
+
 export type EntityJson = {
   id: string;
   parentId?: string;
   table: string;
   title?: string;
+  cone?: Cone; // cone 메타데이터
   props: EntityProp[];
   indexes: EntityIndex[];
   subsets: {
-    [subset: string]: SubsetField[];
+    [subset: string]: SubsetDef;
   };
   enums: {
-    [enumId: string]: {
-      [key: string]: string;
-    };
+    [enumId: string]: EnumDef;
   };
 };
 export type EntitySubsetRow = {
@@ -671,6 +811,11 @@ export type ApiParam = {
   defaultDef?: string;
 };
 export namespace ApiParamType {
+  export type Function = {
+    t: "function";
+    parameters: ApiParam[];
+    returnType: ApiParamType;
+  };
   export type Object = {
     t: "object";
     props: ApiParam[];
@@ -834,7 +979,8 @@ export type ApiParamType =
   | ApiParamType.Ref
   | ApiParamType.IndexedAccess
   | ApiParamType.TypeParam
-  | ApiParamType.TupleType;
+  | ApiParamType.TupleType
+  | ApiParamType.Function;
 
 /* Template */
 /**
@@ -867,6 +1013,8 @@ export type RenderingNode = {
     | "string-image"
     | "string-datetime"
     | "string-date"
+    | "string-id"
+    | "string-fk_id"
     | "datetime"
     | "number-plain"
     | "number-id"
@@ -896,6 +1044,28 @@ const GeneratedColumnSchema = z.object({
   expression: z.string(),
 });
 
+/**
+ * Cone 스키마 검증
+ *
+ * cone 메타데이터의 유효성을 검증합니다.
+ */
+const ConeSchema = z
+  .object({
+    desc: z.string().optional(),
+    note: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    fixtureHint: z.string().optional(),
+    fixtureGenerator: z.string().optional(),
+    fixtureDefault: z.unknown().optional(),
+    dataSource: z
+      .object({
+        strategy: z.enum(["sample", "ids", "query", "file", "recent", "random"]),
+        config: z.unknown().optional(),
+      })
+      .optional(),
+  })
+  .catchall(z.unknown()); // 사용자 정의 메타데이터 허용
+
 const BasePropFields = {
   name: z.string(),
   desc: z.string().optional(),
@@ -903,6 +1073,7 @@ const BasePropFields = {
   toFilter: z.boolean().default(false).optional(),
   dbDefault: z.union([z.string(), z.number(), z.boolean()]).optional(),
   generated: GeneratedColumnSchema.optional(),
+  cone: ConeSchema.optional(),
 };
 
 // 부가 필드가 필요없는 prop
@@ -936,6 +1107,7 @@ const StringPropSchema = z
     ...BasePropFields,
     type: z.literal("string"),
     length: z.number().optional(),
+    zodFormat: ZodStringFormat.optional(),
   })
   .strict();
 const StringArrayPropSchema = z
@@ -943,6 +1115,7 @@ const StringArrayPropSchema = z
     ...BasePropFields,
     type: z.literal("string[]"),
     length: z.number().optional(),
+    zodFormat: ZodStringFormat.optional(),
   })
   .strict();
 
@@ -1238,21 +1411,49 @@ const EntityIndexSchema = z
   })
   .strict();
 
+/**
+ * SubsetDef 스키마
+ *
+ * 하위 호환성을 위해 배열 형태와 객체 형태 둘 다 지원합니다.
+ */
+const SubsetDefSchema = z.union([
+  // 기존 배열 형태
+  z.array(z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })])),
+  // 새로운 객체 형태
+  z.object({
+    fields: z.array(
+      z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })]),
+    ),
+    cone: ConeSchema.optional(),
+  }),
+]);
+
+/**
+ * EnumDef 스키마
+ *
+ * 하위 호환성을 위해 Record 형태와 객체 형태 둘 다 지원합니다.
+ */
+const EnumDefSchema = z.union([
+  // 기존 Record 형태
+  z.record(z.string(), z.string()),
+  // 새로운 객체 형태
+  z.object({
+    values: z.record(z.string(), z.string()),
+    cone: ConeSchema.optional(),
+  }),
+]);
+
 export const EntityJsonSchema = z
   .object({
     id: z.string().describe("PascalCase로 된 Entity ID"),
     title: z.string().describe("Entity 이름"),
     table: z.string().describe("snake_case로 된 테이블명"),
     parentId: z.string().optional().describe("부모 Entity ID"),
+    cone: ConeSchema.optional(),
     props: z.array(EntityPropSchema),
     indexes: z.array(EntityIndexSchema),
-    subsets: z.record(
-      z.string(),
-      z.array(
-        z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })]),
-      ),
-    ),
-    enums: z.record(z.string(), z.record(z.string(), z.string())),
+    subsets: z.record(z.string(), SubsetDefSchema),
+    enums: z.record(z.string(), EnumDefSchema),
   })
   .strict();
 
@@ -1312,14 +1513,6 @@ export const TemplateOptions = z.object({
   view_id_all_select: z.object({
     entityId: z.string(),
   }),
-  view_id_async_select: z.object({
-    entityId: z.string(),
-    textField: z.string(),
-  }),
-  view_enums_select: z.object({
-    entityId: z.string(),
-    enumId: z.string(),
-  }),
   view_enums_buttonset: z.object({
     entityId: z.string(),
     enumId: z.string(),
@@ -1347,8 +1540,6 @@ export const TemplateKey = z.enum([
   "view_search_input",
   "view_form",
   "view_id_all_select",
-  "view_id_async_select",
-  "view_enums_select",
   "view_enums_buttonset",
   "queries",
   "entry_server",
@@ -1378,7 +1569,7 @@ type ColumnValue = string | number | boolean | Date | null;
 export type FixtureRecord = {
   fixtureId: string;
   entityId: string;
-  id: number;
+  id: number | string;
   columns: {
     [key: string]: {
       prop: EntityProp;
@@ -1409,12 +1600,17 @@ export type RelationNode = {
 export interface DatabaseSchemaExtend {}
 // biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스
 export interface DatabaseForeignKeys {}
-export type ManyToManyBaseSchema<FromIdKey extends string, ToIdKey extends string> = {
+export type ManyToManyBaseSchema<
+  FromIdKey extends string,
+  ToIdKey extends string,
+  FromPkType = number,
+  ToPkType = number,
+> = {
   id: number;
 } & {
-  [K in `${FromIdKey}_id`]: number;
+  [K in `${FromIdKey}_id`]: FromPkType;
 } & {
-  [K in `${ToIdKey}_id`]: number;
+  [K in `${ToIdKey}_id`]: ToPkType;
 };
 
 // 객체, 함수, 비동기 함수를 모두 포괄하는 타입

package/src/ui/ai-client.ts

@@ -9,6 +9,7 @@ import { EntityManager } from "../entity/entity-manager";
 import {
   type EntityProp,
   type FixtureRecord,
+  getEnumDefValues,
   isInternalSubsetField,
   normalizeSubsetField,
   TemplateOptions,
@@ -433,6 +434,7 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
               if (updates.parentId !== undefined) entity.parentId = updates.parentId;
               if (updates.title !== undefined) entity.title = updates.title;
               if (updates.table !== undefined) entity.table = updates.table;
+              if (updates.cone !== undefined) entity.cone = updates.cone;
 
               // props: merge 시 이름 기준 병합, replace 시 교체
               if (updates.props !== undefined) {
@@ -483,8 +485,14 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
               }
 
               if (updates.enums !== undefined) {
+                const convertedEnums = Object.fromEntries(
+                  Object.entries(updates.enums).map(([key, enumDef]) => [
+                    key,
+                    getEnumDefValues(enumDef),
+                  ]),
+                );
                 entity.enumLabels =
-                  mode === "replace" ? updates.enums : { ...entity.enumLabels, ...updates.enums };
+                  mode === "replace" ? convertedEnums : { ...entity.enumLabels, ...convertedEnums };
               }
 
               // 저장 전 검증