@sqg/sqg 0.10.0 → 0.12.0

package/dist/sqg.mjs

@@ -2,6 +2,7 @@
 import { exit } from "node:process";
 import { Command } from "commander";
 import consola, { LogLevels } from "consola";
+import updateNotifier from "update-notifier";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
@@ -17,6 +18,7 @@ import { LRParser } from "@lezer/lr";
 import { camelCase, isNotNil, pascalCase, sortBy } from "es-toolkit";
 import { Client } from "pg";
 import types from "pg-types";
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
 import BetterSqlite3 from "better-sqlite3";
 import { camelCase as camelCase$1, pascalCase as pascalCase$1 } from "es-toolkit/string";
 import prettier from "prettier/standalone";
@@ -1088,84 +1090,141 @@ const duckdb = new class {
 
 //#endregion
 //#region src/db/postgres.ts
-const databaseName = "sqg-db-temp";
-let containerInstance = null;
-async function startTestContainer() {
-	if (containerInstance) return containerInstance.getConnectionUri();
-	consola.info("Starting PostgreSQL container via testcontainers...");
-	const { PostgreSqlContainer } = await import("@testcontainers/postgresql");
-	containerInstance = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
-	const connectionUri = containerInstance.getConnectionUri();
-	consola.success(`PostgreSQL container started at: ${connectionUri}`);
-	return connectionUri;
-}
-async function stopTestContainer() {
-	if (containerInstance) {
-		consola.info("Stopping PostgreSQL container...");
-		await containerInstance.stop();
-		containerInstance = null;
-	}
-}
-async function getConnectionString() {
-	if (process.env.SQG_POSTGRES_URL) return process.env.SQG_POSTGRES_URL;
-	return await startTestContainer();
-}
-function getTempConnectionString(baseUrl) {
-	return baseUrl.replace(/\/[^/]+$/, `/${databaseName}`);
-}
+const tempDatabaseName = "sqg-db-temp";
 const typeIdToName = /* @__PURE__ */ new Map();
 for (const [name, id] of Object.entries(types.builtins)) typeIdToName.set(Number(id), name);
-let dynamicTypeCache = /* @__PURE__ */ new Map();
-async function loadTypeCache(db) {
-	const result = await db.query(`
-    SELECT t.oid, t.typname, t.typtype, t.typelem, et.typname AS elemtype
-    FROM pg_type t
-    LEFT JOIN pg_type et ON t.typelem = et.oid
-    WHERE t.typtype IN ('b', 'e', 'r', 'c') -- base, enum, range, composite
-       OR t.typelem != 0 -- array types
-  `);
-	dynamicTypeCache = /* @__PURE__ */ new Map();
-	for (const row of result.rows) {
-		const oid = row.oid;
-		let typeName = row.typname;
-		if (typeName.startsWith("_") && row.elemtype) typeName = `_${row.elemtype.toUpperCase()}`;
-		else typeName = typeName.toUpperCase();
-		dynamicTypeCache.set(oid, typeName);
+/**
+* External database mode: connects directly to the user's database.
+* Uses a single transaction for the entire session and rolls back on close,
+* so the database is never modified. Individual queries use savepoints.
+*/
+var ExternalDbMode = class {
+	constructor(connectionString) {
+		this.connectionString = connectionString;
 	}
-}
-function getTypeName(dataTypeID) {
-	const cached = dynamicTypeCache.get(dataTypeID);
-	if (cached) return cached;
-	return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
-}
-const postgres = new class {
+	async connect() {
+		const db = new Client({ connectionString: this.connectionString });
+		try {
+			await db.connect();
+		} catch (e) {
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}.`);
+		}
+		await db.query("BEGIN");
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("SAVEPOINT sqg_query");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK TO SAVEPOINT sqg_query");
+		}
+	}
+	async close(db) {
+		await db.query("ROLLBACK");
+		await db.end();
+	}
+};
+/**
+* Temp database mode: creates a temporary database for SQG to work in.
+* Connects to the provided server first (dbInitial) to CREATE the temp DB,
+* then connects to the temp DB for all operations.
+* On close, drops the temp DB and optionally stops the testcontainer.
+*/
+var TempDbMode = class {
 	dbInitial;
-	db;
-	usingTestContainer = false;
-	async initializeDatabase(queries) {
-		const connectionString = await getConnectionString();
-		const connectionStringTemp = getTempConnectionString(connectionString);
-		this.usingTestContainer = containerInstance !== null;
-		this.dbInitial = new Client({ connectionString });
-		this.db = new Client({ connectionString: connectionStringTemp });
+	container = null;
+	constructor(connectionString, container) {
+		this.connectionString = connectionString;
+		this.container = container;
+	}
+	async connect() {
+		this.dbInitial = new Client({ connectionString: this.connectionString });
 		try {
 			await this.dbInitial.connect();
 		} catch (e) {
-			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${connectionString}. Set SQG_POSTGRES_URL environment variable to use a different connection string.`);
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}. Set SQG_POSTGRES_URL environment variable to use a different connection string.`);
 		}
 		try {
-			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}";`);
+			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}";`);
 		} catch (error) {}
 		try {
-			await this.dbInitial.query(`CREATE DATABASE "${databaseName}";`);
+			await this.dbInitial.query(`CREATE DATABASE "${tempDatabaseName}";`);
 		} catch (error) {
 			throw new DatabaseError(`Failed to create temporary database: ${error.message}`, "postgres", "Check PostgreSQL user permissions to create databases");
 		}
+		const db = new Client({ connectionString: this.connectionString.replace(/\/[^/]+$/, `/${tempDatabaseName}`) });
 		try {
-			await this.db.connect();
+			await db.connect();
 		} catch (e) {
 			throw new DatabaseError(`Failed to connect to temporary database: ${e.message}`, "postgres");
 		}
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("BEGIN");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK");
+		}
+	}
+	async close(db) {
+		await db.end();
+		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}"`);
+		await this.dbInitial.end();
+		if (this.container) {
+			consola.info("Stopping PostgreSQL container...");
+			await this.container.stop();
+			this.container = null;
+		}
+	}
+};
+const postgres = new class {
+	db;
+	mode;
+	dynamicTypeCache = /* @__PURE__ */ new Map();
+	async startContainer() {
+		consola.info("Starting PostgreSQL container via testcontainers...");
+		const container = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
+		const connectionUri = container.getConnectionUri();
+		consola.success(`PostgreSQL container started at: ${connectionUri}`);
+		return {
+			connectionUri,
+			container
+		};
+	}
+	async loadTypeCache(db) {
+		const result = await db.query(`
+      SELECT t.oid, t.typname, t.typtype, t.typelem, et.typname AS elemtype
+      FROM pg_type t
+      LEFT JOIN pg_type et ON t.typelem = et.oid
+      WHERE t.typtype IN ('b', 'e', 'r', 'c') -- base, enum, range, composite
+         OR t.typelem != 0 -- array types
+    `);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		for (const row of result.rows) {
+			const oid = row.oid;
+			let typeName = row.typname;
+			if (typeName.startsWith("_") && row.elemtype) typeName = `_${row.elemtype.toUpperCase()}`;
+			else typeName = typeName.toUpperCase();
+			this.dynamicTypeCache.set(oid, typeName);
+		}
+	}
+	getTypeName(dataTypeID) {
+		const cached = this.dynamicTypeCache.get(dataTypeID);
+		if (cached) return cached;
+		return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
+	}
+	async initializeDatabase(queries) {
+		const externalUrl = process.env.SQG_POSTGRES_URL;
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		if (externalUrl) this.mode = new ExternalDbMode(externalUrl);
+		else {
+			const { connectionUri, container } = await this.startContainer();
+			this.mode = new TempDbMode(connectionUri, container);
+		}
+		this.db = await this.mode.connect();
 		await initializeDatabase(queries, async (query) => {
 			try {
 				await this.db.query(query.rawQuery);
@@ -1173,7 +1232,7 @@ const postgres = new class {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
 		});
-		await loadTypeCache(this.db);
+		await this.loadTypeCache(this.db);
 	}
 	async executeQueries(queries) {
 		const db = this.db;
@@ -1183,7 +1242,6 @@ const postgres = new class {
 			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) {
@@ -1194,21 +1252,22 @@ const postgres = new class {
 	async executeQuery(db, query) {
 		const statement = query.queryPositional;
 		try {
-			consola.info("Query:", statement.sql);
+			consola.debug("Query:", statement.sql);
 			const parameterValues = statement.parameters.map((p) => {
 				const value = p.value;
 				if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
 				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++) {
-						const typeName = getTypeName(Number(paramTypeResult.rows[i].oid));
+						const oid = Number(paramTypeResult.rows[i].oid);
+						const typeName = this.getTypeName(oid);
 						paramTypes.set(statement.parameters[i].name, typeName);
 					}
 					query.parameterTypes = paramTypes;
@@ -1217,17 +1276,11 @@ const postgres = new class {
 			} catch (e) {
 				consola.debug(`Parameter type introspection failed for ${query.id}, using heuristic:`, e.message);
 			}
-			let result;
-			try {
-				await db.query("BEGIN");
-				result = await db.query(statement.sql, parameterValues);
-			} finally {
-				await db.query("ROLLBACK");
-			}
+			const result = await this.mode.wrapQuery(db, () => db.query(statement.sql, parameterValues));
 			if (query.isQuery) {
 				const columnNames = result.fields.map((field) => field.name);
 				const columnTypes = result.fields.map((field) => {
-					return getTypeName(field.dataTypeID);
+					return this.getTypeName(field.dataTypeID);
 				});
 				consola.debug("Columns:", columnNames);
 				consola.debug("Types:", columnTypes);
@@ -1269,10 +1322,8 @@ const postgres = new class {
 		}
 	}
 	async close() {
-		await this.db.end();
-		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}"`);
-		await this.dbInitial.end();
-		if (this.usingTestContainer) await stopTestContainer();
+		await this.mode.close(this.db);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
 	}
 }();
 
@@ -1459,7 +1510,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",
@@ -1600,6 +1651,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("_")) {
@@ -1857,6 +1909,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({
@@ -2346,10 +2401,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}`);
@@ -2725,7 +2794,7 @@ async function processProject(projectPath) {
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.10.0"
+	version: process.env.npm_package_version ?? "0.12.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -3054,7 +3123,11 @@ async function startMcpServer() {
 
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.10.0";
+const version = process.env.npm_package_version ?? "0.12.0";
+updateNotifier({ pkg: {
+	name: "@sqg/sqg",
+	version
+} }).notify({ message: "Update available {currentVersion} → {latestVersion}" });
 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

@@ -212,8 +212,9 @@ public class {{className}} {
     {{#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 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}}
         var rs = stmt.executeQuery();
         var iter = new Iterator<{{rowType}}>() {
             private Boolean hasNext = null;
@@ -256,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 {
@@ -282,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}});
@@ -327,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "bin": {
@@ -45,6 +45,8 @@
     "@lezer/common": "^1.5.0",
     "@lezer/generator": "^1.8.0",
     "@lezer/lr": "^1.4.6",
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@testcontainers/postgresql": "^10.21.0",
     "better-sqlite3": "^12.5.0",
     "commander": "^14.0.2",
     "consola": "^3.4.2",
@@ -53,12 +55,11 @@
     "handlebars": "^4.7.8",
     "pg": "^8.16.3",
     "pg-types": "^4.1.0",
-    "@testcontainers/postgresql": "^10.21.0",
     "prettier": "^3.7.4",
     "prettier-plugin-java": "^2.7.7",
+    "update-notifier": "^7.3.1",
     "yaml": "^2.8.2",
-    "zod": "^4.3.5",
-    "@modelcontextprotocol/sdk": "^1.0.4"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@libsql/client": "^0.17.0",
@@ -66,6 +67,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.16.0",
+    "@types/update-notifier": "^6.0.8",
     "@vitest/ui": "^4.0.16",
     "tsdown": "0.18.0",
     "tsx": "^4.21.0",