@sqg/sqg 0.1.1

package/dist/sqg.mjs

@@ -0,0 +1,1569 @@
+#!/usr/bin/env node
+import { exit } from "node:process";
+import { Command } from "commander";
+import consola, { LogLevels } from "consola";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import Handlebars from "handlebars";
+import YAML from "yaml";
+import { z } from "zod";
+import { DuckDBEnumType, DuckDBInstance, DuckDBListType, DuckDBMapType, DuckDBStructType } from "@duckdb/node-api";
+import { LRParser } from "@lezer/lr";
+import { camelCase, isNotNil, pascalCase, sortBy } from "es-toolkit";
+import { Client } from "pg";
+import types from "pg-types";
+import BetterSqlite3 from "better-sqlite3";
+import { camelCase as camelCase$1, pascalCase as pascalCase$1 } from "es-toolkit/string";
+import prettier from "prettier/standalone";
+import prettierPluginJava from "prettier-plugin-java";
+import typescriptPlugin from "prettier/parser-typescript";
+import estree from "prettier/plugins/estree";
+
+//#region src/parser/sql-parser.ts
+const parser = LRParser.deserialize({
+	version: 14,
+	states: "&SOVQPOOO_QPO'#CwOdQPO'#CzOiQPO'#CvOnQQO'#C^OOQO'#Cn'#CnQVQPOOO!SQSO,59cO!_QPO,59fOOQO'#Cp'#CpO!gQQO,59bOOQO'#C}'#C}O#RQQO'#CiOOQO,58x,58xOOQO-E6l-E6lOOQO'#Co'#CoO!SQSO1G.}O!VQSO1G.}OOQO'#Cb'#CbOOQO1G.}1G.}O#cQPO1G/QOOQO-E6n-E6nO#kQPO'#CdOOQO'#Cq'#CqO#pQQO1G.|OOQO'#Cm'#CmOOQO'#Cr'#CrO$XQQO,59TOOQO-E6m-E6mO!VQSO7+$iOOQO7+$i7+$iO$iQPO,59OOOQO-E6o-E6oOOQO-E6p-E6pOOQO<<HT<<HTO$nQQO1G.jOOQO'#Ce'#CeOiQPO7+$UO$yQQO<<Gp",
+	stateData: "%r~OiOS~ORPOVQO~OSVO~OSWO~OlXO~OYZOZZO[ZO^ZO_ZO`ZO~OT_OlXOmbO~OT_Olna~OlXOofOYjaZja[ja^ja_ja`ja~OliOR]XV]Xg]X~PnOT_Olni~OSoO~OofOYjiZji[ji^ji_ji`ji~OliOR]aV]ag]a~PnOpsO~OYtOZtO[tO~OlXOYWyZWy[Wy^Wy_Wy`WyoWy~OR`o^iZTmYV_[~",
+	goto: "#prPPsPPPwP!R!VPPP!YPPP!]!a!g!q#T#ZPPP#a#ePP#ePP#iTTOUQcVSn`aRrmTgYhRusR]STj[kQUOR^UQ`VQdWTl`dQYRQaVWeYamvQm`RvuQhYRphQk[RqkTSOUTROUQ[STj[k",
+	nodeNames: "⚠ File QueryBlock BlockCommentStartSpecial Name Modifiers Config LineCommentStartSpecial SetVarLine Value StringLiteral StringLiteralSingle SQLText SQLBlock BlockComment LineComment VarRef BR",
+	maxTerm: 33,
+	skippedNodes: [0],
+	repeatNodeCount: 5,
+	tokenData: "$+x~RqOX#YXY'wYZ(iZ]#Y]^$W^p#Ypq'wqr#Yrs(}st#Ytu6^uw#Ywx9[xz#Yz{%_{}#Y}!OKi!O!P#Y!P!Q# n!Q![$!S![!]$#l!]!_#Y!_!`$&l!`!b#Y!b!c$'l!c!}$!S!}#R#Y#R#S$!S#S#T#Y#T#o$!S#o;'S#Y;'S;=`'q<%lO#YU#_][QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YS$ZTOz$Wz{$j{;'S$W;'S;=`%X<%lO$WS$mVOz$Wz{$j{!P$W!P!Q%S!Q;'S$W;'S;=`%X<%lO$WS%XOmSS%[P;=`<%l$WU%d_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!P#Y!P!Q&c!Q;'S#Y;'S;=`'q<%lO#YU&jVmS[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ'UV[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ'nP;=`<%l'PU'tP;=`<%l#Y~'|Xi~OX$WXY'wYp$Wpq'wqz$Wz{$j{;'S$W;'S;=`%X<%lO$W~(nTl~Oz$Wz{$j{;'S$W;'S;=`%X<%lO$WU)Sb[QOX(}XY*[YZ$WZ](}]^*[^p(}pq*[qr(}rs.yst(}tu*[uz(}z{/y{#O(}#O#P5V#P;'S(};'S;=`6W<%lO(}U*_ZOY*[YZ$WZr*[rs+Qsz*[z{+f{#O*[#O#P.Z#P;'S*[;'S;=`.s<%lO*[U+VTYQOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU+i]OY*[YZ$WZr*[rs+Qsz*[z{+f{!P*[!P!Q,b!Q#O*[#O#P.Z#P;'S*[;'S;=`.s<%lO*[U,gWmSOY-PZr-Prs-ls#O-P#O#P-q#P;'S-P;'S;=`.T<%lO-PQ-SWOY-PZr-Prs-ls#O-P#O#P-q#P;'S-P;'S;=`.T<%lO-PQ-qOYQQ-tTOY-PYZ-PZ;'S-P;'S;=`.T<%lO-PQ.WP;=`<%l-PU.^VOY*[YZ*[Zz*[z{+f{;'S*[;'S;=`.s<%lO*[U.vP;=`<%l*[U/Q]YQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YU0Od[QOX(}XY*[YZ$WZ](}]^*[^p(}pq*[qr(}rs.yst(}tu*[uz(}z{/y{!P(}!P!Q1^!Q#O(}#O#P5V#P;'S(};'S;=`6W<%lO(}U1e_mS[QOX2dXY-PZ]2d]^-P^p2dpq-Pqr2drs3hst2dtu-Pu#O2d#O#P4U#P;'S2d;'S;=`5P<%lO2dQ2i_[QOX2dXY-PZ]2d]^-P^p2dpq-Pqr2drs3hst2dtu-Pu#O2d#O#P4U#P;'S2d;'S;=`5P<%lO2dQ3oVYQ[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ4Z[[QOX2dXY-PYZ-PZ]2d]^-P^p2dpq-Pqt2dtu-Pu;'S2d;'S;=`5P<%lO2dQ5SP;=`<%l2dU5[^[QOX(}XY*[YZ*[Z](}]^*[^p(}pq*[qt(}tu*[uz(}z{/y{;'S(};'S;=`6W<%lO(}U6ZP;=`<%l(}U6cV[QOz$Wz{$j{#o$W#o#p6x#p;'S$W;'S;=`%X<%lO$WU6{]Oz$Wz{$j{!Q$W!Q![7t![!c$W!c!}7t!}#R$W#R#S7t#S#T$W#T#o7t#o;'S$W;'S;=`%X<%lO$WU7w_Oz$Wz{$j{!Q$W!Q![7t![!c$W!c!}7t!}#R$W#R#S7t#S#T$W#T#o7t#o#q$W#q#r8v#r;'S$W;'S;=`%X<%lO$WU8{T`QOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU9ab[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[U:lZOY:iYZ$WZw:iwx;_xz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU;dTZQOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU;v]OY:iYZ$WZw:iwx;_xz:iz{;s{!P:i!P!Q<o!Q#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU<tWmSOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q=aWOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q>OOZQQ>RXOY=^YZ=^Zw=^wx>nx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q>sWZQOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q?`P;=`<%l=^U?fZOY:iYZ:iZw:iwx@Xxz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU@^ZZQOY:iYZ$WZw:iwx;_xz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iUASP;=`<%l:iUA^]ZQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YUB[d[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{!P9[!P!QCj!Q#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UCq_mS[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQDu_[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQE{VZQ[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQFg`[QOXDpXY=^YZ=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxGix#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQGp_ZQ[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQHrP;=`<%lDpUHzb[QOX9[XY:iYZ:iZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxJSxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UJZbZQ[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UKfP;=`<%l9[VKn_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{}#Y}!OLm!O;'S#Y;'S;=`'q<%lO#YVLtf_Q[QOXNYXY!&vYZ$WZ]NY]^! ]^pNYpq!&vqtNYtu! ]uzNYz{!#k{!gNY!g!h!6m!h!oNY!o!p!;_!p!sNY!s!t!Bg!t!vNY!v!w!G]!w;'SNY;'S;=`!&p<%lONYUNa^_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{;'SNY;'S;=`!&p<%lONYU! bV_QOY! ]YZ$WZz! ]z{! w{;'S! ];'S;=`!#e<%lO! ]U! |X_QOY! ]YZ$WZz! ]z{! w{!P! ]!P!Q!!i!Q;'S! ];'S;=`!#e<%lO! ]U!!pSmS_QOY!!|Z;'S!!|;'S;=`!#_<%lO!!|Q!#RS_QOY!!|Z;'S!!|;'S;=`!#_<%lO!!|Q!#bP;=`<%l!!|U!#hP;=`<%l! ]U!#r`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!PNY!P!Q!$t!Q;'SNY;'S;=`!&p<%lONYU!$}ZmS_Q[QOX!%pXY!!|Z]!%p]^!!|^p!%ppq!!|qt!%ptu!!|u;'S!%p;'S;=`!&j<%lO!%pQ!%wZ_Q[QOX!%pXY!!|Z]!%p]^!!|^p!%ppq!!|qt!%ptu!!|u;'S!%p;'S;=`!&j<%lO!%pQ!&mP;=`<%l!%pU!&sP;=`<%lNYV!&{b_QOX! ]XY!&vYZ$WZp! ]pq!&vqz! ]z{! w{!g! ]!g!h!(T!h!o! ]!o!p!*u!p!s! ]!s!t!.}!t!v! ]!v!w!1s!w;'S! ];'S;=`!#e<%lO! ]V!(YX_QOY! ]YZ$WZz! ]z{! w{!z! ]!z!{!(u!{;'S! ];'S;=`!#e<%lO! ]V!(zX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!)g!h;'S! ];'S;=`!#e<%lO! ]V!)lX_QOY! ]YZ$WZz! ]z{! w{!e! ]!e!f!*X!f;'S! ];'S;=`!#e<%lO! ]V!*`VVR_QOY! ]YZ$WZz! ]z{! w{;'S! ];'S;=`!#e<%lO! ]V!*zX_QOY! ]YZ$WZz! ]z{! w{!k! ]!k!l!+g!l;'S! ];'S;=`!#e<%lO! ]V!+lX_QOY! ]YZ$WZz! ]z{! w{!i! ]!i!j!,X!j;'S! ];'S;=`!#e<%lO! ]V!,^X_QOY! ]YZ$WZz! ]z{! w{!t! ]!t!u!,y!u;'S! ];'S;=`!#e<%lO! ]V!-OX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!-k!d;'S! ];'S;=`!#e<%lO! ]V!-pX_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!.]!w;'S! ];'S;=`!#e<%lO! ]V!.bX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!*X!h;'S! ];'S;=`!#e<%lO! ]V!/SX_QOY! ]YZ$WZz! ]z{! w{!w! ]!w!x!/o!x;'S! ];'S;=`!#e<%lO! ]V!/tX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!0a!h;'S! ];'S;=`!#e<%lO! ]V!0fX_QOY! ]YZ$WZz! ]z{! w{!t! ]!t!u!1R!u;'S! ];'S;=`!#e<%lO! ]V!1WX_QOY! ]YZ$WZz! ]z{! w{!{! ]!{!|!*X!|;'S! ];'S;=`!#e<%lO! ]V!1xX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!2e!h;'S! ];'S;=`!#e<%lO! ]V!2jX_QOY! ]YZ$WZz! ]z{! w{!u! ]!u!v!3V!v;'S! ];'S;=`!#e<%lO! ]V!3[X_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!3w!w;'S! ];'S;=`!#e<%lO! ]V!3|X_QOY! ]YZ$WZz! ]z{! w{!f! ]!f!g!4i!g;'S! ];'S;=`!#e<%lO! ]V!4nX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!5Z!d;'S! ];'S;=`!#e<%lO! ]V!5`X_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!5{!w;'S! ];'S;=`!#e<%lO! ]V!6QX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!*X!d;'S! ];'S;=`!#e<%lO! ]V!6t`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!zNY!z!{!7v!{;'SNY;'S;=`!&p<%lONYV!7}`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!9P!h;'SNY;'S;=`!&p<%lONYV!9W`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!eNY!e!f!:Y!f;'SNY;'S;=`!&p<%lONYV!:c^VR_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{;'SNY;'S;=`!&p<%lONYV!;f`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!kNY!k!l!<h!l;'SNY;'S;=`!&p<%lONYV!<o`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!iNY!i!j!=q!j;'SNY;'S;=`!&p<%lONYV!=x`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!tNY!t!u!>z!u;'SNY;'S;=`!&p<%lONYV!?R`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!@T!d;'SNY;'S;=`!&p<%lONYV!@[`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w!A^!w;'SNY;'S;=`!&p<%lONYV!Ae`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!:Y!h;'SNY;'S;=`!&p<%lONYV!Bn`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!wNY!w!x!Cp!x;'SNY;'S;=`!&p<%lONYV!Cw`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!Dy!h;'SNY;'S;=`!&p<%lONYV!EQ`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!tNY!t!u!FS!u;'SNY;'S;=`!&p<%lONYV!FZ`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!{NY!{!|!:Y!|;'SNY;'S;=`!&p<%lONYV!Gd`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!Hf!h;'SNY;'S;=`!&p<%lONYV!Hm`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!uNY!u!v!Io!v;'SNY;'S;=`!&p<%lONYV!Iv`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w!Jx!w;'SNY;'S;=`!&p<%lONYV!KP`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!fNY!f!g!LR!g;'SNY;'S;=`!&p<%lONYV!LY`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!M[!d;'SNY;'S;=`!&p<%lONYV!Mc`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w!Ne!w;'SNY;'S;=`!&p<%lONYV!Nl`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!:Y!d;'SNY;'S;=`!&p<%lONYV# s][QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{#!l{;'S#Y;'S;=`'q<%lO#YV#!qh[QOX#$]XY#(^YZ#(^Z]#$]]^#%Z^p#$]pq#(^qt#$]tu#%Zuz#$]z{#&d{!P#$]!P!Q#4c!Q!g#$]!g!h#9`!h!o#$]!o!p#=l!p!s#$]!s!t#DU!t!v#$]!v!w#Hf!w;'S#$];'S;=`#(W<%lO#$]U#$b][QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{;'S#$];'S;=`#(W<%lO#$]U#%^TOz#%Zz{#%m{;'S#%Z;'S;=`#&^<%lO#%ZU#%pVOz#%Zz{#%m{!P#%Z!P!Q#&V!Q;'S#%Z;'S;=`#&^<%lO#%ZU#&^O^QmSU#&aP;=`<%l#%ZU#&i_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!P#$]!P!Q#'h!Q;'S#$];'S;=`#(W<%lO#$]U#'qV^QmS[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PU#(ZP;=`<%l#$]V#(abOX#%ZXY#(^YZ#(^Zp#%Zpq#(^qz#%Zz{#%m{!g#%Z!g!h#)i!h!o#%Z!o!p#+i!p!s#%Z!s!t#.o!t!v#%Z!v!w#0s!w;'S#%Z;'S;=`#&^<%lO#%ZV#)lVOz#%Zz{#%m{!z#%Z!z!{#*R!{;'S#%Z;'S;=`#&^<%lO#%ZV#*UVOz#%Zz{#%m{!g#%Z!g!h#*k!h;'S#%Z;'S;=`#&^<%lO#%ZV#*nVOz#%Zz{#%m{!e#%Z!e!f#+T!f;'S#%Z;'S;=`#&^<%lO#%ZV#+YTRROz#%Zz{#%m{;'S#%Z;'S;=`#&^<%lO#%ZV#+lVOz#%Zz{#%m{!k#%Z!k!l#,R!l;'S#%Z;'S;=`#&^<%lO#%ZV#,UVOz#%Zz{#%m{!i#%Z!i!j#,k!j;'S#%Z;'S;=`#&^<%lO#%ZV#,nVOz#%Zz{#%m{!t#%Z!t!u#-T!u;'S#%Z;'S;=`#&^<%lO#%ZV#-WVOz#%Zz{#%m{!c#%Z!c!d#-m!d;'S#%Z;'S;=`#&^<%lO#%ZV#-pVOz#%Zz{#%m{!v#%Z!v!w#.V!w;'S#%Z;'S;=`#&^<%lO#%ZV#.YVOz#%Zz{#%m{!g#%Z!g!h#+T!h;'S#%Z;'S;=`#&^<%lO#%ZV#.rVOz#%Zz{#%m{!w#%Z!w!x#/X!x;'S#%Z;'S;=`#&^<%lO#%ZV#/[VOz#%Zz{#%m{!g#%Z!g!h#/q!h;'S#%Z;'S;=`#&^<%lO#%ZV#/tVOz#%Zz{#%m{!t#%Z!t!u#0Z!u;'S#%Z;'S;=`#&^<%lO#%ZV#0^VOz#%Zz{#%m{!{#%Z!{!|#+T!|;'S#%Z;'S;=`#&^<%lO#%ZV#0vVOz#%Zz{#%m{!g#%Z!g!h#1]!h;'S#%Z;'S;=`#&^<%lO#%ZV#1`VOz#%Zz{#%m{!u#%Z!u!v#1u!v;'S#%Z;'S;=`#&^<%lO#%ZV#1xVOz#%Zz{#%m{!v#%Z!v!w#2_!w;'S#%Z;'S;=`#&^<%lO#%ZV#2bVOz#%Zz{#%m{!f#%Z!f!g#2w!g;'S#%Z;'S;=`#&^<%lO#%ZV#2zVOz#%Zz{#%m{!c#%Z!c!d#3a!d;'S#%Z;'S;=`#&^<%lO#%ZV#3dVOz#%Zz{#%m{!v#%Z!v!w#3y!w;'S#%Z;'S;=`#&^<%lO#%ZV#3|VOz#%Zz{#%m{!c#%Z!c!d#+T!d;'S#%Z;'S;=`#&^<%lO#%ZU#4j]mS[QOX#5cXZ#6aZ]#5c]^#6a^p#5cpq#6aqt#5ctu#6auz#5cz{#7h{;'S#5c;'S;=`#9Y<%lO#5cQ#5h][QOX#5cXZ#6aZ]#5c]^#6a^p#5cpq#6aqt#5ctu#6auz#5cz{#7h{;'S#5c;'S;=`#9Y<%lO#5cQ#6dTOz#6az{#6s{;'S#6a;'S;=`#7b<%lO#6aQ#6vVOz#6az{#6s{!P#6a!P!Q#7]!Q;'S#6a;'S;=`#7b<%lO#6aQ#7bO^QQ#7eP;=`<%l#6aQ#7m_[QOX#5cXZ#6aZ]#5c]^#6a^p#5cpq#6aqt#5ctu#6auz#5cz{#7h{!P#5c!P!Q#8l!Q;'S#5c;'S;=`#9Y<%lO#5cQ#8sV^Q[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ#9]P;=`<%l#5cV#9e_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!z#$]!z!{#:d!{;'S#$];'S;=`#(W<%lO#$]V#:i_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!g#$]!g!h#;h!h;'S#$];'S;=`#(W<%lO#$]V#;m_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!e#$]!e!f#<l!f;'S#$];'S;=`#(W<%lO#$]V#<s]RR[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{;'S#$];'S;=`#(W<%lO#$]V#=q_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!k#$]!k!l#>p!l;'S#$];'S;=`#(W<%lO#$]V#>u_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!i#$]!i!j#?t!j;'S#$];'S;=`#(W<%lO#$]V#?y_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!t#$]!t!u#@x!u;'S#$];'S;=`#(W<%lO#$]V#@}_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!c#$]!c!d#A|!d;'S#$];'S;=`#(W<%lO#$]V#BR_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!v#$]!v!w#CQ!w;'S#$];'S;=`#(W<%lO#$]V#CV_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!g#$]!g!h#<l!h;'S#$];'S;=`#(W<%lO#$]V#DZ_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!w#$]!w!x#EY!x;'S#$];'S;=`#(W<%lO#$]V#E__[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!g#$]!g!h#F^!h;'S#$];'S;=`#(W<%lO#$]V#Fc_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!t#$]!t!u#Gb!u;'S#$];'S;=`#(W<%lO#$]V#Gg_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!{#$]!{!|#<l!|;'S#$];'S;=`#(W<%lO#$]V#Hk_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!g#$]!g!h#Ij!h;'S#$];'S;=`#(W<%lO#$]V#Io_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!u#$]!u!v#Jn!v;'S#$];'S;=`#(W<%lO#$]V#Js_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!v#$]!v!w#Kr!w;'S#$];'S;=`#(W<%lO#$]V#Kw_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!f#$]!f!g#Lv!g;'S#$];'S;=`#(W<%lO#$]V#L{_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!c#$]!c!d#Mz!d;'S#$];'S;=`#(W<%lO#$]V#NP_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!v#$]!v!w$ O!w;'S#$];'S;=`#(W<%lO#$]V$ T_[QOX#$]XZ#%ZZ]#$]]^#%Z^p#$]pq#%Zqt#$]tu#%Zuz#$]z{#&d{!c#$]!c!d#<l!d;'S#$];'S;=`#(W<%lO#$]V$!ZeSP[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$!S![!c#Y!c!}$!S!}#R#Y#R#S$!S#S#T#Y#T#o$!S#o;'S#Y;'S;=`'q<%lO#Y~$#qe[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$%S![!c#Y!c!}$%S!}#R#Y#R#S$%S#S#T#Y#T#o$%S#o;'S#Y;'S;=`'q<%lO#Y~$%ZeT~[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$%S![!c#Y!c!}$%S!}#R#Y#R#S$%S#S#T#Y#T#o$%S#o;'S#Y;'S;=`'q<%lO#YV$&s]pP[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YU$'q_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#g#Y#g#h$(p#h;'S#Y;'S;=`'q<%lO#YU$(u_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#X#Y#X#Y$)t#Y;'S#Y;'S;=`'q<%lO#YU$)y_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#h#Y#h#i$*x#i;'S#Y;'S;=`'q<%lO#YU$+P]oQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#Y",
+	tokenizers: [
+		0,
+		1,
+		2
+	],
+	topRules: { "File": [0, 1] },
+	tokenPrec: 205
+});
+
+//#endregion
+//#region src/sql-query.ts
+var ListType = class {
+	constructor(baseType) {
+		this.baseType = baseType;
+	}
+	toString() {
+		return `${this.baseType.toString()}[]`;
+	}
+};
+var StructType = class {
+	constructor(fields) {
+		this.fields = fields;
+	}
+	toString() {
+		return `STRUCT(${this.fields.map((f) => `"${f.name}" ${f.type.toString()}`).join(", ")})`;
+	}
+};
+var MapType = class {
+	constructor(keyType, valueType) {
+		this.keyType = keyType;
+		this.valueType = valueType;
+	}
+	toString() {
+		return `MAP(${this.keyType.toString()}, ${this.valueType.toString()})`;
+	}
+};
+var EnumType = class {
+	constructor(values) {
+		this.values = values;
+	}
+	toString() {
+		return `ENUM(${this.values.map((v) => `'${v}'`).join(", ")})`;
+	}
+};
+var SQLQuery = class {
+	columns;
+	allColumns;
+	constructor(filename, id, rawQuery, queryAnonymous, queryNamed, queryPositional, type, isOne, isPluck, variables, config) {
+		this.filename = filename;
+		this.id = id;
+		this.rawQuery = rawQuery;
+		this.queryAnonymous = queryAnonymous;
+		this.queryNamed = queryNamed;
+		this.queryPositional = queryPositional;
+		this.type = type;
+		this.isOne = isOne;
+		this.isPluck = isPluck;
+		this.variables = variables;
+		this.config = config;
+		this.columns = [];
+	}
+	get isQuery() {
+		return this.type === "QUERY";
+	}
+	get isExec() {
+		return this.type === "EXEC";
+	}
+	get isMigrate() {
+		return this.type === "MIGRATE";
+	}
+	get isTestdata() {
+		return this.type === "TESTDATA";
+	}
+	get skipGenerateFunction() {
+		return this.isTestdata || this.isMigrate || this.id.startsWith("_");
+	}
+	validateVariables() {
+		const missingVars = [];
+		const varRegex = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+		let match;
+		while (true) {
+			match = varRegex.exec(this.rawQuery);
+			if (match === null) break;
+			const varName = match[1];
+			if (!this.variables.has(varName)) missingVars.push(varName);
+		}
+		return missingVars;
+	}
+};
+function parseSQLQueries(filePath, extraVariables) {
+	const content = readFileSync(filePath, "utf-8");
+	consola.info(`Parsing SQL file: ${filePath}`);
+	consola.debug(`File start: ${content.slice(0, 200)}`);
+	const queries = [];
+	const cursor = parser.parse(content).cursor();
+	function getStr(nodeName, optional = false) {
+		const node = cursor.node.getChild(nodeName);
+		if (!node) {
+			if (optional) return;
+			throw new Error(`${nodeName} not found`);
+		}
+		return nodeStr(node);
+	}
+	function nodeStr(node) {
+		return content.slice(node.from, node.to);
+	}
+	const queryNames = /* @__PURE__ */ new Set();
+	do
+		if (cursor.name === "QueryBlock") {
+			const queryType = (getStr("LineCommentStartSpecial", true) ?? getStr("BlockCommentStartSpecial")).replace("--", "").replace("/*", "").trim();
+			const name = getStr("Name").trim();
+			const modifiers = cursor.node.getChildren("Modifiers").map((node) => nodeStr(node));
+			const isOne = modifiers.includes(":one");
+			const isPluck = modifiers.includes(":pluck");
+			let configStr = getStr("Config", true);
+			if (configStr?.endsWith("*/")) configStr = configStr.slice(0, -2);
+			let config = null;
+			if (configStr) config = Config.fromYaml(name, filePath, configStr);
+			const setVars = cursor.node.getChildren("SetVarLine");
+			const variables = /* @__PURE__ */ new Map();
+			for (const setVar of setVars) {
+				const varName = nodeStr(setVar.getChild("Name"));
+				const value = nodeStr(setVar.getChild("Value"));
+				variables.set(varName, value.trim());
+			}
+			function getVariable(varName) {
+				if (variables.has(varName)) return variables.get(varName);
+				for (const extraVariable of extraVariables) if (extraVariable.name === varName) {
+					variables.set(varName, extraVariable.value);
+					return extraVariable.value;
+				}
+				throw error(`Variable '${varName}' not found`);
+			}
+			const sqlNode = cursor.node.getChild("SQLBlock");
+			if (!sqlNode) throw new Error(`'SQLBlock' not found`);
+			const sqlContentStr = nodeStr(sqlNode).trim();
+			const sqlCursor = sqlNode.cursor();
+			let from = -1;
+			let to = -1;
+			function error(message) {
+				return /* @__PURE__ */ new Error(`${message} in ${filePath} query '${name}': ${message}`);
+			}
+			class SQLQueryBuilder {
+				sqlParts = [];
+				appendSql(sql$1) {
+					this.sqlParts.push(sql$1);
+				}
+				appendVariable(varName, value) {
+					this.sqlParts.push({
+						name: varName,
+						value
+					});
+				}
+				trim() {
+					const lastPart = this.sqlParts.length > 0 ? this.sqlParts[this.sqlParts.length - 1] : null;
+					if (lastPart && typeof lastPart === "string") this.sqlParts[this.sqlParts.length - 1] = lastPart.trimEnd();
+				}
+				parameters() {
+					return this.sqlParts.filter((part) => typeof part !== "string" && !part.name.startsWith("sources_"));
+				}
+				toSqlWithAnonymousPlaceholders() {
+					let sql$1 = "";
+					const sqlParts = [];
+					for (const part of this.sqlParts) if (typeof part === "string") {
+						sql$1 += part;
+						sqlParts.push(part);
+					} else {
+						if (sql$1.length > 0) {
+							const last = sql$1[sql$1.length - 1];
+							if (last !== " " && last !== "=" && last !== ">" && last !== "<") sql$1 += " ";
+						}
+						sql$1 += "?";
+						if (part.name.startsWith("sources_")) sqlParts.push(part);
+						else sqlParts.push("?");
+					}
+					return {
+						parameters: this.parameters(),
+						sql: sql$1,
+						sqlParts
+					};
+				}
+				toSqlWithPositionalPlaceholders() {
+					const parameters = [];
+					return {
+						parameters,
+						sqlParts: [],
+						sql: this.sqlParts.map((part) => {
+							if (typeof part === "string") return part;
+							const varName = part.name;
+							const value = part.value;
+							let pos = parameters.findIndex((p) => p.name === varName);
+							if (pos < 0) {
+								parameters.push({
+									name: varName,
+									value
+								});
+								pos = parameters.length - 1;
+							}
+							return ` $${pos + 1} `;
+						}).join("").trim()
+					};
+				}
+				toSqlWithNamedPlaceholders() {
+					return {
+						parameters: this.parameters(),
+						sqlParts: [],
+						sql: this.sqlParts.map((part) => {
+							if (typeof part === "string") return part;
+							return `$${part.name}`;
+						}).join("").trim()
+					};
+				}
+			}
+			const sql = new SQLQueryBuilder();
+			if (sqlCursor.firstChild()) {
+				do {
+					const child = sqlCursor.node;
+					if (child.name === "BlockComment" || child.name === "LineComment") {
+						if (to > from) sql.appendSql(content.slice(from, to));
+						from = child.to;
+						sql.appendSql(" ");
+						continue;
+					}
+					if (child.name === "VarRef") {
+						const varRef = nodeStr(child);
+						if (!varRef.startsWith("${") || !varRef.endsWith("}")) throw error(`Invalid variable reference: ${varRef}`);
+						const varName = varRef.replace("${", "").replace("}", "");
+						const value = getVariable(varName);
+						if (to > from) sql.appendSql(content.slice(from, to));
+						from = child.to;
+						sql.appendVariable(varName, value);
+					} else {
+						if (from < 0) from = child.from;
+						to = child.to;
+					}
+				} while (sqlCursor.nextSibling());
+				if (to > from) sql.appendSql(content.slice(from, to));
+				sql.trim();
+			}
+			consola.debug("Parsed query:", {
+				type: queryType,
+				name,
+				modifiers,
+				variables: Object.fromEntries(variables),
+				sqlContent: sqlContentStr,
+				sql,
+				config
+			});
+			const query = new SQLQuery(filePath, name, sqlContentStr, sql.toSqlWithAnonymousPlaceholders(), sql.toSqlWithNamedPlaceholders(), sql.toSqlWithPositionalPlaceholders(), queryType, isOne, isPluck, variables, config);
+			if (queryNames.has(name)) throw new Error(`Duplicate query name in ${filePath}: ${name}`);
+			queryNames.add(name);
+			queries.push(query);
+			consola.debug(`Added query: ${name} (${queryType})`);
+		}
+	while (cursor.next());
+	consola.info(`Total queries parsed: ${queries.length}`);
+	consola.info(`Query names: ${queries.map((q) => q.id).join(", ")}`);
+	return queries;
+}
+
+//#endregion
+//#region src/db/types.ts
+async function initializeDatabase(queries, execQueries) {
+	const migrationQueries = queries.filter((q) => q.isMigrate);
+	sortBy(migrationQueries, [(q) => Number(q.id.split("_")[1])]);
+	for (const query of migrationQueries) try {
+		await execQueries(query);
+	} catch (error) {
+		consola.error("Failed to initialize database:" + error.message + " when running query:\n\n " + query.rawQuery);
+		throw error;
+	}
+	const testdataQueries = queries.filter((q) => q.isTestdata);
+	for (const query of testdataQueries) try {
+		await execQueries(query);
+	} catch (error) {
+		consola.error("Failed to initialize testdata:" + error.message + " when running query:\n\n " + query.rawQuery);
+		throw error;
+	}
+	if (migrationQueries.length + testdataQueries.length === 0) consola.warn("No migration or testdata queries found");
+	consola.success("Database initialized successfully");
+}
+
+//#endregion
+//#region src/db/duckdb.ts
+const duckdb = new class {
+	db;
+	connection;
+	async initializeDatabase(queries) {
+		this.db = await DuckDBInstance.create(":memory:");
+		this.connection = await this.db.connect();
+		await initializeDatabase(queries, async (query) => {
+			await this.connection.run(query.rawQuery);
+		});
+	}
+	async executeQueries(queries) {
+		const connection = this.connection;
+		if (!connection) throw new Error("Database not initialized");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				consola.info(`Executing query: ${query.id}`);
+				await this.executeQuery(connection, query);
+				if (query.isQuery) {}
+				consola.success(`Query ${query.id} executed successfully`);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	async executeQuery(connection, query) {
+		const statement = query.queryAnonymous;
+		try {
+			consola.debug("Query:", statement.sql, statement.sqlParts);
+			const sql = statement.sqlParts.map((part) => {
+				if (typeof part === "string") return part;
+				return ` ${part.value} `;
+			}).join("");
+			const stmt = await connection.prepare(sql);
+			for (let i = 0; i < stmt.parameterCount; i++) stmt.bindValue(i + 1, statement.parameters[i].value);
+			if (query.isQuery) {
+				const result = await stmt.stream();
+				const columnNames = result.columnNames();
+				const columnTypes = result.columnTypes();
+				consola.debug("Columns:", columnNames);
+				consola.debug("Types:", columnTypes.map((t) => `${t.toString()} / ${t.constructor.name}`));
+				function convertType(type) {
+					if (type instanceof DuckDBListType) return new ListType(convertType(type.valueType));
+					if (type instanceof DuckDBStructType) return new StructType(type.entryTypes.map((t, index) => ({
+						name: type.entryNames[index],
+						type: convertType(t),
+						nullable: true
+					})));
+					if (type instanceof DuckDBMapType) return new MapType({
+						name: "key",
+						type: convertType(type.keyType),
+						nullable: true
+					}, {
+						name: "value",
+						type: convertType(type.valueType),
+						nullable: true
+					});
+					if (type instanceof DuckDBEnumType) return new EnumType(type.values);
+					return type.toString();
+				}
+				query.columns = columnNames.map((name, index) => ({
+					name,
+					type: convertType(columnTypes[index]),
+					nullable: true
+				}));
+			}
+			if (query.isQuery) {
+				if (query.isOne) return await stmt.runAndRead();
+				return await stmt.runAndReadAll();
+			}
+			return await stmt.run();
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}':`, error);
+			throw error;
+		}
+	}
+	close() {
+		this.connection.closeSync();
+	}
+}();
+
+//#endregion
+//#region src/db/postgres.ts
+const databaseName = "sqg-db-temp";
+const connectionString = "postgresql://sqg:secret@localhost:15432/sqg-db";
+const connectionStringTemp = `postgresql://sqg:secret@localhost:15432/${databaseName}`;
+const typeIdToName = /* @__PURE__ */ new Map();
+for (const [name, id] of Object.entries(types.builtins)) typeIdToName.set(Number(id), name);
+const postgres = new class {
+	dbInitial;
+	db;
+	async initializeDatabase(queries) {
+		this.dbInitial = new Client({ connectionString });
+		this.db = new Client({ connectionString: connectionStringTemp });
+		await this.dbInitial.connect();
+		try {
+			await this.dbInitial.query(`DROP DATABASE "${databaseName}";`);
+		} catch (error) {}
+		try {
+			await this.dbInitial.query(`CREATE DATABASE "${databaseName}";`);
+		} catch (error) {
+			consola.error("Error creating database:", error);
+		}
+		await this.db.connect();
+		await initializeDatabase(queries, async (query) => {
+			await this.db.query(query.rawQuery);
+		});
+	}
+	async executeQueries(queries) {
+		const db = this.db;
+		if (!db) throw new Error("Database not initialized");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				consola.debug(`Executing query: ${query.id}`);
+				await this.executeQuery(db, query);
+				if (query.isQuery) {}
+				consola.success(`Query ${query.id} executed successfully`);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	async executeQuery(db, query) {
+		const statement = query.queryPositional;
+		try {
+			consola.info("Query:", statement.sql);
+			let result;
+			try {
+				await db.query("BEGIN");
+				result = await db.query(statement.sql, statement.parameters);
+			} finally {
+				await db.query("ROLLBACK");
+			}
+			if (query.isQuery) {
+				const columnNames = result.fields.map((field) => field.name);
+				const columnTypes = result.fields.map((field) => {
+					return typeIdToName.get(field.dataTypeID) || `type_${field.dataTypeID}`;
+				});
+				consola.debug("Columns:", columnNames);
+				consola.debug("Types:", columnTypes);
+				query.columns = columnNames.map((name, index) => ({
+					name,
+					type: columnTypes[index],
+					nullable: true
+				}));
+			}
+			if (query.isQuery) {
+				if (query.isOne) return result.rows[0] || null;
+				return result.rows;
+			}
+			return result;
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}':`, error);
+			throw error;
+		}
+	}
+	async close() {
+		await this.db.end();
+		await this.dbInitial.query(`DROP DATABASE "${databaseName}"`);
+		await this.dbInitial.end();
+	}
+}();
+
+//#endregion
+//#region src/db/sqlite.ts
+const sqlite = new class {
+	db;
+	async initializeDatabase(queries) {
+		const db = new BetterSqlite3(":memory:");
+		await initializeDatabase(queries, (query) => {
+			db.exec(query.rawQuery);
+			return Promise.resolve();
+		});
+		this.db = db;
+	}
+	executeQueries(queries) {
+		const db = this.db;
+		if (!db) throw new Error("Database not initialized");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				consola.info(`Executing query: ${query.id}`);
+				this.executeQuery(db, query);
+				if (query.isQuery) {}
+				consola.success(`Query ${query.id} executed successfully`);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	close() {
+		this.db.close();
+	}
+	getTableInfo(db, table) {
+		const info = db.pragma(`table_info('${table}')`);
+		return new Map(info.map((col) => [col.name, col]));
+	}
+	executeQuery(db, query) {
+		const statement = query.queryAnonymous;
+		try {
+			consola.debug("Query:", statement.sql);
+			const stmt = db.prepare(statement.sql);
+			if (query.isQuery) {
+				const info = stmt.columns();
+				const tables = new Set(info.map((col) => col.table).filter(isNotNil));
+				const data = new Map(Array.from(tables).map((table) => [table, this.getTableInfo(db, table)]));
+				query.columns = info.map((col) => {
+					const colInfo = col.table ? data.get(col.table)?.get(col.name) : null;
+					return {
+						name: col.name,
+						type: col.type || "unknown",
+						nullable: colInfo?.pk === 0 && colInfo?.notnull === 0
+					};
+				});
+			}
+			if (query.isQuery) {
+				if (query.isOne) return stmt.get(...statement.parameters.map((p) => p.value));
+				return stmt.all(...statement.parameters.map((p) => p.value));
+			}
+			return stmt.run(...statement.parameters.map((p) => p.value));
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}' in ${query.filename}:\n ${statement.sql} \n ${statement.parameters.map((p) => p.value).join(", ")}`, error);
+			throw error;
+		}
+	}
+}();
+
+//#endregion
+//#region src/db/index.ts
+function getDatabaseEngine(engine) {
+	switch (engine) {
+		case "sqlite": return sqlite;
+		case "duckdb": return duckdb;
+		case "postgres": return postgres;
+		default: throw new Error(`Unsupported database engine: ${engine}`);
+	}
+}
+
+//#endregion
+//#region src/type-mapping.ts
+/**
+* Abstract base class for mapping SQL column types to target language types.
+* Subclasses implement language-specific type mappings (e.g., Java, TypeScript).
+*/
+var TypeMapper = class {
+	/**
+	* Returns the target language type name for a given SQL column.
+	* Handles complex types (lists, structs, maps) by recursively resolving nested types.
+	* @param column - The column information including name, type, and nullability
+	* @param path - Optional prefix path for nested type references (e.g., "OuterStruct.")
+	* @returns The fully qualified type name in the target language
+	*/
+	getTypeName(column, path = "") {
+		if (column.type instanceof ListType) {
+			const elementType = this.getTypeName({
+				name: column.name,
+				type: column.type.baseType,
+				nullable: true
+			});
+			return path + this.formatListType(elementType);
+		}
+		if (column.type instanceof StructType) return path + this.formatStructTypeName(column.name);
+		if (column.type instanceof MapType) return path + this.formatMapTypeName(column.name);
+		if (!column.type) throw new Error(`Expected ColumnType ${JSON.stringify(column)}`);
+		return this.mapPrimitiveType(column.type.toString(), column.nullable);
+	}
+	/**
+	* Wraps a column's type in the target language's list/array type.
+	* @param column - The column whose type should be wrapped in a list
+	* @returns The list type representation (e.g., "List<String>" for Java)
+	*/
+	listType(column) {
+		const baseType = this.getTypeName(column);
+		return this.formatListType(baseType);
+	}
+	/**
+	* Generates type declarations for complex types (structs, nested lists).
+	* For structs, generates a full type/interface declaration.
+	* For lists, recursively processes the element type.
+	* @param column - The column containing a complex type
+	* @param path - Optional prefix path for nested type references
+	* @returns Generated type declaration code, or empty string for primitive types
+	*/
+	getDeclarations(column, path = "") {
+		if (column.type instanceof StructType) return this.generateStructDeclaration(column, path);
+		if (column.type instanceof ListType) return this.getDeclarations({
+			name: column.name,
+			type: column.type.baseType,
+			nullable: true
+		}, path);
+		return "";
+	}
+};
+/**
+* Type mapper for generating Java types from SQL column types.
+* Maps SQL types to Java types (e.g., INTEGER -> Integer, VARCHAR -> String).
+* Generates Java records for struct types and handles Java reserved keywords.
+*/
+var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
+	typeMap = {
+		INTEGER: "Integer",
+		REAL: "Double",
+		TEXT: "String",
+		BLOB: "byte[]",
+		BOOLEAN: "Boolean",
+		DATE: "LocalDate",
+		DATETIME: "LocalDateTime",
+		TIMESTAMP: "LocalDateTime",
+		NULL: "null",
+		UNKNOWN: "Object",
+		DOUBLE: "Double",
+		FLOAT: "Float",
+		VARCHAR: "String",
+		TINYINT: "Byte",
+		SMALLINT: "Short",
+		BIGINT: "Long",
+		HUGEINT: "BigInteger",
+		UHUGEINT: "BigInteger",
+		UTINYINT: "Short",
+		USMALLINT: "Integer",
+		UINTEGER: "Long",
+		UBIGINT: "BigInteger",
+		TIME: "LocalTime",
+		"TIME WITH TIME ZONE": "OffsetTime",
+		TIMESTAMP_S: "Instant",
+		TIMESTAMP_MS: "Instant",
+		TIMESTAMP_NS: "Instant",
+		"TIMESTAMP WITH TIME ZONE": "Instant",
+		UUID: "UUID",
+		INTERVAL: "String",
+		BIT: "String",
+		BIGNUM: "BigDecimal",
+		INT4: "Integer"
+	};
+	static javaReservedKeywords = new Set([
+		"abstract",
+		"assert",
+		"boolean",
+		"break",
+		"byte",
+		"case",
+		"catch",
+		"char",
+		"class",
+		"const",
+		"continue",
+		"default",
+		"do",
+		"double",
+		"else",
+		"enum",
+		"extends",
+		"final",
+		"finally",
+		"float",
+		"for",
+		"goto",
+		"if",
+		"implements",
+		"import",
+		"instanceof",
+		"int",
+		"interface",
+		"long",
+		"native",
+		"new",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"return",
+		"short",
+		"static",
+		"strictfp",
+		"super",
+		"switch",
+		"synchronized",
+		"this",
+		"throw",
+		"throws",
+		"transient",
+		"try",
+		"void",
+		"volatile",
+		"while",
+		"true",
+		"false",
+		"null"
+	]);
+	mapPrimitiveType(type, _nullable) {
+		const upperType = type.toString().toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return mappedType;
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) return "BigDecimal";
+		if (upperType.startsWith("ENUM(")) return "String";
+		if (upperType.startsWith("UNION(")) return "Object";
+		if (/\[\d+\]/.test(upperType)) return "Object";
+		console.warn("Mapped type is unknown:", type);
+		return "Object";
+	}
+	formatListType(elementType) {
+		return `List<${elementType}>`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Result`;
+	}
+	generateStructDeclaration(column, path = "") {
+		if (!(column.type instanceof StructType)) throw new Error(`Expected StructType ${column}`);
+		const structName = this.formatStructTypeName(column.name);
+		const newPath = `${path}${structName}.`;
+		const children = column.type.fields.map((field) => {
+			return this.getDeclarations({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			}, newPath);
+		}).join("\n");
+		const fields = column.type.fields.map((field) => {
+			return `${this.getTypeName(field)} ${this.varName(field.name)}`;
+		}).join(", ");
+		const fromAttributes = ` private static ${structName} fromAttributes(Object[] v) {
+          return new ${structName}(${column.type.fields.map((f, i) => `${this.parseValue(f, `v[${i}]`, "")}`).join(",\n")});
+      }`;
+		return `public record ${structName}(${fields}) {
+     ${path.length > 0 ? fromAttributes : ""}
+      ${children}
+    }`;
+	}
+	formatMapTypeName(fieldName) {
+		return "HashMap";
+	}
+	varName(str) {
+		const name = camelCase(str);
+		if (JavaTypeMapper.javaReservedKeywords.has(name)) return `${name}_`;
+		return name;
+	}
+	parseValue(column, value, path) {
+		if (column.type instanceof ListType) {
+			const elementType = this.getTypeName({
+				name: column.name,
+				type: column.type.baseType,
+				nullable: true
+			}, path);
+			if (column.type.baseType instanceof StructType) return `arrayOfStructToList((Array)${value}, ${elementType}::fromAttributes)`;
+			if (column.type.baseType instanceof ListType) return `multiDimArrayToList((Array)${value}, ${this.getInnermostType(column.type)}[].class)`;
+			return `arrayToList((Array)${value}, ${elementType}[].class)`;
+		}
+		if (column.type instanceof StructType) return `${path}${this.formatStructTypeName(column.name)}.fromAttributes(getAttr((Struct)${value}))`;
+		return `(${this.getTypeName(column)})${value}`;
+	}
+	getInnermostType(type) {
+		let current = type.baseType;
+		while (current instanceof ListType) current = current.baseType;
+		return this.getTypeName({
+			name: "",
+			type: current,
+			nullable: true
+		});
+	}
+};
+/**
+* Type mapper for generating TypeScript types from SQL column types.
+* Maps SQL types to TypeScript types (e.g., INTEGER -> number, VARCHAR -> string).
+* Generates TypeScript interfaces for struct types and handles DuckDB's complex types.
+*/
+var TypeScriptTypeMapper = class extends TypeMapper {
+	/**
+	* Returns the TypeScript type name for a given SQL column.
+	* Overrides base to handle DuckDB's map type with key-value entry arrays.
+	*/
+	getTypeName(column, path = "") {
+		if (column.type instanceof MapType) return `{ entries: { key: ${this.getTypeName({
+			name: "key",
+			type: column.type.keyType.type,
+			nullable: true
+		})}; value: ${this.getTypeName({
+			name: "value",
+			type: column.type.valueType.type,
+			nullable: true
+		})} }[] }`;
+		return super.getTypeName(column, path);
+	}
+	typeMap = {
+		INTEGER: "number",
+		REAL: "number",
+		TEXT: "string",
+		BLOB: "{ bytes: Uint8Array }",
+		BOOLEAN: "boolean",
+		DATE: "{ days: number }",
+		DATETIME: "{ micros: bigint }",
+		TIMESTAMP: "{ micros: bigint }",
+		NULL: "null",
+		UNKNOWN: "unknown",
+		DOUBLE: "number",
+		FLOAT: "number",
+		VARCHAR: "string",
+		TINYINT: "number",
+		SMALLINT: "number",
+		BIGINT: "bigint",
+		HUGEINT: "bigint",
+		UHUGEINT: "bigint",
+		UTINYINT: "number",
+		USMALLINT: "number",
+		UINTEGER: "number",
+		UBIGINT: "bigint",
+		TIME: "{ micros: bigint }",
+		"TIME WITH TIME ZONE": "{ micros: bigint; offset: number }",
+		TIMESTAMP_S: "{ seconds: bigint }",
+		TIMESTAMP_MS: "{ millis: bigint }",
+		TIMESTAMP_NS: "{ nanos: bigint }",
+		"TIMESTAMP WITH TIME ZONE": "{ micros: bigint }",
+		UUID: "{ hugeint: bigint }",
+		INTERVAL: "{ months: number; days: number; micros: bigint }",
+		BIT: "{ data: Uint8Array }",
+		BIGNUM: "bigint",
+		INT4: "number"
+	};
+	mapPrimitiveType(type, nullable) {
+		const upperType = type.toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return nullable ? `${mappedType} | null` : mappedType;
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) {
+			const baseType = "{ width: number; scale: number; value: bigint }";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		if (upperType.startsWith("ENUM(")) {
+			const baseType = "string";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		if (upperType.startsWith("UNION(")) {
+			const baseType = "{ tag: string; value: unknown }";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		const fixedArrayMatch = upperType.match(/^([A-Z_]+)\[(\d+)\](\[\d+\])*$/);
+		if (fixedArrayMatch) {
+			const baseTypeName = fixedArrayMatch[1];
+			const baseType = this.typeMap[baseTypeName];
+			if (baseType) {
+				const dimensions = (upperType.match(/\[\d+\]/g) || []).length;
+				let result = baseType;
+				for (let i = 0; i < dimensions; i++) result = `{ items: (${result} | null)[] }`;
+				return nullable ? `${result} | null` : result;
+			}
+		}
+		if (/\[\d+\]/.test(upperType)) return "{ items: unknown[] }";
+		console.warn("Mapped type is unknown:", type);
+		return "unknown";
+	}
+	formatListType(elementType) {
+		return `{ items: (${elementType})[] }`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Struct`;
+	}
+	formatMapTypeName(fieldName) {
+		return "Map";
+	}
+	generateStructDeclaration(column) {
+		if (!(column.type instanceof StructType)) throw new Error("Expected StructType");
+		return `interface ${this.formatStructTypeName(column.name)} {\n  entries: {\n${column.type.fields.map((field) => {
+			const fieldType = this.getTypeName({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			});
+			return `    ${field.name}: ${fieldType};`;
+		}).join("\n")}\n  };\n}`;
+	}
+	parseValue(column, value) {
+		return "/// TODO: parseValue";
+	}
+};
+
+//#endregion
+//#region src/generators/base-generator.ts
+var BaseGenerator = class {
+	constructor(template, typeMapper) {
+		this.template = template;
+		this.typeMapper = typeMapper;
+	}
+	mapType(column) {
+		return this.typeMapper.getTypeName(column);
+	}
+	mapParameterType(type, nullable) {
+		return this.mapType({
+			name: "",
+			type,
+			nullable
+		});
+	}
+	listType(column) {
+		return this.typeMapper.listType(column);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries) {}
+	isCompatibleWith(_engine) {
+		return true;
+	}
+	functionReturnType(query) {
+		if (query.isOne) return this.rowType(query);
+		return this.typeMapper.formatListType(this.rowType(query));
+	}
+	rowType(query) {
+		if (query.isPluck) return this.mapType({
+			...query.columns[0],
+			name: query.id
+		});
+		return this.getClassName(`${query.id}_Result`);
+	}
+	getStatement(q) {
+		return q.queryAnonymous;
+	}
+};
+
+//#endregion
+//#region src/generators/java-generator.ts
+var JavaGenerator = class extends BaseGenerator {
+	constructor(template) {
+		super(template, new JavaTypeMapper());
+		this.template = template;
+	}
+	getFunctionName(id) {
+		return camelCase$1(id);
+	}
+	getFilename(sqlFileName) {
+		return `${pascalCase$1(sqlFileName)}.java`;
+	}
+	getClassName(name) {
+		return pascalCase$1(name);
+	}
+	partsToString(parts) {
+		const stringParts = [];
+		function addPart(str, quote) {
+			if (quote && stringParts.length > 0) {
+				const last = stringParts[stringParts.length - 1];
+				if (last.quote) {
+					last.str += str;
+					return;
+				}
+			}
+			stringParts.push({
+				str,
+				quote
+			});
+		}
+		for (const part of parts) if (typeof part === "string") addPart(part, true);
+		else {
+			addPart(" '", true);
+			addPart(part.name, false);
+			addPart("'", true);
+		}
+		return stringParts.map((part) => {
+			if (part.quote && (part.str.includes("\n") || part.str.includes("\""))) return `"""\n${part.str}"""`;
+			if (part.quote) return `"${part.str}"`;
+			return part.str;
+		}).join(" + ");
+	}
+	readColumn(column, index, path) {
+		return this.typeMapper.parseValue(column, `rs.getObject(${index + 1})`, path);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries) {
+		Handlebars.registerHelper("partsToString", (parts) => this.partsToString(parts));
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return queryHelper.typeMapper.getDeclarations({
+				...query.columns[0],
+				name: query.id
+			}, " ");
+			return queryHelper.typeMapper.getDeclarations(query.allColumns);
+		});
+		Handlebars.registerHelper("readColumns", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return this.readColumn({
+				...query.columns[0],
+				name: query.id
+			}, 0, "");
+			const result = [];
+			const rowType = this.rowType(queryHelper.query);
+			for (let i = 0; i < queryHelper.columns.length; i++) {
+				const column = queryHelper.columns[i];
+				result.push(this.readColumn(column, i, `${rowType}.`));
+			}
+			return `new ${rowType}(${result.join(",\n")})`;
+		});
+	}
+	async afterGenerate(outputPath) {
+		try {
+			consola.debug("Formatting file:", outputPath);
+			const code = readFileSync(outputPath, "utf-8");
+			writeFileSync(outputPath, await prettier.format(code, {
+				parser: "java",
+				plugins: [prettierPluginJava],
+				tabWidth: 4
+			}));
+		} catch (error) {
+			consola.error("Failed to format Java file:", error);
+		}
+	}
+};
+
+//#endregion
+//#region src/generators/java-duckdb-arrow-generator.ts
+var JavaDuckDBArrowGenerator = class extends BaseGenerator {
+	javaGenerator;
+	constructor(template) {
+		super(template, new JavaTypeMapper());
+		this.template = template;
+		this.javaGenerator = new JavaGenerator("templates/java-jdbc.hbs");
+	}
+	getFunctionName(id) {
+		return this.javaGenerator.getFunctionName(id);
+	}
+	async beforeGenerate(projectDir, gen, queries) {
+		const q = queries.filter((q$1) => q$1.isQuery && q$1.isOne || q$1.isMigrate);
+		const name = `${gen.name}-jdbc`;
+		writeGeneratedFile(projectDir, {
+			name,
+			generator: "java/jdbc",
+			output: gen.output,
+			config: gen.config
+		}, this.javaGenerator, name, q);
+	}
+	isCompatibleWith(engine) {
+		return engine === "duckdb";
+	}
+	getFilename(sqlFileName) {
+		return this.javaGenerator.getFilename(sqlFileName);
+	}
+	getClassName(name) {
+		return this.javaGenerator.getClassName(name);
+	}
+	mapType(column) {
+		const { type, nullable } = column;
+		if (typeof type === "string") {
+			const mappedType = {
+				INTEGER: "IntVector",
+				BOOLEAN: "BitVector",
+				DOUBLE: "Float8Vector",
+				FLOAT: "Float4Vector",
+				VARCHAR: "VarCharVector",
+				TEXT: "VarCharVector"
+			}[type.toUpperCase()];
+			if (!mappedType) consola.warn("(duckdb-arrow) Mapped type is unknown:", type);
+			return mappedType ?? "Object";
+		}
+		const mockColumn = {
+			name: "",
+			type,
+			nullable
+		};
+		return this.typeMapper.getTypeName(mockColumn);
+	}
+	mapParameterType(type, nullable) {
+		return this.typeMapper.getTypeName({
+			name: "",
+			type,
+			nullable
+		});
+	}
+	listType(type) {
+		const mockColumn = {
+			name: "",
+			type,
+			nullable: false
+		};
+		return this.typeMapper.listType(mockColumn);
+	}
+	async afterGenerate(outputPath) {
+		return this.javaGenerator.afterGenerate(outputPath);
+	}
+	functionReturnType(query) {
+		if (query.isOne) return this.javaGenerator.rowType(query);
+		return this.rowType(query);
+	}
+	rowType(query) {
+		if (query.isOne) return this.javaGenerator.rowType(query);
+		return this.getClassName(`${query.id}_Result`);
+	}
+};
+
+//#endregion
+//#region src/generators/typescript-generator.ts
+var TsGenerator = class extends BaseGenerator {
+	constructor(template) {
+		super(template, new TypeScriptTypeMapper());
+	}
+	getFunctionName(id) {
+		return camelCase$1(id);
+	}
+	isCompatibleWith(_engine) {
+		return true;
+	}
+	getFilename(sqlFileName) {
+		return `${sqlFileName}.ts`;
+	}
+	getClassName(name) {
+		return pascalCase$1(name);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries) {
+		Handlebars.registerHelper("quote", (value) => this.quote(value));
+		Handlebars.registerHelper("tsType", (column) => {
+			const inlineType = (col) => {
+				const t = col.type;
+				const withNullability = (base) => {
+					if (!col.nullable) return base;
+					if (/\bnull\b/.test(base)) return base;
+					return `${base} | null`;
+				};
+				if (t instanceof ListType) {
+					const element = inlineType({
+						name: col.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return withNullability(`${element.includes(" | ") ? `(${element})` : element}[]`);
+				}
+				if (t instanceof MapType) return withNullability(`Map<${inlineType({
+					name: "key",
+					type: t.keyType.type,
+					nullable: false
+				})}, ${inlineType({
+					name: "value",
+					type: t.valueType.type,
+					nullable: true
+				})}>`);
+				if (t instanceof StructType) {
+					const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+					return withNullability(`{ ${t.fields.map((f) => {
+						return `${isValidIdent(f.name) ? f.name : JSON.stringify(f.name)}: ${inlineType({
+							name: f.name,
+							type: f.type,
+							nullable: true
+						})}`;
+					}).join("; ")} }`);
+				}
+				if (t instanceof EnumType) return withNullability(t.values.map((v) => JSON.stringify(v)).join(" | "));
+				return this.typeMapper.getTypeName(col);
+			};
+			return inlineType(column);
+		});
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const typeMapper = queryHelper.typeMapper;
+			const declarations = /* @__PURE__ */ new Map();
+			const visit = (column) => {
+				const t = column.type;
+				if (t instanceof ListType) {
+					visit({
+						name: column.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return;
+				}
+				if (t instanceof StructType) {
+					const typeName = typeMapper.getTypeName(column);
+					if (!declarations.has(typeName)) declarations.set(typeName, typeMapper.getDeclarations(column));
+					for (const field of t.fields) visit({
+						name: field.name,
+						type: field.type,
+						nullable: true
+					});
+					return;
+				}
+				if (t instanceof MapType) {
+					visit({
+						name: column.name,
+						type: t.keyType.type,
+						nullable: true
+					});
+					visit({
+						name: column.name,
+						type: t.valueType.type,
+						nullable: true
+					});
+				}
+			};
+			if (queryHelper.isPluck) {
+				const col = queryHelper.columns[0];
+				visit({
+					name: col.name,
+					type: col.type,
+					nullable: true
+				});
+			} else for (const col of queryHelper.columns) visit({
+				name: col.name,
+				type: col.type,
+				nullable: true
+			});
+			return Array.from(declarations.values()).filter(Boolean).join("\n\n");
+		});
+	}
+	async afterGenerate(outputPath) {
+		try {
+			consola.debug("Formatting file:", outputPath);
+			const code = readFileSync(outputPath, "utf-8");
+			writeFileSync(outputPath, await prettier.format(code, {
+				parser: "typescript",
+				plugins: [typescriptPlugin, estree]
+			}));
+		} catch (error) {
+			consola.error("Failed to format file:", error);
+		}
+	}
+	quote(value) {
+		return value.includes("\n") || value.includes("'") ? `\`${value}\`` : `'${value}'`;
+	}
+};
+
+//#endregion
+//#region src/generators/typescript-duckdb-generator.ts
+/**
+* TypeScript generator for DuckDB.
+* DuckDB's Node API returns complex types as wrapper objects:
+* - Lists as { items: T[] }
+* - Structs as { entries: { field1: T1, ... } }
+* - Maps as { entries: { key: K, value: V }[] }
+*/
+var TsDuckDBGenerator = class extends TsGenerator {
+	constructor(template) {
+		super(template);
+	}
+	async beforeGenerate(projectDir, gen, queries) {
+		await super.beforeGenerate(projectDir, gen, queries);
+		Handlebars.registerHelper("tsType", (column) => {
+			const inlineType = (col) => {
+				const t = col.type;
+				const withNullability = (base) => {
+					if (!col.nullable) return base;
+					if (/\bnull\b/.test(base)) return base;
+					return `${base} | null`;
+				};
+				if (t instanceof ListType) {
+					const element = inlineType({
+						name: col.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return withNullability(`{ items: ${element.includes(" | ") ? `(${element})` : element}[] }`);
+				}
+				if (t instanceof MapType) return withNullability(`{ entries: { key: ${inlineType({
+					name: "key",
+					type: t.keyType.type,
+					nullable: true
+				})}; value: ${inlineType({
+					name: "value",
+					type: t.valueType.type,
+					nullable: true
+				})} }[] }`);
+				if (t instanceof StructType) {
+					const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+					return withNullability(`{ entries: { ${t.fields.map((f) => {
+						return `${isValidIdent(f.name) ? f.name : JSON.stringify(f.name)}: ${inlineType({
+							name: f.name,
+							type: f.type,
+							nullable: true
+						})}`;
+					}).join("; ")} } }`);
+				}
+				if (t instanceof EnumType) return withNullability(t.values.map((v) => JSON.stringify(v)).join(" | "));
+				return this.typeMapper.getTypeName(col);
+			};
+			return inlineType(column);
+		});
+	}
+};
+
+//#endregion
+//#region src/generators/index.ts
+function getGenerator(generator) {
+	switch (generator) {
+		case "java/jdbc": return new JavaGenerator("templates/java-jdbc.hbs");
+		case "java/duckdb-arrow": return new JavaDuckDBArrowGenerator("templates/java-duckdb-arrow.hbs");
+		case "typescript/better-sqlite3": return new TsGenerator("templates/better-sqlite3.hbs");
+		case "typescript/duckdb": return new TsDuckDBGenerator("templates/typescript-duckdb.hbs");
+		default: throw new Error(`Unsupported generator: ${generator}`);
+	}
+}
+
+//#endregion
+//#region src/sqltool.ts
+const GENERATED_FILE_COMMENT = "This file is generated by SQG. Do not edit manually.";
+const configSchema = z.object({ result: z.record(z.string(), z.string()).optional() });
+var Config = class Config {
+	constructor(result) {
+		this.result = result;
+	}
+	getColumnInfo(name) {
+		return this.result.get(name);
+	}
+	static fromYaml(name, filePath, configStr) {
+		let configObj;
+		try {
+			configObj = YAML.parse(configStr);
+		} catch (e) {
+			throw new Error(`Error parsing YAML config for query ${name} in ${filePath}: \n${configStr}\n ${e}`);
+		}
+		const result = configSchema.safeParse(configObj);
+		if (!result.success) throw new Error(`Error parsing config for query ${name} in ${filePath}: \n${configStr}\n ${result.error}`);
+		const columnMap = /* @__PURE__ */ new Map();
+		for (const [name$1, info] of Object.entries(result.data.result ?? {})) {
+			const parts = info.trim().split(" ").map((part) => part.trim());
+			let type;
+			let nullable = true;
+			if (parts.length === 1) type = parts[0];
+			else if (parts.length === 2) {
+				type = parts[0];
+				if (parts[1].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
+				nullable = true;
+			} else if (parts.length === 3) {
+				type = parts[0];
+				if (parts[1].toLocaleLowerCase() !== "not" || parts[2].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
+				nullable = false;
+			} else throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
+			columnMap.set(name$1, {
+				name: name$1,
+				type,
+				nullable
+			});
+		}
+		return new Config(columnMap);
+	}
+};
+/** Util class to help generating a query with a given generator */
+var SqlQueryHelper = class {
+	constructor(query, generator, statement) {
+		this.query = query;
+		this.generator = generator;
+		this.statement = statement;
+	}
+	get id() {
+		return this.query.id;
+	}
+	get isQuery() {
+		return this.query.isQuery;
+	}
+	get isExec() {
+		return this.query.isExec;
+	}
+	get isMigrate() {
+		return this.query.isMigrate;
+	}
+	get isPluck() {
+		return this.query.isPluck;
+	}
+	get isOne() {
+		return this.query.isOne;
+	}
+	get parameterNames() {
+		return this.statement.parameters.map((param) => param.name);
+	}
+	get skipGenerateFunction() {
+		return this.query.skipGenerateFunction;
+	}
+	get parameters() {
+		const vars = new Map(this.variables.map((param) => [param.name, param.type]));
+		return this.statement.parameters.map((param) => ({
+			name: param.name,
+			type: vars.get(param.name)
+		}));
+	}
+	get columns() {
+		if (!(this.query.allColumns.type instanceof StructType)) throw new Error(`Expected StructType ${this.query.allColumns.type}`);
+		return this.query.allColumns.type.fields;
+	}
+	get variables() {
+		return Array.from(this.query.variables.entries()).map(([name, value]) => ({
+			name,
+			type: this.generator.mapParameterType(detectParameterType(value), false)
+		}));
+	}
+	get sqlQuery() {
+		return this.statement.sql;
+	}
+	get sqlQueryParts() {
+		return this.statement.sqlParts;
+	}
+	get rowTypeStr() {
+		return this.generator.rowType(this.query);
+	}
+	get functionReturnType() {
+		return new Handlebars.SafeString(this.generator.functionReturnType(this.query));
+	}
+	get rowType() {
+		return new Handlebars.SafeString(this.rowTypeStr);
+	}
+	get functionName() {
+		return this.generator.getFunctionName(this.query.id);
+	}
+	get typeMapper() {
+		return this.generator.typeMapper;
+	}
+};
+function generateSourceFile(name, queries, templatePath, generator, config) {
+	const templateSrc = readFileSync(templatePath, "utf-8");
+	const template = Handlebars.compile(templateSrc);
+	Handlebars.registerHelper("mapType", (column) => generator.mapType(column));
+	Handlebars.registerHelper("plusOne", (value) => value + 1);
+	return template({
+		generatedComment: GENERATED_FILE_COMMENT,
+		migrations: queries.filter((q) => q.isMigrate).map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
+		queries: queries.map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
+		className: generator.getClassName(name),
+		config
+	}, {
+		allowProtoPropertiesByDefault: true,
+		allowProtoMethodsByDefault: true
+	});
+}
+const ProjectSchema = z.object({
+	version: z.number(),
+	name: z.string(),
+	sql: z.array(z.object({
+		engine: z.string(),
+		files: z.array(z.string()),
+		gen: z.array(z.object({
+			generator: z.string(),
+			name: z.string().optional(),
+			template: z.string().optional(),
+			output: z.string(),
+			config: z.any().optional()
+		}))
+	})),
+	sources: z.array(z.object({
+		path: z.string(),
+		name: z.string().optional()
+	})).optional()
+});
+var ExtraVariable = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+};
+function createExtraVariables(sources) {
+	return sources.map((source) => {
+		const path = source.path;
+		const resolvedPath = path.replace("$HOME", homedir());
+		const varName = `sources_${(source.name ?? basename(path, extname(resolvedPath))).replace(/\s+/g, "_")}`;
+		consola.info("Extra variable:", varName, resolvedPath);
+		return new ExtraVariable(varName, `'${resolvedPath}'`);
+	});
+}
+function parseProjectConfig(filePath) {
+	const content = readFileSync(filePath, "utf-8");
+	const result = ProjectSchema.safeParse(YAML.parse(content));
+	if (!result.success) {
+		const prettyError = z.prettifyError(result.error);
+		throw new Error(`Error parsing project file ${filePath}:\n${prettyError}`);
+	}
+	return result.data;
+}
+function detectParameterType(value) {
+	const num = Number(value);
+	if (!Number.isNaN(num)) {
+		if (Number.isInteger(num)) return "INTEGER";
+		return "REAL";
+	}
+	if (value.toLowerCase() === "true" || value.toLowerCase() === "false") return "BOOLEAN";
+	return "TEXT";
+}
+function getOutputPath(projectDir, sqlFileName, gen, generator) {
+	const pathParts = [];
+	if (!gen.output.startsWith("/")) pathParts.push(projectDir);
+	if (gen.output.endsWith("/")) {
+		const name = generator.getFilename(sqlFileName);
+		pathParts.push(gen.output, name);
+	} else pathParts.push(gen.output);
+	const outputPath = join(...pathParts);
+	mkdirSync(dirname(outputPath), { recursive: true });
+	return outputPath;
+}
+function validateQueries(queries) {
+	for (const query of queries) {
+		if (query.isQuery && query.isPluck && query.columns.length !== 1) throw new Error(`Query ${query.id} in ${query.filename} has the ':pluck: option, must have exactly one column, but has ${query.columns.length} columns`);
+		const columns = query.columns.map((col) => {
+			const configColumn = query.config?.getColumnInfo(col.name);
+			if (configColumn) return configColumn;
+			return col;
+		});
+		query.allColumns = {
+			name: query.id,
+			nullable: false,
+			type: new StructType(columns)
+		};
+	}
+}
+async function writeGeneratedFile(projectDir, gen, generator, file, queries) {
+	await generator.beforeGenerate(projectDir, gen, queries);
+	const templatePath = join(dirname(new URL(import.meta.url).pathname), gen.template ?? generator.template);
+	const name = gen.name ?? basename(file, extname(file));
+	const sourceFile = generateSourceFile(name, queries, templatePath, generator, gen.config);
+	const outputPath = getOutputPath(projectDir, name, gen, generator);
+	writeFileSync(outputPath, sourceFile);
+	consola.success(`Generated ${outputPath}`);
+	await generator.afterGenerate(outputPath);
+	return outputPath;
+}
+async function processProject(projectPath) {
+	const projectDir = resolve(dirname(projectPath));
+	const project = parseProjectConfig(projectPath);
+	const extraVariables = createExtraVariables(project.sources ?? []);
+	if (extraVariables.length > 0) consola.info("Extra variables:", extraVariables);
+	const files = [];
+	for (const sql of project.sql) for (const sqlFile of sql.files) {
+		let queries;
+		try {
+			queries = parseSQLQueries(join(projectDir, sqlFile), extraVariables);
+			const dbEngine = getDatabaseEngine(sql.engine);
+			await dbEngine.initializeDatabase(queries);
+			await dbEngine.executeQueries(queries);
+			validateQueries(queries);
+			await dbEngine.close();
+		} catch (e) {
+			consola.error(`Error processing SQL file ${sqlFile}: ${e}`);
+			throw e;
+		}
+		for (const gen of sql.gen) {
+			const generator = getGenerator(gen.generator);
+			if (!generator.isCompatibleWith(sql.engine)) throw new Error(`File ${sqlFile}: Generator ${gen.generator} is not compatible with engine ${sql.engine}`);
+			const outputPath = await writeGeneratedFile(projectDir, gen, generator, sqlFile, queries);
+			files.push(outputPath);
+		}
+	}
+	return files;
+}
+
+//#endregion
+//#region src/sqg.ts
+const version = process.env.npm_package_version ?? "0.1.1";
+const description = process.env.npm_package_description ?? "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)";
+consola.level = LogLevels.info;
+const program = new Command().name("sqg").description(description).version(version, "-v, --version", "output the version number").option("--verbose", "Enable debug logging").argument("<project>", "Path to the project YAML config").showHelpAfterError().showSuggestionAfterError().hook("preAction", (thisCommand) => {
+	if (thisCommand.opts().verbose) consola.level = LogLevels.debug;
+}).action(async (projectPath) => {
+	await processProject(projectPath);
+});
+if (process.argv.length <= 2) {
+	program.outputHelp();
+	exit(1);
+}
+try {
+	await program.parseAsync(process.argv);
+} catch (err) {
+	consola.error(err);
+	exit(1);
+}
+
+//#endregion
+export {  };