sonamu 0.7.11 → 0.7.12

package/dist/database/puri.js

@@ -1,5 +1,6 @@
 /** biome-ignore-all lint/suspicious/noThenProperty: Puri는 thenable 인터페이스를 구현하고 있습니다. */ /** biome-ignore-all lint/suspicious/noExplicitAny: Puri는 다양한 타입을 사용하고 있습니다. */ import assert from "assert";
 import chalk from "chalk";
+import inflection from "inflection";
 import { Naite } from "../naite/naite.js";
 export class Puri {
     knex;
@@ -95,6 +96,13 @@ export class Puri {
             _sql: sql
         };
     }
+    static rawStringArray(sql) {
+        return {
+            _type: "sql_expression",
+            _return: "string[]",
+            _sql: sql
+        };
+    }
     static rawNumber(sql) {
         return {
             _type: "sql_expression",
@@ -128,21 +136,50 @@ export class Puri {
    *     maxFragments: 3,
    *   }),
    * })
-   */ static highlight(column, query, options) {
-        const { parser = "websearch_to_tsquery", config = "simple", maxWords, minWords, shortWord, highlightAll, maxFragments, startSel, stopSel, fragmentDelimiter } = options ?? {};
-        const hlOptionParts = [];
-        if (maxWords !== undefined) hlOptionParts.push(`MaxWords=${maxWords}`);
-        if (minWords !== undefined) hlOptionParts.push(`MinWords=${minWords}`);
-        if (shortWord !== undefined) hlOptionParts.push(`ShortWord=${shortWord}`);
-        if (highlightAll !== undefined) hlOptionParts.push(`HighlightAll=${highlightAll}`);
-        if (maxFragments !== undefined) hlOptionParts.push(`MaxFragments=${maxFragments}`);
-        if (startSel !== undefined) hlOptionParts.push(`StartSel="${startSel}"`);
-        if (stopSel !== undefined) hlOptionParts.push(`StopSel="${stopSel}"`);
-        if (fragmentDelimiter !== undefined) hlOptionParts.push(`FragmentDelimiter="${fragmentDelimiter}"`);
+   */ static tsHighlight(column, query, _options) {
+        const { parser = "websearch_to_tsquery", config = "simple", ...options } = _options ?? {};
+        const hlOptionParts = Object.entries(options).map(([key, value])=>{
+            return `${inflection.camelize(key)}=${value}`;
+        });
         const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(", ")}'` : "";
         // TODO: rawBinding 메서드 만들어서 XSS 방지
         return Puri.rawString(`ts_headline('${config}', ${column}, ${parser}('${config}', '${query}')${hlOptions})`);
     }
+    // ts_rank
+    static tsRank(column, query, options) {
+        return Puri._tsRank("ts_rank", column, query, options);
+    }
+    // ts_rank_cd
+    static tsRankCd(column, query, options) {
+        return Puri._tsRank("ts_rank_cd", column, query, options);
+    }
+    static _tsRank(type, column, query, options) {
+        const { parser = "websearch_to_tsquery", config = "simple", normalization, weights } = options ?? {};
+        const weightClause = weights ? `ARRAY[${weights.join(", ")}], ` : "";
+        const normalizationClause = normalization ? `, ${normalization}` : "";
+        return Puri.rawNumber(`${type}(${weightClause}${column}, ${parser}('${config}', '${query}')${normalizationClause})`);
+    }
+    /**
+   * PGroonga FullText 인덱스 검색 점수
+   *
+   * @example
+   * .select({
+   *   score: Puri.score(),
+   * })
+   */ static score() {
+        return Puri.rawNumber("pgroonga_score(tableoid, ctid)");
+    }
+    static highlight(columnOrColumns, query) {
+        const queryClause = `ARRAY[${(Array.isArray(query) ? query : [
+            query
+        ]).map((q)=>`'${q}'`).join(",")}]`;
+        // 단일 컬럼인 경우
+        if (typeof columnOrColumns === "string") {
+            return Puri.rawString(`pgroonga_highlight_html(${columnOrColumns}, ${queryClause})`);
+        }
+        // 컬럼 배열인 경우
+        return Puri.rawStringArray(`pgroonga_highlight_html(ARRAY[${columnOrColumns.join(",")}], ${queryClause})`);
+    }
     // SELECT (overwrite)
     select(selectObj) {
         // 중첩 객체를 flat하게 변환
@@ -151,7 +188,7 @@ export class Puri {
         for (const [alias, columnOrFunction] of Object.entries(flatSelect)){
             if (typeof columnOrFunction === "object" && columnOrFunction._type === "sql_expression") {
                 // SQL 함수인 경우
-                selectClauses.push(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));
+                selectClauses.push(this.knex.raw(`${columnOrFunction._sql} as "${alias}"`));
             } else {
                 // 일반 컬럼인 경우
                 const columnPath = columnOrFunction;
@@ -341,8 +378,30 @@ export class Puri {
         ]);
         return this;
     }
+    /**
+   * PGroonga FullText 인덱스 검색
+   * - 사용할 PGroonga 인덱스와 동일한 컬럼 구성으로 검색해야 인덱스가 사용됩니다.
+   *
+   * 단일 컬럼 검색:
+   * ```sql
+   * WHERE name &@~ 'search'
+   * ```
+   *
+   * 복합 컬럼 검색:
+   * ```sql
+   * WHERE ARRAY[name::text, description::text] &@~ 'search'
+   * ```
+   */ whereSearch(column, value, options) {
+        const { weights } = options ?? {};
+        const columnExpr = Array.isArray(column) ? `ARRAY[${column.map((c)=>`${c}::text`).join(",")}]` : column;
+        const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(",")}]` : ""})`;
+        this.knexQuery.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [
+            value
+        ]);
+        return this;
+    }
     // WHERE FULLTEXT
-    whereSearch(column, value, options) {
+    whereTsSearch(column, value, options) {
         const opts = typeof options === "string" ? {
             config: options
         } : options ?? {};
@@ -379,6 +438,113 @@ export class Puri {
         this.knexQuery.orderBy(column, direction);
         return this;
     }
+    /**
+   * 벡터 유사도 검색 설정
+   *
+   * - SELECT에 similarity 컬럼 추가
+   * - WHERE col IS NOT NULL 추가
+   * - threshold가 있으면 WHERE 조건 추가
+   * - 기존 ORDER BY를 clear하고 원시 연산자로 정렬 (HNSW 인덱스 최적화)
+   *
+   * @param column 벡터 컬럼 경로
+   * @param embedding 쿼리 임베딩 벡터
+   * @param options method, threshold, as 등 옵션
+   *
+   * @example
+   * ```typescript
+   * // cosine similarity (기본값)
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "cosine",
+   *   threshold: 0.5
+   * });
+   *
+   * // L2 distance
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "l2",
+   *   threshold: 1.5  // 거리가 1.5 이하인 결과만
+   * });
+   *
+   * // Inner product
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "inner_product",
+   *   threshold: 0.7
+   * });
+   * ```
+   */ vectorSimilarity(column, embedding, options = {}) {
+        const { method = "cosine", threshold } = options;
+        if (!Array.isArray(embedding) || embedding.length === 0 || embedding.some((v)=>!Number.isFinite(v))) {
+            throw new Error("Invalid embedding vector: expected a non-empty array of finite numbers");
+        }
+        const vectorLiteral = JSON.stringify(embedding.map((v)=>Number(v)));
+        // method별 연산자 및 similarity 계산식
+        // - cosine: <=> (cosine distance, 0~2), similarity = 1 - distance
+        // - l2: <-> (euclidean distance), similarity = distance (낮을수록 유사)
+        // - inner_product: <#> (negative inner product), similarity = -distance (높을수록 유사)
+        const operatorMap = {
+            cosine: "<=>",
+            l2: "<->",
+            inner_product: "<#>"
+        };
+        const operator = operatorMap[method];
+        // SELECT에 similarity 추가
+        if (method === "cosine") {
+            // cosine: similarity = 1 - cosine_distance (0~1, 높을수록 유사)
+            this.knexQuery.select(this.knex.raw(`1 - (?? <=> ?::vector) as similarity`, [
+                column,
+                vectorLiteral
+            ]));
+        } else if (method === "l2") {
+            // l2: distance 그대로 반환 (낮을수록 유사)
+            this.knexQuery.select(this.knex.raw(`?? <-> ?::vector as similarity`, [
+                column,
+                vectorLiteral
+            ]));
+        } else {
+            // inner_product: pgvector는 음수 반환하므로 부호 반전 (높을수록 유사)
+            this.knexQuery.select(this.knex.raw(`-(?? <#> ?::vector) as similarity`, [
+                column,
+                vectorLiteral
+            ]));
+        }
+        // WHERE col IS NOT NULL
+        this.knexQuery.whereNotNull(column);
+        // threshold가 있으면 WHERE 추가
+        if (typeof threshold === "number") {
+            if (!Number.isFinite(threshold)) {
+                throw new Error(`Invalid vectorSimilarity threshold: ${threshold}`);
+            }
+            if (method === "cosine") {
+                // similarity >= threshold  <=>  cosine_distance <= (1 - threshold)
+                this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+                    column,
+                    vectorLiteral,
+                    1 - threshold
+                ]);
+            } else if (method === "l2") {
+                // distance <= threshold (거리가 threshold 이하)
+                this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+                    column,
+                    vectorLiteral,
+                    threshold
+                ]);
+            } else {
+                // inner_product: -distance >= threshold  <=>  distance <= -threshold
+                this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+                    column,
+                    vectorLiteral,
+                    -threshold
+                ]);
+            }
+        }
+        // 기존 ORDER BY clear 후 원시 연산자로 정렬 (HNSW 인덱스 최적화)
+        // 모든 method에서 ASC: 거리/음수값이 작을수록 유사
+        this.knexQuery.clear("order");
+        this.knexQuery.orderByRaw(`?? ${operator} ?::vector`, [
+            column,
+            vectorLiteral
+        ]);
+        return this;
+    }
     // 기본 쿼리 메서드들
     limit(count) {
         if (count < 0) {
@@ -691,4 +857,4 @@ export class JoinClauseGroup {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/puri.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noThenProperty: Puri는 thenable 인터페이스를 구현하고 있습니다. */\n/** biome-ignore-all lint/suspicious/noExplicitAny: Puri는 다양한 타입을 사용하고 있습니다. */\n\nimport assert from \"assert\";\nimport chalk from \"chalk\";\nimport type { Knex } from \"knex\";\nimport { Naite } from \"../naite/naite\";\nimport type {\n  AvailableColumns,\n  ColumnKeys,\n  ComparisonOperator,\n  Expand,\n  ExtractColumnType,\n  FulltextColumns,\n  HighlightOptions,\n  InsertData,\n  InsertResult,\n  LeftJoinedMarker,\n  LeftJoinMarkerFor,\n  NumericColumns,\n  OnConflictAction,\n  ParseSelectObject,\n  ResultAvailableColumns,\n  SelectAllResult,\n  SelectObject,\n  SingleTableValue,\n  SqlExpression,\n  TsQueryConfig,\n  TsQueryOptions,\n  WhereCondition,\n  WhereOperator,\n} from \"./puri.types\";\nimport type { ClearStatements } from \"./puri-subset.types\";\n\nexport class Puri<TSchema, TTables extends Record<string, any>, TResult> {\n  private knexQuery: Knex.QueryBuilder;\n\n  // 생성자 시그니처들\n  constructor(knex: Knex, tableName: string);\n  constructor(knex: Knex, tableSpec: Record<string, string | Puri<TSchema, any, any>>);\n  constructor(\n    public knex: Knex,\n    tableNameOrSpec: any,\n  ) {\n    if (typeof tableNameOrSpec === \"string\") {\n      // Case: new Puri(knex, \"users\")\n      this.knexQuery = this.knex(tableNameOrSpec).from(tableNameOrSpec);\n    } else if (typeof tableNameOrSpec === \"object\") {\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[0];\n      if (typeof spec === \"string\") {\n        this.knexQuery = this.knex(spec).from({ [alias]: spec });\n      } else if (spec instanceof Puri) {\n        const subqueryBuilder = spec.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  // 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(${column})::integer`,\n    };\n  }\n  static sum(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `SUM(${column})`,\n    };\n  }\n  static avg(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `AVG(${column})`,\n    };\n  }\n  static max(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MAX(${column})`,\n    };\n  }\n  static min(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MIN(${column})`,\n    };\n  }\n  static concat(...args: string[]): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `CONCAT(${args.join(\", \")})`,\n    };\n  }\n  static upper(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `UPPER(${column})`,\n    };\n  }\n  static lower(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `LOWER(${column})`,\n    };\n  }\n\n  // Raw functions for SELECT\n  static rawString(sql: string): SqlExpression<\"string\"> {\n    return { _type: \"sql_expression\", _return: \"string\", _sql: sql };\n  }\n  static rawNumber(sql: string): SqlExpression<\"number\"> {\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sql };\n  }\n  static rawBoolean(sql: string): SqlExpression<\"boolean\"> {\n    return { _type: \"sql_expression\", _return: \"boolean\", _sql: sql };\n  }\n  static rawDate(sql: string): SqlExpression<\"date\"> {\n    return { _type: \"sql_expression\", _return: \"date\", _sql: sql };\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 highlight(\n    column: string,\n    query: string,\n    options?: HighlightOptions,\n  ): SqlExpression<\"string\"> {\n    const {\n      parser = \"websearch_to_tsquery\",\n      config = \"simple\",\n      maxWords,\n      minWords,\n      shortWord,\n      highlightAll,\n      maxFragments,\n      startSel,\n      stopSel,\n      fragmentDelimiter,\n    } = options ?? {};\n\n    const hlOptionParts: string[] = [];\n\n    if (maxWords !== undefined) hlOptionParts.push(`MaxWords=${maxWords}`);\n    if (minWords !== undefined) hlOptionParts.push(`MinWords=${minWords}`);\n    if (shortWord !== undefined) hlOptionParts.push(`ShortWord=${shortWord}`);\n    if (highlightAll !== undefined) hlOptionParts.push(`HighlightAll=${highlightAll}`);\n    if (maxFragments !== undefined) hlOptionParts.push(`MaxFragments=${maxFragments}`);\n    if (startSel !== undefined) hlOptionParts.push(`StartSel=\"${startSel}\"`);\n    if (stopSel !== undefined) hlOptionParts.push(`StopSel=\"${stopSel}\"`);\n    if (fragmentDelimiter !== undefined)\n      hlOptionParts.push(`FragmentDelimiter=\"${fragmentDelimiter}\"`);\n\n    const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(\", \")}'` : \"\";\n\n    // TODO: rawBinding 메서드 만들어서 XSS 방지\n    return Puri.rawString(\n      `ts_headline('${config}', ${column}, ${parser}('${config}', '${query}')${hlOptions})`,\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(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));\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(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));\n      } else {\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          selectClauses.push(columnPath);\n        } else {\n          selectClauses.push(`${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  // 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: ComparisonOperator | \"like\" | \"not like\",\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>(\n    column: TColumn,\n    operator: ComparisonOperator | \"like\" | \"not like\",\n    value: any,\n  ): 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  // WHERE FULLTEXT\n  whereSearch<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  // WHERE RAW\n  whereRaw(sql: string, bindings?: readonly unknown[]): 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\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    direction: \"asc\" | \"desc\",\n  ): this;\n  orderBy(column: string, direction: \"asc\" | \"desc\" = \"asc\"): this {\n    this.knexQuery.orderBy(column, direction);\n    return this;\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 as string[]));\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    this.knexQuery.insert(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // UPDATE\n  update(data: WhereCondition<TTables>): ResolvedPuri<number, SingleTableValue<TTables>> {\n    this.knexQuery.update(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\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  // 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  // 중첩 그룹\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\n/*\n  TResolved: 쿼리 실행 후 반환될 결과 타입\n  TReturning: RETURNING 절에 사용될 타입\n*/\nexport class ResolvedPuri<TResolved, TReturning> {\n  constructor(\n    public knexQuery: Knex.QueryBuilder,\n    private knex: Knex,\n  ) {}\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  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResolved | TResult2> {\n    return this.knexQuery.catch(onrejected);\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"],"names":["assert","chalk","Naite","Puri","knexQuery","knex","tableNameOrSpec","from","entries","Object","length","Error","alias","spec","subqueryBuilder","rawQuery","as","count","column","_type","_return","_sql","sum","avg","max","min","concat","args","join","upper","lower","rawString","sql","rawNumber","rawBoolean","rawDate","highlight","query","options","parser","config","maxWords","minWords","shortWord","highlightAll","maxFragments","startSel","stopSel","fragmentDelimiter","hlOptionParts","undefined","push","hlOptions","select","selectObj","flatSelect","flattenSelect","selectClauses","columnOrFunction","raw","columnPath","prefix","key","value","fullKey","nested","assign","appendSelect","selectAll","clear","statement","clearJoin","_statements","filter","s","_alias","_table","table","__commonJoin","leftJoin","joinType","tableName","callback","joinClause","JoinClauseGroup","left","right","where","columnOrConditions","operatorOrValue","whereNull","whereNotNull","whereIn","values","whereNotIn","whereMatch","whereRaw","String","whereSearch","opts","columnExpr","bindings","whereGroup","builder","group","WhereGroup","orWhereGroup","orWhere","orderBy","direction","limit","offset","groupBy","columns","having","conditions","then","onfulfilled","onrejected","t","toQuery","catch","finally","onfinally","first","ResolvedPuri","pluck","insert","data","update","increment","decrement","delete","debug","console","log","cyan","yellow","clone","newPuri","formatSQL","unformatted","keywords","formatted","forEach","keyword","regex","RegExp","replace","toUpperCase","majorClauses","clause","lines","split","indentedLines","indentLevel","line","trimmedLine","trim","closingParens","match","openingParens","Math","indent","repeat","slice","subBuilder","subGroup","on","orOn","onConflict","action","target","Array","isArray","ignore","merge","mergeObj","returning","columnOrColumns"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/puri.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noThenProperty: Puri는 thenable 인터페이스를 구현하고 있습니다. */\n/** biome-ignore-all lint/suspicious/noExplicitAny: Puri는 다양한 타입을 사용하고 있습니다. */\n\nimport assert from \"assert\";\nimport chalk from \"chalk\";\nimport inflection from \"inflection\";\nimport type { Knex } from \"knex\";\nimport { Naite } from \"../naite/naite\";\nimport type {\n  AvailableColumns,\n  ColumnKeys,\n  ComparisonOperator,\n  Expand,\n  ExtractColumnType,\n  FulltextColumns,\n  InsertData,\n  InsertResult,\n  LeftJoinedMarker,\n  LeftJoinMarkerFor,\n  NumericColumns,\n  OnConflictAction,\n  ParseSelectObject,\n  ResultAvailableColumns,\n  SelectAllResult,\n  SelectObject,\n  SingleTableValue,\n  SqlExpression,\n  TsHighlightOptions,\n  TsQueryConfig,\n  TsQueryOptions,\n  TsRankOptions,\n  VectorColumns,\n  WhereCondition,\n  WhereOperator,\n} from \"./puri.types\";\nimport type { ClearStatements } from \"./puri-subset.types\";\n\nexport class Puri<TSchema, TTables extends Record<string, any>, TResult> {\n  private knexQuery: Knex.QueryBuilder;\n\n  // 생성자 시그니처들\n  constructor(knex: Knex, tableName: string);\n  constructor(knex: Knex, tableSpec: Record<string, string | Puri<TSchema, any, any>>);\n  constructor(\n    public knex: Knex,\n    tableNameOrSpec: any,\n  ) {\n    if (typeof tableNameOrSpec === \"string\") {\n      // Case: new Puri(knex, \"users\")\n      this.knexQuery = this.knex(tableNameOrSpec).from(tableNameOrSpec);\n    } else if (typeof tableNameOrSpec === \"object\") {\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[0];\n      if (typeof spec === \"string\") {\n        this.knexQuery = this.knex(spec).from({ [alias]: spec });\n      } else if (spec instanceof Puri) {\n        const subqueryBuilder = spec.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  // 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(${column})::integer`,\n    };\n  }\n  static sum(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `SUM(${column})`,\n    };\n  }\n  static avg(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `AVG(${column})`,\n    };\n  }\n  static max(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MAX(${column})`,\n    };\n  }\n  static min(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MIN(${column})`,\n    };\n  }\n  static concat(...args: string[]): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `CONCAT(${args.join(\", \")})`,\n    };\n  }\n  static upper(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `UPPER(${column})`,\n    };\n  }\n  static lower(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `LOWER(${column})`,\n    };\n  }\n\n  // Raw functions for SELECT\n  static rawString(sql: string): SqlExpression<\"string\"> {\n    return { _type: \"sql_expression\", _return: \"string\", _sql: sql };\n  }\n  static rawStringArray(sql: string): SqlExpression<\"string[]\"> {\n    return { _type: \"sql_expression\", _return: \"string[]\", _sql: sql };\n  }\n  static rawNumber(sql: string): SqlExpression<\"number\"> {\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sql };\n  }\n  static rawBoolean(sql: string): SqlExpression<\"boolean\"> {\n    return { _type: \"sql_expression\", _return: \"boolean\", _sql: sql };\n  }\n  static rawDate(sql: string): SqlExpression<\"date\"> {\n    return { _type: \"sql_expression\", _return: \"date\", _sql: sql };\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    // TODO: rawBinding 메서드 만들어서 XSS 방지\n    return Puri.rawString(\n      `ts_headline('${config}', ${column}, ${parser}('${config}', '${query}')${hlOptions})`,\n    );\n  }\n\n  // ts_rank\n  static tsRank(column: string, query: string, options?: TsRankOptions): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank\", column, query, options);\n  }\n\n  // ts_rank_cd\n  static tsRankCd(column: string, query: string, options?: TsRankOptions): SqlExpression<\"number\"> {\n    return Puri._tsRank(\"ts_rank_cd\", column, query, options);\n  }\n\n  static _tsRank(\n    type: \"ts_rank\" | \"ts_rank_cd\",\n    column: string,\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 weightClause = weights ? `ARRAY[${weights.join(\", \")}], ` : \"\";\n    const normalizationClause = normalization ? `, ${normalization}` : \"\";\n\n    return Puri.rawNumber(\n      `${type}(${weightClause}${column}, ${parser}('${config}', '${query}')${normalizationClause})`,\n    );\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 queryClause = `ARRAY[${(Array.isArray(query) ? query : [query]).map((q) => `'${q}'`).join(\",\")}]`;\n\n    // 단일 컬럼인 경우\n    if (typeof columnOrColumns === \"string\") {\n      return Puri.rawString(`pgroonga_highlight_html(${columnOrColumns}, ${queryClause})`);\n    }\n\n    // 컬럼 배열인 경우\n    return Puri.rawStringArray(\n      `pgroonga_highlight_html(ARRAY[${columnOrColumns.join(\",\")}], ${queryClause})`,\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(this.knex.raw(`${columnOrFunction._sql} as \"${alias}\"`));\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(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));\n      } else {\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          selectClauses.push(columnPath);\n        } else {\n          selectClauses.push(`${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  // 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: ComparisonOperator | \"like\" | \"not like\",\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>(\n    column: TColumn,\n    operator: ComparisonOperator | \"like\" | \"not like\",\n    value: any,\n  ): 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  // WHERE RAW\n  whereRaw(sql: string, bindings?: readonly unknown[]): 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\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    direction: \"asc\" | \"desc\",\n  ): this;\n  orderBy(column: string, direction: \"asc\" | \"desc\" = \"asc\"): this {\n    this.knexQuery.orderBy(column, direction);\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    } = {},\n  ): Puri<TSchema, TTables, TResult & { similarity: number }> {\n    const { method = \"cosine\", threshold } = options;\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    const vectorLiteral = JSON.stringify(embedding.map((v) => Number(v)));\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 operatorMap = {\n      cosine: \"<=>\",\n      l2: \"<->\",\n      inner_product: \"<#>\",\n    } as const;\n    const operator = operatorMap[method];\n\n    // SELECT에 similarity 추가\n    if (method === \"cosine\") {\n      // cosine: similarity = 1 - cosine_distance (0~1, 높을수록 유사)\n      this.knexQuery.select(\n        this.knex.raw(`1 - (?? <=> ?::vector) as similarity`, [column, vectorLiteral]),\n      );\n    } else if (method === \"l2\") {\n      // l2: distance 그대로 반환 (낮을수록 유사)\n      this.knexQuery.select(\n        this.knex.raw(`?? <-> ?::vector as similarity`, [column, vectorLiteral]),\n      );\n    } else {\n      // inner_product: pgvector는 음수 반환하므로 부호 반전 (높을수록 유사)\n      this.knexQuery.select(\n        this.knex.raw(`-(?? <#> ?::vector) as similarity`, [column, vectorLiteral]),\n      );\n    }\n\n    // WHERE col IS NOT NULL\n    this.knexQuery.whereNotNull(column);\n\n    // threshold가 있으면 WHERE 추가\n    if (typeof threshold === \"number\") {\n      if (!Number.isFinite(threshold)) {\n        throw new Error(`Invalid vectorSimilarity threshold: ${threshold}`);\n      }\n\n      if (method === \"cosine\") {\n        // similarity >= threshold  <=>  cosine_distance <= (1 - threshold)\n        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [\n          column,\n          vectorLiteral,\n          1 - threshold,\n        ]);\n      } else if (method === \"l2\") {\n        // distance <= threshold (거리가 threshold 이하)\n        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [\n          column,\n          vectorLiteral,\n          threshold,\n        ]);\n      } else {\n        // inner_product: -distance >= threshold  <=>  distance <= -threshold\n        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [\n          column,\n          vectorLiteral,\n          -threshold,\n        ]);\n      }\n    }\n\n    // 기존 ORDER BY clear 후 원시 연산자로 정렬 (HNSW 인덱스 최적화)\n    // 모든 method에서 ASC: 거리/음수값이 작을수록 유사\n    this.knexQuery.clear(\"order\");\n    this.knexQuery.orderByRaw(`?? ${operator} ?::vector`, [column, vectorLiteral]);\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 as string[]));\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    this.knexQuery.insert(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // UPDATE\n  update(data: WhereCondition<TTables>): ResolvedPuri<number, SingleTableValue<TTables>> {\n    this.knexQuery.update(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\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  // 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  // 중첩 그룹\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\n/*\n  TResolved: 쿼리 실행 후 반환될 결과 타입\n  TReturning: RETURNING 절에 사용될 타입\n*/\nexport class ResolvedPuri<TResolved, TReturning> {\n  constructor(\n    public knexQuery: Knex.QueryBuilder,\n    private knex: Knex,\n  ) {}\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  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResolved | TResult2> {\n    return this.knexQuery.catch(onrejected);\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"],"names":["assert","chalk","inflection","Naite","Puri","knexQuery","knex","tableNameOrSpec","from","entries","Object","length","Error","alias","spec","subqueryBuilder","rawQuery","as","count","column","_type","_return","_sql","sum","avg","max","min","concat","args","join","upper","lower","rawString","sql","rawStringArray","rawNumber","rawBoolean","rawDate","tsHighlight","query","_options","parser","config","options","hlOptionParts","map","key","value","camelize","hlOptions","tsRank","_tsRank","tsRankCd","type","normalization","weights","weightClause","normalizationClause","score","highlight","columnOrColumns","queryClause","Array","isArray","q","select","selectObj","flatSelect","flattenSelect","selectClauses","columnOrFunction","push","raw","columnPath","prefix","fullKey","nested","assign","appendSelect","selectAll","clear","statement","clearJoin","_statements","filter","s","_alias","_table","table","__commonJoin","leftJoin","joinType","tableName","callback","joinClause","JoinClauseGroup","left","right","where","columnOrConditions","operatorOrValue","whereNull","whereNotNull","whereIn","values","whereNotIn","whereMatch","whereRaw","String","whereSearch","columnExpr","c","pgroongaCondition","whereTsSearch","opts","bindings","whereGroup","builder","group","WhereGroup","orWhereGroup","orWhere","orderBy","direction","vectorSimilarity","embedding","method","threshold","some","v","Number","isFinite","vectorLiteral","JSON","stringify","operatorMap","cosine","l2","inner_product","operator","orderByRaw","limit","offset","groupBy","columns","having","conditions","then","onfulfilled","onrejected","t","toQuery","catch","finally","onfinally","first","ResolvedPuri","pluck","insert","data","update","increment","decrement","delete","debug","console","log","cyan","yellow","clone","newPuri","formatSQL","unformatted","keywords","formatted","forEach","keyword","regex","RegExp","replace","toUpperCase","majorClauses","clause","lines","split","indentedLines","indentLevel","line","trimmedLine","trim","closingParens","match","openingParens","Math","indent","repeat","slice","subBuilder","subGroup","on","orOn","onConflict","action","target","ignore","merge","mergeObj","returning"],"mappings":"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"}