@sqg/sqg 0.9.0 → 0.11.0

package/dist/sqg.mjs

@@ -680,7 +680,7 @@ var EnumType = class {
 var SQLQuery = class {
 	columns;
 	allColumns;
-	/** Database-reported parameter types (variable name → SQL type name), set by database adapters */
+	/** Database-reported parameter types (variable name → SQL type), set by database adapters */
 	parameterTypes;
 	constructor(filename, id, rawQuery, queryAnonymous, queryNamed, queryPositional, type, isOne, isPluck, variables, config) {
 		this.filename = filename;
@@ -966,6 +966,25 @@ async function initializeDatabase(queries, execQueries) {
 
 //#endregion
 //#region src/db/duckdb.ts
+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();
+}
 const duckdb = new class {
 	db;
 	connection;
@@ -1005,6 +1024,15 @@ const duckdb = new class {
 				return ` ${part.value} `;
 			}).join("");
 			const stmt = await connection.prepare(sql);
+			if (stmt.parameterCount > 0) {
+				const paramTypes = /* @__PURE__ */ new Map();
+				for (let i = 0; i < stmt.parameterCount; i++) {
+					const paramType = stmt.parameterType(i + 1);
+					paramTypes.set(statement.parameters[i].name, convertType(paramType));
+				}
+				query.parameterTypes = paramTypes;
+				consola.debug("Parameter types:", Object.fromEntries(paramTypes));
+			}
 			for (let i = 0; i < stmt.parameterCount; i++) stmt.bindValue(i + 1, statement.parameters[i].value);
 			if (query.isQuery) {
 				const result = await stmt.stream();
@@ -1012,25 +1040,6 @@ const duckdb = new class {
 				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]),
@@ -1053,33 +1062,17 @@ const duckdb = new class {
 		for (const table of tables) {
 			consola.info(`Introspecting table schema: ${table.tableName}`);
 			try {
-				const rows = (await connection.runAndReadAll(`DESCRIBE ${table.tableName}`)).getRows();
-				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();
-				}
-				table.columns = rows.map((row) => {
-					return {
-						name: row[0],
-						type: row[1],
-						nullable: row[2] !== "NO"
-					};
-				});
+				const descRows = (await connection.runAndReadAll(`DESCRIBE ${table.tableName}`)).getRows();
+				const nullabilityMap = /* @__PURE__ */ new Map();
+				for (const row of descRows) nullabilityMap.set(row[0], row[2] !== "NO");
+				const stream = await (await connection.prepare(`SELECT * FROM ${table.tableName} LIMIT 0`)).stream();
+				const columnNames = stream.columnNames();
+				const columnTypes = stream.columnTypes();
+				table.columns = columnNames.map((name, index) => ({
+					name,
+					type: convertType(columnTypes[index]),
+					nullable: nullabilityMap.get(name) ?? true
+				}));
 				consola.debug(`Table ${table.tableName} columns:`, table.columns);
 				consola.success(`Introspected table: ${table.tableName} (${table.columns.length} columns)`);
 			} catch (error) {
@@ -1208,10 +1201,10 @@ const postgres = new class {
 				return value;
 			});
 			if (statement.parameters.length > 0) try {
-				await db.query(`DEALLOCATE ALL`);
+				await db.query("DEALLOCATE ALL");
 				await db.query(`PREPARE sqg_param_check AS ${statement.sql}`);
 				const paramTypeResult = await db.query(`SELECT unnest(parameter_types)::oid AS oid FROM pg_prepared_statements WHERE name = 'sqg_param_check'`);
-				await db.query(`DEALLOCATE sqg_param_check`);
+				await db.query("DEALLOCATE sqg_param_check");
 				if (paramTypeResult.rows.length === statement.parameters.length) {
 					const paramTypes = /* @__PURE__ */ new Map();
 					for (let i = 0; i < statement.parameters.length; i++) {
@@ -1466,7 +1459,7 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		TIMESTAMP_S: "Instant",
 		TIMESTAMP_MS: "Instant",
 		TIMESTAMP_NS: "Instant",
-		"TIMESTAMP WITH TIME ZONE": "Instant",
+		"TIMESTAMP WITH TIME ZONE": "OffsetDateTime",
 		UUID: "UUID",
 		INTERVAL: "String",
 		BIT: "String",
@@ -1607,6 +1600,7 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		const upperType = column.type?.toString().toUpperCase() ?? "";
 		if (upperType === "TIMESTAMP" || upperType === "DATETIME") return `toLocalDateTime((java.sql.Timestamp)${value})`;
 		if (upperType === "TIMESTAMPTZ") return `toOffsetDateTime((java.sql.Timestamp)${value})`;
+		if (upperType === "TIMESTAMP WITH TIME ZONE") return `(OffsetDateTime)${value}`;
 		if (upperType === "DATE") return `toLocalDate((java.sql.Date)${value})`;
 		if (upperType === "TIME") return `toLocalTime((java.sql.Time)${value})`;
 		if (upperType.startsWith("_")) {
@@ -1864,6 +1858,9 @@ var JavaGenerator = class extends BaseGenerator {
 			}, " ");
 			return queryHelper.typeMapper.getDeclarations(query.allColumns);
 		});
+		Handlebars.registerHelper("appenderType", (column) => {
+			return this.mapType(column);
+		});
 		Handlebars.registerHelper("readColumns", (queryHelper) => {
 			const query = queryHelper.query;
 			if (queryHelper.isPluck) return this.readColumn({
@@ -1983,6 +1980,24 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 
 //#endregion
 //#region src/generators/typescript-generator.ts
+/** Resolve a ColumnType to its DuckDB type constant name (e.g. "VARCHAR", "INTEGER") for use in generated code. */
+function resolveElementType(baseType) {
+	if (baseType instanceof ListType) return `new DuckDBListType(${resolveElementType(baseType.baseType)})`;
+	return {
+		VARCHAR: "VARCHAR",
+		TEXT: "VARCHAR",
+		INTEGER: "INTEGER",
+		INT: "INTEGER",
+		BIGINT: "BIGINT",
+		DOUBLE: "DOUBLE",
+		FLOAT: "FLOAT",
+		BOOLEAN: "BOOLEAN",
+		DATE: "DATE",
+		TIMESTAMP: "TIMESTAMP",
+		SMALLINT: "SMALLINT",
+		TINYINT: "TINYINT"
+	}[baseType.toString().toUpperCase()] || "VARCHAR";
+}
 var TsGenerator = class extends BaseGenerator {
 	constructor(template) {
 		super(template, new TypeScriptTypeMapper());
@@ -2002,6 +2017,7 @@ var TsGenerator = class extends BaseGenerator {
 	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
 		Handlebars.registerHelper("quote", (value) => this.quote(value));
 		Handlebars.registerHelper("appendMethod", (column) => {
+			if (column.type instanceof ListType) return "List";
 			const typeStr = column.type?.toString().toUpperCase() || "";
 			if (typeStr === "INTEGER" || typeStr === "INT" || typeStr === "INT4" || typeStr === "SIGNED") return "Integer";
 			if (typeStr === "SMALLINT" || typeStr === "INT2" || typeStr === "SHORT") return "SmallInt";
@@ -2023,7 +2039,15 @@ var TsGenerator = class extends BaseGenerator {
 			if (typeStr === "INTERVAL") return "Interval";
 			return "Varchar";
 		});
+		Handlebars.registerHelper("appendListTypeArg", (column) => {
+			if (!(column.type instanceof ListType)) return "";
+			return `, new DuckDBListType(${resolveElementType(column.type.baseType)})`;
+		});
 		Handlebars.registerHelper("tsTypeForAppender", (column) => {
+			if (column.type instanceof ListType) {
+				const baseType$1 = "readonly DuckDBValue[]";
+				return column.nullable ? `${baseType$1} | null` : baseType$1;
+			}
 			const typeStr = column.type?.toString().toUpperCase() || "";
 			let baseType;
 			if (typeStr === "INTEGER" || typeStr === "INT" || typeStr === "INT4" || typeStr === "SMALLINT" || typeStr === "INT2" || typeStr === "TINYINT" || typeStr === "INT1" || typeStr === "UINTEGER" || typeStr === "UINT4" || typeStr === "USMALLINT" || typeStr === "UINT2" || typeStr === "UTINYINT" || typeStr === "UINT1" || typeStr === "DOUBLE" || typeStr === "FLOAT8" || typeStr === "FLOAT" || typeStr === "FLOAT4" || typeStr === "REAL") baseType = "number";
@@ -2164,6 +2188,21 @@ var TsDuckDBGenerator = class extends TsGenerator {
 	}
 	async beforeGenerate(projectDir, gen, queries, tables) {
 		await super.beforeGenerate(projectDir, gen, queries, tables);
+		Handlebars.registerHelper("hasListParams", (queryHelper) => {
+			const paramTypes = queryHelper.query.parameterTypes;
+			if (!paramTypes) return false;
+			for (const [, colType] of paramTypes) if (colType instanceof ListType) return true;
+			return false;
+		});
+		Handlebars.registerHelper("bindStatements", (queryHelper) => {
+			const paramNames = queryHelper.parameterNames;
+			const paramTypes = queryHelper.query.parameterTypes;
+			return paramNames.map((name, i) => {
+				const colType = paramTypes?.get(name);
+				if (colType instanceof ListType) return `stmt.bindList(${i + 1}, ${name}.items, new DuckDBListType(${resolveElementType(colType.baseType)}));`;
+				return `stmt.bindValue(${i + 1}, ${name});`;
+			}).join("\n        ");
+		});
 		Handlebars.registerHelper("tsType", (column) => {
 			const inlineType = (col) => {
 				const t = col.type;
@@ -2311,10 +2350,24 @@ var SqlQueryHelper = class {
 	}
 	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)
-		}));
+		return this.statement.parameters.map((param) => {
+			const rawType = this.query.parameterTypes?.get(param.name);
+			let isArray = false;
+			let arrayBaseType = null;
+			if (rawType instanceof ListType) {
+				isArray = true;
+				arrayBaseType = rawType.baseType.toString();
+			} else if (typeof rawType === "string" && rawType.startsWith("_")) {
+				isArray = true;
+				arrayBaseType = rawType.substring(1);
+			}
+			return {
+				name: param.name,
+				type: vars.get(param.name),
+				isArray,
+				arrayBaseType
+			};
+		});
 	}
 	get columns() {
 		if (!(this.query.allColumns.type instanceof StructType)) throw new Error(`Expected StructType ${this.query.allColumns.type}`);
@@ -2533,7 +2586,10 @@ async function writeGeneratedFile(projectDir, gen, generator, file, queries, tab
 	await generator.beforeGenerate(projectDir, gen, queries, tables);
 	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, tables, templatePath, generator, engine, gen.projectName ?? name, gen.config);
+	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.projectName ?? name, {
+		migrations: true,
+		...gen.config
+	});
 	if (writeToStdout) {
 		process.stdout.write(sourceFile);
 		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
@@ -2687,7 +2743,7 @@ async function processProject(projectPath) {
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.9.0"
+	version: process.env.npm_package_version ?? "0.11.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -3016,7 +3072,7 @@ async function startMcpServer() {
 
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.9.0";
+const version = process.env.npm_package_version ?? "0.11.0";
 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}

package/dist/templates/java-jdbc.hbs

@@ -17,11 +17,17 @@ import java.time.OffsetDateTime;
 import java.time.OffsetTime;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 import java.util.HashMap;
 import java.util.Collections;
+import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.Spliterators;
 import java.util.UUID;
 import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 {{#if tables.length}}
 import org.duckdb.DuckDBAppender;
 import org.duckdb.DuckDBConnection;
@@ -203,6 +209,37 @@ public class {{className}} {
             {{> execute}}
         }
     }
+    {{#if isQuery}}{{#unless isOne}}
+    public Stream<{{rowType}}> {{functionName}}Stream({{#each variables}}{{{type}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
+        var stmt = connection.prepareStatement({{{partsToString sqlQueryParts}}});
+        {{#each parameters}}{{#if isArray}}stmt.setArray({{plusOne @index}}, connection.createArrayOf("{{arrayBaseType}}", {{name}}.toArray()));
+        {{else}}stmt.setObject({{plusOne @index}}, {{name}});
+        {{/if}}{{/each}}
+        var rs = stmt.executeQuery();
+        var iter = new Iterator<{{rowType}}>() {
+            private Boolean hasNext = null;
+            public boolean hasNext() {
+                if (hasNext == null) {
+                    try { hasNext = rs.next(); }
+                    catch (SQLException e) { throw new RuntimeException(e); }
+                }
+                return hasNext;
+            }
+            public {{rowType}} next() {
+                if (!hasNext()) throw new NoSuchElementException();
+                hasNext = null;
+                try { return {{> readRow}}; }
+                catch (SQLException e) { throw new RuntimeException(e); }
+            }
+        };
+        return StreamSupport.stream(
+            Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED), false
+        ).onClose(() -> {
+            try { rs.close(); stmt.close(); }
+            catch (SQLException e) { throw new RuntimeException(e); }
+        });
+    }
+    {{/unless}}{{/if}}
     {{/unless}}
     {{/each}}
 
@@ -220,7 +257,7 @@ public class {{className}} {
 
 {{#each tables}}
 /** Row type for {{tableName}} appender */
-public record {{rowTypeName}}({{#each columns}}{{mapType this}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
+public record {{rowTypeName}}({{#each columns}}{{{appenderType this}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
 
 /** Appender for bulk inserts into {{tableName}} */
 public static class {{className}} implements AutoCloseable {
@@ -246,7 +283,7 @@ public static class {{className}} implements AutoCloseable {
     }
 
     /** Append a single row with individual values */
-    public {{className}} append({{#each columns}}{{mapType this}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
+    public {{className}} append({{#each columns}}{{{appenderType this}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
         appender.beginRow();
         {{#each columns}}
         appender.append({{name}});
@@ -291,8 +328,9 @@ int
 {{/inline~}}
 
 {{#*inline "execute"}}
-{{#each parameterNames}}stmt.setObject({{plusOne @index}}, {{this}});
-{{/each}}
+{{#each parameters}}{{#if isArray}}stmt.setArray({{plusOne @index}}, connection.createArrayOf("{{arrayBaseType}}", {{name}}.toArray()));
+{{else}}stmt.setObject({{plusOne @index}}, {{name}});
+{{/if}}{{/each}}
 {{#if isQuery}}
 try(var rs = stmt.executeQuery()) {
 {{#if isOne}}

package/dist/templates/turso.hbs

@@ -33,36 +33,32 @@ export class {{className}} {
 
 {{#if config.migrations}}
     static async applyMigrations(db: Database, projectName = '{{projectName}}'): Promise<void> {
-        const createStmt = await db.prepare(`CREATE TABLE IF NOT EXISTS _sqg_migrations (
+        const createStmt = db.prepare(`CREATE TABLE IF NOT EXISTS _sqg_migrations (
             project TEXT NOT NULL,
             migration_id TEXT NOT NULL,
             applied_at TEXT NOT NULL DEFAULT (datetime('now')),
             PRIMARY KEY (project, migration_id)
         )`);
         await createStmt.run();
-        const tx = await db.transaction('write');
-        try {
-            const selectStmt = await tx.prepare('SELECT migration_id FROM _sqg_migrations WHERE project = ?');
-            const rows = await selectStmt.all(projectName) as { migration_id: string }[];
-            const applied = new Set(rows.map(r => r.migration_id));
-            const migrations: [string, string][] = [
-                {{#each migrations}}
-                ['{{{id}}}', {{{quote sqlQuery}}}],
-                {{/each}}
-            ];
+        const selectStmt = db.prepare('SELECT migration_id FROM _sqg_migrations WHERE project = ?');
+        const rows = await selectStmt.all(projectName) as { migration_id: string }[];
+        const applied = new Set(rows.map(r => r.migration_id));
+        const migrations: [string, string][] = [
+            {{#each migrations}}
+            ['{{{id}}}', {{{quote sqlQuery}}}],
+            {{/each}}
+        ];
+        const applyFn = db.transaction(async () => {
             for (const [id, sql] of migrations) {
                 if (!applied.has(id)) {
-                    const execStmt = await tx.prepare(sql);
+                    const execStmt = db.prepare(sql);
                     await execStmt.run();
-                    const insertStmt = await tx.prepare('INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)');
+                    const insertStmt = db.prepare('INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)');
                     await insertStmt.run(projectName, id);
                 }
             }
-            await tx.commit();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
+        });
+        await applyFn();
     }
 {{/if}}
 

package/dist/templates/typescript-duckdb.hbs

@@ -1,5 +1,5 @@
 // {{generatedComment}}
-import type { DuckDBConnection, DuckDBMaterializedResult, DuckDBAppender, DuckDBDateValue, DuckDBTimeValue, DuckDBTimestampValue, DuckDBBlobValue } from "@duckdb/node-api";
+import { DuckDBListType, listValue, VARCHAR, INTEGER, BIGINT, DOUBLE, FLOAT, BOOLEAN, SMALLINT, TINYINT, type DuckDBConnection, type DuckDBMaterializedResult, type DuckDBAppender, type DuckDBDateValue, type DuckDBTimeValue, type DuckDBTimestampValue, type DuckDBBlobValue, type DuckDBValue } from "@duckdb/node-api";
 
 export class {{className}} {
     
@@ -60,6 +60,28 @@ export class {{className}} {
     {{#unless skipGenerateFunction}}
     async {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): Promise<{{> returnType }}> {
         const sql = {{{quote sqlQuery}}};
+        {{#if (hasListParams this)}}
+        const stmt = await this.conn.prepare(sql);
+        {{{bindStatements this}}}
+        {{#if isQuery}}
+        const reader = await stmt.runAndReadAll();
+        {{#if isPluck}}
+        {{#if isOne}}
+        return reader.getRows()[0]?.[0] as {{> rowType}} | undefined;
+        {{else}}
+        return reader.getRows().map((row) => row[0] as {{> rowType}});
+        {{/if}}
+        {{else}}
+        {{#if isOne}}
+        return reader.getRowObjects()[0] as {{> rowType}} | undefined;
+        {{else}}
+        return reader.getRowObjects() as {{> rowType}}[];
+        {{/if}}
+        {{/if}}
+        {{else}}
+        return await stmt.run();
+        {{/if}}
+        {{else}}
         {{#if isQuery}}
         const reader = await this.conn.runAndReadAll(sql,[{{> params}}]);
         {{#if isPluck}}
@@ -78,6 +100,7 @@ export class {{className}} {
         {{else}}
         return await this.conn.run(sql,[{{> params}}]);
         {{/if}}
+        {{/if}}
     }
     {{/unless}}
 
@@ -113,10 +136,10 @@ export class {{className}} {
         if (row.{{name}} === null || row.{{name}} === undefined) {
             this.appender.appendNull();
         } else {
-            this.appender.append{{appendMethod this}}(row.{{name}});
+            this.appender.append{{appendMethod this}}(row.{{name}}{{{appendListTypeArg this}}});
         }
         {{else}}
-        this.appender.append{{appendMethod this}}(row.{{name}});
+        this.appender.append{{appendMethod this}}(row.{{name}}{{{appendListTypeArg this}}});
         {{/if}}
         {{/each}}
         this.appender.endRow();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "bin": {