sonamu 0.9.13 → 0.9.15

package/dist/database/puri.js

@@ -15,6 +15,33 @@ function normalizeFuzzyOperator(operator) {
 	}
 	return fuzzyOperator;
 }
+function normalizeOrderByDirection(direction = "asc") {
+	if (direction !== "asc" && direction !== "desc") {
+		throw new Error(`Invalid order direction: ${direction}`);
+	}
+	return direction;
+}
+function normalizeOrderByNulls(nulls) {
+	if (nulls === undefined) {
+		return undefined;
+	}
+	if (nulls !== "first" && nulls !== "last") {
+		throw new Error(`Invalid order nulls: ${nulls}`);
+	}
+	return nulls;
+}
+function formatNullsSuffix(nulls) {
+	if (!nulls) {
+		return "";
+	}
+	return ` NULLS ${nulls.toUpperCase()}`;
+}
+function isOrderByEntries(value) {
+	return Array.isArray(value);
+}
+function isSqlExpression(value) {
+	return typeof value === "object" && "_type" in value && value._type === "sql_expression";
+}
 var Puri, WhereGroup, JoinClauseGroup, ResolvedPuri;
 var init_puri = __esmMin((() => {
 	init_entity_manager();
@@ -530,13 +557,28 @@ var init_puri = __esmMin((() => {
 			});
 			return this;
 		}
-		orderBy(column, direction = "asc") {
+		orderBy(columnOrColumns, direction = "asc", nulls) {
+			if (isOrderByEntries(columnOrColumns)) {
+				for (const entry of columnOrColumns) {
+					if (typeof entry === "string" || isSqlExpression(entry)) {
+						this.applyOrderBy(entry);
+					} else {
+						this.applyOrderBy(entry.column, entry.order, entry.nulls);
+					}
+				}
+				return this;
+			}
+			this.applyOrderBy(columnOrColumns, direction, nulls);
+			return this;
+		}
+		applyOrderBy(column, direction, nulls) {
+			const normalizedDirection = normalizeOrderByDirection(direction);
+			const normalizedNulls = normalizeOrderByNulls(nulls);
 			if (typeof column === "object") {
-				this.knexQuery.orderByRaw(`${column._sql} ${direction}`, column._params);
+				this.knexQuery.orderByRaw(`${column._sql} ${normalizedDirection}${formatNullsSuffix(normalizedNulls)}`, column._params);
 			} else {
-				this.knexQuery.orderBy(column, direction);
+				this.knexQuery.orderBy(column, normalizedDirection, normalizedNulls);
 			}
-			return this;
 		}
 		forUpdate() {
 			this.knexQuery.forUpdate();
@@ -1030,4 +1072,4 @@ var init_puri = __esmMin((() => {
 //#endregion
 init_puri();
 export { JoinClauseGroup, Puri, ResolvedPuri, WhereGroup, init_puri };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"puri.js","names":["knex: Knex","selectClauses: (string | Knex.Raw)[]","flatSelect: Record<string, any>","builder: Knex.QueryBuilder","callback: Knex.JoinClause","knexQuery: Knex.QueryBuilder","mergeObj: Record<string, any>"],"sources":["../../src/database/puri.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */ // Puri는 다양한 타입을 사용하고 있습니다.\n\nimport assert from \"assert\";\n\nimport chalk from \"chalk\";\nimport inflection from \"inflection\";\nimport { type Knex } from \"knex\";\n\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type TableSpec } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type ClearStatements } from \"./puri-subset.types\";\nimport {\n  type AvailableColumns,\n  type ColumnKeys,\n  type ComparisonOperator,\n  type Expand,\n  type ExtractColumnType,\n  type FulltextColumns,\n  type FuzzyOperator,\n  type InsertData,\n  type InsertResult,\n  type LeftJoinedMarker,\n  type LeftJoinMarkerFor,\n  type NumericColumns,\n  type OnConflictAction,\n  type ParseSelectObject,\n  type ResultAvailableColumns,\n  type SelectAllResult,\n  type SelectObject,\n  type SingleTableValue,\n  type SqlExpression,\n  type TsHighlightOptions,\n  type TsQueryConfig,\n  type TsQueryOptions,\n  type TsRankOptions,\n  type VectorColumns,\n  type WhereCondition,\n  type WhereOperator,\n} from \"./puri.types\";\nimport { FUZZY_OPERATORS } from \"./puri.types\";\n\nfunction normalizeFuzzyOperator(operator?: string): FuzzyOperator {\n  const normalized = operator?.trim() ?? \"<%\";\n  const fuzzyOperator = FUZZY_OPERATORS.find((candidate) => candidate === normalized);\n\n  if (!fuzzyOperator) {\n    throw new Error(`Invalid fuzzy operator: ${operator ?? \"\"}`);\n  }\n\n  return fuzzyOperator;\n}\n\nexport class Puri<TSchema, TTables extends Record<string, any>, TResult> {\n  private knexQuery: Knex.QueryBuilder;\n  private tableSpec: TableSpec | null = null;\n\n  // 생성자 시그니처들\n  constructor(knex: Knex, tableName: string);\n  constructor(knex: Knex, tableSource: Record<string, string | Puri<TSchema, any, any>>);\n  constructor(\n    public knex: Knex,\n    tableNameOrSource: any,\n  ) {\n    if (typeof tableNameOrSource === \"string\") {\n      // Case: new Puri(knex, \"users\")\n      this.knexQuery = this.knex(tableNameOrSource).from(tableNameOrSource);\n      this.tableSpec = this.safeGetTableSpec(tableNameOrSource);\n    } else if (typeof tableNameOrSource === \"object\") {\n      const entries = Object.entries(tableNameOrSource);\n      if (entries.length !== 1) {\n        throw new Error(\"Table spec must have exactly one entry\");\n      }\n      assert(entries[0]);\n      const [alias, source] = entries[0];\n      if (typeof source === \"string\") {\n        this.knexQuery = this.knex(source).from({ [alias]: source });\n        this.tableSpec = this.safeGetTableSpec(source);\n      } else if (source instanceof Puri) {\n        const subqueryBuilder = source.rawQuery();\n        this.knexQuery = this.knex.from(subqueryBuilder.as(alias));\n      } else {\n        throw new Error(\"Invalid table specification\");\n      }\n    } else {\n      throw new Error(\"Invalid table specification\");\n    }\n  }\n\n  safeGetTableSpec(tableName: string): TableSpec | null {\n    try {\n      return EntityManager.getTableSpec(tableName);\n    } catch {\n      return null;\n    }\n  }\n\n  // Static SQL helper functions for SELECT\n  static count(column: string = \"*\"): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `COUNT(??)::integer`,\n      _params: [column],\n    };\n  }\n  static sum(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `SUM(??)`,\n      _params: [column],\n    };\n  }\n  static avg(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `AVG(??)`,\n      _params: [column],\n    };\n  }\n  static max(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MAX(??)`,\n      _params: [column],\n    };\n  }\n  static min(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MIN(??)`,\n      _params: [column],\n    };\n  }\n  static concat(...args: string[]): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `CONCAT(${args.map(() => \"?\").join(\", \")})`,\n      _params: args,\n    };\n  }\n  static upper(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: \"UPPER(??)\",\n      _params: [column],\n    };\n  }\n  static lower(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: \"LOWER(??)\",\n      _params: [column],\n    };\n  }\n\n  static wordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: \"word_similarity(?, ??)\",\n        _params: [query, column],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `word_similarity(?, ${column._sql})`,\n      _params: [query, ...column._params],\n    };\n  }\n\n  static similarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: \"similarity(??, ?)\",\n        _params: [column, query],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `similarity(${column._sql}, ?)`,\n      _params: [...column._params, query],\n    };\n  }\n\n  static strictWordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: `strict_word_similarity(?, ??)`,\n        _params: [query, column],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `strict_word_similarity(?, ${column._sql})`,\n      _params: [query, ...column._params],\n    };\n  }\n\n  // Raw functions for SELECT\n  static rawString(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"string\"> {\n    return { _type: \"sql_expression\", _return: \"string\", _sql: sql, _params: params };\n  }\n\n  static rawStringArray(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"string[]\"> {\n    return { _type: \"sql_expression\", _return: \"string[]\", _sql: sql, _params: params };\n  }\n\n  static rawNumber(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"number\"> {\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sql, _params: params };\n  }\n\n  static rawBoolean(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"boolean\"> {\n    return { _type: \"sql_expression\", _return: \"boolean\", _sql: sql, _params: params };\n  }\n\n  static rawDate(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"date\"> {\n    return { _type: \"sql_expression\", _return: \"date\", _sql: sql, _params: params };\n  }\n\n  /**\n   * FTS 검색어 하이라이팅\n   *\n   * @example\n   * .select({\n   *   title: Puri.highlight(\"posts.title\", search),\n   *   content: Puri.highlight(\"posts.content\", search, {\n   *     startSel: \"<mark>\",\n   *     stopSel: \"</mark>\",\n   *     maxFragments: 3,\n   *   }),\n   * })\n   */\n  static tsHighlight(\n    column: string,\n    query: string,\n    _options?: TsHighlightOptions,\n  ): SqlExpression<\"string\"> {\n    const { parser = \"websearch_to_tsquery\", config = \"simple\", ...options } = _options ?? {};\n\n    const hlOptionParts = Object.entries(options).map(([key, value]) => {\n      return `${inflection.camelize(key)}=${value}`;\n    });\n\n    const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(\", \")}'` : \"\";\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `ts_headline(?, ??, ${parser}(?, ?)${hlOptions})`,\n      _params: [config, column, config, query],\n    };\n  }\n\n  // ts_rank\n  static tsRank(\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank\", column, query, options);\n  }\n\n  // ts_rank_cd\n  static tsRankCd(\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank_cd\", column, query, options);\n  }\n\n  static toTsVector(column: string, config: string = \"simple\"): SqlExpression<\"tsvector\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"tsvector\",\n      _sql: `to_tsvector(?, ??)`,\n      _params: [config, column],\n    };\n  }\n\n  static _tsRank(\n    type: \"ts_rank\" | \"ts_rank_cd\",\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    const {\n      parser = \"websearch_to_tsquery\",\n      config = \"simple\",\n      normalization,\n      weights,\n    } = options ?? {};\n\n    const params = [];\n    let sqlTemplate = `${type}(`;\n\n    if (weights) {\n      sqlTemplate += `ARRAY[${weights.map(() => \"?\").join(\", \")}]::float4[], `;\n      params.push(...weights);\n    }\n\n    if (typeof column === \"string\") {\n      sqlTemplate += `??, ${parser}(?, ?)`;\n      params.push(column, config, query);\n    } else {\n      sqlTemplate += `${column._sql}, ${parser}(?, ?)`;\n      params.push(...column._params, config, query);\n    }\n\n    if (normalization) {\n      sqlTemplate += \", ?\";\n      params.push(normalization);\n    }\n\n    sqlTemplate += \")\";\n\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sqlTemplate, _params: params };\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색 점수\n   *\n   * @example\n   * .select({\n   *   score: Puri.score(),\n   * })\n   */\n  static score(): SqlExpression<\"number\"> {\n    return Puri.rawNumber(\"pgroonga_score(tableoid, ctid)\");\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색 하이라이팅\n   *\n   * @example\n   * .select({\n   *   title: Puri.highlight(\"posts.title\", search),\n   * })\n   */\n  static highlight(column: string, query: string | string[]): SqlExpression<\"string\">;\n  static highlight(columns: string[], query: string | string[]): SqlExpression<\"string[]\">;\n\n  static highlight(\n    columnOrColumns: string | string[],\n    query: string | string[],\n  ): SqlExpression<\"string\"> | SqlExpression<\"string[]\"> {\n    const queryArr = Array.isArray(query) ? query : [query];\n    const queryClause = `ARRAY[${queryArr.map(() => \"?\").join(\", \")}]`;\n\n    // 단일 컬럼인 경우\n    if (typeof columnOrColumns === \"string\") {\n      return Puri.rawString(`pgroonga_highlight_html(??, ${queryClause})`, [\n        columnOrColumns,\n        ...queryArr,\n      ]);\n    }\n\n    // 컬럼 배열인 경우\n    return Puri.rawStringArray(\n      `pgroonga_highlight_html(ARRAY[${columnOrColumns.map(() => \"??\").join(\", \")}], ${queryClause})`,\n      [...columnOrColumns, ...queryArr],\n    );\n  }\n\n  // SELECT (overwrite)\n  select<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, ParseSelectObject<TTables, TSelect>> {\n    // 중첩 객체를 flat하게 변환\n    const flatSelect = this.flattenSelect(selectObj);\n\n    const selectClauses: (string | Knex.Raw)[] = [];\n\n    for (const [alias, columnOrFunction] of Object.entries(flatSelect)) {\n      if (typeof columnOrFunction === \"object\" && columnOrFunction._type === \"sql_expression\") {\n        // SQL 함수인 경우\n        selectClauses.push(\n          this.knex.raw(`${columnOrFunction._sql} AS \"${alias}\"`, columnOrFunction._params),\n        );\n      } else {\n        // 일반 컬럼인 경우\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          // alias와 컬럼명이 같으면 alias 생략\n          selectClauses.push(columnPath);\n        } else {\n          // alias 지정\n          selectClauses.push(`${columnPath} AS ${alias}`);\n        }\n      }\n    }\n\n    this.knexQuery.select(selectClauses);\n    return this as any;\n  }\n\n  /**\n   * 중첩 객체를 flat 객체로 변환\n   * 예: { parent: { id: \"parent.id\", name: \"parent.name\" } }\n   *   → { parent__id: \"parent.id\", parent__name: \"parent.name\" }\n   */\n  private flattenSelect(selectObj: Record<string, any>, prefix = \"\"): Record<string, any> {\n    const flatSelect: Record<string, any> = {};\n\n    for (const [key, value] of Object.entries(selectObj)) {\n      const fullKey = prefix ? `${prefix}__${key}` : key;\n\n      if (typeof value === \"object\" && value !== null && !(\"_type\" in value)) {\n        // 중첩 객체인 경우 - 재귀 처리\n        const nested = this.flattenSelect(value, fullKey);\n        Object.assign(flatSelect, nested);\n      } else {\n        // 일반 값인 경우 (컬럼 경로 또는 SqlExpression)\n        flatSelect[fullKey] = value;\n      }\n    }\n\n    return flatSelect;\n  }\n\n  // SELECT (select는 overwrite, appendSelect는 append)\n  appendSelect<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, TResult & ParseSelectObject<TTables, TSelect>> {\n    // 중첩 객체를 flat하게 변환\n    const flatSelect = this.flattenSelect(selectObj);\n\n    const selectClauses: (string | Knex.Raw)[] = [];\n\n    for (const [alias, columnOrFunction] of Object.entries(flatSelect)) {\n      if (typeof columnOrFunction === \"object\" && columnOrFunction._type === \"sql_expression\") {\n        selectClauses.push(\n          this.knex.raw(`${columnOrFunction._sql} AS ${alias}`, columnOrFunction._params),\n        );\n      } else {\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          selectClauses.push(columnPath);\n        } else {\n          selectClauses.push(this.knex.ref(columnPath).as(alias));\n        }\n      }\n    }\n\n    this.knexQuery.select(selectClauses);\n    return this as any;\n  }\n\n  // SELECT *\n  selectAll(): Puri<TSchema, TTables, SelectAllResult<TTables>> {\n    this.knexQuery.select(\"*\");\n    return this as any;\n  }\n\n  // DISTINCT\n  distinct<TColumns extends AvailableColumns<TTables>>(...columns: TColumns[]): this;\n  distinct(...columns: string[]): this {\n    this.knexQuery.distinct(...columns);\n    return this;\n  }\n\n  // CLEAR\n  clear(statement: ClearStatements): this {\n    this.knexQuery.clear(statement);\n    return this;\n  }\n\n  // knex에 없어서 직접 구현함\n  clearJoin(alias: string): this {\n    (this.knexQuery as any)._statements = (this.knexQuery as any)._statements.filter((s: any) => {\n      if (\"joinType\" in s) {\n        const [_alias, _table] = Object.entries(s.table)[0];\n        return _alias !== alias;\n      } else {\n        return true;\n      }\n    });\n    return this;\n  }\n\n  // JOIN: 서브쿼리 + Alias\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSubResult>, // 서브쿼리의 TResult\n    TResult\n  >;\n  // JOIN: 테이블 + Alias\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSchema[TJoinTable]>, // TTables 확장!\n    TResult\n  >;\n  // JOIN: 테이블명\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    left: AvailableColumns<TTables>,\n    right: `${TJoinTable & string}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinTable, TSchema[TJoinTable]>, // 테이블명이 키\n    TResult\n  >;\n  // JOIN: 서브쿼리 + Alias + 콜백\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult>, TResult>;\n  // JOIN: 테이블 + Alias + 콜백\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable]>, TResult>;\n  // JOIN: 테이블명 + 콜백\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinTable, TSchema[TJoinTable]>, TResult>;\n  // JOIN 실제 구현\n  join(tableNameOrSpec: any, ...args: any[]): any {\n    return this.__commonJoin(\"join\", tableNameOrSpec, ...args);\n  }\n\n  // LEFT JOIN: 서브쿼리 + Alias\n  leftJoin<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult & LeftJoinedMarker>, TResult>; // 서브쿼리의 TResult\n  // LEFT JOIN: 테이블 + Alias\n  // FK nullable 여부에 따라 자동으로 LeftJoinedMarker 결정\n  leftJoin<\n    TJoinTable extends keyof TSchema,\n    TJoinAlias extends string,\n    TLeft extends AvailableColumns<TTables>,\n  >(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    left: TLeft,\n    right: `${TJoinAlias}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSchema[TJoinTable] & LeftJoinMarkerFor<TTables, TLeft>>,\n    TResult\n  >;\n  // LEFT JOIN: 테이블명\n  leftJoin<TJoinTable extends keyof TSchema, TLeft extends AvailableColumns<TTables>>(\n    tableName: TJoinTable,\n    left: TLeft,\n    right: `${TJoinTable & string}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinTable, TSchema[TJoinTable] & LeftJoinMarkerFor<TTables, TLeft>>,\n    TResult\n  >;\n  // LEFT JOIN: 서브쿼리 + Alias + 콜백\n  leftJoin<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN: 테이블 + Alias + 콜백\n  leftJoin<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable] & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN: 테이블명 + 콜백\n  leftJoin<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinTable, TSchema[TJoinTable] & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN 실제 구현\n  leftJoin(tableNameOrSpec: any, ...args: any[]): any {\n    return this.__commonJoin(\"leftJoin\", tableNameOrSpec, ...args);\n  }\n\n  __commonJoin(joinType: \"join\" | \"leftJoin\", tableNameOrSpec: any, ...args: any[]): this {\n    if (typeof tableNameOrSpec === \"string\") {\n      // Case 1: join(\"posts\", ...)\n      const tableName = tableNameOrSpec;\n\n      if (args.length === 1 && typeof args[0] === \"function\") {\n        // join(\"posts\", callback)\n        const callback = args[0];\n        this.knexQuery[joinType](tableName, (joinClause) => {\n          callback(new JoinClauseGroup(joinClause));\n        });\n      } else {\n        // join(\"posts\", left, right)\n        const [left, right] = args;\n        this.knexQuery[joinType](tableName, left, right);\n      }\n    } else if (typeof tableNameOrSpec === \"object\") {\n      // Case 2: join({ alias: \"table\" }, ...) or join({ alias: subquery }, ...)\n      const entries = Object.entries(tableNameOrSpec);\n      if (entries.length !== 1) {\n        throw new Error(\"Table spec must have exactly one entry\");\n      }\n      assert(entries[0]);\n      const [[alias, spec]] = entries;\n\n      if (typeof spec === \"string\") {\n        // 테이블: join({ p: \"posts\" }, ...)\n        if (args.length === 1 && typeof args[0] === \"function\") {\n          // Callback\n          const callback = args[0];\n          this.knexQuery[joinType]({ [alias]: spec }, (joinClause) => {\n            callback(new JoinClauseGroup(joinClause));\n          });\n        } else {\n          // Simple\n          const [left, right] = args;\n          this.knexQuery[joinType]({ [alias]: spec }, left, right);\n        }\n      } else if (spec instanceof Puri) {\n        // 서브쿼리: join({ sq: subquery }, ...)\n        if (args.length === 1 && typeof args[0] === \"function\") {\n          // Callback\n          const callback = args[0];\n          this.knexQuery[joinType](spec.rawQuery().as(alias), (joinClause) => {\n            callback(new JoinClauseGroup(joinClause));\n          });\n        } else {\n          // Simple\n          const [left, right] = args;\n          this.knexQuery[joinType](spec.rawQuery().as(alias), left, right);\n        }\n      } else {\n        throw new Error(\"Invalid table specification\");\n      }\n    } else {\n      throw new Error(\"Invalid arguments\");\n    }\n\n    return this;\n  }\n\n  // WHERE: 객체 - 사용: .where({ \"u.id\": 1, \"u.status\": \"active\" })\n  where(conditions: WhereCondition<TTables>): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", 1), .where(\"u.id\", null)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \">\", 10), .where(\"u.id\", \"!=\", null)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: SQL 표현식 - 사용: .where(puri.raw(\"CONCAT(u.name, u.email)\"), \"like\", \"%test%\")\n  where<TColumn extends Knex.Raw>(column: TColumn, operator: WhereOperator, value: any): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \"like\", \"%test%\")\n  where(...args: [columnOrConditions: any, operatorOrValue?: any, value?: any]): this {\n    const [columnOrConditions, operatorOrValue, value] = args;\n    if (typeof columnOrConditions === \"object\") {\n      this.knexQuery.where(columnOrConditions);\n    } else if (typeof value === \"undefined\") {\n      if (operatorOrValue === null) {\n        this.knexQuery.whereNull(columnOrConditions);\n        return this;\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue);\n    } else if (typeof value !== \"undefined\") {\n      if (value === null) {\n        if (operatorOrValue === \"!=\") {\n          this.knexQuery.whereNotNull(columnOrConditions);\n          return this;\n        } else if (operatorOrValue === \"=\") {\n          this.knexQuery.whereNull(columnOrConditions);\n          return this;\n        }\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue, value);\n    } else {\n      this.knexQuery.where(columnOrConditions);\n    }\n    return this;\n  }\n\n  // WHERE IN\n  whereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereIn(column, values);\n    return this as any;\n  }\n\n  // WHERE NOT IN\n  whereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereNotIn(column, values);\n    return this as any;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this {\n    this.knexQuery.whereRaw(`MATCH (${String(column)}) AGAINST (?)`, [value]);\n    return this;\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색\n   * - 사용할 PGroonga 인덱스와 동일한 컬럼 구성으로 검색해야 인덱스가 사용됩니다.\n   *\n   * 단일 컬럼 검색:\n   * ```sql\n   * WHERE name &@~ 'search'\n   * ```\n   *\n   * 복합 컬럼 검색:\n   * ```sql\n   * WHERE ARRAY[name::text, description::text] &@~ 'search'\n   * ```\n   */\n  whereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this {\n    const { weights } = options ?? {};\n    const columnExpr = Array.isArray(column)\n      ? `ARRAY[${column.map((c) => `${c}::text`).join(\",\")}]`\n      : column;\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n\n    this.knexQuery.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [value]);\n\n    return this;\n  }\n\n  // WHERE FULLTEXT\n  whereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this {\n    const opts =\n      typeof options === \"string\" ? ({ config: options } as TsQueryOptions) : (options ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof column === \"object\" && column._type === \"sql_expression\"\n        ? column._sql\n        : String(column);\n\n    this.knexQuery.whereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, value]);\n    return this;\n  }\n\n  whereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this {\n    const operator = normalizeFuzzyOperator(options?.operator);\n\n    if (operator === \"%\") {\n      if (typeof column === \"object\") {\n        this.knexQuery.whereRaw(`${column._sql} ${operator} ?`, [...column._params, value]);\n      } else {\n        this.knexQuery.whereRaw(`?? ${operator} ?`, [column, value]);\n      }\n      return this;\n    }\n\n    if (typeof column === \"object\") {\n      this.knexQuery.whereRaw(`? ${operator} ${column._sql}`, [value, ...column._params]);\n    } else {\n      this.knexQuery.whereRaw(`? ${operator} ??`, [value, column]);\n    }\n    return this;\n  }\n\n  // WHERE RAW\n  whereRaw(sql: string, bindings?: readonly Knex.RawBinding[]): this {\n    this.knexQuery.whereRaw(sql, bindings);\n    return this;\n  }\n\n  // WHERE 괄호 그룹핑\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.where((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.orWhere((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n\n  // ORDER BY (SqlExpression으로도 할 수 있어야 함)\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn | SqlExpression<\"number\"> | SqlExpression<\"string\">,\n    direction: \"asc\" | \"desc\",\n  ): this;\n  orderBy(\n    column: string | SqlExpression<\"number\"> | SqlExpression<\"string\">,\n    direction: \"asc\" | \"desc\" = \"asc\",\n  ): this {\n    if (typeof column === \"object\") {\n      this.knexQuery.orderByRaw(`${column._sql} ${direction}`, column._params);\n    } else {\n      this.knexQuery.orderBy(column, direction);\n    }\n    return this;\n  }\n\n  forUpdate(): this {\n    this.knexQuery.forUpdate();\n    return this;\n  }\n\n  forShare(): this {\n    this.knexQuery.forShare();\n    return this;\n  }\n\n  /**\n   * 벡터 유사도 검색 설정\n   *\n   * - SELECT에 similarity 컬럼 추가\n   * - WHERE col IS NOT NULL 추가\n   * - threshold가 있으면 WHERE 조건 추가\n   * - 기존 ORDER BY를 clear하고 원시 연산자로 정렬 (HNSW 인덱스 최적화)\n   *\n   * @param column 벡터 컬럼 경로\n   * @param embedding 쿼리 임베딩 벡터\n   * @param options method, threshold, as 등 옵션\n   *\n   * @example\n   * ```typescript\n   * // cosine similarity (기본값)\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"cosine\",\n   *   threshold: 0.5\n   * });\n   *\n   * // L2 distance\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"l2\",\n   *   threshold: 1.5  // 거리가 1.5 이하인 결과만\n   * });\n   *\n   * // Inner product\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"inner_product\",\n   *   threshold: 0.7\n   * });\n   * ```\n   */\n  vectorSimilarity(\n    column: VectorColumns<TTables>,\n    embedding: number[],\n    options: {\n      method?: \"cosine\" | \"l2\" | \"inner_product\";\n      threshold?: number;\n      distinctOn?: AvailableColumns<TTables>;\n    } = {},\n  ): Puri<TSchema, TTables, TResult & { similarity: number }> {\n    const { method = \"cosine\", threshold, distinctOn } = options;\n\n    if (\n      !Array.isArray(embedding) ||\n      embedding.length === 0 ||\n      embedding.some((v) => !Number.isFinite(v))\n    ) {\n      throw new Error(\"Invalid embedding vector: expected a non-empty array of finite numbers\");\n    }\n\n    const vectorLiteral = JSON.stringify(embedding.map((v) => Number(v)));\n    const operator = { cosine: \"<=>\", l2: \"<->\", inner_product: \"<#>\" }[method];\n\n    // method별 연산자 및 similarity 계산식\n    // - cosine: <=> (cosine distance, 0~2), similarity = 1 - distance\n    // - l2: <-> (euclidean distance), similarity = distance (낮을수록 유사)\n    // - inner_product: <#> (negative inner product), similarity = -distance (높을수록 유사)\n    const similarityExpr =\n      method === \"cosine\"\n        ? this.knex.raw(`1 - (?? ${operator} ?::vector) as similarity`, [column, vectorLiteral])\n        : method === \"l2\"\n          ? this.knex.raw(`?? ${operator} ?::vector as similarity`, [column, vectorLiteral])\n          : this.knex.raw(`-(?? ${operator} ?::vector) as similarity`, [column, vectorLiteral]);\n\n    // WHERE NOT NULL\n    this.knexQuery.whereNotNull(column);\n\n    // 기존 ORDER BY clear\n    this.knexQuery.clear(\"order\");\n    if (distinctOn) {\n      // DISTINCT ON은 SELECT 절의 맨 앞에 와야 하므로, 기존 select(subset 필드들)를 보존 후 clear하고 다시 추가\n      const existingSubsetCols = (this.knexQuery as any)._statements\n        .filter((s: any) => s.grouping === \"columns\")\n        .flatMap((s: any) => s.value);\n      this.knexQuery.clear(\"select\");\n      this.knexQuery.select(this.knex.raw(`DISTINCT ON (??) ??`, [distinctOn, distinctOn]));\n      existingSubsetCols.map((col: any) => this.knexQuery.select(col));\n      this.knexQuery.select(similarityExpr);\n      this.knexQuery.orderByRaw(`??, ?? ${operator} ?::vector`, [\n        distinctOn,\n        column,\n        vectorLiteral,\n      ]);\n\n      this.knexQuery = this.knex\n        .from(this.knexQuery.as(\"distinct_vectors\"))\n        .select(\"*\")\n        .orderBy(\"similarity\", \"desc\");\n    } else {\n      this.knexQuery.select(similarityExpr);\n      this.knexQuery.orderByRaw(`?? ${operator} ?::vector`, [column, vectorLiteral]);\n    }\n\n    // threshold\n    if (typeof threshold === \"number\") {\n      if (!Number.isFinite(threshold)) {\n        throw new Error(`Invalid vectorSimilarity threshold: ${threshold}`);\n      }\n\n      if (distinctOn) {\n        const thresholdOp = method === \"l2\" ? \"<=\" : \">=\";\n        this.knexQuery.where(\"similarity\", thresholdOp, threshold);\n      } else {\n        const thresholdValue =\n          method === \"cosine\" ? 1 - threshold : method === \"inner_product\" ? -threshold : threshold;\n        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [\n          column,\n          vectorLiteral,\n          thresholdValue,\n        ]);\n      }\n    }\n\n    return this as any;\n  }\n\n  // 기본 쿼리 메서드들\n  limit(count: number): this {\n    if (count < 0) {\n      throw new Error(\"Invalid limit: must be >= 0\");\n    }\n    this.knexQuery.limit(count);\n    return this;\n  }\n\n  offset(count: number): this {\n    if (count < 0) {\n      throw new Error(\"Invalid offset: must be >= 0\");\n    }\n    this.knexQuery.offset(count);\n    return this;\n  }\n\n  // GROUP BY\n  groupBy<TColumns extends ResultAvailableColumns<TTables, TResult>>(...columns: TColumns[]): this;\n  groupBy(...columns: string[]): this {\n    this.knexQuery.groupBy(...columns);\n    return this;\n  }\n\n  // HAVING\n  having(condition: string): this;\n  having<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    operator: ComparisonOperator,\n    value: any,\n  ): this;\n  // HAVING 구현\n  having(...conditions: any[]): this {\n    if (conditions.length === 1) {\n      // having(\"COUNT(*) > 10\")\n      this.knexQuery.having(this.knex.raw(conditions[0]));\n    } else if (conditions.length === 3) {\n      // having(\"count\", \">\", 10)\n      this.knexQuery.having(\n        this.knex.raw(conditions[0]),\n        conditions[1],\n        this.knex.raw(conditions[2]),\n      );\n    } else {\n      throw new Error(\"Invalid having arguments\");\n    }\n    return this;\n  }\n\n  // 실행 메서드들 - thenable 구현\n  then<TResult1 = Expand<TResult>[], TResult2 = never>(\n    onfulfilled?: ((value: Expand<TResult>[]) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n  finally(onfinally?: (() => void) | null): Promise<TResult> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // 하나만 쿼리\n  first(): ResolvedPuri<Expand<TResult>, never> {\n    this.knexQuery.first();\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴\n  pluck<TColumn extends keyof TResult | ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n  ): ResolvedPuri<\n    TColumn extends keyof TResult\n      ? TResult[TColumn][]\n      : ExtractColumnType<TTables, TColumn & string>[],\n    never\n  > {\n    this.knexQuery.pluck(column as string);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // INSERT : 단일 객체\n  insert(\n    data: InsertData<SingleTableValue<TTables>>,\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>>;\n  // INSERT: 배열\n  insert(\n    data: InsertData<SingleTableValue<TTables>>[],\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>>;\n  // INSERT 실제 구현\n  insert(\n    rawData: InsertData<SingleTableValue<TTables>> | InsertData<SingleTableValue<TTables>>[],\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>> {\n    // JSON 컬럼 stringify 로직을 메서드로 분리하여 중복 제거\n    const refinedData = this.refineJsonColumns(rawData);\n    this.knexQuery.insert(refinedData);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // UPDATE\n  update(rawData: WhereCondition<TTables>): ResolvedPuri<number, SingleTableValue<TTables>> {\n    // JSON 컬럼 stringify 로직을 메서드로 분리하여 중복 제거\n    const refinedData = this.refineJsonColumns(rawData);\n    this.knexQuery.update(refinedData);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  /**\n   * JSON 컬럼에 대해 stringify 처리를 수행하는 내부 메서드입니다.\n   * object 또는 object 배열을 받고, JSON 컬럼이 있으면 직렬화하여 반환합니다.\n   * 직접 값을 변경하므로 side effect가 있습니다.\n   */\n  private refineJsonColumns(\n    data: Record<string, unknown> | Record<string, unknown>[],\n  ): typeof data {\n    // tableSpec이나 jsonColumns 없는 경우 바로 반환\n    if (!this.tableSpec || !this.tableSpec.jsonColumns.length) {\n      return data;\n    }\n\n    // 등록된 TableSpec을 통해 JSON컬럼 목록을 가져와 JSON.stringify 처리\n    const jsonColumns = this.tableSpec.jsonColumns;\n    if (Array.isArray(data)) {\n      for (const item of data) {\n        for (const column of jsonColumns) {\n          const value = item[column];\n          if (value !== undefined && value !== null) {\n            item[column] = JSON.stringify(value);\n          }\n        }\n      }\n    } else {\n      for (const column of jsonColumns) {\n        const value = data[column];\n        if (value !== undefined && value !== null) {\n          data[column] = JSON.stringify(value);\n        }\n      }\n    }\n    return data;\n  }\n\n  // Increment\n  increment<TColumn extends NumericColumns<TTables>>(\n    column: TColumn,\n    value: number,\n  ): ResolvedPuri<number, SingleTableValue<TTables>> {\n    if (value <= 0) {\n      throw new Error(\"Increment value must be greater than 0\");\n    }\n    this.knexQuery.increment(column, value);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n  // Decrement\n  decrement<TColumn extends NumericColumns<TTables>>(\n    column: TColumn,\n    value: number,\n  ): ResolvedPuri<number, SingleTableValue<TTables>> {\n    if (value <= 0) {\n      throw new Error(\"Decrement value must be greater than 0\");\n    }\n    this.knexQuery.decrement(column, value);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // DELETE\n  delete(): ResolvedPuri<number, SingleTableValue<TTables>> {\n    this.knexQuery.delete();\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // 확인 쿼리 리턴\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  // 쿼리 디버깅 로그 출력\n  debug(): this {\n    console.log(`${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`);\n    return this;\n  }\n\n  clone(): Puri<TSchema, TTables, TResult> {\n    // 'dual'은 더미 테이블이며, 바로 아래 줄에서 knexQuery가 덮어씌워집니다.\n    const newPuri = new Puri<TSchema, TTables, TResult>(this.knex, \"dual\");\n    newPuri.knexQuery = this.knexQuery.clone();\n    return newPuri;\n  }\n\n  formatSQL(unformatted: string): string {\n    // SQL 예약어 목록\n    const keywords = [\n      \"SELECT\",\n      \"FROM\",\n      \"WHERE\",\n      \"INSERT\",\n      \"INTO\",\n      \"VALUES\",\n      \"UPDATE\",\n      \"DELETE\",\n      \"CREATE\",\n      \"TABLE\",\n      \"ALTER\",\n      \"DROP\",\n      \"JOIN\",\n      \"ON\",\n      \"INNER\",\n      \"LEFT\",\n      \"RIGHT\",\n      \"FULL\",\n      \"OUTER\",\n      \"GROUP\",\n      \"BY\",\n      \"ORDER\",\n      \"HAVING\",\n      \"DISTINCT\",\n      \"LIMIT\",\n      \"OFFSET\",\n      \"AS\",\n      \"AND\",\n      \"OR\",\n      \"NOT\",\n      \"IN\",\n      \"LIKE\",\n      \"IS\",\n      \"NULL\",\n      \"CASE\",\n      \"WHEN\",\n      \"THEN\",\n      \"ELSE\",\n      \"END\",\n      \"UNION\",\n      \"ALL\",\n      \"EXISTS\",\n      \"BETWEEN\",\n    ];\n\n    let formatted = unformatted;\n\n    // 예약어를 대문자로 변환\n    keywords.forEach((keyword) => {\n      const regex = new RegExp(`\\\\b${keyword}\\\\b`, \"gi\");\n      formatted = formatted.replace(regex, keyword.toUpperCase());\n    });\n\n    // 주요 절 앞에 줄바꿈 추가\n    const majorClauses = [\n      \"SELECT\",\n      \"FROM\",\n      \"WHERE\",\n      \"GROUP BY\",\n      \"ORDER BY\",\n      \"HAVING\",\n      \"LIMIT\",\n      \"UNION\",\n    ];\n    majorClauses.forEach((clause) => {\n      const regex = new RegExp(`\\\\s+(${clause})\\\\s+`, \"gi\");\n      formatted = formatted.replace(regex, `\\n${clause.toUpperCase()} `);\n    });\n\n    // JOIN 절 처리\n    formatted = formatted.replace(/\\s+((?:INNER|LEFT|RIGHT|FULL OUTER)\\s+)?JOIN\\s+/gi, \"\\n$1JOIN \");\n\n    // AND, OR 조건 처리\n    formatted = formatted.replace(/\\s+(AND|OR)\\s+/gi, \"\\n  $1 \");\n\n    // 괄호 처리 및 들여쓰기\n    const lines = formatted.split(\"\\n\");\n    const indentedLines = [];\n    let indentLevel = 0;\n\n    for (const line of lines) {\n      const trimmedLine = line.trim();\n      if (!trimmedLine) continue;\n\n      // 닫는 괄호가 있으면 들여쓰기 레벨 감소\n      const closingParens = (trimmedLine.match(/\\)/g) || []).length;\n      const openingParens = (trimmedLine.match(/\\(/g) || []).length;\n\n      if (closingParens > 0 && openingParens === 0) {\n        indentLevel = Math.max(0, indentLevel - closingParens);\n      }\n\n      // 현재 들여쓰기 적용\n      const indent = \"  \".repeat(indentLevel);\n      indentedLines.push(indent + trimmedLine);\n\n      // 여는 괄호가 있으면 들여쓰기 레벨 증가\n      if (openingParens > closingParens) {\n        indentLevel += openingParens - closingParens;\n      }\n    }\n\n    return indentedLines.join(\"\\n\").trim();\n  }\n\n  raw(sql: string): Knex.Raw {\n    return this.knex.raw(sql);\n  }\n\n  // Knex 쿼리 빌더 직접 접근\n  rawQuery(): Knex.QueryBuilder {\n    return this.knexQuery;\n  }\n}\n\nexport class WhereGroup<TTables extends Record<string, any>> {\n  constructor(private builder: Knex.QueryBuilder) {}\n\n  // where 메서드들\n  where(conditions: WhereCondition<TTables>): this;\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  where(...args: any[]): WhereGroup<TTables> {\n    this.builder.where(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // whereIn / whereNotIn 메서드들\n  whereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  whereIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.whereIn(args[0], args[1]);\n    return this;\n  }\n\n  whereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  whereNotIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.whereNotIn(args[0], args[1]);\n    return this;\n  }\n\n  // orWhere 메서드들\n  orWhere(conditions: WhereCondition<TTables>): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhere(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // orWhereIn / orWhereNotIn 메서드들\n  orWhereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  orWhereIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhereIn(args[0], args[1]);\n    return this;\n  }\n\n  orWhereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  orWhereNotIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhereNotIn(args[0], args[1]);\n    return this;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this;\n  whereMatch(...args: any[]): this {\n    this.builder.whereRaw(`MATCH (${String(args[0])}) AGAINST (?)`, [args[1]]);\n    return this;\n  }\n\n  orWhereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this;\n  orWhereMatch(...args: any[]): this {\n    this.builder.orWhereRaw(`MATCH (${String(args[0])}) AGAINST (?)`, [args[1]]);\n    return this;\n  }\n\n  // WHERE SEARCH\n  whereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this;\n  whereSearch(...args: any[]): this {\n    const { weights } = args[2] ?? {};\n    const columnExpr = Array.isArray(args[0])\n      ? `ARRAY[${args[0].map((c) => `${c}::text`).join(\",\")}]`\n      : args[0];\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n    this.builder.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [args[1]]);\n\n    return this;\n  }\n\n  orWhereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this;\n  orWhereSearch(...args: any[]): this {\n    const { weights } = args[2] ?? {};\n    const columnExpr = Array.isArray(args[0])\n      ? `ARRAY[${args[0].map((c) => `${c}::text`).join(\",\")}]`\n      : args[0];\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n    this.builder.orWhereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [args[1]]);\n\n    return this;\n  }\n\n  // WHERE FULLTEXT\n  whereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this;\n  whereTsSearch(...args: any[]): this {\n    const opts =\n      typeof args[2] === \"string\" ? ({ config: args[2] } as TsQueryOptions) : (args[2] ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof args[0] === \"object\" && args[0]._type === \"sql_expression\"\n        ? args[0]._sql\n        : String(args[0]);\n\n    this.builder.whereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, args[1]]);\n    return this;\n  }\n\n  orWhereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this;\n  orWhereTsSearch(...args: any[]): this {\n    const opts =\n      typeof args[2] === \"string\" ? ({ config: args[2] } as TsQueryOptions) : (args[2] ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof args[0] === \"object\" && args[0]._type === \"sql_expression\"\n        ? args[0]._sql\n        : String(args[0]);\n\n    this.builder.orWhereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, args[1]]);\n    return this;\n  }\n\n  whereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this;\n  whereFuzzy(...args: any[]): this {\n    const operator = normalizeFuzzyOperator(args[2]?.operator);\n\n    if (operator === \"%\") {\n      if (typeof args[0] === \"object\") {\n        this.builder.whereRaw(`${args[0]._sql} ${operator} ?`, [...args[0]._params, args[1]]);\n      } else {\n        this.builder.whereRaw(`?? ${operator} ?`, [args[0], args[1]]);\n      }\n      return this;\n    }\n\n    if (typeof args[0] === \"object\") {\n      this.builder.whereRaw(`? ${operator} ${args[0]._sql}`, [args[1], ...args[0]._params]);\n    } else {\n      this.builder.whereRaw(`? ${operator} ??`, [args[1], args[0]]);\n    }\n    return this;\n  }\n\n  orWhereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this;\n  orWhereFuzzy(...args: any[]): this {\n    const operator = normalizeFuzzyOperator(args[2]?.operator);\n\n    if (operator === \"%\") {\n      if (typeof args[0] === \"object\") {\n        this.builder.orWhereRaw(`${args[0]._sql} ${operator} ?`, [...args[0]._params, args[1]]);\n      } else {\n        this.builder.orWhereRaw(`?? ${operator} ?`, [args[0], args[1]]);\n      }\n      return this;\n    }\n\n    if (typeof args[0] === \"object\") {\n      this.builder.orWhereRaw(`? ${operator} ${args[0]._sql}`, [args[1], ...args[0]._params]);\n    } else {\n      this.builder.orWhereRaw(`? ${operator} ??`, [args[1], args[0]]);\n    }\n    return this;\n  }\n\n  // 중첩 그룹\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.where((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.orWhere((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n}\n\n// JOIN 절 그룹에는 Left와 Right에 대한 순서가 필요하지 않으므로, 모든 경우의 수를 계산해야함.\nexport class JoinClauseGroup<\n  TLeft extends Record<string, any>,\n  TRight extends Record<string, any>,\n> {\n  constructor(private callback: Knex.JoinClause) {}\n\n  // ON(AND): 컬럼 = 컬럼\n  on(left: AvailableColumns<TLeft>, right: AvailableColumns<TRight>): this;\n  on(left: AvailableColumns<TRight>, right: AvailableColumns<TLeft>): this;\n  // ON(AND): 컬럼 = 값\n  on(\n    left: AvailableColumns<TLeft>,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(AND): 컬럼 (연산자) 컬럼\n  on(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TLeft>,\n  ): this;\n  // ON(AND): 컬럼 (연산자) 값\n  on(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(AND): 콜백\n  on(callback: (nested: JoinClauseGroup<TLeft, TRight>) => void): this;\n  on(callback: (nested: JoinClauseGroup<TRight, TLeft>) => void): this;\n  // ON(AND) 구현\n  on(...args: any[]): this {\n    this.callback.on(...(args as [string, string]));\n    return this;\n  }\n\n  // ON(OR): 컬럼 = 컬럼\n  orOn(left: AvailableColumns<TLeft>, right: AvailableColumns<TRight>): this;\n  orOn(left: AvailableColumns<TRight>, right: AvailableColumns<TLeft>): this;\n  // ON(OR): 컬럼 = 값\n  orOn(\n    left: AvailableColumns<TLeft>,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(OR): 컬럼 (연산자) 컬럼\n  orOn(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TLeft>,\n  ): this;\n  // ON(OR): 컬럼 (연산자) 값\n  orOn(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(OR): 콜백\n  orOn(callback: (nested: JoinClauseGroup<TLeft, TRight>) => void): this;\n  orOn(callback: (nested: JoinClauseGroup<TRight, TLeft>) => void): this;\n  // ON(OR) 구현\n  orOn(...args: any[]): this {\n    this.callback.orOn(...(args as [string, string]));\n    return this;\n  }\n\n  // ON VAL(AND): 컬럼 = 값 (값을 컬럼 참조가 아닌 파라미터로 바인딩)\n  onVal(column: AvailableColumns<TLeft>, value: any): this;\n  onVal(column: AvailableColumns<TRight>, value: any): this;\n  onVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  onVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  onVal(...args: any[]): this {\n    (this.callback as any).onVal(...args);\n    return this;\n  }\n\n  // AND ON VAL: onVal의 명시적 alias (Knex 호환)\n  andOnVal(column: AvailableColumns<TLeft>, value: any): this;\n  andOnVal(column: AvailableColumns<TRight>, value: any): this;\n  andOnVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  andOnVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  andOnVal(...args: any[]): this {\n    (this.callback as any).andOnVal(...args);\n    return this;\n  }\n\n  // OR ON VAL: OR 조건으로 값 바인딩\n  orOnVal(column: AvailableColumns<TLeft>, value: any): this;\n  orOnVal(column: AvailableColumns<TRight>, value: any): this;\n  orOnVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  orOnVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  orOnVal(...args: any[]): this {\n    (this.callback as any).orOnVal(...args);\n    return this;\n  }\n}\n\n/*\n  TResolved: 쿼리 실행 후 반환될 결과 타입\n  TReturning: RETURNING 절에 사용될 타입\n*/\nexport class ResolvedPuri<TResolved, TReturning> implements Promise<TResolved> {\n  constructor(\n    public knexQuery: Knex.QueryBuilder,\n    private knex: Knex,\n  ) {}\n\n  [Symbol.toStringTag]: string = \"Promise\";\n\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  debug(): this {\n    console.log(`${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`);\n    return this;\n  }\n\n  then<TResult1 = TResolved, TResult2 = never>(\n    onfulfilled?: ((value: TResolved) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResolved | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<TResolved> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // ON CONFLICT - 컬럼 기반\n  onConflict<TTables extends Record<string, TReturning>>(\n    columns: string | string[],\n    action?: OnConflictAction<TTables>,\n  ): this {\n    const target = Array.isArray(columns) ? columns : [columns];\n\n    if (!action || action === \"nothing\") {\n      // DO NOTHING\n      this.knexQuery.onConflict(target).ignore();\n    } else {\n      // DO UPDATE\n      const { update } = action;\n\n      // action.update 배열 형태 : [\"name\", \"email\"]\n      if (Array.isArray(update)) {\n        this.knexQuery.onConflict(target).merge(update);\n      } else {\n        // action.update 객체 형태: { name: \"John\", count: raw(...) }\n        const mergeObj: Record<string, any> = {};\n\n        for (const [key, value] of Object.entries(update)) {\n          if (\n            value &&\n            typeof value === \"object\" &&\n            \"_type\" in value &&\n            value._type === \"sql_expression\"\n          ) {\n            // SqlExpression → knex.raw()로 변환\n            mergeObj[key] = this.knex.raw((value as SqlExpression<any>)._sql);\n          } else {\n            // 일반 값\n            mergeObj[key] = value;\n          }\n        }\n\n        this.knexQuery.onConflict(target).merge(mergeObj);\n      }\n    }\n\n    return this;\n  }\n\n  // RETURNING: \"*\" - 전체 컬럼\n  returning(column: \"*\"): ResolvedPuri<TReturning[], never>;\n  // RETURNING: 단일 컬럼\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    column: TColumn,\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING: 복수 컬럼 (배열)\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    columns: TColumn[],\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING 구현\n  returning(columnOrColumns: string | string[]): ResolvedPuri<any[], never> {\n    this.knexQuery.returning(columnOrColumns);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"puri.js","names":["knex: Knex","selectClauses: (string | Knex.Raw)[]","flatSelect: Record<string, any>","builder: Knex.QueryBuilder","callback: Knex.JoinClause","knexQuery: Knex.QueryBuilder","mergeObj: Record<string, any>"],"sources":["../../src/database/puri.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */ // Puri는 다양한 타입을 사용하고 있습니다.\n\nimport assert from \"assert\";\n\nimport chalk from \"chalk\";\nimport inflection from \"inflection\";\nimport { type Knex } from \"knex\";\n\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type TableSpec } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type ClearStatements } from \"./puri-subset.types\";\nimport {\n  type AvailableColumns,\n  type ColumnKeys,\n  type ComparisonOperator,\n  type Expand,\n  type ExtractColumnType,\n  type FulltextColumns,\n  type FuzzyOperator,\n  type InsertData,\n  type InsertResult,\n  type LeftJoinedMarker,\n  type LeftJoinMarkerFor,\n  type NumericColumns,\n  type OnConflictAction,\n  type ParseSelectObject,\n  type ResultAvailableColumns,\n  type SelectAllResult,\n  type SelectObject,\n  type SingleTableValue,\n  type SqlExpression,\n  type TsHighlightOptions,\n  type TsQueryConfig,\n  type TsQueryOptions,\n  type TsRankOptions,\n  type VectorColumns,\n  type WhereCondition,\n  type WhereOperator,\n} from \"./puri.types\";\nimport { FUZZY_OPERATORS } from \"./puri.types\";\n\ntype PuriOrderByDirection = \"asc\" | \"desc\";\ntype PuriOrderByNulls = \"first\" | \"last\";\ntype PuriOrderByExpression = SqlExpression<\"number\"> | SqlExpression<\"string\">;\ntype PuriOrderByItem<TColumn extends string> = {\n  column: TColumn | PuriOrderByExpression;\n  order?: PuriOrderByDirection;\n  nulls?: PuriOrderByNulls;\n};\ntype PuriOrderByEntry<TColumn extends string> =\n  | TColumn\n  | PuriOrderByExpression\n  | PuriOrderByItem<TColumn>;\ntype PuriOrderByRuntimeItem = {\n  column: string | PuriOrderByExpression;\n  order?: PuriOrderByDirection;\n  nulls?: PuriOrderByNulls;\n};\ntype PuriOrderByRuntimeEntry = string | PuriOrderByExpression | PuriOrderByRuntimeItem;\n\nfunction normalizeFuzzyOperator(operator?: string): FuzzyOperator {\n  const normalized = operator?.trim() ?? \"<%\";\n  const fuzzyOperator = FUZZY_OPERATORS.find((candidate) => candidate === normalized);\n\n  if (!fuzzyOperator) {\n    throw new Error(`Invalid fuzzy operator: ${operator ?? \"\"}`);\n  }\n\n  return fuzzyOperator;\n}\n\nfunction normalizeOrderByDirection(direction: PuriOrderByDirection = \"asc\"): PuriOrderByDirection {\n  if (direction !== \"asc\" && direction !== \"desc\") {\n    throw new Error(`Invalid order direction: ${direction}`);\n  }\n\n  return direction;\n}\n\nfunction normalizeOrderByNulls(nulls?: PuriOrderByNulls): PuriOrderByNulls | undefined {\n  if (nulls === undefined) {\n    return undefined;\n  }\n\n  if (nulls !== \"first\" && nulls !== \"last\") {\n    throw new Error(`Invalid order nulls: ${nulls}`);\n  }\n\n  return nulls;\n}\n\nfunction formatNullsSuffix(nulls?: PuriOrderByNulls): string {\n  if (!nulls) {\n    return \"\";\n  }\n\n  return ` NULLS ${nulls.toUpperCase()}`;\n}\n\nfunction isOrderByEntries(value: unknown): value is readonly PuriOrderByRuntimeEntry[] {\n  return Array.isArray(value);\n}\n\nfunction isSqlExpression(value: PuriOrderByRuntimeEntry): value is PuriOrderByExpression {\n  return typeof value === \"object\" && \"_type\" in value && value._type === \"sql_expression\";\n}\n\nexport class Puri<TSchema, TTables extends Record<string, any>, TResult> {\n  private knexQuery: Knex.QueryBuilder;\n  private tableSpec: TableSpec | null = null;\n\n  // 생성자 시그니처들\n  constructor(knex: Knex, tableName: string);\n  constructor(knex: Knex, tableSource: Record<string, string | Puri<TSchema, any, any>>);\n  constructor(\n    public knex: Knex,\n    tableNameOrSource: any,\n  ) {\n    if (typeof tableNameOrSource === \"string\") {\n      // Case: new Puri(knex, \"users\")\n      this.knexQuery = this.knex(tableNameOrSource).from(tableNameOrSource);\n      this.tableSpec = this.safeGetTableSpec(tableNameOrSource);\n    } else if (typeof tableNameOrSource === \"object\") {\n      const entries = Object.entries(tableNameOrSource);\n      if (entries.length !== 1) {\n        throw new Error(\"Table spec must have exactly one entry\");\n      }\n      assert(entries[0]);\n      const [alias, source] = entries[0];\n      if (typeof source === \"string\") {\n        this.knexQuery = this.knex(source).from({ [alias]: source });\n        this.tableSpec = this.safeGetTableSpec(source);\n      } else if (source instanceof Puri) {\n        const subqueryBuilder = source.rawQuery();\n        this.knexQuery = this.knex.from(subqueryBuilder.as(alias));\n      } else {\n        throw new Error(\"Invalid table specification\");\n      }\n    } else {\n      throw new Error(\"Invalid table specification\");\n    }\n  }\n\n  safeGetTableSpec(tableName: string): TableSpec | null {\n    try {\n      return EntityManager.getTableSpec(tableName);\n    } catch {\n      return null;\n    }\n  }\n\n  // Static SQL helper functions for SELECT\n  static count(column: string = \"*\"): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `COUNT(??)::integer`,\n      _params: [column],\n    };\n  }\n  static sum(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `SUM(??)`,\n      _params: [column],\n    };\n  }\n  static avg(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `AVG(??)`,\n      _params: [column],\n    };\n  }\n  static max(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MAX(??)`,\n      _params: [column],\n    };\n  }\n  static min(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MIN(??)`,\n      _params: [column],\n    };\n  }\n  static concat(...args: string[]): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `CONCAT(${args.map(() => \"?\").join(\", \")})`,\n      _params: args,\n    };\n  }\n  static upper(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: \"UPPER(??)\",\n      _params: [column],\n    };\n  }\n  static lower(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: \"LOWER(??)\",\n      _params: [column],\n    };\n  }\n\n  static wordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: \"word_similarity(?, ??)\",\n        _params: [query, column],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `word_similarity(?, ${column._sql})`,\n      _params: [query, ...column._params],\n    };\n  }\n\n  static similarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: \"similarity(??, ?)\",\n        _params: [column, query],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `similarity(${column._sql}, ?)`,\n      _params: [...column._params, query],\n    };\n  }\n\n  static strictWordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    if (typeof column === \"string\") {\n      return {\n        _type: \"sql_expression\",\n        _return: \"number\",\n        _sql: `strict_word_similarity(?, ??)`,\n        _params: [query, column],\n      };\n    }\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `strict_word_similarity(?, ${column._sql})`,\n      _params: [query, ...column._params],\n    };\n  }\n\n  // Raw functions for SELECT\n  static rawString(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"string\"> {\n    return { _type: \"sql_expression\", _return: \"string\", _sql: sql, _params: params };\n  }\n\n  static rawStringArray(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"string[]\"> {\n    return { _type: \"sql_expression\", _return: \"string[]\", _sql: sql, _params: params };\n  }\n\n  static rawNumber(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"number\"> {\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sql, _params: params };\n  }\n\n  static rawBoolean(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"boolean\"> {\n    return { _type: \"sql_expression\", _return: \"boolean\", _sql: sql, _params: params };\n  }\n\n  static rawDate(sql: string, params: Knex.RawBinding[] = []): SqlExpression<\"date\"> {\n    return { _type: \"sql_expression\", _return: \"date\", _sql: sql, _params: params };\n  }\n\n  /**\n   * FTS 검색어 하이라이팅\n   *\n   * @example\n   * .select({\n   *   title: Puri.highlight(\"posts.title\", search),\n   *   content: Puri.highlight(\"posts.content\", search, {\n   *     startSel: \"<mark>\",\n   *     stopSel: \"</mark>\",\n   *     maxFragments: 3,\n   *   }),\n   * })\n   */\n  static tsHighlight(\n    column: string,\n    query: string,\n    _options?: TsHighlightOptions,\n  ): SqlExpression<\"string\"> {\n    const { parser = \"websearch_to_tsquery\", config = \"simple\", ...options } = _options ?? {};\n\n    const hlOptionParts = Object.entries(options).map(([key, value]) => {\n      return `${inflection.camelize(key)}=${value}`;\n    });\n\n    const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(\", \")}'` : \"\";\n\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `ts_headline(?, ??, ${parser}(?, ?)${hlOptions})`,\n      _params: [config, column, config, query],\n    };\n  }\n\n  // ts_rank\n  static tsRank(\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank\", column, query, options);\n  }\n\n  // ts_rank_cd\n  static tsRankCd(\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank_cd\", column, query, options);\n  }\n\n  static toTsVector(column: string, config: string = \"simple\"): SqlExpression<\"tsvector\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"tsvector\",\n      _sql: `to_tsvector(?, ??)`,\n      _params: [config, column],\n    };\n  }\n\n  static _tsRank(\n    type: \"ts_rank\" | \"ts_rank_cd\",\n    column: string | SqlExpression<\"tsvector\">,\n    query: string,\n    options?: TsRankOptions,\n  ): SqlExpression<\"number\"> {\n    const {\n      parser = \"websearch_to_tsquery\",\n      config = \"simple\",\n      normalization,\n      weights,\n    } = options ?? {};\n\n    const params = [];\n    let sqlTemplate = `${type}(`;\n\n    if (weights) {\n      sqlTemplate += `ARRAY[${weights.map(() => \"?\").join(\", \")}]::float4[], `;\n      params.push(...weights);\n    }\n\n    if (typeof column === \"string\") {\n      sqlTemplate += `??, ${parser}(?, ?)`;\n      params.push(column, config, query);\n    } else {\n      sqlTemplate += `${column._sql}, ${parser}(?, ?)`;\n      params.push(...column._params, config, query);\n    }\n\n    if (normalization) {\n      sqlTemplate += \", ?\";\n      params.push(normalization);\n    }\n\n    sqlTemplate += \")\";\n\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sqlTemplate, _params: params };\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색 점수\n   *\n   * @example\n   * .select({\n   *   score: Puri.score(),\n   * })\n   */\n  static score(): SqlExpression<\"number\"> {\n    return Puri.rawNumber(\"pgroonga_score(tableoid, ctid)\");\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색 하이라이팅\n   *\n   * @example\n   * .select({\n   *   title: Puri.highlight(\"posts.title\", search),\n   * })\n   */\n  static highlight(column: string, query: string | string[]): SqlExpression<\"string\">;\n  static highlight(columns: string[], query: string | string[]): SqlExpression<\"string[]\">;\n\n  static highlight(\n    columnOrColumns: string | string[],\n    query: string | string[],\n  ): SqlExpression<\"string\"> | SqlExpression<\"string[]\"> {\n    const queryArr = Array.isArray(query) ? query : [query];\n    const queryClause = `ARRAY[${queryArr.map(() => \"?\").join(\", \")}]`;\n\n    // 단일 컬럼인 경우\n    if (typeof columnOrColumns === \"string\") {\n      return Puri.rawString(`pgroonga_highlight_html(??, ${queryClause})`, [\n        columnOrColumns,\n        ...queryArr,\n      ]);\n    }\n\n    // 컬럼 배열인 경우\n    return Puri.rawStringArray(\n      `pgroonga_highlight_html(ARRAY[${columnOrColumns.map(() => \"??\").join(\", \")}], ${queryClause})`,\n      [...columnOrColumns, ...queryArr],\n    );\n  }\n\n  // SELECT (overwrite)\n  select<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, ParseSelectObject<TTables, TSelect>> {\n    // 중첩 객체를 flat하게 변환\n    const flatSelect = this.flattenSelect(selectObj);\n\n    const selectClauses: (string | Knex.Raw)[] = [];\n\n    for (const [alias, columnOrFunction] of Object.entries(flatSelect)) {\n      if (typeof columnOrFunction === \"object\" && columnOrFunction._type === \"sql_expression\") {\n        // SQL 함수인 경우\n        selectClauses.push(\n          this.knex.raw(`${columnOrFunction._sql} AS \"${alias}\"`, columnOrFunction._params),\n        );\n      } else {\n        // 일반 컬럼인 경우\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          // alias와 컬럼명이 같으면 alias 생략\n          selectClauses.push(columnPath);\n        } else {\n          // alias 지정\n          selectClauses.push(`${columnPath} AS ${alias}`);\n        }\n      }\n    }\n\n    this.knexQuery.select(selectClauses);\n    return this as any;\n  }\n\n  /**\n   * 중첩 객체를 flat 객체로 변환\n   * 예: { parent: { id: \"parent.id\", name: \"parent.name\" } }\n   *   → { parent__id: \"parent.id\", parent__name: \"parent.name\" }\n   */\n  private flattenSelect(selectObj: Record<string, any>, prefix = \"\"): Record<string, any> {\n    const flatSelect: Record<string, any> = {};\n\n    for (const [key, value] of Object.entries(selectObj)) {\n      const fullKey = prefix ? `${prefix}__${key}` : key;\n\n      if (typeof value === \"object\" && value !== null && !(\"_type\" in value)) {\n        // 중첩 객체인 경우 - 재귀 처리\n        const nested = this.flattenSelect(value, fullKey);\n        Object.assign(flatSelect, nested);\n      } else {\n        // 일반 값인 경우 (컬럼 경로 또는 SqlExpression)\n        flatSelect[fullKey] = value;\n      }\n    }\n\n    return flatSelect;\n  }\n\n  // SELECT (select는 overwrite, appendSelect는 append)\n  appendSelect<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, TResult & ParseSelectObject<TTables, TSelect>> {\n    // 중첩 객체를 flat하게 변환\n    const flatSelect = this.flattenSelect(selectObj);\n\n    const selectClauses: (string | Knex.Raw)[] = [];\n\n    for (const [alias, columnOrFunction] of Object.entries(flatSelect)) {\n      if (typeof columnOrFunction === \"object\" && columnOrFunction._type === \"sql_expression\") {\n        selectClauses.push(\n          this.knex.raw(`${columnOrFunction._sql} AS ${alias}`, columnOrFunction._params),\n        );\n      } else {\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          selectClauses.push(columnPath);\n        } else {\n          selectClauses.push(this.knex.ref(columnPath).as(alias));\n        }\n      }\n    }\n\n    this.knexQuery.select(selectClauses);\n    return this as any;\n  }\n\n  // SELECT *\n  selectAll(): Puri<TSchema, TTables, SelectAllResult<TTables>> {\n    this.knexQuery.select(\"*\");\n    return this as any;\n  }\n\n  // DISTINCT\n  distinct<TColumns extends AvailableColumns<TTables>>(...columns: TColumns[]): this;\n  distinct(...columns: string[]): this {\n    this.knexQuery.distinct(...columns);\n    return this;\n  }\n\n  // CLEAR\n  clear(statement: ClearStatements): this {\n    this.knexQuery.clear(statement);\n    return this;\n  }\n\n  // knex에 없어서 직접 구현함\n  clearJoin(alias: string): this {\n    (this.knexQuery as any)._statements = (this.knexQuery as any)._statements.filter((s: any) => {\n      if (\"joinType\" in s) {\n        const [_alias, _table] = Object.entries(s.table)[0];\n        return _alias !== alias;\n      } else {\n        return true;\n      }\n    });\n    return this;\n  }\n\n  // JOIN: 서브쿼리 + Alias\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSubResult>, // 서브쿼리의 TResult\n    TResult\n  >;\n  // JOIN: 테이블 + Alias\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSchema[TJoinTable]>, // TTables 확장!\n    TResult\n  >;\n  // JOIN: 테이블명\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    left: AvailableColumns<TTables>,\n    right: `${TJoinTable & string}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinTable, TSchema[TJoinTable]>, // 테이블명이 키\n    TResult\n  >;\n  // JOIN: 서브쿼리 + Alias + 콜백\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult>, TResult>;\n  // JOIN: 테이블 + Alias + 콜백\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable]>, TResult>;\n  // JOIN: 테이블명 + 콜백\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinTable, TSchema[TJoinTable]>, TResult>;\n  // JOIN 실제 구현\n  join(tableNameOrSpec: any, ...args: any[]): any {\n    return this.__commonJoin(\"join\", tableNameOrSpec, ...args);\n  }\n\n  // LEFT JOIN: 서브쿼리 + Alias\n  leftJoin<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult & LeftJoinedMarker>, TResult>; // 서브쿼리의 TResult\n  // LEFT JOIN: 테이블 + Alias\n  // FK nullable 여부에 따라 자동으로 LeftJoinedMarker 결정\n  leftJoin<\n    TJoinTable extends keyof TSchema,\n    TJoinAlias extends string,\n    TLeft extends AvailableColumns<TTables>,\n  >(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    left: TLeft,\n    right: `${TJoinAlias}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSchema[TJoinTable] & LeftJoinMarkerFor<TTables, TLeft>>,\n    TResult\n  >;\n  // LEFT JOIN: 테이블명\n  leftJoin<TJoinTable extends keyof TSchema, TLeft extends AvailableColumns<TTables>>(\n    tableName: TJoinTable,\n    left: TLeft,\n    right: `${TJoinTable & string}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinTable, TSchema[TJoinTable] & LeftJoinMarkerFor<TTables, TLeft>>,\n    TResult\n  >;\n  // LEFT JOIN: 서브쿼리 + Alias + 콜백\n  leftJoin<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN: 테이블 + Alias + 콜백\n  leftJoin<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable] & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN: 테이블명 + 콜백\n  leftJoin<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinTable, TSchema[TJoinTable] & LeftJoinedMarker>, TResult>;\n  // LEFT JOIN 실제 구현\n  leftJoin(tableNameOrSpec: any, ...args: any[]): any {\n    return this.__commonJoin(\"leftJoin\", tableNameOrSpec, ...args);\n  }\n\n  __commonJoin(joinType: \"join\" | \"leftJoin\", tableNameOrSpec: any, ...args: any[]): this {\n    if (typeof tableNameOrSpec === \"string\") {\n      // Case 1: join(\"posts\", ...)\n      const tableName = tableNameOrSpec;\n\n      if (args.length === 1 && typeof args[0] === \"function\") {\n        // join(\"posts\", callback)\n        const callback = args[0];\n        this.knexQuery[joinType](tableName, (joinClause) => {\n          callback(new JoinClauseGroup(joinClause));\n        });\n      } else {\n        // join(\"posts\", left, right)\n        const [left, right] = args;\n        this.knexQuery[joinType](tableName, left, right);\n      }\n    } else if (typeof tableNameOrSpec === \"object\") {\n      // Case 2: join({ alias: \"table\" }, ...) or join({ alias: subquery }, ...)\n      const entries = Object.entries(tableNameOrSpec);\n      if (entries.length !== 1) {\n        throw new Error(\"Table spec must have exactly one entry\");\n      }\n      assert(entries[0]);\n      const [[alias, spec]] = entries;\n\n      if (typeof spec === \"string\") {\n        // 테이블: join({ p: \"posts\" }, ...)\n        if (args.length === 1 && typeof args[0] === \"function\") {\n          // Callback\n          const callback = args[0];\n          this.knexQuery[joinType]({ [alias]: spec }, (joinClause) => {\n            callback(new JoinClauseGroup(joinClause));\n          });\n        } else {\n          // Simple\n          const [left, right] = args;\n          this.knexQuery[joinType]({ [alias]: spec }, left, right);\n        }\n      } else if (spec instanceof Puri) {\n        // 서브쿼리: join({ sq: subquery }, ...)\n        if (args.length === 1 && typeof args[0] === \"function\") {\n          // Callback\n          const callback = args[0];\n          this.knexQuery[joinType](spec.rawQuery().as(alias), (joinClause) => {\n            callback(new JoinClauseGroup(joinClause));\n          });\n        } else {\n          // Simple\n          const [left, right] = args;\n          this.knexQuery[joinType](spec.rawQuery().as(alias), left, right);\n        }\n      } else {\n        throw new Error(\"Invalid table specification\");\n      }\n    } else {\n      throw new Error(\"Invalid arguments\");\n    }\n\n    return this;\n  }\n\n  // WHERE: 객체 - 사용: .where({ \"u.id\": 1, \"u.status\": \"active\" })\n  where(conditions: WhereCondition<TTables>): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", 1), .where(\"u.id\", null)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \">\", 10), .where(\"u.id\", \"!=\", null)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: SQL 표현식 - 사용: .where(puri.raw(\"CONCAT(u.name, u.email)\"), \"like\", \"%test%\")\n  where<TColumn extends Knex.Raw>(column: TColumn, operator: WhereOperator, value: any): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \"like\", \"%test%\")\n  where(...args: [columnOrConditions: any, operatorOrValue?: any, value?: any]): this {\n    const [columnOrConditions, operatorOrValue, value] = args;\n    if (typeof columnOrConditions === \"object\") {\n      this.knexQuery.where(columnOrConditions);\n    } else if (typeof value === \"undefined\") {\n      if (operatorOrValue === null) {\n        this.knexQuery.whereNull(columnOrConditions);\n        return this;\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue);\n    } else if (typeof value !== \"undefined\") {\n      if (value === null) {\n        if (operatorOrValue === \"!=\") {\n          this.knexQuery.whereNotNull(columnOrConditions);\n          return this;\n        } else if (operatorOrValue === \"=\") {\n          this.knexQuery.whereNull(columnOrConditions);\n          return this;\n        }\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue, value);\n    } else {\n      this.knexQuery.where(columnOrConditions);\n    }\n    return this;\n  }\n\n  // WHERE IN\n  whereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereIn(column, values);\n    return this as any;\n  }\n\n  // WHERE NOT IN\n  whereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereNotIn(column, values);\n    return this as any;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this {\n    this.knexQuery.whereRaw(`MATCH (${String(column)}) AGAINST (?)`, [value]);\n    return this;\n  }\n\n  /**\n   * PGroonga FullText 인덱스 검색\n   * - 사용할 PGroonga 인덱스와 동일한 컬럼 구성으로 검색해야 인덱스가 사용됩니다.\n   *\n   * 단일 컬럼 검색:\n   * ```sql\n   * WHERE name &@~ 'search'\n   * ```\n   *\n   * 복합 컬럼 검색:\n   * ```sql\n   * WHERE ARRAY[name::text, description::text] &@~ 'search'\n   * ```\n   */\n  whereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this {\n    const { weights } = options ?? {};\n    const columnExpr = Array.isArray(column)\n      ? `ARRAY[${column.map((c) => `${c}::text`).join(\",\")}]`\n      : column;\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n\n    this.knexQuery.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [value]);\n\n    return this;\n  }\n\n  // WHERE FULLTEXT\n  whereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this {\n    const opts =\n      typeof options === \"string\" ? ({ config: options } as TsQueryOptions) : (options ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof column === \"object\" && column._type === \"sql_expression\"\n        ? column._sql\n        : String(column);\n\n    this.knexQuery.whereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, value]);\n    return this;\n  }\n\n  whereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this {\n    const operator = normalizeFuzzyOperator(options?.operator);\n\n    if (operator === \"%\") {\n      if (typeof column === \"object\") {\n        this.knexQuery.whereRaw(`${column._sql} ${operator} ?`, [...column._params, value]);\n      } else {\n        this.knexQuery.whereRaw(`?? ${operator} ?`, [column, value]);\n      }\n      return this;\n    }\n\n    if (typeof column === \"object\") {\n      this.knexQuery.whereRaw(`? ${operator} ${column._sql}`, [value, ...column._params]);\n    } else {\n      this.knexQuery.whereRaw(`? ${operator} ??`, [value, column]);\n    }\n    return this;\n  }\n\n  // WHERE RAW\n  whereRaw(sql: string, bindings?: readonly Knex.RawBinding[]): this {\n    this.knexQuery.whereRaw(sql, bindings);\n    return this;\n  }\n\n  // WHERE 괄호 그룹핑\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.where((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.orWhere((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n\n  // ORDER BY (SqlExpression으로도 할 수 있어야 함)\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn | PuriOrderByExpression,\n    direction?: PuriOrderByDirection,\n    nulls?: PuriOrderByNulls,\n  ): this;\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    columns: readonly PuriOrderByEntry<TColumn>[],\n  ): this;\n  orderBy(\n    columnOrColumns: string | PuriOrderByExpression | readonly PuriOrderByRuntimeEntry[],\n    direction: PuriOrderByDirection = \"asc\",\n    nulls?: PuriOrderByNulls,\n  ): this {\n    if (isOrderByEntries(columnOrColumns)) {\n      for (const entry of columnOrColumns) {\n        if (typeof entry === \"string\" || isSqlExpression(entry)) {\n          this.applyOrderBy(entry);\n        } else {\n          this.applyOrderBy(entry.column, entry.order, entry.nulls);\n        }\n      }\n      return this;\n    }\n\n    this.applyOrderBy(columnOrColumns, direction, nulls);\n    return this;\n  }\n\n  private applyOrderBy(\n    column: string | PuriOrderByExpression,\n    direction?: PuriOrderByDirection,\n    nulls?: PuriOrderByNulls,\n  ): void {\n    const normalizedDirection = normalizeOrderByDirection(direction);\n    const normalizedNulls = normalizeOrderByNulls(nulls);\n\n    if (typeof column === \"object\") {\n      this.knexQuery.orderByRaw(\n        `${column._sql} ${normalizedDirection}${formatNullsSuffix(normalizedNulls)}`,\n        column._params,\n      );\n    } else {\n      this.knexQuery.orderBy(column, normalizedDirection, normalizedNulls);\n    }\n  }\n\n  forUpdate(): this {\n    this.knexQuery.forUpdate();\n    return this;\n  }\n\n  forShare(): this {\n    this.knexQuery.forShare();\n    return this;\n  }\n\n  /**\n   * 벡터 유사도 검색 설정\n   *\n   * - SELECT에 similarity 컬럼 추가\n   * - WHERE col IS NOT NULL 추가\n   * - threshold가 있으면 WHERE 조건 추가\n   * - 기존 ORDER BY를 clear하고 원시 연산자로 정렬 (HNSW 인덱스 최적화)\n   *\n   * @param column 벡터 컬럼 경로\n   * @param embedding 쿼리 임베딩 벡터\n   * @param options method, threshold, as 등 옵션\n   *\n   * @example\n   * ```typescript\n   * // cosine similarity (기본값)\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"cosine\",\n   *   threshold: 0.5\n   * });\n   *\n   * // L2 distance\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"l2\",\n   *   threshold: 1.5  // 거리가 1.5 이하인 결과만\n   * });\n   *\n   * // Inner product\n   * qb.vectorSimilarity(\"columnName\", queryVector, {\n   *   method: \"inner_product\",\n   *   threshold: 0.7\n   * });\n   * ```\n   */\n  vectorSimilarity(\n    column: VectorColumns<TTables>,\n    embedding: number[],\n    options: {\n      method?: \"cosine\" | \"l2\" | \"inner_product\";\n      threshold?: number;\n      distinctOn?: AvailableColumns<TTables>;\n    } = {},\n  ): Puri<TSchema, TTables, TResult & { similarity: number }> {\n    const { method = \"cosine\", threshold, distinctOn } = options;\n\n    if (\n      !Array.isArray(embedding) ||\n      embedding.length === 0 ||\n      embedding.some((v) => !Number.isFinite(v))\n    ) {\n      throw new Error(\"Invalid embedding vector: expected a non-empty array of finite numbers\");\n    }\n\n    const vectorLiteral = JSON.stringify(embedding.map((v) => Number(v)));\n    const operator = { cosine: \"<=>\", l2: \"<->\", inner_product: \"<#>\" }[method];\n\n    // method별 연산자 및 similarity 계산식\n    // - cosine: <=> (cosine distance, 0~2), similarity = 1 - distance\n    // - l2: <-> (euclidean distance), similarity = distance (낮을수록 유사)\n    // - inner_product: <#> (negative inner product), similarity = -distance (높을수록 유사)\n    const similarityExpr =\n      method === \"cosine\"\n        ? this.knex.raw(`1 - (?? ${operator} ?::vector) as similarity`, [column, vectorLiteral])\n        : method === \"l2\"\n          ? this.knex.raw(`?? ${operator} ?::vector as similarity`, [column, vectorLiteral])\n          : this.knex.raw(`-(?? ${operator} ?::vector) as similarity`, [column, vectorLiteral]);\n\n    // WHERE NOT NULL\n    this.knexQuery.whereNotNull(column);\n\n    // 기존 ORDER BY clear\n    this.knexQuery.clear(\"order\");\n    if (distinctOn) {\n      // DISTINCT ON은 SELECT 절의 맨 앞에 와야 하므로, 기존 select(subset 필드들)를 보존 후 clear하고 다시 추가\n      const existingSubsetCols = (this.knexQuery as any)._statements\n        .filter((s: any) => s.grouping === \"columns\")\n        .flatMap((s: any) => s.value);\n      this.knexQuery.clear(\"select\");\n      this.knexQuery.select(this.knex.raw(`DISTINCT ON (??) ??`, [distinctOn, distinctOn]));\n      existingSubsetCols.map((col: any) => this.knexQuery.select(col));\n      this.knexQuery.select(similarityExpr);\n      this.knexQuery.orderByRaw(`??, ?? ${operator} ?::vector`, [\n        distinctOn,\n        column,\n        vectorLiteral,\n      ]);\n\n      this.knexQuery = this.knex\n        .from(this.knexQuery.as(\"distinct_vectors\"))\n        .select(\"*\")\n        .orderBy(\"similarity\", \"desc\");\n    } else {\n      this.knexQuery.select(similarityExpr);\n      this.knexQuery.orderByRaw(`?? ${operator} ?::vector`, [column, vectorLiteral]);\n    }\n\n    // threshold\n    if (typeof threshold === \"number\") {\n      if (!Number.isFinite(threshold)) {\n        throw new Error(`Invalid vectorSimilarity threshold: ${threshold}`);\n      }\n\n      if (distinctOn) {\n        const thresholdOp = method === \"l2\" ? \"<=\" : \">=\";\n        this.knexQuery.where(\"similarity\", thresholdOp, threshold);\n      } else {\n        const thresholdValue =\n          method === \"cosine\" ? 1 - threshold : method === \"inner_product\" ? -threshold : threshold;\n        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [\n          column,\n          vectorLiteral,\n          thresholdValue,\n        ]);\n      }\n    }\n\n    return this as any;\n  }\n\n  // 기본 쿼리 메서드들\n  limit(count: number): this {\n    if (count < 0) {\n      throw new Error(\"Invalid limit: must be >= 0\");\n    }\n    this.knexQuery.limit(count);\n    return this;\n  }\n\n  offset(count: number): this {\n    if (count < 0) {\n      throw new Error(\"Invalid offset: must be >= 0\");\n    }\n    this.knexQuery.offset(count);\n    return this;\n  }\n\n  // GROUP BY\n  groupBy<TColumns extends ResultAvailableColumns<TTables, TResult>>(...columns: TColumns[]): this;\n  groupBy(...columns: string[]): this {\n    this.knexQuery.groupBy(...columns);\n    return this;\n  }\n\n  // HAVING\n  having(condition: string): this;\n  having<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    operator: ComparisonOperator,\n    value: any,\n  ): this;\n  // HAVING 구현\n  having(...conditions: any[]): this {\n    if (conditions.length === 1) {\n      // having(\"COUNT(*) > 10\")\n      this.knexQuery.having(this.knex.raw(conditions[0]));\n    } else if (conditions.length === 3) {\n      // having(\"count\", \">\", 10)\n      this.knexQuery.having(\n        this.knex.raw(conditions[0]),\n        conditions[1],\n        this.knex.raw(conditions[2]),\n      );\n    } else {\n      throw new Error(\"Invalid having arguments\");\n    }\n    return this;\n  }\n\n  // 실행 메서드들 - thenable 구현\n  then<TResult1 = Expand<TResult>[], TResult2 = never>(\n    onfulfilled?: ((value: Expand<TResult>[]) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n  finally(onfinally?: (() => void) | null): Promise<TResult> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // 하나만 쿼리\n  first(): ResolvedPuri<Expand<TResult>, never> {\n    this.knexQuery.first();\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴\n  pluck<TColumn extends keyof TResult | ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n  ): ResolvedPuri<\n    TColumn extends keyof TResult\n      ? TResult[TColumn][]\n      : ExtractColumnType<TTables, TColumn & string>[],\n    never\n  > {\n    this.knexQuery.pluck(column as string);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // INSERT : 단일 객체\n  insert(\n    data: InsertData<SingleTableValue<TTables>>,\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>>;\n  // INSERT: 배열\n  insert(\n    data: InsertData<SingleTableValue<TTables>>[],\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>>;\n  // INSERT 실제 구현\n  insert(\n    rawData: InsertData<SingleTableValue<TTables>> | InsertData<SingleTableValue<TTables>>[],\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>> {\n    // JSON 컬럼 stringify 로직을 메서드로 분리하여 중복 제거\n    const refinedData = this.refineJsonColumns(rawData);\n    this.knexQuery.insert(refinedData);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // UPDATE\n  update(rawData: WhereCondition<TTables>): ResolvedPuri<number, SingleTableValue<TTables>> {\n    // JSON 컬럼 stringify 로직을 메서드로 분리하여 중복 제거\n    const refinedData = this.refineJsonColumns(rawData);\n    this.knexQuery.update(refinedData);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  /**\n   * JSON 컬럼에 대해 stringify 처리를 수행하는 내부 메서드입니다.\n   * object 또는 object 배열을 받고, JSON 컬럼이 있으면 직렬화하여 반환합니다.\n   * 직접 값을 변경하므로 side effect가 있습니다.\n   */\n  private refineJsonColumns(\n    data: Record<string, unknown> | Record<string, unknown>[],\n  ): typeof data {\n    // tableSpec이나 jsonColumns 없는 경우 바로 반환\n    if (!this.tableSpec || !this.tableSpec.jsonColumns.length) {\n      return data;\n    }\n\n    // 등록된 TableSpec을 통해 JSON컬럼 목록을 가져와 JSON.stringify 처리\n    const jsonColumns = this.tableSpec.jsonColumns;\n    if (Array.isArray(data)) {\n      for (const item of data) {\n        for (const column of jsonColumns) {\n          const value = item[column];\n          if (value !== undefined && value !== null) {\n            item[column] = JSON.stringify(value);\n          }\n        }\n      }\n    } else {\n      for (const column of jsonColumns) {\n        const value = data[column];\n        if (value !== undefined && value !== null) {\n          data[column] = JSON.stringify(value);\n        }\n      }\n    }\n    return data;\n  }\n\n  // Increment\n  increment<TColumn extends NumericColumns<TTables>>(\n    column: TColumn,\n    value: number,\n  ): ResolvedPuri<number, SingleTableValue<TTables>> {\n    if (value <= 0) {\n      throw new Error(\"Increment value must be greater than 0\");\n    }\n    this.knexQuery.increment(column, value);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n  // Decrement\n  decrement<TColumn extends NumericColumns<TTables>>(\n    column: TColumn,\n    value: number,\n  ): ResolvedPuri<number, SingleTableValue<TTables>> {\n    if (value <= 0) {\n      throw new Error(\"Decrement value must be greater than 0\");\n    }\n    this.knexQuery.decrement(column, value);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // DELETE\n  delete(): ResolvedPuri<number, SingleTableValue<TTables>> {\n    this.knexQuery.delete();\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // 확인 쿼리 리턴\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  // 쿼리 디버깅 로그 출력\n  debug(): this {\n    console.log(`${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`);\n    return this;\n  }\n\n  clone(): Puri<TSchema, TTables, TResult> {\n    // 'dual'은 더미 테이블이며, 바로 아래 줄에서 knexQuery가 덮어씌워집니다.\n    const newPuri = new Puri<TSchema, TTables, TResult>(this.knex, \"dual\");\n    newPuri.knexQuery = this.knexQuery.clone();\n    return newPuri;\n  }\n\n  formatSQL(unformatted: string): string {\n    // SQL 예약어 목록\n    const keywords = [\n      \"SELECT\",\n      \"FROM\",\n      \"WHERE\",\n      \"INSERT\",\n      \"INTO\",\n      \"VALUES\",\n      \"UPDATE\",\n      \"DELETE\",\n      \"CREATE\",\n      \"TABLE\",\n      \"ALTER\",\n      \"DROP\",\n      \"JOIN\",\n      \"ON\",\n      \"INNER\",\n      \"LEFT\",\n      \"RIGHT\",\n      \"FULL\",\n      \"OUTER\",\n      \"GROUP\",\n      \"BY\",\n      \"ORDER\",\n      \"HAVING\",\n      \"DISTINCT\",\n      \"LIMIT\",\n      \"OFFSET\",\n      \"AS\",\n      \"AND\",\n      \"OR\",\n      \"NOT\",\n      \"IN\",\n      \"LIKE\",\n      \"IS\",\n      \"NULL\",\n      \"CASE\",\n      \"WHEN\",\n      \"THEN\",\n      \"ELSE\",\n      \"END\",\n      \"UNION\",\n      \"ALL\",\n      \"EXISTS\",\n      \"BETWEEN\",\n    ];\n\n    let formatted = unformatted;\n\n    // 예약어를 대문자로 변환\n    keywords.forEach((keyword) => {\n      const regex = new RegExp(`\\\\b${keyword}\\\\b`, \"gi\");\n      formatted = formatted.replace(regex, keyword.toUpperCase());\n    });\n\n    // 주요 절 앞에 줄바꿈 추가\n    const majorClauses = [\n      \"SELECT\",\n      \"FROM\",\n      \"WHERE\",\n      \"GROUP BY\",\n      \"ORDER BY\",\n      \"HAVING\",\n      \"LIMIT\",\n      \"UNION\",\n    ];\n    majorClauses.forEach((clause) => {\n      const regex = new RegExp(`\\\\s+(${clause})\\\\s+`, \"gi\");\n      formatted = formatted.replace(regex, `\\n${clause.toUpperCase()} `);\n    });\n\n    // JOIN 절 처리\n    formatted = formatted.replace(/\\s+((?:INNER|LEFT|RIGHT|FULL OUTER)\\s+)?JOIN\\s+/gi, \"\\n$1JOIN \");\n\n    // AND, OR 조건 처리\n    formatted = formatted.replace(/\\s+(AND|OR)\\s+/gi, \"\\n  $1 \");\n\n    // 괄호 처리 및 들여쓰기\n    const lines = formatted.split(\"\\n\");\n    const indentedLines = [];\n    let indentLevel = 0;\n\n    for (const line of lines) {\n      const trimmedLine = line.trim();\n      if (!trimmedLine) continue;\n\n      // 닫는 괄호가 있으면 들여쓰기 레벨 감소\n      const closingParens = (trimmedLine.match(/\\)/g) || []).length;\n      const openingParens = (trimmedLine.match(/\\(/g) || []).length;\n\n      if (closingParens > 0 && openingParens === 0) {\n        indentLevel = Math.max(0, indentLevel - closingParens);\n      }\n\n      // 현재 들여쓰기 적용\n      const indent = \"  \".repeat(indentLevel);\n      indentedLines.push(indent + trimmedLine);\n\n      // 여는 괄호가 있으면 들여쓰기 레벨 증가\n      if (openingParens > closingParens) {\n        indentLevel += openingParens - closingParens;\n      }\n    }\n\n    return indentedLines.join(\"\\n\").trim();\n  }\n\n  raw(sql: string): Knex.Raw {\n    return this.knex.raw(sql);\n  }\n\n  // Knex 쿼리 빌더 직접 접근\n  rawQuery(): Knex.QueryBuilder {\n    return this.knexQuery;\n  }\n}\n\nexport class WhereGroup<TTables extends Record<string, any>> {\n  constructor(private builder: Knex.QueryBuilder) {}\n\n  // where 메서드들\n  where(conditions: WhereCondition<TTables>): this;\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  where(...args: any[]): WhereGroup<TTables> {\n    this.builder.where(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // whereIn / whereNotIn 메서드들\n  whereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  whereIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.whereIn(args[0], args[1]);\n    return this;\n  }\n\n  whereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  whereNotIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.whereNotIn(args[0], args[1]);\n    return this;\n  }\n\n  // orWhere 메서드들\n  orWhere(conditions: WhereCondition<TTables>): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: WhereOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhere(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // orWhereIn / orWhereNotIn 메서드들\n  orWhereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  orWhereIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhereIn(args[0], args[1]);\n    return this;\n  }\n\n  orWhereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): this;\n  orWhereNotIn(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhereNotIn(args[0], args[1]);\n    return this;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this;\n  whereMatch(...args: any[]): this {\n    this.builder.whereRaw(`MATCH (${String(args[0])}) AGAINST (?)`, [args[1]]);\n    return this;\n  }\n\n  orWhereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this;\n  orWhereMatch(...args: any[]): this {\n    this.builder.orWhereRaw(`MATCH (${String(args[0])}) AGAINST (?)`, [args[1]]);\n    return this;\n  }\n\n  // WHERE SEARCH\n  whereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this;\n  whereSearch(...args: any[]): this {\n    const { weights } = args[2] ?? {};\n    const columnExpr = Array.isArray(args[0])\n      ? `ARRAY[${args[0].map((c) => `${c}::text`).join(\",\")}]`\n      : args[0];\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n    this.builder.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [args[1]]);\n\n    return this;\n  }\n\n  orWhereSearch<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn | TColumn[],\n    value: string,\n    options?: {\n      weights?: number[]; // 정수 배열\n    },\n  ): this;\n  orWhereSearch(...args: any[]): this {\n    const { weights } = args[2] ?? {};\n    const columnExpr = Array.isArray(args[0])\n      ? `ARRAY[${args[0].map((c) => `${c}::text`).join(\",\")}]`\n      : args[0];\n    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(\",\")}]` : \"\"})`;\n    this.builder.orWhereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [args[1]]);\n\n    return this;\n  }\n\n  // WHERE FULLTEXT\n  whereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this;\n  whereTsSearch(...args: any[]): this {\n    const opts =\n      typeof args[2] === \"string\" ? ({ config: args[2] } as TsQueryOptions) : (args[2] ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof args[0] === \"object\" && args[0]._type === \"sql_expression\"\n        ? args[0]._sql\n        : String(args[0]);\n\n    this.builder.whereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, args[1]]);\n    return this;\n  }\n\n  orWhereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: TsQueryOptions | TsQueryConfig,\n  ): this;\n  orWhereTsSearch(...args: any[]): this {\n    const opts =\n      typeof args[2] === \"string\" ? ({ config: args[2] } as TsQueryOptions) : (args[2] ?? {});\n\n    const parser = opts.parser ?? \"websearch_to_tsquery\";\n    const config = opts.config ?? \"simple\";\n    const columnExpr =\n      typeof args[0] === \"object\" && args[0]._type === \"sql_expression\"\n        ? args[0]._sql\n        : String(args[0]);\n\n    this.builder.orWhereRaw(`${columnExpr} @@ ${parser}(?, ?)`, [config, args[1]]);\n    return this;\n  }\n\n  whereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this;\n  whereFuzzy(...args: any[]): this {\n    const operator = normalizeFuzzyOperator(args[2]?.operator);\n\n    if (operator === \"%\") {\n      if (typeof args[0] === \"object\") {\n        this.builder.whereRaw(`${args[0]._sql} ${operator} ?`, [...args[0]._params, args[1]]);\n      } else {\n        this.builder.whereRaw(`?? ${operator} ?`, [args[0], args[1]]);\n      }\n      return this;\n    }\n\n    if (typeof args[0] === \"object\") {\n      this.builder.whereRaw(`? ${operator} ${args[0]._sql}`, [args[1], ...args[0]._params]);\n    } else {\n      this.builder.whereRaw(`? ${operator} ??`, [args[1], args[0]]);\n    }\n    return this;\n  }\n\n  orWhereFuzzy<TColumn extends AvailableColumns<TTables> | SqlExpression<\"string\">>(\n    column: TColumn,\n    value: string,\n    options?: {\n      operator?: FuzzyOperator;\n    },\n  ): this;\n  orWhereFuzzy(...args: any[]): this {\n    const operator = normalizeFuzzyOperator(args[2]?.operator);\n\n    if (operator === \"%\") {\n      if (typeof args[0] === \"object\") {\n        this.builder.orWhereRaw(`${args[0]._sql} ${operator} ?`, [...args[0]._params, args[1]]);\n      } else {\n        this.builder.orWhereRaw(`?? ${operator} ?`, [args[0], args[1]]);\n      }\n      return this;\n    }\n\n    if (typeof args[0] === \"object\") {\n      this.builder.orWhereRaw(`? ${operator} ${args[0]._sql}`, [args[1], ...args[0]._params]);\n    } else {\n      this.builder.orWhereRaw(`? ${operator} ??`, [args[1], args[0]]);\n    }\n    return this;\n  }\n\n  // 중첩 그룹\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.where((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.orWhere((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n}\n\n// JOIN 절 그룹에는 Left와 Right에 대한 순서가 필요하지 않으므로, 모든 경우의 수를 계산해야함.\nexport class JoinClauseGroup<\n  TLeft extends Record<string, any>,\n  TRight extends Record<string, any>,\n> {\n  constructor(private callback: Knex.JoinClause) {}\n\n  // ON(AND): 컬럼 = 컬럼\n  on(left: AvailableColumns<TLeft>, right: AvailableColumns<TRight>): this;\n  on(left: AvailableColumns<TRight>, right: AvailableColumns<TLeft>): this;\n  // ON(AND): 컬럼 = 값\n  on(\n    left: AvailableColumns<TLeft>,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(AND): 컬럼 (연산자) 컬럼\n  on(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TLeft>,\n  ): this;\n  // ON(AND): 컬럼 (연산자) 값\n  on(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  on(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(AND): 콜백\n  on(callback: (nested: JoinClauseGroup<TLeft, TRight>) => void): this;\n  on(callback: (nested: JoinClauseGroup<TRight, TLeft>) => void): this;\n  // ON(AND) 구현\n  on(...args: any[]): this {\n    this.callback.on(...(args as [string, string]));\n    return this;\n  }\n\n  // ON(OR): 컬럼 = 컬럼\n  orOn(left: AvailableColumns<TLeft>, right: AvailableColumns<TRight>): this;\n  orOn(left: AvailableColumns<TRight>, right: AvailableColumns<TLeft>): this;\n  // ON(OR): 컬럼 = 값\n  orOn(\n    left: AvailableColumns<TLeft>,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(OR): 컬럼 (연산자) 컬럼\n  orOn(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TLeft>,\n  ): this;\n  // ON(OR): 컬럼 (연산자) 값\n  orOn(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TLeft, AvailableColumns<TLeft> & string>,\n  ): this;\n  orOn(\n    left: AvailableColumns<TRight>,\n    operator: ComparisonOperator,\n    right: ExtractColumnType<TRight, AvailableColumns<TRight> & string>,\n  ): this;\n  // ON(OR): 콜백\n  orOn(callback: (nested: JoinClauseGroup<TLeft, TRight>) => void): this;\n  orOn(callback: (nested: JoinClauseGroup<TRight, TLeft>) => void): this;\n  // ON(OR) 구현\n  orOn(...args: any[]): this {\n    this.callback.orOn(...(args as [string, string]));\n    return this;\n  }\n\n  // ON VAL(AND): 컬럼 = 값 (값을 컬럼 참조가 아닌 파라미터로 바인딩)\n  onVal(column: AvailableColumns<TLeft>, value: any): this;\n  onVal(column: AvailableColumns<TRight>, value: any): this;\n  onVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  onVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  onVal(...args: any[]): this {\n    (this.callback as any).onVal(...args);\n    return this;\n  }\n\n  // AND ON VAL: onVal의 명시적 alias (Knex 호환)\n  andOnVal(column: AvailableColumns<TLeft>, value: any): this;\n  andOnVal(column: AvailableColumns<TRight>, value: any): this;\n  andOnVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  andOnVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  andOnVal(...args: any[]): this {\n    (this.callback as any).andOnVal(...args);\n    return this;\n  }\n\n  // OR ON VAL: OR 조건으로 값 바인딩\n  orOnVal(column: AvailableColumns<TLeft>, value: any): this;\n  orOnVal(column: AvailableColumns<TRight>, value: any): this;\n  orOnVal(column: AvailableColumns<TLeft>, operator: ComparisonOperator, value: any): this;\n  orOnVal(column: AvailableColumns<TRight>, operator: ComparisonOperator, value: any): this;\n  orOnVal(...args: any[]): this {\n    (this.callback as any).orOnVal(...args);\n    return this;\n  }\n}\n\n/*\n  TResolved: 쿼리 실행 후 반환될 결과 타입\n  TReturning: RETURNING 절에 사용될 타입\n*/\nexport class ResolvedPuri<TResolved, TReturning> implements Promise<TResolved> {\n  constructor(\n    public knexQuery: Knex.QueryBuilder,\n    private knex: Knex,\n  ) {}\n\n  [Symbol.toStringTag]: string = \"Promise\";\n\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  debug(): this {\n    console.log(`${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`);\n    return this;\n  }\n\n  then<TResult1 = TResolved, TResult2 = never>(\n    onfulfilled?: ((value: TResolved) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResolved | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<TResolved> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // ON CONFLICT - 컬럼 기반\n  onConflict<TTables extends Record<string, TReturning>>(\n    columns: string | string[],\n    action?: OnConflictAction<TTables>,\n  ): this {\n    const target = Array.isArray(columns) ? columns : [columns];\n\n    if (!action || action === \"nothing\") {\n      // DO NOTHING\n      this.knexQuery.onConflict(target).ignore();\n    } else {\n      // DO UPDATE\n      const { update } = action;\n\n      // action.update 배열 형태 : [\"name\", \"email\"]\n      if (Array.isArray(update)) {\n        this.knexQuery.onConflict(target).merge(update);\n      } else {\n        // action.update 객체 형태: { name: \"John\", count: raw(...) }\n        const mergeObj: Record<string, any> = {};\n\n        for (const [key, value] of Object.entries(update)) {\n          if (\n            value &&\n            typeof value === \"object\" &&\n            \"_type\" in value &&\n            value._type === \"sql_expression\"\n          ) {\n            // SqlExpression → knex.raw()로 변환\n            mergeObj[key] = this.knex.raw((value as SqlExpression<any>)._sql);\n          } else {\n            // 일반 값\n            mergeObj[key] = value;\n          }\n        }\n\n        this.knexQuery.onConflict(target).merge(mergeObj);\n      }\n    }\n\n    return this;\n  }\n\n  // RETURNING: \"*\" - 전체 컬럼\n  returning(column: \"*\"): ResolvedPuri<TReturning[], never>;\n  // RETURNING: 단일 컬럼\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    column: TColumn,\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING: 복수 컬럼 (배열)\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    columns: TColumn[],\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING 구현\n  returning(columnOrColumns: string | string[]): ResolvedPuri<any[], never> {\n    this.knexQuery.returning(columnOrColumns);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n}\n"],"mappings":"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"}

package/dist/entity/entity-manager.d.ts

@@ -661,6 +661,7 @@ declare class EntityManagerClass {
             name: string;
             using?: "btree" | "hash" | "gin" | "gist" | "pgroonga" | undefined;
             nullsNotDistinct?: boolean | undefined;
+            where?: string | undefined;
             m?: number | undefined;
             efConstruction?: number | undefined;
             lists?: number | undefined;

package/dist/entity/entity-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-manager.d.ts","sourceRoot":"","sources":["../../src/entity/entity-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"entity-manager.d.ts","sourceRoot":"","sources":["../../src/entity/entity-manager.ts"],"names":[],"mappings":"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"}

package/dist/migration/code-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generation.d.ts","sourceRoot":"","sources":["../../src/migration/code-generation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAKjC,OAAO,EAEL,KAAK,gBAAgB,EAGrB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAqhDxB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;SAG/E,cAAc,EAAE;UACf,cAAc,EAAE;EAuC/B;AAWD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAoB/E;AAuHD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7F;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,IAAI,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0G7B"}
+{"version":3,"file":"code-generation.d.ts","sourceRoot":"","sources":["../../src/migration/code-generation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAKjC,OAAO,EAEL,KAAK,gBAAgB,EAGrB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AA6hDxB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;SAG/E,cAAc,EAAE;UACf,cAAc,EAAE;EAyC/B;AAWD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAsB/E;AA0LD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7F;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,IAAI,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0G7B"}