sonamu 0.10.3 → 0.10.4

package/dist/template/implementations/generated.template.js

@@ -157,12 +157,17 @@ var Template__generated = class extends Template {
 		*/
 		const hasVectorColumns = entity.props.filter((prop) => prop.type === "vector" || prop.type === "vector[]").map((prop) => prop.name);
 		/**
+		* JSON props
+		* - json 타입인 컬럼
+		*/
+		const jsonColumns = entity.props.filter((prop) => prop.type === "json").map((prop) => prop.name);
+		/**
 		* generated props
 		* - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)
 		*/
 		const generatedColumns = entity.props.filter((prop) => prop.type !== "relation" && (prop.generated !== void 0 || prop.type === "searchText")).map((prop) => prop.name);
-		const hasMetadata = fulltextColumns.length > 0 || virtualProps.length > 0 || virtualQueryProps.length > 0 || hasDefaultColumns.length > 0 || generatedColumns.length > 0 || hasVectorColumns.length > 0;
-		const lines = [`export const ${schemaName} = ${schemaBody};`, `export type ${schemaName} = z.infer<typeof ${schemaName}>` + (hasMetadata ? ` & {${(fulltextColumns.length > 0 ? `readonly __fulltext__: readonly [${fulltextColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (virtualProps.length > 0 ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `"${prop}"`).join(", ")}],` : "") + (virtualQueryProps.length > 0 ? `readonly __virtual_query__: readonly [${virtualQueryProps.map((prop) => `"${prop}"`).join(", ")}],` : "") + (hasDefaultColumns.length > 0 ? `readonly __hasDefault__: readonly [${hasDefaultColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (generatedColumns.length > 0 ? `readonly __generated__: readonly [${generatedColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (hasVectorColumns.length > 0 ? `readonly __vector__: readonly [${hasVectorColumns.map((col) => `"${col}"`).join(", ")}],` : "")}}` : "") + ";"];
+		const hasMetadata = fulltextColumns.length > 0 || virtualProps.length > 0 || virtualQueryProps.length > 0 || hasDefaultColumns.length > 0 || generatedColumns.length > 0 || hasVectorColumns.length > 0 || jsonColumns.length > 0;
+		const lines = [`export const ${schemaName} = ${schemaBody};`, `export type ${schemaName} = z.infer<typeof ${schemaName}>` + (hasMetadata ? ` & {${(fulltextColumns.length > 0 ? `readonly __fulltext__: readonly [${fulltextColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (virtualProps.length > 0 ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `"${prop}"`).join(", ")}],` : "") + (virtualQueryProps.length > 0 ? `readonly __virtual_query__: readonly [${virtualQueryProps.map((prop) => `"${prop}"`).join(", ")}],` : "") + (hasDefaultColumns.length > 0 ? `readonly __hasDefault__: readonly [${hasDefaultColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (generatedColumns.length > 0 ? `readonly __generated__: readonly [${generatedColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (hasVectorColumns.length > 0 ? `readonly __vector__: readonly [${hasVectorColumns.map((col) => `"${col}"`).join(", ")}],` : "") + (jsonColumns.length > 0 ? `readonly __json__: readonly [${jsonColumns.map((col) => `"${col}"`).join(", ")}],` : "")}}` : "") + ";"];
 		return {
 			label: `BaseSchema: ${entity.id}`,
 			importKeys,
@@ -239,4 +244,4 @@ z.object({
 //#endregion
 export { Template__generated };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated.template.js","names":[],"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../../api\";\nimport { type Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { isVirtualCodeProp, isVirtualQueryProp } from \"../../types/types\";\nimport { type EntityIndex, type EntityPropNode } from \"../../types/types\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { BUILT_IN_TYPES, propNodeToZodTypeDef, zodTypeToZodCode } from \"../zod-converter\";\n\nexport type SourceCode = {\n  label: string;\n  lines: string[];\n  importKeys: string[];\n};\nexport class Template__generated extends Template {\n  constructor() {\n    super(\"generated\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities.flatMap((entity) => {\n      return [\n        this.getEnumsSourceCode(entity),\n        this.getBaseSchemaSourceCode(entity),\n        this.getBaseListParamsSourceCode(entity),\n        this.getSubsetSourceCode(entity),\n      ].filter(nonNullable);\n    });\n    Naite.t(\"Template__generated:sourceCodes\", sourceCodes);\n\n    // Sort\n    const LABEL_KEY_ORDER = [\"Enums\", \"BaseSchema\", \"BaseListParams\", \"Subsets\", \"SubsetQueries\"];\n    sourceCodes.sort((a, b) => {\n      const [aKey] = a.label.split(\":\");\n      const [bKey] = b.label.split(\":\");\n      const aIndex = LABEL_KEY_ORDER.indexOf(aKey);\n      const bIndex = LABEL_KEY_ORDER.indexOf(bKey);\n      if (aIndex > bIndex) {\n        return 1;\n      } else if (aIndex < bIndex) {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys].toSorted()),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리\n    const allTypeKeys = entities.flatMap((entity) => Object.keys(entity.types));\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey),\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys.flatMap((importKey) => {\n        const entity = entities.find((entity) => entity.types[importKey]);\n        if (!entity) {\n          throw new Error(`ZodType not found ${importKey}`);\n        }\n        const zodType = entity.types[importKey];\n        assert(zodType);\n\n        return [\n          `// CustomScalar: ${importKey}`,\n          `const ${importKey} = ${zodTypeToZodCode(zodType, sourceCode.importKeys)};`,\n          `type ${importKey} = z.infer<typeof ${importKey}>`,\n          \"\",\n        ];\n      });\n      sourceCode.lines = [...customScalarLines, ...sourceCode.lines];\n      sourceCode.importKeys = unique(\n        sourceCode.importKeys.filter((importKey) => !cdImportKeys.includes(importKey)),\n      );\n    }\n\n    const body = sourceCode.lines.join(\"\\n\");\n    Naite.t(\"Template__generated:body\", body);\n\n    // import\n    // sourceCode.importKeys에 내장 타입의 스키마가 있으면 sonamu import에 추가\n    const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map(\n      (info) => info.schemaName as string,\n    );\n    const builtInSchemas = sourceCode.importKeys.filter((key) => builtInSchemaNames.includes(key));\n    const sonamuImports = [\n      \"zArrayable\",\n      \"SQLDateTimeString\",\n      \"SubsetQuery\",\n      \"SonamuQueryMode\",\n      \"ApplySonamuFilter\",\n      ...builtInSchemas,\n    ].filter((mod) => body.includes(mod));\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        \"/**\",\n        \" * @generated\",\n        \" * 직접 수정하지 마세요.\",\n        \" */\",\n        \"\",\n        \"/* oxlint-disable */\",\n        \"\",\n        `import { z } from 'zod';`,\n        `import { ${sonamuImports.join(\",\")} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getEnumsSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.enumLabels).length === 0) {\n      return null;\n    }\n    return {\n      label: `Enums: ${entity.id}`,\n      lines: Object.entries(entity.enumLabels)\n        .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)\n        .flatMap(([enumId, enumLabel]) => [\n          `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(\n            (el) => `\"${el}\"`,\n          )}]).describe(\"${enumId}\");`,\n          `export type ${enumId} = z.infer<typeof ${enumId}>;`,\n          `export const ${enumId}Label = ${JSON.stringify(enumLabel)};`,\n        ]),\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): SourceCode {\n    const schemaName = `${entity.names.module}BaseSchema`;\n    const propNode: EntityPropNode = {\n      nodeType: \"object\",\n      children: entity.props.map((prop) => {\n        return {\n          nodeType: \"plain\",\n          prop,\n        };\n      }),\n    };\n\n    const schemaBody = (() => {\n      const result = propNodeToZodTypeDef(propNode, importKeys);\n      if (result.endsWith(\",\")) {\n        return result.slice(0, -1);\n      }\n\n      return result;\n    })();\n\n    // fulltext index에 포함된 컬럼들 추출\n    // TODO: GIN/GiST 인덱스 생성된 컬럼 추출\n    const fulltextColumns: EntityIndex[\"columns\"][] = [];\n\n    // virtual props (virtualType: \"code\" 또는 undefined인 것만 포함)\n    const virtualProps = entity.props\n      .filter((prop) => isVirtualCodeProp(prop))\n      .map((prop) => prop.name);\n\n    // query virtual props (virtualType: \"query\"인 것만 포함)\n    const virtualQueryProps = entity.props\n      .filter((prop) => isVirtualQueryProp(prop))\n      .map((prop) => prop.name);\n\n    /**\n     * hasDefault props\n     * - nullable 또는 dbDefault가 있는 컬럼 (id 포함)\n     * - relation이 아니거나, relation이어도 nullable이면 포함\n     */\n    const hasDefaultColumns = entity.props\n      .filter(\n        (prop) =>\n          (prop.type !== \"relation\" || prop.nullable === true) &&\n          (prop.nullable === true || (prop.type !== \"relation\" && prop.dbDefault !== undefined)),\n      )\n      .map((prop) => (prop.type === \"relation\" ? `${prop.name}_id` : prop.name))\n      .concat(\"id\");\n\n    /**\n     * hasVector props\n     * - vector 타입인 컬럼\n     */\n    const hasVectorColumns = entity.props\n      .filter((prop) => prop.type === \"vector\" || prop.type === \"vector[]\")\n      .map((prop) => prop.name);\n\n    /**\n     * generated props\n     * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)\n     */\n    const generatedColumns = entity.props\n      .filter(\n        (prop) =>\n          prop.type !== \"relation\" && (prop.generated !== undefined || prop.type === \"searchText\"),\n      )\n      .map((prop) => prop.name);\n\n    const hasMetadata =\n      fulltextColumns.length > 0 ||\n      virtualProps.length > 0 ||\n      virtualQueryProps.length > 0 ||\n      hasDefaultColumns.length > 0 ||\n      generatedColumns.length > 0 ||\n      hasVectorColumns.length > 0;\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +\n        (hasMetadata\n          ? ` & {${\n              (fulltextColumns.length > 0\n                ? `readonly __fulltext__: readonly [${fulltextColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (virtualProps.length > 0\n                ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (virtualQueryProps.length > 0\n                ? `readonly __virtual_query__: readonly [${virtualQueryProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (hasDefaultColumns.length > 0\n                ? `readonly __hasDefault__: readonly [${hasDefaultColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (generatedColumns.length > 0\n                ? `readonly __generated__: readonly [${generatedColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (hasVectorColumns.length > 0\n                ? `readonly __vector__: readonly [${hasVectorColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\")\n            }}`\n          : \"\") +\n        \";\",\n    ];\n\n    return {\n      label: `BaseSchema: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getBaseListParamsSourceCode(entity: Entity): SourceCode | null {\n    // Prop 없는 MD인 경우 생성 제외\n    if (entity.props.length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const schemaName = `${entity.names.module}BaseListParams`;\n\n    const filterProps = entity.props.filter((prop) => prop.toFilter === true);\n\n    const propNodes: EntityPropNode[] = filterProps.map((prop) => {\n      return {\n        nodeType: \"plain\" as const,\n        prop,\n        children: [],\n      };\n    });\n\n    const importKeys: string[] = [];\n    const filterBody = propNodes\n      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))\n      .join(\"\\n\");\n\n    // FilterQuery 타입을 위한 제외할 props 추출 (virtual만 제외)\n    const excludedProps = entity.props.filter((p) => p.type === \"virtual\").map((p) => p.name);\n\n    // numeric 타입인 props 추출\n    const numericProps = entity.props.filter((p) => p.type === \"numeric\");\n\n    // ApplySonamuFilter 타입 인자 생성\n    const entityType = `${entity.id}BaseSchema`;\n    const numericKeysUnion =\n      numericProps.length > 0 ? numericProps.map((prop) => `\"${prop.name}\"`).join(\" | \") : \"never\";\n    const omitKeysUnion =\n      excludedProps.length > 0 ? excludedProps.map((n) => `\"${n}\"`).join(\" | \") : \"never\";\n\n    // PK 타입에 따른 id Zod 타입 결정\n    const pkType = entity.getPkType();\n    const idZodType =\n      pkType === \"string\" || pkType === \"uuid\"\n        ? \"zArrayable(z.string())\"\n        : \"zArrayable(z.number().int().positive())\";\n\n    const schemaBody = `\nz.object({\n  num: z.number().int().nonnegative(),\n  page: z.number().int().min(1),\n  search: ${entity.id}SearchField,\n  keyword: z.string(),\n  orderBy: ${entity.id}OrderBy,\n  queryMode: SonamuQueryMode,\n  id: ${idZodType},\n  sonamuFilter: z.custom<ApplySonamuFilter<${entityType}, ${omitKeysUnion}, ${numericKeysUnion}>>(),${filterBody}\n}).partial();\n`.trim();\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n    ];\n\n    return {\n      label: `BaseListParams: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getSubsetSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.subsets).length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const subsetKeys = Object.keys(entity.subsets);\n    const importKeys: string[] = [];\n    const lines: string[] = [\n      ...subsetKeys.flatMap((subsetKey) => {\n        // 서브셋에서 FieldExpr[] 가져옴\n        const fieldExprs = entity.subsets[subsetKey];\n\n        // FieldExpr[]로 EntityPropNode[] 가져옴\n        const propNodes = entity.fieldExprsToPropNodes(fieldExprs);\n        const schemaName = `${entity.names.module}Subset${subsetKey}`;\n        const propNode: EntityPropNode = {\n          nodeType: \"object\",\n          children: propNodes,\n        };\n\n        // EntityPropNode[]로 ZodTypeDef(string)을 가져옴\n        const body = propNodeToZodTypeDef(propNode, importKeys);\n\n        return [\n          `export const ${schemaName} = ${body.replace(/,$/, \"\")};`,\n          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n        ];\n      }),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),\n      \"};\",\n      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys\n        .map((k) => `\"${k}\"`)\n        .join(\",\")}]);`,\n      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>;`,\n      \"\",\n    ];\n\n    return {\n      label: `Subsets: ${entity.id}`,\n      lines,\n      importKeys: unique(importKeys),\n    };\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated.template.js","names":[],"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../../api\";\nimport { type Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { isVirtualCodeProp, isVirtualQueryProp } from \"../../types/types\";\nimport { type EntityIndex, type EntityPropNode } from \"../../types/types\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { BUILT_IN_TYPES, propNodeToZodTypeDef, zodTypeToZodCode } from \"../zod-converter\";\n\nexport type SourceCode = {\n  label: string;\n  lines: string[];\n  importKeys: string[];\n};\nexport class Template__generated extends Template {\n  constructor() {\n    super(\"generated\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities.flatMap((entity) => {\n      return [\n        this.getEnumsSourceCode(entity),\n        this.getBaseSchemaSourceCode(entity),\n        this.getBaseListParamsSourceCode(entity),\n        this.getSubsetSourceCode(entity),\n      ].filter(nonNullable);\n    });\n    Naite.t(\"Template__generated:sourceCodes\", sourceCodes);\n\n    // Sort\n    const LABEL_KEY_ORDER = [\"Enums\", \"BaseSchema\", \"BaseListParams\", \"Subsets\", \"SubsetQueries\"];\n    sourceCodes.sort((a, b) => {\n      const [aKey] = a.label.split(\":\");\n      const [bKey] = b.label.split(\":\");\n      const aIndex = LABEL_KEY_ORDER.indexOf(aKey);\n      const bIndex = LABEL_KEY_ORDER.indexOf(bKey);\n      if (aIndex > bIndex) {\n        return 1;\n      } else if (aIndex < bIndex) {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys].toSorted()),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리\n    const allTypeKeys = entities.flatMap((entity) => Object.keys(entity.types));\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey),\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys.flatMap((importKey) => {\n        const entity = entities.find((entity) => entity.types[importKey]);\n        if (!entity) {\n          throw new Error(`ZodType not found ${importKey}`);\n        }\n        const zodType = entity.types[importKey];\n        assert(zodType);\n\n        return [\n          `// CustomScalar: ${importKey}`,\n          `const ${importKey} = ${zodTypeToZodCode(zodType, sourceCode.importKeys)};`,\n          `type ${importKey} = z.infer<typeof ${importKey}>`,\n          \"\",\n        ];\n      });\n      sourceCode.lines = [...customScalarLines, ...sourceCode.lines];\n      sourceCode.importKeys = unique(\n        sourceCode.importKeys.filter((importKey) => !cdImportKeys.includes(importKey)),\n      );\n    }\n\n    const body = sourceCode.lines.join(\"\\n\");\n    Naite.t(\"Template__generated:body\", body);\n\n    // import\n    // sourceCode.importKeys에 내장 타입의 스키마가 있으면 sonamu import에 추가\n    const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map(\n      (info) => info.schemaName as string,\n    );\n    const builtInSchemas = sourceCode.importKeys.filter((key) => builtInSchemaNames.includes(key));\n    const sonamuImports = [\n      \"zArrayable\",\n      \"SQLDateTimeString\",\n      \"SubsetQuery\",\n      \"SonamuQueryMode\",\n      \"ApplySonamuFilter\",\n      ...builtInSchemas,\n    ].filter((mod) => body.includes(mod));\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        \"/**\",\n        \" * @generated\",\n        \" * 직접 수정하지 마세요.\",\n        \" */\",\n        \"\",\n        \"/* oxlint-disable */\",\n        \"\",\n        `import { z } from 'zod';`,\n        `import { ${sonamuImports.join(\",\")} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getEnumsSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.enumLabels).length === 0) {\n      return null;\n    }\n    return {\n      label: `Enums: ${entity.id}`,\n      lines: Object.entries(entity.enumLabels)\n        .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)\n        .flatMap(([enumId, enumLabel]) => [\n          `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(\n            (el) => `\"${el}\"`,\n          )}]).describe(\"${enumId}\");`,\n          `export type ${enumId} = z.infer<typeof ${enumId}>;`,\n          `export const ${enumId}Label = ${JSON.stringify(enumLabel)};`,\n        ]),\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): SourceCode {\n    const schemaName = `${entity.names.module}BaseSchema`;\n    const propNode: EntityPropNode = {\n      nodeType: \"object\",\n      children: entity.props.map((prop) => {\n        return {\n          nodeType: \"plain\",\n          prop,\n        };\n      }),\n    };\n\n    const schemaBody = (() => {\n      const result = propNodeToZodTypeDef(propNode, importKeys);\n      if (result.endsWith(\",\")) {\n        return result.slice(0, -1);\n      }\n\n      return result;\n    })();\n\n    // fulltext index에 포함된 컬럼들 추출\n    // TODO: GIN/GiST 인덱스 생성된 컬럼 추출\n    const fulltextColumns: EntityIndex[\"columns\"][] = [];\n\n    // virtual props (virtualType: \"code\" 또는 undefined인 것만 포함)\n    const virtualProps = entity.props\n      .filter((prop) => isVirtualCodeProp(prop))\n      .map((prop) => prop.name);\n\n    // query virtual props (virtualType: \"query\"인 것만 포함)\n    const virtualQueryProps = entity.props\n      .filter((prop) => isVirtualQueryProp(prop))\n      .map((prop) => prop.name);\n\n    /**\n     * hasDefault props\n     * - nullable 또는 dbDefault가 있는 컬럼 (id 포함)\n     * - relation이 아니거나, relation이어도 nullable이면 포함\n     */\n    const hasDefaultColumns = entity.props\n      .filter(\n        (prop) =>\n          (prop.type !== \"relation\" || prop.nullable === true) &&\n          (prop.nullable === true || (prop.type !== \"relation\" && prop.dbDefault !== undefined)),\n      )\n      .map((prop) => (prop.type === \"relation\" ? `${prop.name}_id` : prop.name))\n      .concat(\"id\");\n\n    /**\n     * hasVector props\n     * - vector 타입인 컬럼\n     */\n    const hasVectorColumns = entity.props\n      .filter((prop) => prop.type === \"vector\" || prop.type === \"vector[]\")\n      .map((prop) => prop.name);\n\n    /**\n     * JSON props\n     * - json 타입인 컬럼\n     */\n    const jsonColumns = entity.props\n      .filter((prop) => prop.type === \"json\")\n      .map((prop) => prop.name);\n\n    /**\n     * generated props\n     * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)\n     */\n    const generatedColumns = entity.props\n      .filter(\n        (prop) =>\n          prop.type !== \"relation\" && (prop.generated !== undefined || prop.type === \"searchText\"),\n      )\n      .map((prop) => prop.name);\n\n    const hasMetadata =\n      fulltextColumns.length > 0 ||\n      virtualProps.length > 0 ||\n      virtualQueryProps.length > 0 ||\n      hasDefaultColumns.length > 0 ||\n      generatedColumns.length > 0 ||\n      hasVectorColumns.length > 0 ||\n      jsonColumns.length > 0;\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +\n        (hasMetadata\n          ? ` & {${\n              (fulltextColumns.length > 0\n                ? `readonly __fulltext__: readonly [${fulltextColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (virtualProps.length > 0\n                ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (virtualQueryProps.length > 0\n                ? `readonly __virtual_query__: readonly [${virtualQueryProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (hasDefaultColumns.length > 0\n                ? `readonly __hasDefault__: readonly [${hasDefaultColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (generatedColumns.length > 0\n                ? `readonly __generated__: readonly [${generatedColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (hasVectorColumns.length > 0\n                ? `readonly __vector__: readonly [${hasVectorColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (jsonColumns.length > 0\n                ? `readonly __json__: readonly [${jsonColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\")\n            }}`\n          : \"\") +\n        \";\",\n    ];\n\n    return {\n      label: `BaseSchema: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getBaseListParamsSourceCode(entity: Entity): SourceCode | null {\n    // Prop 없는 MD인 경우 생성 제외\n    if (entity.props.length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const schemaName = `${entity.names.module}BaseListParams`;\n\n    const filterProps = entity.props.filter((prop) => prop.toFilter === true);\n\n    const propNodes: EntityPropNode[] = filterProps.map((prop) => {\n      return {\n        nodeType: \"plain\" as const,\n        prop,\n        children: [],\n      };\n    });\n\n    const importKeys: string[] = [];\n    const filterBody = propNodes\n      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))\n      .join(\"\\n\");\n\n    // FilterQuery 타입을 위한 제외할 props 추출 (virtual만 제외)\n    const excludedProps = entity.props.filter((p) => p.type === \"virtual\").map((p) => p.name);\n\n    // numeric 타입인 props 추출\n    const numericProps = entity.props.filter((p) => p.type === \"numeric\");\n\n    // ApplySonamuFilter 타입 인자 생성\n    const entityType = `${entity.id}BaseSchema`;\n    const numericKeysUnion =\n      numericProps.length > 0 ? numericProps.map((prop) => `\"${prop.name}\"`).join(\" | \") : \"never\";\n    const omitKeysUnion =\n      excludedProps.length > 0 ? excludedProps.map((n) => `\"${n}\"`).join(\" | \") : \"never\";\n\n    // PK 타입에 따른 id Zod 타입 결정\n    const pkType = entity.getPkType();\n    const idZodType =\n      pkType === \"string\" || pkType === \"uuid\"\n        ? \"zArrayable(z.string())\"\n        : \"zArrayable(z.number().int().positive())\";\n\n    const schemaBody = `\nz.object({\n  num: z.number().int().nonnegative(),\n  page: z.number().int().min(1),\n  search: ${entity.id}SearchField,\n  keyword: z.string(),\n  orderBy: ${entity.id}OrderBy,\n  queryMode: SonamuQueryMode,\n  id: ${idZodType},\n  sonamuFilter: z.custom<ApplySonamuFilter<${entityType}, ${omitKeysUnion}, ${numericKeysUnion}>>(),${filterBody}\n}).partial();\n`.trim();\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n    ];\n\n    return {\n      label: `BaseListParams: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getSubsetSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.subsets).length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const subsetKeys = Object.keys(entity.subsets);\n    const importKeys: string[] = [];\n    const lines: string[] = [\n      ...subsetKeys.flatMap((subsetKey) => {\n        // 서브셋에서 FieldExpr[] 가져옴\n        const fieldExprs = entity.subsets[subsetKey];\n\n        // FieldExpr[]로 EntityPropNode[] 가져옴\n        const propNodes = entity.fieldExprsToPropNodes(fieldExprs);\n        const schemaName = `${entity.names.module}Subset${subsetKey}`;\n        const propNode: EntityPropNode = {\n          nodeType: \"object\",\n          children: propNodes,\n        };\n\n        // EntityPropNode[]로 ZodTypeDef(string)을 가져옴\n        const body = propNodeToZodTypeDef(propNode, importKeys);\n\n        return [\n          `export const ${schemaName} = ${body.replace(/,$/, \"\")};`,\n          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n        ];\n      }),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),\n      \"};\",\n      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys\n        .map((k) => `\"${k}\"`)\n        .join(\",\")}]);`,\n      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>;`,\n      \"\",\n    ];\n\n    return {\n      label: `Subsets: ${entity.id}`,\n      lines,\n      importKeys: unique(importKeys),\n    };\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",
@@ -130,9 +130,9 @@
     "vite": "8.0.16",
     "vitest": "^4.1.9",
     "@sonamu-kit/hmr-hook": "^0.5.1",
+    "@sonamu-kit/tasks": "^0.3.1",
     "@sonamu-kit/hmr-runner": "^0.2.0",
-    "@sonamu-kit/ts-loader": "^2.2.0",
-    "@sonamu-kit/tasks": "^0.3.1"
+    "@sonamu-kit/ts-loader": "^2.2.0"
   },
   "devDependencies": {
     "@types/bcrypt": "^6",

package/src/database/__tests__/puri.test.ts

@@ -7,6 +7,16 @@ type TestSchema = {
   users: {
     id: number;
     name: string;
+    payload: {
+      actor: {
+        id: string;
+        role: string;
+      };
+      message: string;
+    };
+    tags: string[];
+    state: string;
+    readonly __json__: readonly ["payload", "tags", "state"];
   };
 };
 
@@ -33,3 +43,59 @@ describe("Puri locking methods", () => {
     expect(query).toBe('select * from "users" where "id" = 1 limit 1 for share');
   });
 });
+
+describe("Puri JSONB containment", () => {
+  it("object array scalar and hostile-looking values remain serialized bindings", () => {
+    const hostileValue = `x' OR 1=1 --`;
+    const objectQuery = usersQuery()
+      .whereJsonSupersetOf("users.payload", {
+        actor: { id: hostileValue },
+      })
+      .rawQuery()
+      .toSQL();
+    const arrayQuery = usersQuery().whereJsonSupersetOf("tags", [hostileValue]).rawQuery().toSQL();
+    const scalarQuery = usersQuery().whereJsonSupersetOf("state", hostileValue).rawQuery().toSQL();
+
+    expect(objectQuery.sql).toBe('select * from "users" where "users"."payload" @> ?');
+    expect(objectQuery.bindings).toEqual([
+      JSON.stringify({
+        actor: { id: hostileValue },
+      }),
+    ]);
+    expect(arrayQuery.sql).toBe('select * from "users" where "tags" @> ?');
+    expect(arrayQuery.bindings).toEqual([JSON.stringify([hostileValue])]);
+    expect(scalarQuery.sql).toBe('select * from "users" where "state" @> ?');
+    expect(scalarQuery.bindings).toEqual([JSON.stringify(hostileValue)]);
+
+    expect(objectQuery.sql).not.toContain(hostileValue);
+    expect(arrayQuery.sql).not.toContain(hostileValue);
+    expect(scalarQuery.sql).not.toContain(hostileValue);
+  });
+
+  it("WhereGroup preserves AND OR ordering and undefined is rejected", () => {
+    const groupedQuery = usersQuery()
+      .where("id", 1)
+      .whereGroup((group) => {
+        group
+          .whereJsonSupersetOf("payload", { actor: { role: "admin" } })
+          .orWhereJsonSupersetOf("tags", ["urgent"]);
+      })
+      .rawQuery()
+      .toSQL();
+
+    expect(groupedQuery.sql).toBe(
+      'select * from "users" where "id" = ? and ("payload" @> ? or "tags" @> ?)',
+    );
+    expect(groupedQuery.bindings).toEqual([
+      1,
+      JSON.stringify({ actor: { role: "admin" } }),
+      JSON.stringify(["urgent"]),
+    ]);
+
+    const query = usersQuery();
+    expect(() => Reflect.apply(query.whereJsonSupersetOf, query, ["payload", undefined])).toThrow(
+      "Puri JSONB containment value must be JSON-serializable; JSON.stringify returned undefined.",
+    );
+    expect(query.rawQuery().toSQL().sql).toBe('select * from "users"');
+  });
+});

package/src/database/puri.ts

@@ -20,6 +20,8 @@ import {
   type FuzzyOperator,
   type InsertData,
   type InsertResult,
+  type JsonColumns,
+  type JsonSupersetValue,
   type LeftJoinedMarker,
   type LeftJoinMarkerFor,
   type NumericColumns,
@@ -70,6 +72,18 @@ function normalizeFuzzyOperator(operator?: string): FuzzyOperator {
   return fuzzyOperator;
 }
 
+function serializeJsonSupersetValue(value: unknown): string {
+  const serialized = JSON.stringify(value);
+
+  if (serialized === undefined) {
+    throw new TypeError(
+      "Puri JSONB containment value must be JSON-serializable; JSON.stringify returned undefined.",
+    );
+  }
+
+  return serialized;
+}
+
 function normalizeOrderByDirection(direction: PuriOrderByDirection = "asc"): PuriOrderByDirection {
   if (direction !== "asc" && direction !== "desc") {
     throw new Error(`Invalid order direction: ${direction}`);
@@ -784,6 +798,15 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
     return this as any;
   }
 
+  // WHERE JSONB SUPERSET (@>)
+  whereJsonSupersetOf<TColumn extends JsonColumns<TTables>>(
+    column: TColumn,
+    value: JsonSupersetValue<ExtractColumnType<TTables, TColumn>>,
+  ): this {
+    this.knexQuery.whereJsonSupersetOf(column, serializeJsonSupersetValue(value));
+    return this;
+  }
+
   // WHERE MATCH
   whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this {
     this.knexQuery.whereRaw(`MATCH (${String(column)}) AGAINST (?)`, [value]);
@@ -1449,6 +1472,23 @@ export class WhereGroup<TTables extends Record<string, any>> {
     return this;
   }
 
+  // WHERE JSONB SUPERSET (@>)
+  whereJsonSupersetOf<TColumn extends JsonColumns<TTables>>(
+    column: TColumn,
+    value: JsonSupersetValue<ExtractColumnType<TTables, TColumn>>,
+  ): this {
+    this.builder.whereJsonSupersetOf(column, serializeJsonSupersetValue(value));
+    return this;
+  }
+
+  orWhereJsonSupersetOf<TColumn extends JsonColumns<TTables>>(
+    column: TColumn,
+    value: JsonSupersetValue<ExtractColumnType<TTables, TColumn>>,
+  ): this {
+    this.builder.orWhereJsonSupersetOf(column, serializeJsonSupersetValue(value));
+    return this;
+  }
+
   // WHERE MATCH
   whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this;
   whereMatch(...args: any[]): this {

package/src/database/puri.types.test-d.ts

@@ -1,9 +1,11 @@
 import { describe, expectTypeOf, it } from "vitest";
 
-import { type Puri } from "./puri";
+import { Puri } from "./puri";
 import {
   type AvailableColumns,
   type ExtractColumnType,
+  type JsonColumns,
+  type JsonSupersetValue,
   type LeftJoinedMarker,
   type ParseSelectObject,
 } from "./puri.types";
@@ -18,6 +20,28 @@ type MockSchema = {
     name: string;
     email: string;
     department_id: number | null;
+    preferences: {
+      theme: "light" | "dark";
+      notifications: {
+        email: boolean;
+        sms: boolean;
+      };
+      labels: string[];
+      sessions: {
+        id: string;
+        active: boolean;
+      }[];
+    };
+    json_tags: string[];
+    json_scalar: string;
+    nullable_payload: {
+      enabled: boolean;
+    } | null;
+    native_tags: string[];
+    created_at: Date;
+    embedding: number[];
+    readonly __json__: readonly ["preferences", "json_tags", "json_scalar", "nullable_payload"];
+    readonly __vector__: readonly ["embedding"];
   };
   departments: {
     id: number;
@@ -458,6 +482,96 @@ describe("AvailableColumns", () => {
   });
 });
 
+describe("JsonColumns and JsonSupersetValue", () => {
+  it("JSON metadata selects only JSON columns and preserves recursive RHS types", () => {
+    type Tables = { users: MockSchema["users"] };
+    type Columns = JsonColumns<Tables>;
+    type PreferencesValue = JsonSupersetValue<MockSchema["users"]["preferences"]>;
+    type NullablePayloadValue = JsonSupersetValue<MockSchema["users"]["nullable_payload"]>;
+
+    expectTypeOf<Columns>().toEqualTypeOf<
+      | "users.preferences"
+      | "users.json_tags"
+      | "users.json_scalar"
+      | "users.nullable_payload"
+      | "preferences"
+      | "json_tags"
+      | "json_scalar"
+      | "nullable_payload"
+    >();
+
+    const partialObject: PreferencesValue = {
+      notifications: { email: true },
+      sessions: [{ active: false }],
+    };
+    const arrayRoot: JsonSupersetValue<MockSchema["users"]["json_tags"]> = ["urgent"];
+    const scalarRoot: JsonSupersetValue<MockSchema["users"]["json_scalar"]> = "active";
+    const nullableColumnValue: NullablePayloadValue = { enabled: true };
+
+    expectTypeOf(partialObject).toExtend<PreferencesValue>();
+    expectTypeOf(arrayRoot).toEqualTypeOf<string[]>();
+    expectTypeOf(scalarRoot).toEqualTypeOf<string>();
+    expectTypeOf(nullableColumnValue).toExtend<NullablePayloadValue>();
+
+    // @ts-expect-error nested boolean property must not accept a string.
+    const wrongNestedType: PreferencesValue = { notifications: { email: "yes" } };
+    // @ts-expect-error array element types are preserved.
+    const wrongArrayElement: JsonSupersetValue<MockSchema["users"]["json_tags"]> = [1];
+    // @ts-expect-error object array elements retain their recursive partial shape.
+    const wrongObjectArrayElement: PreferencesValue = { sessions: [{ active: "yes" }] };
+    // @ts-expect-error nullable JSON columns do not accept top-level null as a containment value.
+    const nullRoot: NullablePayloadValue = null;
+    // @ts-expect-error undefined cannot be serialized as a JSONB containment value.
+    const undefinedRoot: PreferencesValue = undefined;
+
+    const unknownValue: unknown = { notifications: { email: true } };
+    // @ts-expect-error unknown must be narrowed before it can be used as a containment value.
+    const unknownRoot: PreferencesValue = unknownValue;
+
+    expectTypeOf(wrongNestedType).toExtend<PreferencesValue>();
+    expectTypeOf(wrongArrayElement).toEqualTypeOf<string[]>();
+    expectTypeOf(wrongObjectArrayElement).toExtend<PreferencesValue>();
+    expectTypeOf(nullRoot).toExtend<NullablePayloadValue>();
+    expectTypeOf(undefinedRoot).toExtend<PreferencesValue>();
+    expectTypeOf(unknownRoot).toExtend<PreferencesValue>();
+
+    type Query = Puri<MockSchema, Tables, MockSchema["users"]>;
+    const query = {} as Query;
+
+    expectTypeOf(
+      query.whereJsonSupersetOf("preferences", {
+        notifications: { sms: false },
+      }),
+    ).toEqualTypeOf<Query>();
+    expectTypeOf(
+      query.whereGroup((group) =>
+        group
+          .whereJsonSupersetOf("users.preferences", { theme: "dark" })
+          .orWhereJsonSupersetOf("users.json_tags", ["urgent"]),
+      ),
+    ).toEqualTypeOf<Query>();
+
+    // @ts-expect-error ordinary string columns are not JSON columns.
+    query.whereJsonSupersetOf("name", "Noa");
+    // @ts-expect-error date columns are not JSON columns.
+    query.whereJsonSupersetOf("created_at", new Date());
+    // @ts-expect-error native PostgreSQL array columns are not JSON columns.
+    query.whereJsonSupersetOf("native_tags", ["urgent"]);
+    // @ts-expect-error vector columns are not JSON columns.
+    query.whereJsonSupersetOf("embedding", [0.1, 0.2]);
+    // @ts-expect-error scalar JSON roots retain their scalar type.
+    query.whereJsonSupersetOf("json_scalar", { state: "active" });
+    // @ts-expect-error top-level null is rejected even when the JSON column itself is nullable.
+    query.whereJsonSupersetOf("nullable_payload", null);
+    // @ts-expect-error top-level undefined is not JSON-serializable.
+    query.whereJsonSupersetOf("preferences", undefined);
+    // @ts-expect-error unknown must be narrowed before calling the public method.
+    query.whereJsonSupersetOf("preferences", unknownValue);
+    // @ts-expect-error top-level OR is intentionally exposed only through whereGroup.
+    query.orWhereJsonSupersetOf("preferences", { theme: "light" });
+  });
+});
+
 describe("Puri locking methods", () => {
   it("forUpdate 체이닝 후 first 결과 타입을 유지한다", () => {
     type Query = Puri<MockSchema, { users: MockSchema["users"] }, MockSchema["users"]>;

package/src/database/puri.types.ts

@@ -16,6 +16,7 @@ type LeftJoinedKey = "__leftJoined__";
 type HasDefault = "__hasDefault__";
 type GeneratedKey = "__generated__";
 type VectorKey = "__vector__";
+type JsonKey = "__json__";
 type VirtualQueryKey = "__virtual_query__";
 
 type InternalTypeKeys =
@@ -25,6 +26,7 @@ type InternalTypeKeys =
   | HasDefault
   | GeneratedKey
   | VectorKey
+  | JsonKey
   | VirtualQueryKey;
 
 // ============================================
@@ -42,6 +44,23 @@ export type VectorColumns<TTables extends Record<string, any>> =
     }[keyof TTables]
   | (IsSingleKey<TTables> extends true ? VectorColumnKeys<TTables[keyof TTables]> : never);
 
+// __json__ 메타데이터에서 JSON 컬럼 추출
+type JsonColumnKeys<T> = T extends { [K in JsonKey]: readonly (infer J)[] } ? J & string : never;
+
+export type JsonColumns<TTables extends Record<string, any>> =
+  | {
+      [TAlias in keyof TTables]: `${TAlias & string}.${JsonColumnKeys<TTables[TAlias]>}`;
+    }[keyof TTables]
+  | (IsSingleKey<TTables> extends true ? JsonColumnKeys<TTables[keyof TTables]> : never);
+
+type JsonSupersetNestedValue<T> = T extends readonly (infer Element)[]
+  ? JsonSupersetNestedValue<Element>[]
+  : T extends object
+    ? { [K in keyof T]?: JsonSupersetNestedValue<T[K]> }
+    : T;
+
+export type JsonSupersetValue<T> = JsonSupersetNestedValue<NonNullable<T>>;
+
 // 테이블명 타입
 export type TableName<TSchema> = keyof TSchema & string;
 

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

@@ -90,8 +90,7 @@ class PostgreSQLSchemaReaderClass {
       if (e instanceof Error && e.message.includes("Table not found")) {
         return null;
       }
-      console.error(e);
-      return null;
+      throw e;
     }
 
     // vector 컬럼의 dimensions 조회

package/src/naite/naite-reporter.ts

@@ -42,6 +42,12 @@ function getSocketPath(): string {
     : join(homedir(), ".sonamu", `naite-${hash}.sock`);
 }
 
+/**
+ * 연결 실패가 지속될 때(extension 미실행 등) buffer가 무한히 커지지 않도록
+ * 최근 메시지만 이 개수만큼 유지합니다.
+ */
+const MAX_BUFFERED_MESSAGES = 1000;
+
 class NaiteReporterClass {
   private socketPath: string | null = null;
   private socket: Socket | null = null;
@@ -97,8 +103,11 @@ class NaiteReporterClass {
     if (this.connected && this.socket) {
       this.socket.write(msg);
     } else {
-      // 연결 대기 중이면 버퍼에 저장
+      // 연결 대기 중이면 버퍼에 저장, 상한 초과 시 오래된 메시지부터 폐기
       this.buffer.push(msg);
+      if (this.buffer.length > MAX_BUFFERED_MESSAGES) {
+        this.buffer.shift();
+      }
     }
   }
 

package/src/skills/sonamu/puri.md

@@ -171,6 +171,34 @@ db.where("status", "active").orWhereGroup((g) => {
 });
 ```
 
+### JSONB Containment (`@>`)
+
+Use `whereJsonSupersetOf()` to require a JSONB column to contain a JSON value. The column and
+containment value are checked against the generated Entity type, and the value is serialized and
+bound internally.
+
+```typescript
+db.table("products").whereJsonSupersetOf("metadata", { warranty: 2 });
+
+// Aliased columns are supported.
+db.table({ p: "products" }).whereJsonSupersetOf("p.metadata", {
+  tags: ["featured"],
+});
+```
+
+Inside a WHERE group, both AND and OR variants are available:
+
+```typescript
+db.whereGroup((g) => {
+  g.where("status", "active").orWhereJsonSupersetOf("metadata", {
+    tags: ["featured"],
+  });
+});
+```
+
+Do not call `JSON.stringify()` yourself. For other JSONB operators such as `->>`, `->`, and `?`,
+continue to use parameterized `whereRaw()`.
+
 ## JOIN
 
 ```typescript

package/src/template/__tests__/generated.template.search-text.test.ts

@@ -62,6 +62,8 @@ async function registerEntityWithFileCustomScalar() {
     table: `generated_template_file_${entitySeq}`,
     props: [
       { name: "id", type: "integer" as const },
+      { name: "title", type: "string" as const },
+      { name: "created_at", type: "date" as const },
       {
         name: "file_props",
         type: "json" as const,
@@ -70,7 +72,7 @@ async function registerEntityWithFileCustomScalar() {
     ],
     indexes: [],
     subsets: {
-      A: ["id", "file_props"],
+      A: ["id", "title", "created_at", "file_props"],
     },
     enums: {},
   };
@@ -82,7 +84,7 @@ async function registerEntityWithFileCustomScalar() {
     image: SonamuFileSchema.nullable(),
   });
 
-  return { typeId };
+  return { entity: registeredEntity, typeId };
 }
 
 describe("Template__generated searchText", () => {
@@ -151,3 +153,16 @@ describe("Template__generated searchText", () => {
     );
   });
 });
+
+describe("Template__generated JSON metadata", () => {
+  test("only type=json properties appear in readonly __json__", async () => {
+    const { entity } = await registerEntityWithFileCustomScalar();
+    const template = new Template__generated();
+
+    const source = template.getBaseSchemaSourceCode(entity).lines.join("\n");
+
+    expect(source).toContain('readonly __json__: readonly ["file_props"],');
+    expect(source).not.toContain('readonly __json__: readonly ["title"');
+    expect(source).not.toContain('readonly __json__: readonly ["created_at"');
+  });
+});

package/src/template/implementations/generated.template.ts

@@ -215,6 +215,14 @@ export class Template__generated extends Template {
       .filter((prop) => prop.type === "vector" || prop.type === "vector[]")
       .map((prop) => prop.name);
 
+    /**
+     * JSON props
+     * - json 타입인 컬럼
+     */
+    const jsonColumns = entity.props
+      .filter((prop) => prop.type === "json")
+      .map((prop) => prop.name);
+
     /**
      * generated props
      * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)
@@ -232,7 +240,8 @@ export class Template__generated extends Template {
       virtualQueryProps.length > 0 ||
       hasDefaultColumns.length > 0 ||
       generatedColumns.length > 0 ||
-      hasVectorColumns.length > 0;
+      hasVectorColumns.length > 0 ||
+      jsonColumns.length > 0;
 
     const lines = [
       `export const ${schemaName} = ${schemaBody};`,
@@ -264,6 +273,11 @@ export class Template__generated extends Template {
                 ? `readonly __vector__: readonly [${hasVectorColumns
                     .map((col) => `"${col}"`)
                     .join(", ")}],`
+                : "") +
+              (jsonColumns.length > 0
+                ? `readonly __json__: readonly [${jsonColumns
+                    .map((col) => `"${col}"`)
+                    .join(", ")}],`
                 : "")
             }}`
           : "") +