sonamu 0.5.7 → 0.7.0

package/dist/database/puri.js

@@ -1,2 +1,601 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get JoinClauseGroup(){return JoinClauseGroup},get Puri(){return Puri},get WhereGroup(){return WhereGroup}});var _chalk=/*#__PURE__*/_interop_require_default(require("chalk"));var _assert=/*#__PURE__*/_interop_require_default(require("assert"));function _array_like_to_array(arr,len){if(len==null||len>arr.length)len=arr.length;for(var i=0,arr2=new Array(len);i<len;i++)arr2[i]=arr[i];return arr2}function _array_with_holes(arr){if(Array.isArray(arr))return arr}function _array_without_holes(arr){if(Array.isArray(arr))return _array_like_to_array(arr)}function asyncGeneratorStep(gen,resolve,reject,_next,_throw,key,arg){try{var info=gen[key](arg);var value=info.value}catch(error){reject(error);return}if(info.done){resolve(value)}else{Promise.resolve(value).then(_next,_throw)}}function _async_to_generator(fn){return function(){var self=this,args=arguments;return new Promise(function(resolve,reject){var gen=fn.apply(self,args);function _next(value){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"next",value)}function _throw(err){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"throw",err)}_next(undefined)})}}function _class_call_check(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError("Cannot call a class as a function")}}function _defineProperties(target,props){for(var i=0;i<props.length;i++){var descriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"in descriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor)}}function _create_class(Constructor,protoProps,staticProps){if(protoProps)_defineProperties(Constructor.prototype,protoProps);if(staticProps)_defineProperties(Constructor,staticProps);return Constructor}function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}function _instanceof(left,right){if(right!=null&&typeof Symbol!=="undefined"&&right[Symbol.hasInstance]){return!!right[Symbol.hasInstance](left)}else{return left instanceof right}}function _interop_require_default(obj){return obj&&obj.__esModule?obj:{default:obj}}function _iterable_to_array(iter){if(typeof Symbol!=="undefined"&&iter[Symbol.iterator]!=null||iter["@@iterator"]!=null)return Array.from(iter)}function _iterable_to_array_limit(arr,i){var _i=arr==null?null:typeof Symbol!=="undefined"&&arr[Symbol.iterator]||arr["@@iterator"];if(_i==null)return;var _arr=[];var _n=true;var _d=false;var _s,_e;try{for(_i=_i.call(arr);!(_n=(_s=_i.next()).done);_n=true){_arr.push(_s.value);if(i&&_arr.length===i)break}}catch(err){_d=true;_e=err}finally{try{if(!_n&&_i["return"]!=null)_i["return"]()}finally{if(_d)throw _e}}return _arr}function _non_iterable_rest(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _non_iterable_spread(){throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _sliced_to_array(arr,i){return _array_with_holes(arr)||_iterable_to_array_limit(arr,i)||_unsupported_iterable_to_array(arr,i)||_non_iterable_rest()}function _to_consumable_array(arr){return _array_without_holes(arr)||_iterable_to_array(arr)||_unsupported_iterable_to_array(arr)||_non_iterable_spread()}function _type_of(obj){"@swc/helpers - typeof";return obj&&typeof Symbol!=="undefined"&&obj.constructor===Symbol?"symbol":typeof obj}function _unsupported_iterable_to_array(o,minLen){if(!o)return;if(typeof o==="string")return _array_like_to_array(o,minLen);var n=Object.prototype.toString.call(o).slice(8,-1);if(n==="Object"&&o.constructor)n=o.constructor.name;if(n==="Map"||n==="Set")return Array.from(n);if(n==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return _array_like_to_array(o,minLen)}function _ts_generator(thisArg,body){var f,y,t,_={label:0,sent:function(){if(t[0]&1)throw t[1];return t[1]},trys:[],ops:[]},g=Object.create((typeof Iterator==="function"?Iterator:Object).prototype);return g.next=verb(0),g["throw"]=verb(1),g["return"]=verb(2),typeof Symbol==="function"&&(g[Symbol.iterator]=function(){return this}),g;function verb(n){return function(v){return step([n,v])}}function step(op){if(f)throw new TypeError("Generator is already executing.");while(g&&(g=0,op[0]&&(_=0)),_)try{if(f=1,y&&(t=op[0]&2?y["return"]:op[0]?y["throw"]||((t=y["return"])&&t.call(y),0):y.next)&&!(t=t.call(y,op[1])).done)return t;if(y=0,t)op=[op[0]&2,t.value];switch(op[0]){case 0:case 1:t=op;break;case 4:_.label++;return{value:op[1],done:false};case 5:_.label++;y=op[1];op=[0];continue;case 7:op=_.ops.pop();_.trys.pop();continue;default:if(!(t=_.trys,t=t.length>0&&t[t.length-1])&&(op[0]===6||op[0]===2)){_=0;continue}if(op[0]===3&&(!t||op[1]>t[0]&&op[1]<t[3])){_.label=op[1];break}if(op[0]===6&&_.label<t[1]){_.label=t[1];t=op;break}if(t&&_.label<t[2]){_.label=t[2];_.ops.push(op);break}if(t[2])_.ops.pop();_.trys.pop();continue}op=body.call(thisArg,_)}catch(e){op=[6,e];y=0}finally{f=t=0}if(op[0]&5)throw op[1];return{value:op[0]?op[1]:void 0,done:true}}}var Puri=/*#__PURE__*/function(){"use strict";function Puri(knex,tableNameOrSpec){_class_call_check(this,Puri);_define_property(this,"knex",void 0);_define_property(this,"knexQuery",void 0);this.knex=knex;if(typeof tableNameOrSpec==="string"){this.knexQuery=this.knex(tableNameOrSpec).from(tableNameOrSpec)}else if((typeof tableNameOrSpec==="undefined"?"undefined":_type_of(tableNameOrSpec))==="object"){var entries=Object.entries(tableNameOrSpec);if(entries.length!==1){throw new Error("Table spec must have exactly one entry")}(0,_assert.default)(entries[0]);var _entries_=_sliced_to_array(entries[0],2),alias=_entries_[0],spec=_entries_[1];if(typeof spec==="string"){this.knexQuery=this.knex(spec).from(_define_property({},alias,spec))}else if(_instanceof(spec,Puri)){var subqueryBuilder=spec.raw();this.knexQuery=this.knex.from(subqueryBuilder.as(alias))}else{throw new Error("Invalid table specification")}}else{throw new Error("Invalid table specification")}}_create_class(Puri,[{key:"select",value:function select(selectObj){var selectClauses=[];var _iteratorNormalCompletion=true,_didIteratorError=false,_iteratorError=undefined;try{for(var _iterator=Object.entries(selectObj)[Symbol.iterator](),_step;!(_iteratorNormalCompletion=(_step=_iterator.next()).done);_iteratorNormalCompletion=true){var _step_value=_sliced_to_array(_step.value,2),alias=_step_value[0],columnOrFunction=_step_value[1];if((typeof columnOrFunction==="undefined"?"undefined":_type_of(columnOrFunction))==="object"&&columnOrFunction._type==="sql_expression"){selectClauses.push(this.knex.raw("".concat(columnOrFunction._sql," as ").concat(alias)))}else{var columnPath=columnOrFunction;if(alias===columnPath){selectClauses.push(columnPath)}else{selectClauses.push("".concat(columnPath," as ").concat(alias))}}}}catch(err){_didIteratorError=true;_iteratorError=err}finally{try{if(!_iteratorNormalCompletion&&_iterator.return!=null){_iterator.return()}}finally{if(_didIteratorError){throw _iteratorError}}}this.knexQuery.select(selectClauses);return this}},{key:"selectAll",value:function selectAll(){this.knexQuery.select("*");return this}},{key:"join",value:function join(tableNameOrSpec){for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key]}return this.__commonJoin.apply(this,["join",tableNameOrSpec].concat(_to_consumable_array(args)))}},{key:"leftJoin",value:function leftJoin(tableNameOrSpec){for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key]}return this.__commonJoin.apply(this,["leftJoin",tableNameOrSpec].concat(_to_consumable_array(args)))}},{key:"__commonJoin",value:function __commonJoin(joinType,tableNameOrSpec){for(var _len=arguments.length,args=new Array(_len>2?_len-2:0),_key=2;_key<_len;_key++){args[_key-2]=arguments[_key]}if(typeof tableNameOrSpec==="string"){var tableName=tableNameOrSpec;if(args.length===1&&typeof args[0]==="function"){var callback=args[0];this.knexQuery[joinType](tableName,function(joinClause){callback(new JoinClauseGroup(joinClause))})}else{var _args=_sliced_to_array(args,2),left=_args[0],right=_args[1];this.knexQuery[joinType](tableName,left,right)}}else if((typeof tableNameOrSpec==="undefined"?"undefined":_type_of(tableNameOrSpec))==="object"){var entries=Object.entries(tableNameOrSpec);if(entries.length!==1){throw new Error("Table spec must have exactly one entry")}(0,_assert.default)(entries[0]);var _entries=_sliced_to_array(entries,1),_entries_=_sliced_to_array(_entries[0],2),alias=_entries_[0],spec=_entries_[1];if(typeof spec==="string"){if(args.length===1&&typeof args[0]==="function"){var callback1=args[0];this.knexQuery[joinType](_define_property({},alias,spec),function(joinClause){callback1(new JoinClauseGroup(joinClause))})}else{var _args1=_sliced_to_array(args,2),left1=_args1[0],right1=_args1[1];this.knexQuery[joinType](_define_property({},alias,spec),left1,right1)}}else if(_instanceof(spec,Puri)){if(args.length===1&&typeof args[0]==="function"){var callback2=args[0];this.knexQuery[joinType](spec.raw().as(alias),function(joinClause){callback2(new JoinClauseGroup(joinClause))})}else{var _args2=_sliced_to_array(args,2),left2=_args2[0],right2=_args2[1];this.knexQuery[joinType](spec.raw().as(alias),left2,right2)}}else{throw new Error("Invalid table specification")}}else{throw new Error("Invalid arguments")}return this}},{key:"where",value:function where(columnOrConditions,operatorOrValue,value){if((typeof columnOrConditions==="undefined"?"undefined":_type_of(columnOrConditions))==="object"){this.knexQuery.where(columnOrConditions)}else if(arguments.length===2){if(operatorOrValue===null){this.knexQuery.whereNull(columnOrConditions);return this}this.knexQuery.where(columnOrConditions,operatorOrValue)}else if(arguments.length===3){if(value===null){if(operatorOrValue==="!="){this.knexQuery.whereNotNull(columnOrConditions);return this}else if(operatorOrValue==="="){this.knexQuery.whereNull(columnOrConditions);return this}}this.knexQuery.where(columnOrConditions,operatorOrValue,value)}else{this.knexQuery.where(columnOrConditions)}return this}},{key:"whereIn",value:function whereIn(column,values){this.knexQuery.whereIn(column,values);return this}},{key:"whereNotIn",value:function whereNotIn(column,values){this.knexQuery.whereIn(column,values);return this}},{key:"whereMatch",value:function whereMatch(column,value){this.knexQuery.whereRaw("MATCH (".concat(String(column),") AGAINST (?)"),[value]);return this}},{key:"whereGroup",value:function whereGroup(callback){this.knexQuery.where(function(builder){var group=new WhereGroup(builder);callback(group)});return this}},{key:"orWhereGroup",value:function orWhereGroup(callback){this.knexQuery.orWhere(function(builder){var group=new WhereGroup(builder);callback(group)});return this}},{key:"orderBy",value:function orderBy(column){var direction=arguments.length>1&&arguments[1]!==void 0?arguments[1]:"asc";this.knexQuery.orderBy(column,direction);return this}},{key:"limit",value:function limit(count){this.knexQuery.limit(count);return this}},{key:"offset",value:function offset(count){this.knexQuery.offset(count);return this}},{key:"groupBy",value:function groupBy(){for(var _len=arguments.length,columns=new Array(_len),_key=0;_key<_len;_key++){columns[_key]=arguments[_key]}var _this_knexQuery;(_this_knexQuery=this.knexQuery).groupBy.apply(_this_knexQuery,_to_consumable_array(columns));return this}},{key:"having",value:function having(){for(var _len=arguments.length,conditions=new Array(_len),_key=0;_key<_len;_key++){conditions[_key]=arguments[_key]}if(conditions.length===1){this.knexQuery.having(conditions[0])}else if(conditions.length===3){this.knexQuery.having(conditions[0],conditions[1],conditions[2])}else{throw new Error("Invalid having arguments")}return this}},{key:"then",value:function then(onfulfilled,onrejected){return this.knexQuery.then(onfulfilled,onrejected)}},{key:"catch",value:function _catch(onrejected){return this.knexQuery.catch(onrejected)}},{key:"finally",value:function _finally(onfinally){return this.knexQuery.finally(onfinally)}},{key:"first",value:function first(){return _async_to_generator(function(){return _ts_generator(this,function(_state){return[2,this.knexQuery.first()]})}).call(this)}},{key:"firstOrFail",value:function firstOrFail(){return _async_to_generator(function(){var result;return _ts_generator(this,function(_state){switch(_state.label){case 0:return[4,this.knexQuery.first()];case 1:result=_state.sent();if(!result){throw new Error("No results found")}return[2,result]}})}).call(this)}},{key:"at",value:function at(index){return _async_to_generator(function(){var results;return _ts_generator(this,function(_state){switch(_state.label){case 0:return[4,this];case 1:results=_state.sent();return[2,results[index]]}})}).call(this)}},{key:"assertAt",value:function assertAt(index){return _async_to_generator(function(){var results,result;return _ts_generator(this,function(_state){switch(_state.label){case 0:return[4,this];case 1:results=_state.sent();result=results[index];if(result===undefined){throw new Error("No result found at index ".concat(index))}return[2,result]}})}).call(this)}},{key:"pluck",value:function pluck(column){return _async_to_generator(function(){return _ts_generator(this,function(_state){return[2,this.knexQuery.pluck(column)]})}).call(this)}},{key:"insert",value:function insert(data){this.knexQuery.insert(data);return this}},{key:"update",value:function update(data){this.knexQuery.update(data);return this}},{key:"increment",value:function increment(column,value){if(value<=0){throw new Error("Increment value must be greater than 0")}this.knexQuery.increment(column,value);return this}},{key:"decrement",value:function decrement(column,value){if(value<=0){throw new Error("Decrement value must be greater than 0")}this.knexQuery.decrement(column,value);return this}},{key:"delete",value:function _delete(){this.knexQuery.delete();return this}},{key:"toQuery",value:function toQuery(){return this.knexQuery.toQuery()}},{key:"debug",value:function debug(){console.log("".concat(_chalk.default.cyan("[Puri Debug]")," ").concat(_chalk.default.yellow(this.toQuery())));return this}},{key:"formatSQL",value:function formatSQL(unformatted){var keywords=["SELECT","FROM","WHERE","INSERT","INTO","VALUES","UPDATE","DELETE","CREATE","TABLE","ALTER","DROP","JOIN","ON","INNER","LEFT","RIGHT","FULL","OUTER","GROUP","BY","ORDER","HAVING","DISTINCT","LIMIT","OFFSET","AS","AND","OR","NOT","IN","LIKE","IS","NULL","CASE","WHEN","THEN","ELSE","END","UNION","ALL","EXISTS","BETWEEN"];var formatted=unformatted;keywords.forEach(function(keyword){var regex=new RegExp("\\b".concat(keyword,"\\b"),"gi");formatted=formatted.replace(regex,keyword.toUpperCase())});var majorClauses=["SELECT","FROM","WHERE","GROUP BY","ORDER BY","HAVING","LIMIT","UNION"];majorClauses.forEach(function(clause){var regex=new RegExp("\\s+(".concat(clause,")\\s+"),"gi");formatted=formatted.replace(regex,"\n".concat(clause.toUpperCase()," "))});formatted=formatted.replace(/\s+((?:INNER|LEFT|RIGHT|FULL OUTER)\s+)?JOIN\s+/gi,"\n$1JOIN ");formatted=formatted.replace(/\s+(AND|OR)\s+/gi,"\n  $1 ");var lines=formatted.split("\n");var indentedLines=[];var indentLevel=0;var _iteratorNormalCompletion=true,_didIteratorError=false,_iteratorError=undefined;try{for(var _iterator=lines[Symbol.iterator](),_step;!(_iteratorNormalCompletion=(_step=_iterator.next()).done);_iteratorNormalCompletion=true){var line=_step.value;var trimmedLine=line.trim();if(!trimmedLine)continue;var closingParens=(trimmedLine.match(/\)/g)||[]).length;var openingParens=(trimmedLine.match(/\(/g)||[]).length;if(closingParens>0&&openingParens===0){indentLevel=Math.max(0,indentLevel-closingParens)}var indent="  ".repeat(indentLevel);indentedLines.push(indent+trimmedLine);if(openingParens>closingParens){indentLevel+=openingParens-closingParens}}}catch(err){_didIteratorError=true;_iteratorError=err}finally{try{if(!_iteratorNormalCompletion&&_iterator.return!=null){_iterator.return()}}finally{if(_didIteratorError){throw _iteratorError}}}return indentedLines.join("\n").trim()}},{key:"raw",value:function raw(){return this.knexQuery}}],[{key:"count",value:function count(){var column=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"*";return{_type:"sql_expression",_return:"number",_sql:"COUNT(".concat(column,")")}}},{key:"sum",value:function sum(column){return{_type:"sql_expression",_return:"number",_sql:"SUM(".concat(column,")")}}},{key:"avg",value:function avg(column){return{_type:"sql_expression",_return:"number",_sql:"AVG(".concat(column,")")}}},{key:"max",value:function max(column){return{_type:"sql_expression",_return:"number",_sql:"MAX(".concat(column,")")}}},{key:"min",value:function min(column){return{_type:"sql_expression",_return:"number",_sql:"MIN(".concat(column,")")}}},{key:"concat",value:function concat(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key]}return{_type:"sql_expression",_return:"string",_sql:"CONCAT(".concat(args.join(", "),")")}}},{key:"upper",value:function upper(column){return{_type:"sql_expression",_return:"string",_sql:"UPPER(".concat(column,")")}}},{key:"lower",value:function lower(column){return{_type:"sql_expression",_return:"string",_sql:"LOWER(".concat(column,")")}}},{key:"rawString",value:function rawString(sql){return{_type:"sql_expression",_return:"string",_sql:sql}}},{key:"rawNumber",value:function rawNumber(sql){return{_type:"sql_expression",_return:"number",_sql:sql}}},{key:"rawBoolean",value:function rawBoolean(sql){return{_type:"sql_expression",_return:"boolean",_sql:sql}}},{key:"rawDate",value:function rawDate(sql){return{_type:"sql_expression",_return:"date",_sql:sql}}}]);return Puri}();var WhereGroup=/*#__PURE__*/function(){"use strict";function WhereGroup(builder){_class_call_check(this,WhereGroup);_define_property(this,"builder",void 0);this.builder=builder}_create_class(WhereGroup,[{key:"where",value:function where(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key]}var _this_builder;(_this_builder=this.builder).where.apply(_this_builder,[args[0]].concat(_to_consumable_array(args.slice(1))));return this}},{key:"orWhere",value:function orWhere(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key]}var _this_builder;(_this_builder=this.builder).orWhere.apply(_this_builder,[args[0]].concat(_to_consumable_array(args.slice(1))));return this}},{key:"whereGroup",value:function whereGroup(callback){this.builder.where(function(subBuilder){var subGroup=new WhereGroup(subBuilder);callback(subGroup)});return this}},{key:"orWhereGroup",value:function orWhereGroup(callback){this.builder.orWhere(function(subBuilder){var subGroup=new WhereGroup(subBuilder);callback(subGroup)});return this}}]);return WhereGroup}();var JoinClauseGroup=/*#__PURE__*/function(){"use strict";function JoinClauseGroup(callback){_class_call_check(this,JoinClauseGroup);_define_property(this,"callback",void 0);this.callback=callback}_create_class(JoinClauseGroup,[{key:"on",value:function on(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key]}var _this_callback;(_this_callback=this.callback).on.apply(_this_callback,_to_consumable_array(args));return this}},{key:"orOn",value:function orOn(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key]}var _this_callback;(_this_callback=this.callback).orOn.apply(_this_callback,_to_consumable_array(args));return this}}]);return JoinClauseGroup}();
-//# sourceMappingURL=puri.js.map
+/** biome-ignore-all lint/suspicious/noThenProperty: Puri는 thenable 인터페이스를 구현하고 있습니다. */ /** biome-ignore-all lint/suspicious/noExplicitAny: Puri는 다양한 타입을 사용하고 있습니다. */ import assert from "assert";
+import chalk from "chalk";
+import { Naite } from "../naite/naite.js";
+export class Puri {
+    knex;
+    knexQuery;
+    constructor(knex, tableNameOrSpec){
+        this.knex = knex;
+        if (typeof tableNameOrSpec === "string") {
+            // Case: new Puri(knex, "users")
+            this.knexQuery = this.knex(tableNameOrSpec).from(tableNameOrSpec);
+        } else if (typeof tableNameOrSpec === "object") {
+            const entries = Object.entries(tableNameOrSpec);
+            if (entries.length !== 1) {
+                throw new Error("Table spec must have exactly one entry");
+            }
+            assert(entries[0]);
+            const [alias, spec] = entries[0];
+            if (typeof spec === "string") {
+                this.knexQuery = this.knex(spec).from({
+                    [alias]: spec
+                });
+            } else if (spec instanceof Puri) {
+                const subqueryBuilder = spec.raw();
+                this.knexQuery = this.knex.from(subqueryBuilder.as(alias));
+            } else {
+                throw new Error("Invalid table specification");
+            }
+        } else {
+            throw new Error("Invalid table specification");
+        }
+    }
+    // Static SQL helper functions for SELECT
+    static count(column = "*") {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: `COUNT(${column})::integer`
+        };
+    }
+    static sum(column) {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: `SUM(${column})`
+        };
+    }
+    static avg(column) {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: `AVG(${column})`
+        };
+    }
+    static max(column) {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: `MAX(${column})`
+        };
+    }
+    static min(column) {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: `MIN(${column})`
+        };
+    }
+    static concat(...args) {
+        return {
+            _type: "sql_expression",
+            _return: "string",
+            _sql: `CONCAT(${args.join(", ")})`
+        };
+    }
+    static upper(column) {
+        return {
+            _type: "sql_expression",
+            _return: "string",
+            _sql: `UPPER(${column})`
+        };
+    }
+    static lower(column) {
+        return {
+            _type: "sql_expression",
+            _return: "string",
+            _sql: `LOWER(${column})`
+        };
+    }
+    // Raw functions for SELECT
+    static rawString(sql) {
+        return {
+            _type: "sql_expression",
+            _return: "string",
+            _sql: sql
+        };
+    }
+    static rawNumber(sql) {
+        return {
+            _type: "sql_expression",
+            _return: "number",
+            _sql: sql
+        };
+    }
+    static rawBoolean(sql) {
+        return {
+            _type: "sql_expression",
+            _return: "boolean",
+            _sql: sql
+        };
+    }
+    static rawDate(sql) {
+        return {
+            _type: "sql_expression",
+            _return: "date",
+            _sql: sql
+        };
+    }
+    // SELECT (overwrite)
+    select(selectObj) {
+        const selectClauses = [];
+        for (const [alias, columnOrFunction] of Object.entries(selectObj)){
+            if (typeof columnOrFunction === "object" && columnOrFunction._type === "sql_expression") {
+                // SQL 함수인 경우
+                selectClauses.push(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));
+            } else {
+                // 일반 컬럼인 경우
+                const columnPath = columnOrFunction;
+                if (alias === columnPath) {
+                    // alias와 컬럼명이 같으면 alias 생략
+                    selectClauses.push(columnPath);
+                } else {
+                    // alias 지정
+                    selectClauses.push(`${columnPath} as ${alias}`);
+                }
+            }
+        }
+        this.knexQuery.select(selectClauses);
+        return this;
+    }
+    // SELECT (select는 overwrite, appendSelect는 append)
+    appendSelect(selectObj) {
+        return this.select(selectObj);
+    }
+    // SELECT *
+    selectAll() {
+        this.knexQuery.select("*");
+        return this;
+    }
+    // CLEAR
+    clear(statement) {
+        this.knexQuery.clear(statement);
+        return this;
+    }
+    // knex에 없어서 직접 구현함
+    clearJoin(alias) {
+        this.knexQuery._statements = this.knexQuery._statements.filter((s)=>{
+            if ("joinType" in s) {
+                const [_alias, _table] = Object.entries(s.table)[0];
+                return _alias !== alias;
+            } else {
+                return true;
+            }
+        });
+        return this;
+    }
+    // JOIN 실제 구현
+    join(tableNameOrSpec, ...args) {
+        return this.__commonJoin("join", tableNameOrSpec, ...args);
+    }
+    // LEFT JOIN 실제 구현
+    leftJoin(tableNameOrSpec, ...args) {
+        return this.__commonJoin("leftJoin", tableNameOrSpec, ...args);
+    }
+    __commonJoin(joinType, tableNameOrSpec, ...args) {
+        if (typeof tableNameOrSpec === "string") {
+            // Case 1: join("posts", ...)
+            const tableName = tableNameOrSpec;
+            if (args.length === 1 && typeof args[0] === "function") {
+                // join("posts", callback)
+                const callback = args[0];
+                this.knexQuery[joinType](tableName, (joinClause)=>{
+                    callback(new JoinClauseGroup(joinClause));
+                });
+            } else {
+                // join("posts", left, right)
+                const [left, right] = args;
+                this.knexQuery[joinType](tableName, left, right);
+            }
+        } else if (typeof tableNameOrSpec === "object") {
+            // Case 2: join({ alias: "table" }, ...) or join({ alias: subquery }, ...)
+            const entries = Object.entries(tableNameOrSpec);
+            if (entries.length !== 1) {
+                throw new Error("Table spec must have exactly one entry");
+            }
+            assert(entries[0]);
+            const [[alias, spec]] = entries;
+            if (typeof spec === "string") {
+                // 테이블: join({ p: "posts" }, ...)
+                if (args.length === 1 && typeof args[0] === "function") {
+                    // Callback
+                    const callback = args[0];
+                    this.knexQuery[joinType]({
+                        [alias]: spec
+                    }, (joinClause)=>{
+                        callback(new JoinClauseGroup(joinClause));
+                    });
+                } else {
+                    // Simple
+                    const [left, right] = args;
+                    this.knexQuery[joinType]({
+                        [alias]: spec
+                    }, left, right);
+                }
+            } else if (spec instanceof Puri) {
+                // 서브쿼리: join({ sq: subquery }, ...)
+                if (args.length === 1 && typeof args[0] === "function") {
+                    // Callback
+                    const callback = args[0];
+                    this.knexQuery[joinType](spec.raw().as(alias), (joinClause)=>{
+                        callback(new JoinClauseGroup(joinClause));
+                    });
+                } else {
+                    // Simple
+                    const [left, right] = args;
+                    this.knexQuery[joinType](spec.raw().as(alias), left, right);
+                }
+            } else {
+                throw new Error("Invalid table specification");
+            }
+        } else {
+            throw new Error("Invalid arguments");
+        }
+        return this;
+    }
+    // WHERE: 컬럼 - 사용: .where("u.id", "like", "%test%")
+    where(...args) {
+        const [columnOrConditions, operatorOrValue, value] = args;
+        if (typeof columnOrConditions === "object") {
+            this.knexQuery.where(columnOrConditions);
+        } else if (typeof value === "undefined") {
+            if (operatorOrValue === null) {
+                this.knexQuery.whereNull(columnOrConditions);
+                return this;
+            }
+            this.knexQuery.where(columnOrConditions, operatorOrValue);
+        } else if (typeof value !== "undefined") {
+            if (value === null) {
+                if (operatorOrValue === "!=") {
+                    this.knexQuery.whereNotNull(columnOrConditions);
+                    return this;
+                } else if (operatorOrValue === "=") {
+                    this.knexQuery.whereNull(columnOrConditions);
+                    return this;
+                }
+            }
+            this.knexQuery.where(columnOrConditions, operatorOrValue, value);
+        } else {
+            this.knexQuery.where(columnOrConditions);
+        }
+        return this;
+    }
+    // WHERE IN
+    whereIn(column, values) {
+        this.knexQuery.whereIn(column, values);
+        return this;
+    }
+    // WHERE NOT IN
+    whereNotIn(column, values) {
+        this.knexQuery.whereNotIn(column, values);
+        return this;
+    }
+    // WHERE MATCH
+    whereMatch(column, value) {
+        this.knexQuery.whereRaw(`MATCH (${String(column)}) AGAINST (?)`, [
+            value
+        ]);
+        return this;
+    }
+    // WHERE 괄호 그룹핑
+    whereGroup(callback) {
+        this.knexQuery.where((builder)=>{
+            const group = new WhereGroup(builder);
+            callback(group);
+        });
+        return this;
+    }
+    orWhereGroup(callback) {
+        this.knexQuery.orWhere((builder)=>{
+            const group = new WhereGroup(builder);
+            callback(group);
+        });
+        return this;
+    }
+    orderBy(column, direction = "asc") {
+        this.knexQuery.orderBy(column, direction);
+        return this;
+    }
+    // 기본 쿼리 메서드들
+    limit(count) {
+        this.knexQuery.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.knexQuery.offset(count);
+        return this;
+    }
+    groupBy(...columns) {
+        this.knexQuery.groupBy(...columns);
+        return this;
+    }
+    // HAVING 구현
+    having(...conditions) {
+        if (conditions.length === 1) {
+            // having("COUNT(*) > 10")
+            this.knexQuery.having(this.knex.raw(conditions[0]));
+        } else if (conditions.length === 3) {
+            // having("count", ">", 10)
+            this.knexQuery.having(this.knex.raw(conditions[0]), conditions[1], this.knex.raw(conditions[2]));
+        } else {
+            throw new Error("Invalid having arguments");
+        }
+        return this;
+    }
+    // 실행 메서드들 - thenable 구현
+    then(onfulfilled, onrejected) {
+        Naite.t("puri:executed-query", this.toQuery());
+        return this.knexQuery.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.knexQuery.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.knexQuery.finally(onfinally);
+    }
+    // 하나만 쿼리
+    first() {
+        this.knexQuery.first();
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴
+    pluck(column) {
+        this.knexQuery.pluck(column);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // INSERT
+    insert(data) {
+        this.knexQuery.insert(data);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // UPDATE
+    update(data) {
+        this.knexQuery.update(data);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // Increment
+    increment(column, value) {
+        if (value <= 0) {
+            throw new Error("Increment value must be greater than 0");
+        }
+        this.knexQuery.increment(column, value);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // Decrement
+    decrement(column, value) {
+        if (value <= 0) {
+            throw new Error("Decrement value must be greater than 0");
+        }
+        this.knexQuery.decrement(column, value);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // DELETE
+    delete() {
+        this.knexQuery.delete();
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+    // 확인 쿼리 리턴
+    toQuery() {
+        return this.knexQuery.toQuery();
+    }
+    // 쿼리 디버깅 로그 출력
+    debug() {
+        console.log(`${chalk.cyan("[Puri Debug]")} ${chalk.yellow(this.toQuery())}`);
+        return this;
+    }
+    clone() {
+        // 'dual'은 더미 테이블이며, 바로 아래 줄에서 knexQuery가 덮어씌워집니다.
+        const newPuri = new Puri(this.knex, "dual");
+        newPuri.knexQuery = this.knexQuery.clone();
+        return newPuri;
+    }
+    formatSQL(unformatted) {
+        // SQL 예약어 목록
+        const keywords = [
+            "SELECT",
+            "FROM",
+            "WHERE",
+            "INSERT",
+            "INTO",
+            "VALUES",
+            "UPDATE",
+            "DELETE",
+            "CREATE",
+            "TABLE",
+            "ALTER",
+            "DROP",
+            "JOIN",
+            "ON",
+            "INNER",
+            "LEFT",
+            "RIGHT",
+            "FULL",
+            "OUTER",
+            "GROUP",
+            "BY",
+            "ORDER",
+            "HAVING",
+            "DISTINCT",
+            "LIMIT",
+            "OFFSET",
+            "AS",
+            "AND",
+            "OR",
+            "NOT",
+            "IN",
+            "LIKE",
+            "IS",
+            "NULL",
+            "CASE",
+            "WHEN",
+            "THEN",
+            "ELSE",
+            "END",
+            "UNION",
+            "ALL",
+            "EXISTS",
+            "BETWEEN"
+        ];
+        let formatted = unformatted;
+        // 예약어를 대문자로 변환
+        keywords.forEach((keyword)=>{
+            const regex = new RegExp(`\\b${keyword}\\b`, "gi");
+            formatted = formatted.replace(regex, keyword.toUpperCase());
+        });
+        // 주요 절 앞에 줄바꿈 추가
+        const majorClauses = [
+            "SELECT",
+            "FROM",
+            "WHERE",
+            "GROUP BY",
+            "ORDER BY",
+            "HAVING",
+            "LIMIT",
+            "UNION"
+        ];
+        majorClauses.forEach((clause)=>{
+            const regex = new RegExp(`\\s+(${clause})\\s+`, "gi");
+            formatted = formatted.replace(regex, `\n${clause.toUpperCase()} `);
+        });
+        // JOIN 절 처리
+        formatted = formatted.replace(/\s+((?:INNER|LEFT|RIGHT|FULL OUTER)\s+)?JOIN\s+/gi, "\n$1JOIN ");
+        // AND, OR 조건 처리
+        formatted = formatted.replace(/\s+(AND|OR)\s+/gi, "\n  $1 ");
+        // 괄호 처리 및 들여쓰기
+        const lines = formatted.split("\n");
+        const indentedLines = [];
+        let indentLevel = 0;
+        for (const line of lines){
+            const trimmedLine = line.trim();
+            if (!trimmedLine) continue;
+            // 닫는 괄호가 있으면 들여쓰기 레벨 감소
+            const closingParens = (trimmedLine.match(/\)/g) || []).length;
+            const openingParens = (trimmedLine.match(/\(/g) || []).length;
+            if (closingParens > 0 && openingParens === 0) {
+                indentLevel = Math.max(0, indentLevel - closingParens);
+            }
+            // 현재 들여쓰기 적용
+            const indent = "  ".repeat(indentLevel);
+            indentedLines.push(indent + trimmedLine);
+            // 여는 괄호가 있으면 들여쓰기 레벨 증가
+            if (openingParens > closingParens) {
+                indentLevel += openingParens - closingParens;
+            }
+        }
+        return indentedLines.join("\n").trim();
+    }
+    // Knex 쿼리 빌더 직접 접근
+    raw() {
+        return this.knexQuery;
+    }
+}
+export class WhereGroup {
+    builder;
+    constructor(builder){
+        this.builder = builder;
+    }
+    where(...args) {
+        this.builder.where(args[0], ...args.slice(1));
+        return this;
+    }
+    orWhere(...args) {
+        this.builder.orWhere(args[0], ...args.slice(1));
+        return this;
+    }
+    whereGroup(callback) {
+        this.builder.where((subBuilder)=>{
+            const subGroup = new WhereGroup(subBuilder);
+            callback(subGroup);
+        });
+        return this;
+    }
+    orWhereGroup(callback) {
+        this.builder.orWhere((subBuilder)=>{
+            const subGroup = new WhereGroup(subBuilder);
+            callback(subGroup);
+        });
+        return this;
+    }
+}
+export class JoinClauseGroup {
+    callback;
+    constructor(callback){
+        this.callback = callback;
+    }
+    // ON(AND) 구현
+    on(...args) {
+        this.callback.on(...args);
+        return this;
+    }
+    // ON(OR) 구현
+    orOn(...args) {
+        this.callback.orOn(...args);
+        return this;
+    }
+}
+/*
+  TResolved: 쿼리 실행 후 반환될 결과 타입
+  TReturning: RETURNING 절에 사용될 타입
+*/ export class ResolvedPuri {
+    knexQuery;
+    knex;
+    constructor(knexQuery, knex){
+        this.knexQuery = knexQuery;
+        this.knex = knex;
+    }
+    toQuery() {
+        return this.knexQuery.toQuery();
+    }
+    debug() {
+        console.log(`${chalk.cyan("[Puri Debug]")} ${chalk.yellow(this.toQuery())}`);
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        Naite.t("puri:executed-query", this.toQuery());
+        return this.knexQuery.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.knexQuery.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.knexQuery.finally(onfinally);
+    }
+    // ON CONFLICT - 컬럼 기반
+    onConflict(columns, action) {
+        const target = Array.isArray(columns) ? columns : [
+            columns
+        ];
+        if (!action || action === "nothing") {
+            // DO NOTHING
+            this.knexQuery.onConflict(target).ignore();
+        } else {
+            // DO UPDATE
+            const { update } = action;
+            // action.update 배열 형태 : ["name", "email"]
+            if (Array.isArray(update)) {
+                this.knexQuery.onConflict(target).merge(update);
+            } else {
+                // action.update 객체 형태: { name: "John", count: raw(...) }
+                const mergeObj = {};
+                for (const [key, value] of Object.entries(update)){
+                    if (value && typeof value === "object" && "_type" in value && value._type === "sql_expression") {
+                        // SqlExpression → knex.raw()로 변환
+                        mergeObj[key] = this.knex.raw(value._sql);
+                    } else {
+                        // 일반 값
+                        mergeObj[key] = value;
+                    }
+                }
+                this.knexQuery.onConflict(target).merge(mergeObj);
+            }
+        }
+        return this;
+    }
+    // RETURNING 구현
+    returning(columnOrColumns) {
+        this.knexQuery.returning(columnOrColumns);
+        return new ResolvedPuri(this.knexQuery, this.knex);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/puri.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noThenProperty: Puri는 thenable 인터페이스를 구현하고 있습니다. */\n/** biome-ignore-all lint/suspicious/noExplicitAny: Puri는 다양한 타입을 사용하고 있습니다. */\n\nimport assert from \"assert\";\nimport chalk from \"chalk\";\nimport type { Knex } from \"knex\";\nimport { Naite } from \"../naite/naite\";\nimport type {\n  AvailableColumns,\n  ColumnKeys,\n  ComparisonOperator,\n  Expand,\n  ExtractColumnType,\n  FulltextColumns,\n  InsertData,\n  InsertResult,\n  OnConflictAction,\n  ParseSelectObject,\n  ResultAvailableColumns,\n  SelectObject,\n  SingleTableValue,\n  SqlExpression,\n  WhereCondition,\n} from \"./puri.types\";\nimport type { ClearStatements } from \"./puri-subset.types\";\n\nexport class Puri<TSchema, TTables extends Record<string, any>, TResult> {\n  private knexQuery: Knex.QueryBuilder;\n\n  // 생성자 시그니처들\n  constructor(knex: Knex, tableName: string);\n  constructor(knex: Knex, tableSpec: Record<string, string | Puri<TSchema, any, any>>);\n  constructor(\n    public knex: Knex,\n    tableNameOrSpec: any,\n  ) {\n    if (typeof tableNameOrSpec === \"string\") {\n      // Case: new Puri(knex, \"users\")\n      this.knexQuery = this.knex(tableNameOrSpec).from(tableNameOrSpec);\n    } else if (typeof tableNameOrSpec === \"object\") {\n      const entries = Object.entries(tableNameOrSpec);\n      if (entries.length !== 1) {\n        throw new Error(\"Table spec must have exactly one entry\");\n      }\n      assert(entries[0]);\n      const [alias, spec] = entries[0];\n      if (typeof spec === \"string\") {\n        this.knexQuery = this.knex(spec).from({ [alias]: spec });\n      } else if (spec instanceof Puri) {\n        const subqueryBuilder = spec.raw();\n        this.knexQuery = this.knex.from(subqueryBuilder.as(alias));\n      } else {\n        throw new Error(\"Invalid table specification\");\n      }\n    } else {\n      throw new Error(\"Invalid table specification\");\n    }\n  }\n\n  // Static SQL helper functions for SELECT\n  static count(column: string = \"*\"): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `COUNT(${column})::integer`,\n    };\n  }\n  static sum(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `SUM(${column})`,\n    };\n  }\n  static avg(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `AVG(${column})`,\n    };\n  }\n  static max(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MAX(${column})`,\n    };\n  }\n  static min(column: string): SqlExpression<\"number\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"number\",\n      _sql: `MIN(${column})`,\n    };\n  }\n  static concat(...args: string[]): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `CONCAT(${args.join(\", \")})`,\n    };\n  }\n  static upper(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `UPPER(${column})`,\n    };\n  }\n  static lower(column: string): SqlExpression<\"string\"> {\n    return {\n      _type: \"sql_expression\",\n      _return: \"string\",\n      _sql: `LOWER(${column})`,\n    };\n  }\n\n  // Raw functions for SELECT\n  static rawString(sql: string): SqlExpression<\"string\"> {\n    return { _type: \"sql_expression\", _return: \"string\", _sql: sql };\n  }\n  static rawNumber(sql: string): SqlExpression<\"number\"> {\n    return { _type: \"sql_expression\", _return: \"number\", _sql: sql };\n  }\n  static rawBoolean(sql: string): SqlExpression<\"boolean\"> {\n    return { _type: \"sql_expression\", _return: \"boolean\", _sql: sql };\n  }\n  static rawDate(sql: string): SqlExpression<\"date\"> {\n    return { _type: \"sql_expression\", _return: \"date\", _sql: sql };\n  }\n\n  // SELECT (overwrite)\n  select<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, ParseSelectObject<TTables, TSelect>> {\n    const selectClauses: (string | Knex.Raw)[] = [];\n\n    for (const [alias, columnOrFunction] of Object.entries(selectObj)) {\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  // SELECT (select는 overwrite, appendSelect는 append)\n  appendSelect<TSelect extends SelectObject<TTables>>(\n    selectObj: TSelect,\n  ): Puri<TSchema, TTables, TResult & ParseSelectObject<TTables, TSelect>> {\n    return this.select(selectObj) as any;\n  }\n\n  // SELECT *\n  selectAll(): this {\n    this.knexQuery.select(\"*\");\n    return this as any;\n  }\n\n  // CLEAR\n  clear(statement: ClearStatements): this {\n    this.knexQuery.clear(statement);\n    return this;\n  }\n\n  // knex에 없어서 직접 구현함\n  clearJoin(alias: string): this {\n    (this.knexQuery as any)._statements = (this.knexQuery as any)._statements.filter((s: any) => {\n      if (\"joinType\" in s) {\n        const [_alias, _table] = Object.entries(s.table)[0];\n        return _alias !== alias;\n      } else {\n        return true;\n      }\n    });\n    return this;\n  }\n\n  // JOIN: 서브쿼리 + Alias\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSubResult>, // 서브쿼리의 TResult\n    TResult\n  >;\n  // JOIN: 테이블 + Alias\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSchema[TJoinTable]>, // TTables 확장!\n    TResult\n  >;\n  // JOIN: 테이블명\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    left: AvailableColumns<TTables>,\n    right: `${TJoinTable & string}.${ColumnKeys<TSchema[TJoinTable]>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinTable, TSchema[TJoinTable]>, // 테이블명이 키\n    TResult\n  >;\n  // JOIN: 서브쿼리 + Alias + 콜백\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSubResult>, TResult>;\n  // JOIN: 테이블 + Alias + 콜백\n  join<TJoinTable extends keyof TSchema, TJoinAlias extends string>(\n    tableSpec: { [K in TJoinAlias]: TJoinTable },\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable]>, TResult>;\n  // JOIN: 테이블명 + 콜백\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>) => void,\n  ): Puri<TSchema, TTables & Record<TJoinTable, TSchema[TJoinTable]>, TResult>;\n  // JOIN 실제 구현\n  join(tableNameOrSpec: any, ...args: any[]): any {\n    return this.__commonJoin(\"join\", tableNameOrSpec, ...args);\n  }\n\n  // LEFT JOIN: 서브쿼리 + Alias\n  leftJoin<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${ColumnKeys<TSubResult>}`,\n  ): Puri<\n    TSchema,\n    TTables & Record<TJoinAlias, TSubResult>, // 서브쿼리의 TResult\n    TResult\n  >;\n  // LEFT JOIN: 테이블 + Alias\n  leftJoin<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  // LEFT JOIN: 테이블명\n  leftJoin<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  // 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>, 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]>, 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]>, 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.raw().as(alias), (joinClause) => {\n            callback(new JoinClauseGroup(joinClause));\n          });\n        } else {\n          // Simple\n          const [left, right] = args;\n          this.knexQuery[joinType](spec.raw().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)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \">\", 10)\n  where<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: ComparisonOperator | \"like\" | \"not like\",\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  // WHERE: 컬럼 - 사용: .where(\"u.id\", \"like\", \"%test%\")\n  where(...args: [columnOrConditions: any, operatorOrValue?: any, value?: any]): this {\n    const [columnOrConditions, operatorOrValue, value] = args;\n    if (typeof columnOrConditions === \"object\") {\n      this.knexQuery.where(columnOrConditions);\n    } else if (typeof value === \"undefined\") {\n      if (operatorOrValue === null) {\n        this.knexQuery.whereNull(columnOrConditions);\n        return this;\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue);\n    } else if (typeof value !== \"undefined\") {\n      if (value === null) {\n        if (operatorOrValue === \"!=\") {\n          this.knexQuery.whereNotNull(columnOrConditions);\n          return this;\n        } else if (operatorOrValue === \"=\") {\n          this.knexQuery.whereNull(columnOrConditions);\n          return this;\n        }\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue, value);\n    } else {\n      this.knexQuery.where(columnOrConditions);\n    }\n    return this;\n  }\n\n  // WHERE IN\n  whereIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereIn(column, values);\n    return this as any;\n  }\n\n  // WHERE NOT IN\n  whereNotIn<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    values: ExtractColumnType<TTables, TColumn & string>[],\n  ): Puri<TSchema, TTables, TResult> {\n    this.knexQuery.whereNotIn(column, values);\n    return this as any;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(column: TColumn, value: string): this {\n    this.knexQuery.whereRaw(`MATCH (${String(column)}) AGAINST (?)`, [value]);\n    return this;\n  }\n\n  // WHERE 괄호 그룹핑\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.where((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this {\n    this.knexQuery.orWhere((builder) => {\n      const group = new WhereGroup<TTables>(builder);\n      callback(group);\n    });\n    return this;\n  }\n\n  // ORDER BY\n  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    direction: \"asc\" | \"desc\",\n  ): this;\n  orderBy(column: string, direction: \"asc\" | \"desc\" = \"asc\"): this {\n    this.knexQuery.orderBy(column, direction);\n    return this;\n  }\n\n  // 기본 쿼리 메서드들\n  limit(count: number): this {\n    this.knexQuery.limit(count);\n    return this;\n  }\n\n  offset(count: number): this {\n    this.knexQuery.offset(count);\n    return this;\n  }\n\n  // GROUP BY\n  groupBy<TColumns extends ResultAvailableColumns<TTables, TResult>>(...columns: TColumns[]): this;\n  groupBy(...columns: string[]): this {\n    this.knexQuery.groupBy(...(columns as string[]));\n    return this;\n  }\n\n  // HAVING\n  having(condition: string): this;\n  having<TColumn extends ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n    operator: ComparisonOperator,\n    value: any,\n  ): this;\n  // HAVING 구현\n  having(...conditions: any[]): this {\n    if (conditions.length === 1) {\n      // having(\"COUNT(*) > 10\")\n      this.knexQuery.having(this.knex.raw(conditions[0]));\n    } else if (conditions.length === 3) {\n      // having(\"count\", \">\", 10)\n      this.knexQuery.having(\n        this.knex.raw(conditions[0]),\n        conditions[1],\n        this.knex.raw(conditions[2]),\n      );\n    } else {\n      throw new Error(\"Invalid having arguments\");\n    }\n    return this;\n  }\n\n  // 실행 메서드들 - thenable 구현\n  then<TResult1 = Expand<TResult>[], TResult2 = never>(\n    onfulfilled?: ((value: Expand<TResult>[]) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n  finally(onfinally?: (() => void) | null): Promise<TResult> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // 하나만 쿼리\n  first(): ResolvedPuri<Expand<TResult>, never> {\n    this.knexQuery.first();\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴\n  pluck<TColumn extends keyof TResult | ResultAvailableColumns<TTables, TResult>>(\n    column: TColumn,\n  ): ResolvedPuri<\n    TColumn extends keyof TResult\n      ? TResult[TColumn][]\n      : ExtractColumnType<TTables, TColumn & string>[],\n    never\n  > {\n    this.knexQuery.pluck(column as string);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // INSERT\n  insert(\n    data: InsertData<SingleTableValue<TTables>>,\n  ): ResolvedPuri<InsertResult, SingleTableValue<TTables>> {\n    this.knexQuery.insert(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // UPDATE\n  update(data: WhereCondition<TTables>): ResolvedPuri<number, SingleTableValue<TTables>> {\n    this.knexQuery.update(data);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n\n  // Increment\n  increment<TColumn extends AvailableColumns<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 AvailableColumns<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  // Knex 쿼리 빌더 직접 접근\n  raw(): 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: ComparisonOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  where(...args: any[]): WhereGroup<TTables> {\n    this.builder.where(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // orWhere 메서드들\n  orWhere(conditions: WhereCondition<TTables>): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    operator: ComparisonOperator,\n    value: ExtractColumnType<TTables, TColumn & string>,\n  ): this;\n  orWhere(...args: any[]): WhereGroup<TTables> {\n    this.builder.orWhere(args[0], ...args.slice(1));\n    return this;\n  }\n\n  // 중첩 그룹\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  whereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.where((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): this;\n  orWhereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {\n    this.builder.orWhere((subBuilder) => {\n      const subGroup = new WhereGroup<TTables>(subBuilder);\n      callback(subGroup);\n    });\n    return this;\n  }\n}\n\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(AND): 컬럼 (연산자) 컬럼\n  on(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  // ON(AND): 콜백\n  on(callback: (nested: JoinClauseGroup<TLeft, TRight>) => 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  // ON(OR): 컬럼 (연산자) 컬럼\n  orOn(\n    left: AvailableColumns<TLeft>,\n    operator: ComparisonOperator,\n    right: AvailableColumns<TRight>,\n  ): this;\n  // ON(OR): 콜백\n  orOn(callback: (nested: JoinClauseGroup<TLeft, TRight>) => void): this;\n  // ON(OR) 구현\n  orOn(...args: any[]): this {\n    this.callback.orOn(...(args as [string, string]));\n    return this;\n  }\n}\n\n/*\n  TResolved: 쿼리 실행 후 반환될 결과 타입\n  TReturning: RETURNING 절에 사용될 타입\n*/\nexport class ResolvedPuri<TResolved, TReturning> {\n  constructor(\n    public knexQuery: Knex.QueryBuilder,\n    private knex: Knex,\n  ) {}\n\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  debug(): this {\n    console.log(`${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`);\n    return this;\n  }\n\n  then<TResult1 = TResolved, TResult2 = never>(\n    onfulfilled?: ((value: TResolved) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri:executed-query\", this.toQuery());\n    return this.knexQuery.then(onfulfilled as any, onrejected);\n  }\n  catch<TResult2 = never>(\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResolved | TResult2> {\n    return this.knexQuery.catch(onrejected);\n  }\n  finally(onfinally?: (() => void) | null): Promise<TResolved> {\n    return this.knexQuery.finally(onfinally);\n  }\n\n  // ON CONFLICT - 컬럼 기반\n  onConflict<TTables extends Record<string, TReturning>>(\n    columns: string | string[],\n    action?: OnConflictAction<TTables>,\n  ): this {\n    const target = Array.isArray(columns) ? columns : [columns];\n\n    if (!action || action === \"nothing\") {\n      // DO NOTHING\n      this.knexQuery.onConflict(target).ignore();\n    } else {\n      // DO UPDATE\n      const { update } = action;\n\n      // action.update 배열 형태 : [\"name\", \"email\"]\n      if (Array.isArray(update)) {\n        this.knexQuery.onConflict(target).merge(update);\n      } else {\n        // action.update 객체 형태: { name: \"John\", count: raw(...) }\n        const mergeObj: Record<string, any> = {};\n\n        for (const [key, value] of Object.entries(update)) {\n          if (\n            value &&\n            typeof value === \"object\" &&\n            \"_type\" in value &&\n            value._type === \"sql_expression\"\n          ) {\n            // SqlExpression → knex.raw()로 변환\n            mergeObj[key] = this.knex.raw((value as SqlExpression<any>)._sql);\n          } else {\n            // 일반 값\n            mergeObj[key] = value;\n          }\n        }\n\n        this.knexQuery.onConflict(target).merge(mergeObj);\n      }\n    }\n\n    return this;\n  }\n\n  // RETURNING: \"*\" - 전체 컬럼\n  returning(column: \"*\"): ResolvedPuri<TReturning[], never>;\n  // RETURNING: 단일 컬럼\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    column: TColumn,\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING: 복수 컬럼 (배열)\n  returning<TColumn extends ColumnKeys<TReturning>>(\n    columns: TColumn[],\n  ): ResolvedPuri<Pick<TReturning, TColumn>[], never>;\n  // RETURNING 구현\n  returning(columnOrColumns: string | string[]): ResolvedPuri<any[], never> {\n    this.knexQuery.returning(columnOrColumns);\n    return new ResolvedPuri(this.knexQuery, this.knex);\n  }\n}\n"],"names":["assert","chalk","Naite","Puri","knexQuery","knex","tableNameOrSpec","from","entries","Object","length","Error","alias","spec","subqueryBuilder","raw","as","count","column","_type","_return","_sql","sum","avg","max","min","concat","args","join","upper","lower","rawString","sql","rawNumber","rawBoolean","rawDate","select","selectObj","selectClauses","columnOrFunction","push","columnPath","appendSelect","selectAll","clear","statement","clearJoin","_statements","filter","s","_alias","_table","table","__commonJoin","leftJoin","joinType","tableName","callback","joinClause","JoinClauseGroup","left","right","where","columnOrConditions","operatorOrValue","value","whereNull","whereNotNull","whereIn","values","whereNotIn","whereMatch","whereRaw","String","whereGroup","builder","group","WhereGroup","orWhereGroup","orWhere","orderBy","direction","limit","offset","groupBy","columns","having","conditions","then","onfulfilled","onrejected","t","toQuery","catch","finally","onfinally","first","ResolvedPuri","pluck","insert","data","update","increment","decrement","delete","debug","console","log","cyan","yellow","clone","newPuri","formatSQL","unformatted","keywords","formatted","forEach","keyword","regex","RegExp","replace","toUpperCase","majorClauses","clause","lines","split","indentedLines","indentLevel","line","trimmedLine","trim","closingParens","match","openingParens","Math","indent","repeat","slice","subBuilder","subGroup","on","orOn","onConflict","action","target","Array","isArray","ignore","merge","mergeObj","key","returning","columnOrColumns"],"mappings":"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"}