sonamu 0.5.7 → 0.7.0

package/src/types/types.ts

@@ -1,57 +1,16 @@
-import type { GuardKey } from "./../api/decorators";
-import type { FastifyCorsOptions } from "@fastify/cors";
-import type { FastifyFormbodyOptions } from "@fastify/formbody";
-import type {
-  FastifyInstance,
-  FastifyReply,
-  FastifyRequest,
-  FastifyServerOptions,
-} from "fastify";
-import type { QsPluginOptions } from "fastify-qs";
+import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
 import type { ApiDecoratorOptions, AuthContext, Context } from "../api";
-import type { FastifyMultipartOptions } from "@fastify/multipart";
-import type { Driver } from "../file-storage/driver";
-import type { SsePluginOptions } from "fastify-sse-v2/lib/types";
-import type { FastifyStaticOptions } from "@fastify/static";
-import { SecureSessionPluginOptions } from "@fastify/secure-session";
-import {
-  DeserializeFunction,
-  SerializeFunction,
-} from "@fastify/passport/dist/Authenticator";
-
-/*
-  Enums
-*/
-export type EnumsLabel<T extends string, L extends "ko" | "en"> = {
-  [key in T]: { [lang in L]: string };
-};
-export type EnumsLabelKo<T extends string> = EnumsLabel<T, "ko">;
-
-/*
-  Custom Scalars
-*/
-export const SQLDateTimeString = z
-  .string()
-  .regex(/([0-9]{4}-[0-9]{2}-[0-9]{2}( [0-9]{2}:[0-9]{2}:[0-9]{2})*)$/, {
-    message: "잘못된 SQLDate 타입",
-  })
-  .min(10)
-  .max(19)
-  .describe("SQLDateTimeString");
-export type SQLDateTimeString = z.infer<typeof SQLDateTimeString>;
+import type { GuardKey } from "./../api/decorators";
 
 /*
   Utility Types
 */
-export function zArrayable<T extends z.ZodTypeAny>(
-  shape: T
-): z.ZodUnion<[T, z.ZodArray<T>]> {
+export function zArrayable<T extends z.ZodTypeAny>(shape: T): z.ZodUnion<[T, z.ZodArray<T>]> {
   return z.union([shape, shape.array()]);
 }
-export type DistributiveOmit<T, K extends keyof any> = T extends any
-  ? Omit<T, K>
-  : never;
+// biome-ignore lint/suspicious/noExplicitAny: any is used to make the type distributive
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 
 /*
   Model-Defintion
@@ -65,81 +24,84 @@ export type CommonProp = {
 };
 export type IntegerProp = CommonProp & {
   type: "integer";
-  unsigned?: true;
-};
+}; // PG: integer / TS: number / JSON: number
+export type IntegerArrayProp = CommonProp & {
+  type: "integer[]";
+}; // PG: integer[] / TS: number[] / JSON: number[]
 export type BigIntegerProp = CommonProp & {
   type: "bigInteger";
-  unsigned?: true;
-};
-export type TextProp = CommonProp & {
-  type: "text";
-  textType: "text" | "mediumtext" | "longtext";
-};
+}; // PG: bigint / TS: bigint / JSON: bigint
+export type BigIntegerArrayProp = CommonProp & {
+  type: "bigInteger[]";
+}; // PG: bigint[] / TS: bigint[] / JSON: bigint[]
 export type StringProp = CommonProp & {
   type: "string";
-  length: number;
-};
+  length?: number; // PG: varchar(n), text / TS: string / JSON: string
+}; // PG: text / TS: string / JSON: string
+export type StringArrayProp = CommonProp & {
+  type: "string[]";
+  length?: number; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]
+}; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]
 export type EnumProp = CommonProp & {
   type: "enum";
-  length: number;
   id: string;
-};
-export type FloatProp = CommonProp & {
-  type: "float";
-  unsigned?: true;
-  precision: number;
-  scale: number;
-};
-export type DoubleProp = CommonProp & {
-  type: "double";
-  unsigned?: true;
-  precision: number;
-  scale: number;
-};
-export type DecimalProp = CommonProp & {
-  type: "decimal";
-  unsigned?: true;
-  precision: number;
-  scale: number;
-};
+  length?: number;
+}; // PG: text / TS: string / JSON: string
+export type EnumArrayProp = CommonProp & {
+  type: "enum[]";
+  id: string;
+}; // PG: text[] / TS: string[] / JSON: string[]
+export type NumberProp = CommonProp & {
+  type: "number";
+  precision?: number; // PG: numeric(p, s) / TS: number / JSON: number
+  scale?: number; // PG: numeric(p, s) / TS: number / JSON: number
+  numberType?: "real" | "double precision" | "numeric"; // 기본값: numeric
+}; // PG: numeric(p, s) / TS: number / JSON: number
+export type NumberArrayProp = CommonProp & {
+  type: "number[]";
+  precision?: number;
+  scale?: number;
+  numberType?: "real" | "double precision" | "numeric"; // 기본값: numeric
+}; // PG: numeric(p, s)[] / TS: number[] / JSON: number[]
+export type NumericProp = CommonProp & {
+  type: "numeric";
+  precision?: number;
+  scale?: number;
+}; // PG: numeric(p, s) / TS: string / JSON: string
+export type NumericArrayProp = CommonProp & {
+  type: "numeric[]";
+  precision?: number;
+  scale?: number;
+}; // PG: numeric(p, s)[] / TS: string[] / JSON: string[]
 export type BooleanProp = CommonProp & {
   type: "boolean";
-};
+}; // PG: boolean / TS: boolean / JSON: boolean
+export type BooleanArrayProp = CommonProp & {
+  type: "boolean[]";
+}; // PG: boolean[] / TS: boolean[] / JSON: boolean[]
 export type DateProp = CommonProp & {
   type: "date";
-};
-export type DateTimeProp = CommonProp & {
-  type: "datetime";
-};
-export type TimeProp = CommonProp & {
-  type: "time";
-};
-export type TimestampProp = CommonProp & {
-  type: "timestamp";
-};
+}; // PG: timestampz / TS: Date / JSON: string(ISOString)
+export type DateArrayProp = CommonProp & {
+  type: "date[]";
+}; // PG: timestamptz[] / TS: Date[] / JSON: string[]
 export type JsonProp = CommonProp & {
   type: "json";
   id: string;
-};
+}; // PG: json / TS: any(id) / JSON: any
 export type UuidProp = CommonProp & {
   type: "uuid";
-};
+}; // PG: uuid / TS: string / JSON: string
+export type UuidArrayProp = CommonProp & {
+  type: "uuid[]";
+}; // PG: uuid[] / TS: string[] / JSON: string[]
 export type VirtualProp = CommonProp & {
   type: "virtual";
   id: string;
-};
+}; // PG: none / TS: any(id) / JSON: any
 
-export type RelationType =
-  | "HasMany"
-  | "BelongsToOne"
-  | "ManyToMany"
-  | "OneToOne";
-export type RelationOn =
-  | "CASCADE"
-  | "SET NULL"
-  | "NO ACTION"
-  | "SET DEFAULT"
-  | "RESTRICT";
+export type RelationType = "HasMany" | "BelongsToOne" | "ManyToMany" | "OneToOne";
+export type RelationOn = "CASCADE" | "SET NULL" | "NO ACTION" | "SET DEFAULT" | "RESTRICT";
 type _RelationProp = {
   type: "relation";
   name: string;
@@ -188,20 +150,25 @@ export type RelationProp =
 
 export type EntityProp =
   | IntegerProp
+  | IntegerArrayProp
   | BigIntegerProp
-  | TextProp
+  | BigIntegerArrayProp
   | StringProp
-  | FloatProp
-  | DoubleProp
-  | DecimalProp
+  | StringArrayProp
+  | EnumProp
+  | EnumArrayProp
+  | NumberProp
+  | NumberArrayProp
+  | NumericProp
+  | NumericArrayProp
+  | NumericProp
   | BooleanProp
+  | BooleanArrayProp
   | DateProp
-  | DateTimeProp
-  | TimeProp
-  | TimestampProp
-  | JsonProp
+  | DateArrayProp
   | UuidProp
-  | EnumProp
+  | UuidArrayProp
+  | JsonProp
   | VirtualProp
   | RelationProp;
 
@@ -239,23 +206,26 @@ export type EntitySubsetRow = {
 };
 export type FlattenSubsetRow = Omit<EntitySubsetRow, "children">;
 
-// SMD Legacy
-export type SMDInput<T extends string> = {
-  id: string;
-  parentId?: string;
-  table?: string;
-  title?: string;
-  props?: EntityProp[];
-  indexes?: EntityIndex[];
-  subsets?: {
-    [subset: string]: T[];
-  };
-};
-
 /*
   PropNode
 */
 
+/**
+ * 엔티티의 필드 구조를 트리 형태로 표현하는 중간 노드입니다.
+ *
+ * **목적**: Entity의 subset 필드 표현식(예: "id", "user.name", "tags[]")을
+ * 재귀적인 트리 구조로 파싱하여 Zod 스키마 생성의 중간 단계로 사용합니다.
+ *
+ * **변환 흐름**:
+ * Entity subset → EntityPropNode (트리 구조) → Zod 스키마 → RenderingNode (UI용)
+ *
+ * **nodeType**:
+ * - "plain": 단일 필드 (예: "id", "name")
+ * - "object": 중첩 객체 (예: "user.name" → user 객체)
+ * - "array": 배열 (예: "tags[]" → tags 배열)
+ *
+ * **사용 위치**: entity-converter.ts의 propNodeToZodType()
+ */
 export type EntityPropNode =
   | {
       nodeType: "plain";
@@ -270,70 +240,107 @@ export type EntityPropNode =
 /*
   Prop Type Guards
 */
-export function isIntegerProp(p: any): p is IntegerProp {
-  return p?.type === "integer";
+export function isIntegerSingleProp(p: unknown): p is IntegerProp {
+  return (p as IntegerProp)?.type === "integer";
+}
+export function isIntegerArrayProp(p: unknown): p is IntegerArrayProp {
+  return (p as IntegerArrayProp)?.type === "integer[]";
+}
+export function isIntegerProp(p: unknown): p is IntegerProp | IntegerArrayProp {
+  return isIntegerSingleProp(p) || isIntegerArrayProp(p);
 }
-export function isBigIntegerProp(p: any): p is BigIntegerProp {
-  return p?.type === "bigInteger";
+export function isBigIntegerSingleProp(p: unknown): p is BigIntegerProp {
+  return (p as BigIntegerProp)?.type === "bigInteger";
 }
-export function isTextProp(p: any): p is TextProp {
-  return p?.type === "text";
+export function isBigIntegerArrayProp(p: unknown): p is BigIntegerArrayProp {
+  return (p as BigIntegerArrayProp)?.type === "bigInteger[]";
 }
-export function isStringProp(p: any): p is StringProp {
-  return p?.type === "string";
+export function isBigIntegerProp(p: unknown): p is BigIntegerProp | BigIntegerArrayProp {
+  return isBigIntegerSingleProp(p) || isBigIntegerArrayProp(p);
 }
-export function isEnumProp(p: any): p is EnumProp {
-  return p?.type === "enum";
+export function isStringSingleProp(p: unknown): p is StringProp {
+  return (p as StringProp)?.type === "string";
 }
-export function isFloatProp(p: any): p is FloatProp {
-  return p?.type === "float";
+export function isStringArrayProp(p: unknown): p is StringArrayProp {
+  return (p as StringArrayProp)?.type === "string[]";
 }
-export function isDoubleProp(p: any): p is DoubleProp {
-  return p?.type === "double";
+export function isStringProp(p: unknown): p is StringProp | StringArrayProp {
+  return isStringSingleProp(p) || isStringArrayProp(p);
 }
-export function isDecimalProp(p: any): p is DecimalProp {
-  return p?.type === "decimal";
+export function isEnumSingleProp(p: unknown): p is EnumProp {
+  return (p as EnumProp)?.type === "enum";
 }
-export function isBooleanProp(p: any): p is BooleanProp {
-  return p?.type === "boolean";
+export function isEnumArrayProp(p: unknown): p is EnumArrayProp {
+  return (p as EnumArrayProp)?.type === "enum[]";
 }
-export function isDateProp(p: any): p is DateProp {
-  return p?.type === "date";
+export function isEnumProp(p: unknown): p is EnumProp | EnumArrayProp {
+  return isEnumSingleProp(p) || isEnumArrayProp(p);
 }
-export function isDateTimeProp(p: any): p is DateTimeProp {
-  return p?.type === "datetime";
+export function isNumberSingleProp(p: unknown): p is NumberProp {
+  return (p as NumberProp)?.type === "number";
 }
-export function isTimeProp(p: any): p is TimeProp {
-  return p?.type === "time";
+export function isNumberArrayProp(p: unknown): p is NumberArrayProp {
+  return (p as NumberArrayProp)?.type === "number[]";
 }
-export function isTimestampProp(p: any): p is TimestampProp {
-  return p?.type === "timestamp";
+export function isNumberProp(p: unknown): p is NumberProp | NumberArrayProp {
+  return isNumberSingleProp(p) || isNumberArrayProp(p);
 }
-export function isJsonProp(p: any): p is JsonProp {
-  return p?.type === "json";
+export function isNumericSingleProp(p: unknown): p is NumericProp {
+  return (p as NumericProp)?.type === "numeric";
 }
-export function isUuidProp(p: any): p is UuidProp {
-  return p?.type === "uuid";
+export function isNumericArrayProp(p: unknown): p is NumericArrayProp {
+  return (p as NumericArrayProp)?.type === "numeric[]";
 }
-export function isVirtualProp(p: any): p is VirtualProp {
-  return p?.type === "virtual";
+export function isNumericProp(p: unknown): p is NumericProp | NumericArrayProp {
+  return isNumericSingleProp(p) || isNumericArrayProp(p);
 }
-export function isRelationProp(p: any): p is RelationProp {
-  return p?.type === "relation";
+export function isBooleanSingleProp(p: unknown): p is BooleanProp {
+  return (p as BooleanProp)?.type === "boolean";
 }
-export function isOneToOneRelationProp(p: any): p is OneToOneRelationProp {
-  return p?.relationType === "OneToOne";
+export function isBooleanArrayProp(p: unknown): p is BooleanArrayProp {
+  return (p as BooleanArrayProp)?.type === "boolean[]";
 }
-export function isBelongsToOneRelationProp(
-  p: any
-): p is BelongsToOneRelationProp {
-  return p?.relationType === "BelongsToOne";
+export function isBooleanProp(p: unknown): p is BooleanProp | BooleanArrayProp {
+  return isBooleanSingleProp(p) || isBooleanArrayProp(p);
 }
-export function isHasManyRelationProp(p: any): p is HasManyRelationProp {
-  return p?.relationType === "HasMany";
+export function isDateSingleProp(p: unknown): p is DateProp {
+  return (p as DateProp)?.type === "date";
 }
-export function isManyToManyRelationProp(p: any): p is ManyToManyRelationProp {
-  return p?.relationType === "ManyToMany";
+export function isDateArrayProp(p: unknown): p is DateArrayProp {
+  return (p as DateArrayProp)?.type === "date[]";
+}
+export function isDateProp(p: unknown): p is DateProp | DateArrayProp {
+  return isDateSingleProp(p) || isDateArrayProp(p);
+}
+export function isUuidSingleProp(p: unknown): p is UuidProp {
+  return (p as UuidProp)?.type === "uuid";
+}
+export function isUuidArrayProp(p: unknown): p is UuidArrayProp {
+  return (p as UuidArrayProp)?.type === "uuid[]";
+}
+export function isUuidProp(p: unknown): p is UuidProp | UuidArrayProp {
+  return isUuidSingleProp(p) || isUuidArrayProp(p);
+}
+export function isJsonProp(p: unknown): p is JsonProp {
+  return (p as JsonProp)?.type === "json";
+}
+export function isVirtualProp(p: unknown): p is VirtualProp {
+  return (p as VirtualProp)?.type === "virtual";
+}
+export function isRelationProp(p: unknown): p is RelationProp {
+  return (p as RelationProp)?.type === "relation";
+}
+export function isOneToOneRelationProp(p: unknown): p is OneToOneRelationProp {
+  return (p as OneToOneRelationProp)?.relationType === "OneToOne";
+}
+export function isBelongsToOneRelationProp(p: unknown): p is BelongsToOneRelationProp {
+  return (p as BelongsToOneRelationProp)?.relationType === "BelongsToOne";
+}
+export function isHasManyRelationProp(p: unknown): p is HasManyRelationProp {
+  return (p as HasManyRelationProp)?.relationType === "HasMany";
+}
+export function isManyToManyRelationProp(p: unknown): p is ManyToManyRelationProp {
+  return (p as ManyToManyRelationProp)?.relationType === "ManyToMany";
 }
 
 type JoinClause =
@@ -344,44 +351,9 @@ type JoinClause =
   | {
       custom: string;
     };
-export function isCustomJoinClause(p: any): p is { custom: string } {
-  return p?.custom;
-}
-
-/* 서브셋 */
-// type SubsetLoader = {
-//   as: string;
-//   table: string;
-//   manyJoin: {
-//     fromTable: string;
-//     fromCol: string;
-//     idField: string;
-//     toTable: string;
-//     toCol: string;
-//     through?: {
-//       table: string;
-//       fromCol: string;
-//       toCol: string;
-//     };
-//   };
-//   oneJoins: ({
-//     as: string;
-//     join: "inner" | "outer";
-//     table: string;
-//   } & JoinClause)[];
-//   select: (string | Knex.Raw)[];
-//   loaders?: SubsetLoader[];
-// };
-// export type SubsetQuery = {
-//   select: (string | Knex.Raw)[];
-//   virtual: string[];
-//   joins: ({
-//     as: string;
-//     join: "inner" | "outer";
-//     table: string;
-//   } & JoinClause)[];
-//   loaders: SubsetLoader[];
-// };
+export function isCustomJoinClause(p: unknown): p is { custom: string } {
+  return !!(p as { custom: string })?.custom;
+}
 
 type SubsetLoader = {
   as: string;
@@ -430,8 +402,8 @@ export type KnexError = {
   sqlMessage: string;
   sqlState: string;
 };
-export function isKnexError(e: any): e is KnexError {
-  return e.code && e.sqlMessage && e.sqlState;
+export function isKnexError(e: unknown): e is KnexError {
+  return !!(e as KnexError)?.code && !!(e as KnexError)?.sqlMessage && !!(e as KnexError)?.sqlState;
 }
 
 export type KnexColumnType =
@@ -452,11 +424,27 @@ export type KnexColumnType =
   | "date"
   | "time"
   | "datetime";
+export type MigrationColumnType =
+  | "string"
+  | "string[]"
+  | "integer"
+  | "integer[]"
+  | "bigInteger"
+  | "bigInteger[]"
+  | "numberOrNumeric"
+  | "numberOrNumeric[]"
+  | "boolean"
+  | "boolean[]"
+  | "date"
+  | "date[]"
+  | "uuid"
+  | "uuid[]"
+  | "json";
 export type MigrationColumn = {
   name: string;
-  type: KnexColumnType;
+  type: MigrationColumnType;
   nullable: boolean;
-  unsigned?: boolean;
+  numberType?: "real" | "double precision" | "numeric";
   length?: number;
   defaultTo?: string;
   precision?: number;
@@ -567,53 +555,83 @@ export namespace ApiParamType {
     constraint?: ApiParamType;
   };
 
-  export function isObject(v: any): v is ApiParamType.Object {
-    return v?.t === "object";
+  export function isObject(v: unknown): v is ApiParamType.Object {
+    return (v as ApiParamType.Object)?.t === "object";
   }
-  export function isUnion(v: any): v is ApiParamType.Union {
-    return v?.t === "union";
+  export function isUnion(v: unknown): v is ApiParamType.Union {
+    return (v as ApiParamType.Union)?.t === "union";
   }
-  export function isIntersection(v: any): v is ApiParamType.Intersection {
-    return v?.t === "intersection";
+  export function isIntersection(v: unknown): v is ApiParamType.Intersection {
+    return (v as ApiParamType.Intersection)?.t === "intersection";
   }
-  export function isStringLiteral(v: any): v is ApiParamType.StringLiteral {
-    return v?.t === "string-literal";
+  export function isStringLiteral(v: unknown): v is ApiParamType.StringLiteral {
+    return (v as ApiParamType.StringLiteral)?.t === "string-literal";
   }
-  export function isNumericLiteral(v: any): v is ApiParamType.NumericLiteral {
-    return v?.t === "numeric-literal";
+  export function isNumericLiteral(v: unknown): v is ApiParamType.NumericLiteral {
+    return (v as ApiParamType.NumericLiteral)?.t === "numeric-literal";
   }
-  export function isArray(v: any): v is ApiParamType.Array {
-    return v?.t === "array";
+  export function isArray(v: unknown): v is ApiParamType.Array {
+    return (v as ApiParamType.Array)?.t === "array";
   }
-  export function isRef(v: any): v is ApiParamType.Ref {
-    return v?.t === "ref";
+  export function isRef(v: unknown): v is ApiParamType.Ref {
+    return typeof v === "object" && v !== null && (v as { t?: unknown }).t === "ref";
   }
-  export function isIndexedAccess(v: any): v is ApiParamType.IndexedAccess {
-    return v?.t === "indexed-access";
+  export function isIndexedAccess(v: unknown): v is ApiParamType.IndexedAccess {
+    return typeof v === "object" && v !== null && (v as { t?: unknown }).t === "indexed-access";
   }
-  export function isTupleType(v: any): v is ApiParamType.TupleType {
-    return v?.t === "tuple-type";
+  export function isTupleType(v: unknown): v is ApiParamType.TupleType {
+    return typeof v === "object" && v !== null && (v as { t?: unknown }).t === "tuple-type";
   }
-  export function isPick(v: any): v is ApiParamType.Pick {
-    return v?.t === "ref" && v.id === "Pick";
+  export function isPick(v: unknown): v is ApiParamType.Pick {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Pick"
+    );
   }
-  export function isOmit(v: any): v is ApiParamType.Omit {
-    return v?.t === "ref" && v.id === "Omit";
+  export function isOmit(v: unknown): v is ApiParamType.Omit {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Omit"
+    );
   }
-  export function isPartial(v: any): v is ApiParamType.Partial {
-    return v?.t === "ref" && v.id === "Partial";
+  export function isPartial(v: unknown): v is ApiParamType.Partial {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Partial"
+    );
   }
-  export function isPromise(v: any): v is ApiParamType.Promise {
-    return v?.t === "ref" && v.id === "Promise";
+  export function isPromise(v: unknown): v is ApiParamType.Promise {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Promise"
+    );
   }
-  export function isContext(v: any): v is ApiParamType.Context {
-    return v?.t === "ref" && v.id === "Context";
+  export function isContext(v: unknown): v is ApiParamType.Context {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Context"
+    );
   }
-  export function isRefKnex(v: any): v is ApiParamType.Ref {
-    return v?.t === "ref" && v.id === "Knex";
+  export function isRefKnex(v: unknown): v is ApiParamType.Ref {
+    return (
+      typeof v === "object" &&
+      v !== null &&
+      (v as { t?: unknown }).t === "ref" &&
+      (v as { id?: unknown }).id === "Knex"
+    );
   }
-  export function isTypeParam(v: any): v is ApiParamType.TypeParam {
-    return v?.t === "type-param";
+  export function isTypeParam(v: unknown): v is ApiParamType.TypeParam {
+    return typeof v === "object" && v !== null && (v as { t?: unknown }).t === "type-param";
   }
 }
 export type ApiParamType =
@@ -639,6 +657,26 @@ export type ApiParamType =
   | ApiParamType.TupleType;
 
 /* Template */
+/**
+ * UI 컴포넌트 렌더링을 위한 메타데이터 노드입니다.
+ *
+ * **목적**: Zod 스키마로부터 프론트엔드 UI 컴포넌트를 자동 생성하기 위한
+ * 렌더링 정보를 담은 트리 구조입니다. 각 필드가 어떤 UI 컴포넌트로
+ * 표현되어야 하는지(텍스트, 이미지, 날짜, Enum 선택 등)를 명시합니다.
+ *
+ * **변환 흐름**:
+ * Entity subset → EntityPropNode → Zod 스키마 → RenderingNode (UI용) → React 컴포넌트 코드 생성
+ *
+ * **주요 필드**:
+ * - `renderType`: UI 컴포넌트 유형 (string-plain, number-fk_id, enums, array 등)
+ * - `zodType`: 원본 Zod 스키마 (validation 용)
+ * - `children`: 중첩된 객체 필드들 (object일 때)
+ * - `element`: 배열 요소 타입 (array일 때)
+ *
+ * **사용 위치**:
+ * - zod-converter.ts의 zodTypeToRenderingNode()에서 생성
+ * - view_form.template.ts, view_list.template.ts 등에서 React 컴포넌트 코드 생성에 사용
+ */
 // 셀프 참조 타입이므로 Zod 생략하고 직접 정의
 export const RenderingNode = z.any();
 export type RenderingNode = {
@@ -670,17 +708,270 @@ export type RenderingNode = {
   nullable?: boolean;
 };
 
+const BasePropFields = {
+  name: z.string(),
+  desc: z.string().optional(),
+  nullable: z.boolean().optional(),
+  toFilter: z.literal(true).optional(),
+  dbDefault: z.union([z.string(), z.number(), z.boolean()]).optional(),
+};
+
+// 부가 필드가 필요없는 prop
+const BasePropFieldsWithoutAdditional = z
+  .object({
+    ...BasePropFields,
+    type: z.union([
+      z.literal("integer"),
+      z.literal("integer[]"),
+      z.literal("bigInteger"),
+      z.literal("bigInteger[]"),
+      z.literal("boolean"),
+      z.literal("boolean[]"),
+      z.literal("date"),
+      z.literal("date[]"),
+      z.literal("uuid"),
+      z.literal("uuid[]"),
+    ]),
+  })
+  .strict();
+
+// precision/scale 필드
+const PrecisionScaleFields = {
+  precision: z.number().optional(),
+  scale: z.number().optional(),
+};
+
+// 각 타입별 스키마 정의
+
+const StringPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("string"),
+    length: z.number().optional(),
+  })
+  .strict();
+const StringArrayPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("string[]"),
+    length: z.number().optional(),
+  })
+  .strict();
+
+const EnumPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("enum"),
+    id: z.string(),
+  })
+  .strict();
+const EnumArrayPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("enum[]"),
+    id: z.string(),
+  })
+  .strict();
+
+const NumberPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("number"),
+    ...PrecisionScaleFields,
+    numberType: z.enum(["real", "double precision", "numeric"]).optional(),
+  })
+  .strict();
+const NumberArrayPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("number[]"),
+    ...PrecisionScaleFields,
+    numberType: z.enum(["real", "double precision", "numeric"]).optional(),
+  })
+  .strict();
+
+const NumericPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("numeric"),
+    ...PrecisionScaleFields,
+  })
+  .strict();
+const NumericArrayPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("numeric[]"),
+    ...PrecisionScaleFields,
+  })
+  .strict();
+
+const JsonPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("json"),
+    id: z.string(),
+  })
+  .strict();
+
+const VirtualPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("virtual"),
+    id: z.string(),
+  })
+  .strict();
+
+// Relation 타입은 relationType에 따라 세분화
+const BaseRelationFields = {
+  ...BasePropFields,
+  type: z.literal("relation"),
+  with: z.string(),
+};
+
+// RelationOn 타입
+const RelationOnSchema = z.enum(["CASCADE", "SET NULL", "NO ACTION", "SET DEFAULT", "RESTRICT"]);
+
+const BelongsToOneRelationPropSchema = z
+  .object({
+    ...BaseRelationFields,
+    relationType: z.literal("BelongsToOne"),
+    customJoinClause: z.string().optional(),
+    useConstraint: z.boolean().optional(),
+    onUpdate: RelationOnSchema.optional(),
+    onDelete: RelationOnSchema.optional(),
+  })
+  .strict();
+
+const HasManyRelationPropSchema = z
+  .object({
+    ...BaseRelationFields,
+    relationType: z.literal("HasMany"),
+    joinColumn: z.string(),
+    fromColumn: z.string().optional(),
+  })
+  .strict();
+
+const ManyToManyRelationPropSchema = z
+  .object({
+    ...BaseRelationFields,
+    relationType: z.literal("ManyToMany"),
+    joinTable: z.string(),
+    onUpdate: RelationOnSchema,
+    onDelete: RelationOnSchema,
+  })
+  .strict();
+
+const OneToOneRelationPropSchema = z
+  .object({
+    ...BaseRelationFields,
+    relationType: z.literal("OneToOne"),
+    customJoinClause: z.string().optional(),
+    hasJoinColumn: z.boolean().optional(),
+    useConstraint: z.boolean().optional(),
+    onUpdate: RelationOnSchema.optional(),
+    onDelete: RelationOnSchema.optional(),
+  })
+  .strict();
+
+const RelationTypes = ["BelongsToOne", "HasMany", "ManyToMany", "OneToOne"] as const;
+export const RelationPropSchema = z.discriminatedUnion(
+  "relationType",
+  [
+    BelongsToOneRelationPropSchema,
+    HasManyRelationPropSchema,
+    ManyToManyRelationPropSchema,
+    OneToOneRelationPropSchema,
+  ],
+  {
+    error: (iss) =>
+      `relationType은 ${RelationTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.relationType}"`,
+  },
+);
+
+const NormalPropTypes = [
+  "integer",
+  "integer[]",
+  "bigInteger",
+  "bigInteger[]",
+  "string",
+  "string[]",
+  "enum",
+  "enum[]",
+  "number",
+  "number[]",
+  "numeric",
+  "numeric[]",
+  "boolean",
+  "boolean[]",
+  "date",
+  "date[]",
+  "uuid",
+  "uuid[]",
+  "json",
+  "virtual",
+] as const;
+export const NormalPropSchema = z.discriminatedUnion(
+  "type",
+  [
+    BasePropFieldsWithoutAdditional,
+    StringPropSchema,
+    StringArrayPropSchema,
+    EnumPropSchema,
+    EnumArrayPropSchema,
+    NumberPropSchema,
+    NumberArrayPropSchema,
+    NumericPropSchema,
+    NumericArrayPropSchema,
+    JsonPropSchema,
+    VirtualPropSchema,
+  ],
+  {
+    error: (iss) =>
+      `type은 ${NormalPropTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.type}"`,
+  },
+);
+
+const AllPropTypes = [...NormalPropTypes, "relation"] as const;
+const EntityPropSchema = z.discriminatedUnion("type", [NormalPropSchema, RelationPropSchema], {
+  error: (iss) =>
+    `type은 ${AllPropTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.type}"`,
+});
+
+// EntityIndex 스키마 정의
+const EntityIndexSchema = z
+  .object({
+    type: z.enum(["index", "unique", "fulltext"]),
+    columns: z.array(z.string()),
+    name: z.string().optional(),
+    parser: z.enum(["built-in", "ngram"]).optional(),
+  })
+  .strict();
+
+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"),
+    props: z.array(EntityPropSchema),
+    indexes: z.array(EntityIndexSchema),
+    subsets: z.record(z.string(), z.array(z.string())),
+    enums: z.record(z.string(), z.record(z.string(), z.string())),
+  })
+  .strict();
+
 export const TemplateOptions = z.object({
-  entity: z.object({
-    entityId: z.string(),
-    parentId: z.string().optional(),
-    title: z.string(),
-    table: z.string().optional(),
-    props: z.array(z.object({})).optional(),
-    indexes: z.array(z.object({})).optional(),
-    subsets: z.object({}).optional(),
-    enums: z.object({}).optional(),
-  }),
+  entity: EntityJsonSchema.omit({ id: true })
+    .extend({
+      entityId: z.string(),
+    })
+    .partial({
+      table: true,
+      props: true,
+      indexes: true,
+      subsets: true,
+      enums: true,
+    }),
   init_types: z.object({
     entityId: z.string(),
   }),
@@ -691,8 +982,8 @@ export const TemplateOptions = z.object({
   }),
   model: z.object({
     entityId: z.string(),
-    defaultSearchField: z.string(),
-    defaultOrderBy: z.string(),
+    defaultSearchField: z.string().optional(),
+    defaultOrderBy: z.string().optional(),
   }),
   model_test: z.object({
     entityId: z.string(),
@@ -796,6 +1087,7 @@ export type FixtureSearchOptions = {
   searchType: "equals" | "like";
 };
 
+type ColumnValue = string | number | boolean | Date | null;
 export type FixtureRecord = {
   fixtureId: string;
   entityId: string;
@@ -803,7 +1095,7 @@ export type FixtureRecord = {
   columns: {
     [key: string]: {
       prop: EntityProp;
-      value: any;
+      value: ColumnValue | ColumnValue[];
     };
   };
   fetchedRecords: string[];
@@ -816,7 +1108,7 @@ export type FixtureRecord = {
 export type FixtureImportResult = {
   entityId: string;
   data: {
-    [key: string]: any;
+    [key: string]: ColumnValue;
   };
 };
 
@@ -826,11 +1118,9 @@ export type RelationNode = {
   related: Set<string>;
 };
 
+// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스
 export interface DatabaseSchemaExtend {}
-export type ManyToManyBaseSchema<
-  FromIdKey extends string,
-  ToIdKey extends string,
-> = {
+export type ManyToManyBaseSchema<FromIdKey extends string, ToIdKey extends string> = {
   id: number;
 } & {
   [K in `${FromIdKey}_id`]: number;
@@ -840,13 +1130,10 @@ export type ManyToManyBaseSchema<
 
 export type SonamuFastifyConfig = {
   contextProvider: (
-    defaultContext: Pick<
-      Context,
-      "request" | "reply" | "headers" | "createSSE"
-    > &
+    defaultContext: Pick<Context, "request" | "reply" | "headers" | "createSSE" | "naiteStore"> &
       AuthContext,
     request: FastifyRequest,
-    reply: FastifyReply
+    reply: FastifyReply,
   ) => Context | Promise<Context>;
   guardHandler: (
     guard: GuardKey,
@@ -859,7 +1146,7 @@ export type SonamuFastifyConfig = {
       methodName: string;
       path: string;
       options: ApiDecoratorOptions;
-    }
+    },
   ) => void;
   cache?: {
     get: (key: string) => Promise<unknown | null>;
@@ -868,7 +1155,7 @@ export type SonamuFastifyConfig = {
       path: string,
       reqBody: {
         [key: string]: unknown;
-      }
+      },
     ) =>
       | {
           cache: false;
@@ -880,45 +1167,3 @@ export type SonamuFastifyConfig = {
         };
   };
 };
-
-export type SonamuServerOptions = {
-  fastify?: FastifyServerOptions;
-
-  listen?: {
-    port: number;
-    host?: string;
-  };
-
-  plugins?: {
-    cors?: boolean | FastifyCorsOptions;
-    formbody?: boolean | FastifyFormbodyOptions;
-    multipart?: boolean | FastifyMultipartOptions;
-    qs?: boolean | QsPluginOptions;
-    sse?: boolean | SsePluginOptions;
-    static?: boolean | FastifyStaticOptions;
-    session?: boolean | SecureSessionPluginOptions;
-
-    custom?: (server: FastifyInstance) => void;
-  };
-
-  auth?:
-    | boolean
-    | {
-        userSerializer: SerializeFunction<unknown, unknown>;
-        userDeserializer: DeserializeFunction<unknown, unknown>;
-      };
-
-  apiConfig: SonamuFastifyConfig;
-
-  storage?: Driver;
-
-  lifecycle?: {
-    onStart?: (server: FastifyInstance) => Promise<void> | void;
-    onShutdown?: (server: FastifyInstance) => Promise<void> | void;
-    onError?: (
-      error: Error,
-      request: FastifyRequest,
-      reply: FastifyReply
-    ) => Promise<void> | void;
-  };
-};