sonamu 0.8.13 → 0.8.14

package/dist/database/puri.js

@@ -3,6 +3,15 @@ import chalk from "chalk";
 import inflection from "inflection";
 import { EntityManager } from "../entity/entity-manager.js";
 import { Naite } from "../naite/naite.js";
+import { FUZZY_OPERATORS } from "./puri.types.js";
+function normalizeFuzzyOperator(operator) {
+    const normalized = operator?.trim() ?? "<%";
+    const fuzzyOperator = FUZZY_OPERATORS.find((candidate)=>candidate === normalized);
+    if (!fuzzyOperator) {
+        throw new Error(`Invalid fuzzy operator: ${operator ?? ""}`);
+    }
+    return fuzzyOperator;
+}
 export class Puri {
     knex;
     knexQuery;
@@ -99,6 +108,24 @@ export class Puri {
             _sql: `LOWER(${column})`
         };
     }
+    static escapeSqlLiteral(value) {
+        return value.replaceAll("'", "''");
+    }
+    static toTextOperand(column) {
+        if (typeof column === "object" && column._type === "sql_expression") {
+            return `(${column._sql})::text`;
+        }
+        return `${column}::text`;
+    }
+    static wordSimilarity(column, query) {
+        return Puri.rawNumber(`word_similarity('${Puri.escapeSqlLiteral(query)}'::text, ${Puri.toTextOperand(column)})`);
+    }
+    static similarity(column, query) {
+        return Puri.rawNumber(`similarity(${Puri.toTextOperand(column)}, '${Puri.escapeSqlLiteral(query)}'::text)`);
+    }
+    static strictWordSimilarity(column, query) {
+        return Puri.rawNumber(`strict_word_similarity('${Puri.escapeSqlLiteral(query)}'::text, ${Puri.toTextOperand(column)})`);
+    }
     // Raw functions for SELECT
     static rawString(sql) {
         return {
@@ -429,6 +456,20 @@ export class Puri {
         ]);
         return this;
     }
+    whereFuzzy(column, value, options) {
+        const operator = normalizeFuzzyOperator(options?.operator);
+        const textColumnExpr = Puri.toTextOperand(column);
+        if (operator === "%") {
+            this.knexQuery.whereRaw(`${textColumnExpr} ${operator} ?::text`, [
+                value
+            ]);
+            return this;
+        }
+        this.knexQuery.whereRaw(`?::text ${operator} ${textColumnExpr}`, [
+            value
+        ]);
+        return this;
+    }
     // WHERE RAW
     whereRaw(sql, bindings) {
         this.knexQuery.whereRaw(sql, bindings);
@@ -931,4 +972,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 inflection from \"inflection\";\nimport type { Knex } from \"knex\";\nimport { EntityManager, type TableSpec } from \"../entity/entity-manager\";\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  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(${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  // DISTINCT\n  distinct<TColumns extends AvailableColumns<TTables>>(...columns: TColumns[]): this;\n  distinct(...columns: string[]): this {\n    this.knexQuery.distinct(...(columns as string[]));\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  // 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      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 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  // 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  // 중첩 그룹\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"],"names":["assert","chalk","inflection","EntityManager","Naite","Puri","knexQuery","tableSpec","knex","tableNameOrSource","from","safeGetTableSpec","entries","Object","length","Error","alias","source","subqueryBuilder","rawQuery","as","tableName","getTableSpec","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","distinct","columns","clear","statement","clearJoin","_statements","filter","s","_alias","_table","table","tableNameOrSpec","__commonJoin","leftJoin","joinType","callback","joinClause","JoinClauseGroup","left","right","spec","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","distinctOn","some","v","Number","isFinite","vectorLiteral","JSON","stringify","operator","cosine","l2","inner_product","similarityExpr","existingSubsetCols","grouping","flatMap","col","orderByRaw","thresholdOp","thresholdValue","limit","offset","groupBy","having","conditions","then","onfulfilled","onrejected","t","toQuery","catch","finally","onfinally","first","ResolvedPuri","pluck","insert","rawData","refinedData","refineJsonColumns","update","data","jsonColumns","item","undefined","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","orWhereIn","orWhereNotIn","subBuilder","subGroup","on","orOn","onVal","andOnVal","orOnVal","Symbol","toStringTag","onConflict","action","target","ignore","merge","mergeObj","returning"],"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 { EntityManager, type TableSpec } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport type {\n  AvailableColumns,\n  ColumnKeys,\n  ComparisonOperator,\n  Expand,\n  ExtractColumnType,\n  FulltextColumns,\n  FuzzyOperator,\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 { FUZZY_OPERATORS } from \"./puri.types\";\nimport type { ClearStatements } from \"./puri-subset.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(${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  private static escapeSqlLiteral(value: string): string {\n    return value.replaceAll(\"'\", \"''\");\n  }\n\n  private static toTextOperand(column: string | SqlExpression<\"string\">): string {\n    if (typeof column === \"object\" && column._type === \"sql_expression\") {\n      return `(${column._sql})::text`;\n    }\n\n    return `${column}::text`;\n  }\n\n  static wordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    return Puri.rawNumber(\n      `word_similarity('${Puri.escapeSqlLiteral(query)}'::text, ${Puri.toTextOperand(column)})`,\n    );\n  }\n\n  static similarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    return Puri.rawNumber(\n      `similarity(${Puri.toTextOperand(column)}, '${Puri.escapeSqlLiteral(query)}'::text)`,\n    );\n  }\n\n  static strictWordSimilarity(\n    column: string | SqlExpression<\"string\">,\n    query: string,\n  ): SqlExpression<\"number\"> {\n    return Puri.rawNumber(\n      `strict_word_similarity('${Puri.escapeSqlLiteral(query)}'::text, ${Puri.toTextOperand(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  // DISTINCT\n  distinct<TColumns extends AvailableColumns<TTables>>(...columns: TColumns[]): this;\n  distinct(...columns: string[]): this {\n    this.knexQuery.distinct(...(columns as string[]));\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    const textColumnExpr = Puri.toTextOperand(column);\n\n    if (operator === \"%\") {\n      this.knexQuery.whereRaw(`${textColumnExpr} ${operator} ?::text`, [value]);\n      return this;\n    }\n\n    this.knexQuery.whereRaw(`?::text ${operator} ${textColumnExpr}`, [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      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 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  // 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  // 중첩 그룹\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"],"names":["assert","chalk","inflection","EntityManager","Naite","FUZZY_OPERATORS","normalizeFuzzyOperator","operator","normalized","trim","fuzzyOperator","find","candidate","Error","Puri","knexQuery","tableSpec","knex","tableNameOrSource","from","safeGetTableSpec","entries","Object","length","alias","source","subqueryBuilder","rawQuery","as","tableName","getTableSpec","count","column","_type","_return","_sql","sum","avg","max","min","concat","args","join","upper","lower","escapeSqlLiteral","value","replaceAll","toTextOperand","wordSimilarity","query","rawNumber","similarity","strictWordSimilarity","rawString","sql","rawStringArray","rawBoolean","rawDate","tsHighlight","_options","parser","config","options","hlOptionParts","map","key","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","distinct","columns","clear","statement","clearJoin","_statements","filter","s","_alias","_table","table","tableNameOrSpec","__commonJoin","leftJoin","joinType","callback","joinClause","JoinClauseGroup","left","right","spec","where","columnOrConditions","operatorOrValue","whereNull","whereNotNull","whereIn","values","whereNotIn","whereMatch","whereRaw","String","whereSearch","columnExpr","c","pgroongaCondition","whereTsSearch","opts","whereFuzzy","textColumnExpr","bindings","whereGroup","builder","group","WhereGroup","orWhereGroup","orWhere","orderBy","direction","vectorSimilarity","embedding","method","threshold","distinctOn","some","v","Number","isFinite","vectorLiteral","JSON","stringify","cosine","l2","inner_product","similarityExpr","existingSubsetCols","grouping","flatMap","col","orderByRaw","thresholdOp","thresholdValue","limit","offset","groupBy","having","conditions","then","onfulfilled","onrejected","t","toQuery","catch","finally","onfinally","first","ResolvedPuri","pluck","insert","rawData","refinedData","refineJsonColumns","update","data","jsonColumns","item","undefined","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","closingParens","match","openingParens","Math","indent","repeat","slice","orWhereIn","orWhereNotIn","subBuilder","subGroup","on","orOn","onVal","andOnVal","orOnVal","Symbol","toStringTag","onConflict","action","target","ignore","merge","mergeObj","returning"],"mappings":"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"}

package/dist/database/puri.types.d.ts

@@ -70,6 +70,8 @@ export type FulltextColumns<TTables extends Record<string, any>> = {
 }[keyof TTables];
 export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
 export type WhereOperator = ComparisonOperator | "like" | "not like" | "ilike" | "not ilike";
+export declare const FUZZY_OPERATORS: readonly ["<%", "%", "<<%"];
+export type FuzzyOperator = (typeof FUZZY_OPERATORS)[number];
 export type SqlExpression<T extends "string" | "number" | "boolean" | "date" | "string[]"> = {
     _type: "sql_expression";
     _return: T;

package/dist/database/puri.types.d.ts.map

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