sonamu 0.5.6 → 0.6.0

package/dist/database/puri.js

@@ -1,2 +1,539 @@
-"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}});var _chalk=/*#__PURE__*/_interop_require_default(require("chalk"));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,tableNameOrSubquery,alias){_class_call_check(this,Puri);_define_property(this,"knex",void 0);_define_property(this,"knexQuery",void 0);this.knex=knex;if(typeof tableNameOrSubquery==="string"){this.knexQuery=knex(tableNameOrSubquery).from(tableNameOrSubquery)}else{this.knexQuery=knex.from(tableNameOrSubquery.raw().as(alias))}}_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_function"){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:"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.whereNotIn(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:"join",value:function join(tableOrSubquery){for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key]}if(_instanceof(tableOrSubquery,Puri)){var _args=_sliced_to_array(args,3),alias=_args[0],left=_args[1],right=_args[2];this.knexQuery.join(tableOrSubquery.raw().as(alias),left,right)}else if(args.length===2&&typeof args[0]==="string"&&typeof args[1]==="string"){var _args1=_sliced_to_array(args,2),left1=_args1[0],right1=_args1[1];this.knexQuery.join(tableOrSubquery,left1,right1)}else if(args.length===1&&typeof args[0]==="function"){var joinCallback=args[0];this.knexQuery.join(tableOrSubquery,function(joinClause){joinCallback(new JoinClauseGroup(joinClause))})}else{throw new Error("Invalid arguments")}return this}},{key:"leftJoin",value:function leftJoin(tableOrSubquery){for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key]}if(_instanceof(tableOrSubquery,Puri)){var _args=_sliced_to_array(args,3),alias=_args[0],left=_args[1],right=_args[2];this.knexQuery.leftJoin(tableOrSubquery.raw().as(alias),left,right)}else{var _args1=_sliced_to_array(args,2),left1=_args1[0],right1=_args1[1];this.knexQuery.leftJoin(tableOrSubquery,left1,right1)}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]}var _this_knexQuery;(_this_knexQuery=this.knexQuery).having.apply(_this_knexQuery,_to_consumable_array(conditions));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){return _async_to_generator(function(){return _ts_generator(this,function(_state){return[2,this.knexQuery.insert(data)]})}).call(this)}},{key:"update",value:function update(data){return _async_to_generator(function(){return _ts_generator(this,function(_state){return[2,this.knexQuery.update(data)]})}).call(this)}},{key:"delete",value:function _delete(){return _async_to_generator(function(){return _ts_generator(this,function(_state){return[2,this.knexQuery.delete()]})}).call(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.formatSQL(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:"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:"count",value:function count(){var column=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"*";return{_type:"sql_function",_return:"number",_sql:"COUNT(".concat(column,")")}}},{key:"sum",value:function sum(column){return{_type:"sql_function",_return:"number",_sql:"SUM(".concat(column,")")}}},{key:"avg",value:function avg(column){return{_type:"sql_function",_return:"number",_sql:"AVG(".concat(column,")")}}},{key:"max",value:function max(column){return{_type:"sql_function",_return:"number",_sql:"MAX(".concat(column,")")}}},{key:"min",value:function min(column){return{_type:"sql_function",_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_function",_return:"string",_sql:"CONCAT(".concat(args.join(", "),")")}}},{key:"upper",value:function upper(column){return{_type:"sql_function",_return:"string",_sql:"UPPER(".concat(column,")")}}},{key:"lower",value:function lower(column){return{_type:"sql_function",_return:"string",_sql:"LOWER(".concat(column,")")}}},{key:"rawString",value:function rawString(sql){return{_type:"sql_function",_return:"string",_sql:sql}}},{key:"rawNumber",value:function rawNumber(sql){return{_type:"sql_function",_return:"number",_sql:sql}}},{key:"rawBoolean",value:function rawBoolean(sql){return{_type:"sql_function",_return:"boolean",_sql:sql}}},{key:"rawDate",value:function rawDate(sql){return{_type:"sql_function",_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:"whereIn",value:function whereIn(column,values){this.builder.whereIn(column,values);return this}},{key:"orWhereIn",value:function orWhereIn(column,values){this.builder.orWhereIn(column,values);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
+import chalk from "chalk";
+import assert from "assert";
+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})`
+        };
+    }
+    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;
+    }
+    // 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(columnOrConditions, operatorOrValue, value) {
+        if (typeof 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;
+    }
+    // WHERE IN
+    whereIn(column, values) {
+        this.knexQuery.whereIn(column, values);
+        return this;
+    }
+    // WHERE NOT IN
+    whereNotIn(column, values) {
+        this.knexQuery.whereIn(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(conditions[0]);
+        } else if (conditions.length === 3) {
+            // having("count", ">", 10)
+            this.knexQuery.having(conditions[0], conditions[1], conditions[2]);
+        } else {
+            throw new Error("Invalid having arguments");
+        }
+        return this;
+    }
+    // 실행 메서드들 - thenable 구현
+    then(onfulfilled, onrejected) {
+        Naite.t("puri-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);
+    }
+    // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴
+    pluck(column) {
+        this.knexQuery.pluck(column);
+        return new ResolvedPuri(this.knexQuery);
+    }
+    // INSERT
+    insert(data) {
+        this.knexQuery.insert(data);
+        return new ResolvedPuri(this.knexQuery);
+    }
+    // UPDATE
+    update(data) {
+        this.knexQuery.update(data);
+        return new ResolvedPuri(this.knexQuery);
+    }
+    // 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);
+    }
+    // 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);
+    }
+    // DELETE
+    delete() {
+        this.knexQuery.delete();
+        return new ResolvedPuri(this.knexQuery);
+    }
+    // 확인 쿼리 리턴
+    toQuery() {
+        return this.knexQuery.toQuery();
+    }
+    // 쿼리 디버깅 로그 출력
+    debug() {
+        console.log(`${chalk.cyan("[Puri Debug]")} ${chalk.yellow(this.toQuery())}`);
+        return this;
+    }
+    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 (let 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;
+    constructor(knexQuery){
+        this.knexQuery = knexQuery;
+    }
+    toQuery() {
+        return this.knexQuery.toQuery();
+    }
+    debug() {
+        console.log(`${chalk.cyan("[Puri Debug]")} ${chalk.yellow(this.toQuery())}`);
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        Naite.t("puri-query", this.toQuery());
+        return this.knexQuery.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.knexQuery.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.knexQuery.finally(onfinally);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/database/puri.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n  AvailableColumns,\n  SelectObject,\n  ParseSelectObject,\n  WhereCondition,\n  ComparisonOperator,\n  ExtractColumnType,\n  SqlExpression,\n  Expand,\n  FulltextColumns,\n  ResultAvailableColumns,\n  InsertData,\n  SingleTableValue,\n} from \"./puri.types\";\nimport chalk from \"chalk\";\nimport assert from \"assert\";\nimport { Naite } from \"../naite/naite\";\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(\n    knex: Knex,\n    tableSpec: Record<string, string | Puri<TSchema, any, any>>\n  );\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})`,\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 (\n        typeof columnOrFunction === \"object\" &&\n        columnOrFunction._type === \"sql_expression\"\n      ) {\n        // SQL 함수인 경우\n        selectClauses.push(\n          this.knex.raw(`${columnOrFunction._sql} as ${alias}`)\n        );\n      } else {\n        // 일반 컬럼인 경우\n        const columnPath = columnOrFunction as string;\n        if (alias === columnPath) {\n          // alias와 컬럼명이 같으면 alias 생략\n          selectClauses.push(columnPath);\n        } else {\n          // alias 지정\n          selectClauses.push(`${columnPath} as ${alias}`);\n        }\n      }\n    }\n\n    this.knexQuery.select(selectClauses);\n    return this as any;\n  }\n\n  // 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  // JOIN: 서브쿼리 + Alias\n  join<TJoinAlias extends string, TSubResult>(\n    tableSpec: { [K in TJoinAlias]: Puri<TSchema, any, TSubResult> },\n    left: AvailableColumns<TTables>,\n    right: `${TJoinAlias}.${keyof TSubResult & string}`\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}.${keyof TSchema[TJoinTable] & string}`\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}.${keyof TSchema[TJoinTable] & string}`\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: (\n      j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>\n    ) => 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: (\n      j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>\n    ) => void\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable]>, TResult>;\n  // JOIN: 테이블명 + 콜백\n  join<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (\n      j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>\n    ) => 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}.${keyof TSubResult & string}`\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}.${keyof TSchema[TJoinTable] & string}`\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}.${keyof TSchema[TJoinTable] & string}`\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: (\n      j: JoinClauseGroup<TTables, Record<TJoinAlias, TSubResult>>\n    ) => 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: (\n      j: JoinClauseGroup<TTables, Record<TJoinAlias, TSchema[TJoinTable]>>\n    ) => void\n  ): Puri<TSchema, TTables & Record<TJoinAlias, TSchema[TJoinTable]>, TResult>;\n  // LEFT JOIN: 테이블명 + 콜백\n  leftJoin<TJoinTable extends keyof TSchema>(\n    tableName: TJoinTable,\n    callback: (\n      j: JoinClauseGroup<TTables, Record<TJoinTable, TSchema[TJoinTable]>>\n    ) => 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(\n    joinType: \"join\" | \"leftJoin\",\n    tableNameOrSpec: any,\n    ...args: any[]\n  ): 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(columnOrConditions: any, operatorOrValue?: any, value?: any): this {\n    if (typeof columnOrConditions === \"object\") {\n      this.knexQuery.where(columnOrConditions);\n    } else if (arguments.length === 2) {\n      if (operatorOrValue === null) {\n        this.knexQuery.whereNull(columnOrConditions);\n        return this;\n      }\n      this.knexQuery.where(columnOrConditions, operatorOrValue);\n    } else if (arguments.length === 3) {\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.whereIn(column, values);\n    return this as any;\n  }\n\n  // WHERE MATCH\n  whereMatch<TColumn extends FulltextColumns<TTables>>(\n    column: TColumn,\n    value: string\n  ): 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>>(\n    ...columns: TColumns[]\n  ): 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(conditions[0]);\n    } else if (conditions.length === 3) {\n      // having(\"count\", \">\", 10)\n      this.knexQuery.having(conditions[0], conditions[1], conditions[2]);\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?:\n      | ((value: Expand<TResult>[]) => TResult1 | PromiseLike<TResult1>)\n      | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri-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);\n  }\n\n  // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴\n  pluck<\n    TColumn extends keyof TResult | ResultAvailableColumns<TTables, TResult>,\n  >(\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);\n  }\n\n  // INSERT\n  insert(\n    data: InsertData<SingleTableValue<TTables>>\n  ): ResolvedPuri<[number], never> {\n    this.knexQuery.insert(data);\n    return new ResolvedPuri(this.knexQuery);\n  }\n\n  // UPDATE\n  update(data: WhereCondition<TTables>): ResolvedPuri<TResult, number> {\n    this.knexQuery.update(data);\n    return new ResolvedPuri(this.knexQuery);\n  }\n\n  // Increment\n  increment<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: number\n  ): ResolvedPuri<number, never> {\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);\n  }\n  // Decrement\n  decrement<TColumn extends AvailableColumns<TTables>>(\n    column: TColumn,\n    value: number\n  ): ResolvedPuri<number, never> {\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);\n  }\n\n  // DELETE\n  delete(): ResolvedPuri<number, never> {\n    this.knexQuery.delete();\n    return new ResolvedPuri(this.knexQuery);\n  }\n\n  // 확인 쿼리 리턴\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  // 쿼리 디버깅 로그 출력\n  debug(): this {\n    console.log(\n      `${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`\n    );\n    return this;\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(\n      /\\s+((?:INNER|LEFT|RIGHT|FULL OUTER)\\s+)?JOIN\\s+/gi,\n      \"\\n$1JOIN \"\n    );\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 (let 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(\n    callback: (g: WhereGroup<TTables>) => void\n  ): 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(public knexQuery: Knex.QueryBuilder) {}\n\n  toQuery(): string {\n    return this.knexQuery.toQuery();\n  }\n\n  debug(): this {\n    console.log(\n      `${chalk.cyan(\"[Puri Debug]\")} ${chalk.yellow(this.toQuery())}`\n    );\n    return this;\n  }\n\n  then<TResult1 = TResolved, TResult2 = never>(\n    onfulfilled?:\n      | ((value: TResolved) => TResult1 | PromiseLike<TResult1>)\n      | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    Naite.t(\"puri-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"],"names":["chalk","assert","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","__commonJoin","leftJoin","joinType","tableName","callback","joinClause","JoinClauseGroup","left","right","where","columnOrConditions","operatorOrValue","value","arguments","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","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"],"mappings":"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"}