@sqg/sqg 0.6.0 → 0.8.0

package/dist/sqg.mjs

@@ -55,6 +55,22 @@ const GENERATORS = {
 		extension: ".ts",
 		template: "node-sqlite.hbs"
 	},
+	"typescript/sqlite/libsql": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "libsql",
+		description: "TypeScript with @libsql/client (Turso)",
+		extension: ".ts",
+		template: "libsql.hbs"
+	},
+	"typescript/sqlite/turso": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "turso",
+		description: "TypeScript with Turso (limbo) native driver",
+		extension: ".ts",
+		template: "turso.hbs"
+	},
 	"typescript/duckdb/node-api": {
 		language: "typescript",
 		engine: "duckdb",
@@ -1078,14 +1094,63 @@ const duckdb = new class {
 //#endregion
 //#region src/db/postgres.ts
 const databaseName = "sqg-db-temp";
-const connectionString = process.env.SQG_POSTGRES_URL || "postgresql://sqg:secret@localhost:15432/sqg-db";
-const connectionStringTemp = process.env.SQG_POSTGRES_URL ? process.env.SQG_POSTGRES_URL.replace(/\/[^/]+$/, `/${databaseName}`) : `postgresql://sqg:secret@localhost:15432/${databaseName}`;
+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 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);
+	}
+}
+function getTypeName(dataTypeID) {
+	const cached = dynamicTypeCache.get(dataTypeID);
+	if (cached) return cached;
+	return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
+}
 const postgres = new 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 });
 		try {
@@ -1094,7 +1159,7 @@ const postgres = new class {
 			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.`);
 		}
 		try {
-			await this.dbInitial.query(`DROP DATABASE "${databaseName}";`);
+			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}";`);
 		} catch (error) {}
 		try {
 			await this.dbInitial.query(`CREATE DATABASE "${databaseName}";`);
@@ -1113,6 +1178,7 @@ const postgres = new class {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
 		});
+		await loadTypeCache(this.db);
 	}
 	async executeQueries(queries) {
 		const db = this.db;
@@ -1134,17 +1200,22 @@ const postgres = new class {
 		const statement = query.queryPositional;
 		try {
 			consola.info("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;
+			});
 			let result;
 			try {
 				await db.query("BEGIN");
-				result = await db.query(statement.sql, statement.parameters);
+				result = await db.query(statement.sql, parameterValues);
 			} 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}`;
+					return getTypeName(field.dataTypeID);
 				});
 				consola.debug("Columns:", columnNames);
 				consola.debug("Types:", columnTypes);
@@ -1187,8 +1258,9 @@ const postgres = new class {
 	}
 	async close() {
 		await this.db.end();
-		await this.dbInitial.query(`DROP DATABASE "${databaseName}"`);
+		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}"`);
 		await this.dbInitial.end();
+		if (this.usingTestContainer) await stopTestContainer();
 	}
 }();
 
@@ -1380,7 +1452,20 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		INTERVAL: "String",
 		BIT: "String",
 		BIGNUM: "BigDecimal",
-		INT4: "Integer"
+		INT2: "Short",
+		INT4: "Integer",
+		INT8: "Long",
+		FLOAT4: "Float",
+		FLOAT8: "Double",
+		NUMERIC: "BigDecimal",
+		BOOL: "Boolean",
+		BYTEA: "byte[]",
+		TIMESTAMPTZ: "OffsetDateTime",
+		JSON: "String",
+		JSONB: "String",
+		OID: "Long",
+		SERIAL: "Integer",
+		BIGSERIAL: "Long"
 	};
 	static javaReservedKeywords = new Set([
 		"abstract",
@@ -1441,12 +1526,15 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		const upperType = type.toString().toUpperCase();
 		const mappedType = this.typeMap[upperType];
 		if (mappedType) return mappedType;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			return `List<${this.typeMap[baseType] || "Object"}>`;
+		}
 		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";
+		return "String";
 	}
 	formatListType(elementType) {
 		return `List<${elementType}>`;
@@ -1499,8 +1587,13 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		const fieldType = this.getTypeName(column);
 		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 === "DATE") return `toLocalDate((java.sql.Date)${value})`;
 		if (upperType === "TIME") return `toLocalTime((java.sql.Time)${value})`;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			return `arrayToList((Array)${value}, ${this.typeMap[baseType] || "Object"}[].class)`;
+		}
 		return `(${fieldType})${value}`;
 	}
 	getInnermostType(type) {
@@ -1568,12 +1661,30 @@ var TypeScriptTypeMapper = class extends TypeMapper {
 		INTERVAL: "{ months: number; days: number; micros: bigint }",
 		BIT: "{ data: Uint8Array }",
 		BIGNUM: "bigint",
-		INT4: "number"
+		INT2: "number",
+		INT4: "number",
+		INT8: "bigint",
+		FLOAT4: "number",
+		FLOAT8: "number",
+		NUMERIC: "string",
+		BOOL: "boolean",
+		BYTEA: "Buffer",
+		TIMESTAMPTZ: "Date",
+		JSON: "unknown",
+		JSONB: "unknown",
+		OID: "number",
+		SERIAL: "number",
+		BIGSERIAL: "bigint"
 	};
 	mapPrimitiveType(type, nullable) {
 		const upperType = type.toUpperCase();
 		const mappedType = this.typeMap[upperType];
 		if (mappedType) return nullable ? `${mappedType} | null` : mappedType;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			const arrayType = `${this.typeMap[baseType] || "unknown"}[]`;
+			return nullable ? `${arrayType} | null` : arrayType;
+		}
 		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) {
 			const baseType = "{ width: number; scale: number; value: bigint }";
 			return nullable ? `${baseType} | null` : baseType;
@@ -1598,8 +1709,7 @@ var TypeScriptTypeMapper = class extends TypeMapper {
 			}
 		}
 		if (/\[\d+\]/.test(upperType)) return "{ items: unknown[] }";
-		console.warn("Mapped type is unknown:", type);
-		return "unknown";
+		return nullable ? "string | null" : "string";
 	}
 	formatListType(elementType) {
 		return `{ items: (${elementType})[] }`;
@@ -1784,7 +1894,8 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 			name,
 			generator: "java/duckdb/jdbc",
 			output: gen.output,
-			config: gen.config
+			config: gen.config,
+			projectName: gen.projectName
 		}, this.javaGenerator, name, q, tables, "duckdb");
 	}
 	isCompatibleWith(engine) {
@@ -2090,7 +2201,9 @@ function getGenerator(generator) {
 		const key = `${info.language}/${info.driver}`;
 		switch (key) {
 			case "typescript/better-sqlite3":
-			case "typescript/node": return new TsGenerator(`templates/${info.template}`);
+			case "typescript/node":
+			case "typescript/libsql":
+			case "typescript/turso": return new TsGenerator(`templates/${info.template}`);
 			case "typescript/node-api": return new TsDuckDBGenerator(`templates/${info.template}`);
 			case "java/jdbc": return new JavaGenerator(`templates/${info.template}`);
 			case "java/arrow": return new JavaDuckDBArrowGenerator(`templates/${info.template}`);
@@ -2248,7 +2361,7 @@ var TableHelper = class {
 		return this.generator.typeMapper;
 	}
 };
-function generateSourceFile(name, queries, tables, templatePath, generator, engine, config) {
+function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config) {
 	const templateSrc = readFileSync(templatePath, "utf-8");
 	const template = Handlebars.compile(templateSrc);
 	Handlebars.registerHelper("mapType", (column) => generator.mapType(column));
@@ -2261,6 +2374,7 @@ function generateSourceFile(name, queries, tables, templatePath, generator, engi
 		queries: queries.map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
 		tables: tableHelpers,
 		className: generator.getClassName(name),
+		projectName,
 		config
 	}, {
 		allowProtoPropertiesByDefault: true,
@@ -2400,7 +2514,7 @@ 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.config);
+	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.projectName ?? name, gen.config);
 	if (writeToStdout) {
 		process.stdout.write(sourceFile);
 		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
@@ -2527,7 +2641,11 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 						});
 					}
 					for (const gen of gens) {
-						const outputPath = await writeGeneratedFile(projectDir, gen, getGenerator(gen.generator), sqlFile, queries, tables, engine, writeToStdout);
+						const generator = getGenerator(gen.generator);
+						const outputPath = await writeGeneratedFile(projectDir, {
+							...gen,
+							projectName: project.name
+						}, generator, sqlFile, queries, tables, engine, writeToStdout);
 						if (outputPath !== null) files.push(outputPath);
 					}
 				}
@@ -2550,7 +2668,7 @@ async function processProject(projectPath) {
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.6.0"
+	version: process.env.npm_package_version ?? "0.8.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -2879,7 +2997,7 @@ async function startMcpServer() {
 
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.6.0";
+const version = process.env.npm_package_version ?? "0.8.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/better-sqlite3.hbs

@@ -18,7 +18,7 @@ export class {{className}} {
         return stmt as Statement<BindParameters, Result>;
     }
 
-    static getMigrations(): string[] {   
+    static getMigrations(): string[] {
         return [
             {{#each migrations}}
             {{{quote sqlQuery}}},
@@ -26,6 +26,36 @@ export class {{className}} {
         ];
     }
 
+{{#if config.migrations}}
+    static applyMigrations(db: Database, projectName = '{{projectName}}'): void {
+        db.exec(`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)
+        )`);
+        const runMigrations = db.transaction(() => {
+            const applied = new Set(
+                db.prepare('SELECT migration_id FROM _sqg_migrations WHERE project = ?')
+                    .pluck().all(projectName) as string[]
+            );
+            const migrations: [string, string][] = [
+                {{#each migrations}}
+                ['{{{id}}}', {{{quote sqlQuery}}}],
+                {{/each}}
+            ];
+            for (const [id, sql] of migrations) {
+                if (!applied.has(id)) {
+                    db.exec(sql);
+                    db.prepare('INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)')
+                        .run(projectName, id);
+                }
+            }
+        });
+        runMigrations.immediate();
+    }
+{{/if}}
+
     static getQueryNames(): Map<string, keyof {{className}}> {
         return new Map([
             {{#each queries}} {{#unless skipGenerateFunction}}

package/dist/templates/java-duckdb-arrow.hbs

@@ -29,10 +29,20 @@ public class {{className}} {
     }
 
 
-    public static List<String> getMigrations() {   
+    public static List<String> getMigrations() {
         return {{className}}Jdbc.getMigrations();
     }
 
+{{#if config.migrations}}
+    public static void applyMigrations(Connection connection) throws SQLException {
+        {{className}}Jdbc.applyMigrations(connection);
+    }
+
+    public static void applyMigrations(Connection connection, String projectName) throws SQLException {
+        {{className}}Jdbc.applyMigrations(connection, projectName);
+    }
+{{/if}}
+
     {{#each queries}}
     {{#unless skipGenerateFunction}}
     {{#if isOne}}

package/dist/templates/java-jdbc.hbs

@@ -13,6 +13,7 @@ import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.OffsetDateTime;
 import java.time.OffsetTime;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -65,6 +66,10 @@ public class {{className}} {
     private static LocalTime toLocalTime(java.sql.Time t) {
         return t != null ? t.toLocalTime() : null;
     }
+
+    private static OffsetDateTime toOffsetDateTime(java.sql.Timestamp ts) {
+        return ts != null ? ts.toInstant().atOffset(java.time.ZoneOffset.UTC) : null;
+    }
     
     private static <K> List<K> arrayToList(
         Array array,
@@ -129,10 +134,67 @@ public class {{className}} {
         {{/each}}
     );
 
-    public static List<String> getMigrations() {   
+{{#if config.migrations}}
+    private static final List<String> migrationIds = List.of(
+        {{#each migrations}}"{{id}}"{{#unless @last}},{{/unless}}
+        {{/each}}
+    );
+{{/if}}
+
+    public static List<String> getMigrations() {
         return migrations;
     }
 
+{{#if config.migrations}}
+    public static void applyMigrations(Connection connection) throws SQLException {
+        applyMigrations(connection, "{{projectName}}");
+    }
+
+    public static void applyMigrations(Connection connection, String projectName) throws SQLException {
+        try (var stmt = connection.createStatement()) {
+            stmt.execute("""
+                CREATE TABLE IF NOT EXISTS _sqg_migrations (
+                    project TEXT NOT NULL,
+                    migration_id TEXT NOT NULL,
+                    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (project, migration_id)
+                )""");
+        }
+        boolean wasAutoCommit = connection.getAutoCommit();
+        connection.setAutoCommit(false);
+        try {
+            var applied = new java.util.HashSet<String>();
+            try (var stmt = connection.prepareStatement("SELECT migration_id FROM _sqg_migrations WHERE project = ?")) {
+                stmt.setString(1, projectName);
+                try (var rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        applied.add(rs.getString(1));
+                    }
+                }
+            }
+            for (int i = 0; i < migrations.size(); i++) {
+                var id = migrationIds.get(i);
+                if (!applied.contains(id)) {
+                    try (var stmt = connection.createStatement()) {
+                        stmt.execute(migrations.get(i));
+                    }
+                    try (var stmt = connection.prepareStatement("INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)")) {
+                        stmt.setString(1, projectName);
+                        stmt.setString(2, id);
+                        stmt.executeUpdate();
+                    }
+                }
+            }
+            connection.commit();
+        } catch (SQLException e) {
+            connection.rollback();
+            throw e;
+        } finally {
+            connection.setAutoCommit(wasAutoCommit);
+        }
+    }
+{{/if}}
+
     {{#each queries}}
     {{#unless skipGenerateFunction}}
     {{>columnTypesRecord}}

package/dist/templates/libsql.hbs

@@ -0,0 +1,141 @@
+// {{generatedComment}}
+import type { Client, InArgs } from '@libsql/client';
+
+interface RunResult {
+    changes: number;
+    lastInsertRowid: bigint;
+}
+
+export class {{className}} {
+    constructor(private client: Client) {}
+
+    static getMigrations(): string[] {
+        return [
+            {{#each migrations}}
+            {{{quote sqlQuery}}},
+            {{/each}}
+        ];
+    }
+
+{{#if config.migrations}}
+    static async applyMigrations(client: Client, projectName = '{{projectName}}'): Promise<void> {
+        await client.execute({
+            sql: `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)
+            )`,
+            args: [],
+        });
+        const tx = await client.transaction('write');
+        try {
+            const result = await tx.execute({
+                sql: 'SELECT migration_id FROM _sqg_migrations WHERE project = ?',
+                args: [projectName],
+            });
+            const applied = new Set(result.rows.map(r => r.migration_id as string));
+            const migrations: [string, string][] = [
+                {{#each migrations}}
+                ['{{{id}}}', {{{quote sqlQuery}}}],
+                {{/each}}
+            ];
+            for (const [id, sql] of migrations) {
+                if (!applied.has(id)) {
+                    await tx.execute({ sql, args: [] });
+                    await tx.execute({
+                        sql: 'INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)',
+                        args: [projectName, id],
+                    });
+                }
+            }
+            await tx.commit();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    }
+{{/if}}
+
+    static getQueryNames(): Map<string, keyof {{className}}> {
+        return new Map([
+            {{#each queries}} {{#unless skipGenerateFunction}}
+            ["{{id}}", "{{functionName}}"],{{/unless}}{{/each}}]
+        );
+    }
+
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    async {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): Promise<{{> returnType }}> {
+        const result = await this.client.execute({
+            sql: {{{quote sqlQuery}}},
+            args: [{{> params}}] as InArgs,
+        });
+        {{> execute}}
+    }
+    {{/unless}}
+    {{/each}}
+}
+
+{{#*inline "params"}}{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "paramTypes"}}{{#each parameters}}{{type}} {{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "columnTypes"}}{{#each columns}}{{name}}: {{mapType .}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "rowType"}}
+{{#if isQuery~}}
+{{#if isPluck~}}
+{{#if columns.length~}} {{mapType (lookup columns 0)}} {{else}}unknown{{/if~}}
+{{~else~}}
+{{#if columns.length}}{ {{> columnTypes}} }{{else}}unknown{{/if~}}
+{{/if~}}
+{{~else~}}
+unknown
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "resultType"}}
+{{#if isQuery~}}
+{{> rowType}}
+{{~else~}}
+unknown
+{{~/if~}}
+{{/inline~}}
+
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{#if isOne~}}
+{{> rowType}} | undefined
+{{~else~}}
+{{> rowType}}[]
+{{/if~}}
+{{~else~}}
+RunResult
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "execute"}}
+{{#if isQuery}}
+{{#if isOne}}
+{{#if isPluck}}
+const row = result.rows[0];
+return row ? Object.values(row)[0] as {{> rowType}} : undefined;
+{{else}}
+return (result.rows as unknown[])[0] as {{> rowType}} | undefined;
+{{/if}}
+{{else}}
+{{#if isPluck}}
+return result.rows.map(row => Object.values(row)[0] as {{> rowType}});
+{{else}}
+return (result.rows as unknown[]) as {{> rowType}}[];
+{{/if}}
+{{/if}}
+{{else}}
+return {
+    changes: result.rowsAffected,
+    lastInsertRowid: result.lastInsertRowid ?? 0n,
+};
+{{/if}}
+{{/inline}}

package/dist/templates/node-sqlite.hbs

@@ -28,6 +28,39 @@ export class {{className}} {
         ];
     }
 
+{{#if config.migrations}}
+    static applyMigrations(db: DatabaseSync, projectName = '{{projectName}}'): void {
+        db.exec(`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)
+        )`);
+        db.exec('BEGIN IMMEDIATE');
+        try {
+            const rows = db.prepare('SELECT migration_id FROM _sqg_migrations WHERE project = ?')
+                .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}}
+            ];
+            for (const [id, sql] of migrations) {
+                if (!applied.has(id)) {
+                    db.exec(sql);
+                    db.prepare('INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)')
+                        .run(projectName, id);
+                }
+            }
+            db.exec('COMMIT');
+        } catch (e) {
+            db.exec('ROLLBACK');
+            throw e;
+        }
+    }
+{{/if}}
+
     static getQueryNames(): Map<string, keyof {{className}}> {
         return new Map([
             {{#each queries}} {{#unless skipGenerateFunction}}

package/dist/templates/turso.hbs

@@ -0,0 +1,147 @@
+// {{generatedComment}}
+import { connect, type Database } from '@tursodatabase/database';
+
+interface RunResult {
+    changes: number;
+    lastInsertRowid: number;
+}
+
+// Statement type inferred from Database.prepare()
+type Statement = Awaited<ReturnType<Database['prepare']>>;
+
+export class {{className}} {
+    private statements = new Map<string, Statement>();
+
+    constructor(private db: Database) {}
+
+    private async prepare(id: string, query: string): Promise<Statement> {
+        let stmt = this.statements.get(id);
+        if (!stmt) {
+            stmt = await this.db.prepare(query);
+            this.statements.set(id, stmt);
+        }
+        return stmt;
+    }
+
+    static getMigrations(): string[] {
+        return [
+            {{#each migrations}}
+            {{{quote sqlQuery}}},
+            {{/each}}
+        ];
+    }
+
+{{#if config.migrations}}
+    static async applyMigrations(db: Database, projectName = '{{projectName}}'): Promise<void> {
+        const createStmt = await 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}}
+            ];
+            for (const [id, sql] of migrations) {
+                if (!applied.has(id)) {
+                    const execStmt = await tx.prepare(sql);
+                    await execStmt.run();
+                    const insertStmt = await tx.prepare('INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)');
+                    await insertStmt.run(projectName, id);
+                }
+            }
+            await tx.commit();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    }
+{{/if}}
+
+    static getQueryNames(): Map<string, keyof {{className}}> {
+        return new Map([
+            {{#each queries}} {{#unless skipGenerateFunction}}
+            ["{{id}}", "{{functionName}}"],{{/unless}}{{/each}}]
+        );
+    }
+
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    async {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): Promise<{{> returnType }}> {
+        const stmt = await this.prepare('{{id}}',
+            {{{quote sqlQuery}}});
+        {{> execute}}
+    }
+    {{/unless}}
+    {{/each}}
+}
+
+{{#*inline "params"}}{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "paramTypes"}}{{#each parameters}}{{type}} {{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "columnTypes"}}{{#each columns}}{{name}}: {{mapType .}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "rowType"}}
+{{#if isQuery~}}
+{{#if isPluck~}}
+{{#if columns.length~}} {{mapType (lookup columns 0)}} {{else}}unknown{{/if~}}
+{{~else~}}
+{{#if columns.length}}{ {{> columnTypes}} }{{else}}unknown{{/if~}}
+{{/if~}}
+{{~else~}}
+unknown
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "resultType"}}
+{{#if isQuery~}}
+{{> rowType}}
+{{~else~}}
+unknown
+{{~/if~}}
+{{/inline~}}
+
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{#if isOne~}}
+{{> rowType}} | undefined
+{{~else~}}
+{{> rowType}}[]
+{{/if~}}
+{{~else~}}
+RunResult
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "execute"}}
+{{#if isQuery}}
+{{#if isOne}}
+{{#if isPluck}}
+const row = await stmt.get({{> params}}) as Record<string, {{> rowType}}> | undefined;
+return row ? Object.values(row)[0] : undefined;
+{{else}}
+return await stmt.get({{> params}}) as {{> rowType}} | undefined;
+{{/if}}
+{{else}}
+{{#if isPluck}}
+const rows = await stmt.all({{> params}}) as Record<string, {{> rowType}}>[];
+return rows.map(row => Object.values(row)[0]);
+{{else}}
+return await stmt.all({{> params}}) as {{> rowType}}[];
+{{/if}}
+{{/if}}
+{{else}}
+const result = await stmt.run({{> params}});
+return result as RunResult;
+{{/if}}
+{{/inline}}

package/dist/templates/typescript-duckdb.hbs

@@ -5,7 +5,7 @@ export class {{className}} {
     
     constructor(private conn: DuckDBConnection) {}
 
-    static getMigrations(): string[] {   
+    static getMigrations(): string[] {
         return [
             {{#each migrations}}
             {{{quote sqlQuery}}},
@@ -13,6 +13,42 @@ export class {{className}} {
         ];
     }
 
+{{#if config.migrations}}
+    static async applyMigrations(conn: DuckDBConnection, projectName = '{{projectName}}'): Promise<void> {
+        await conn.run(`CREATE TABLE IF NOT EXISTS _sqg_migrations (
+            project TEXT NOT NULL,
+            migration_id TEXT NOT NULL,
+            applied_at TIMESTAMP NOT NULL DEFAULT now(),
+            PRIMARY KEY (project, migration_id)
+        )`);
+        await conn.run('BEGIN');
+        try {
+            const result = await conn.runAndReadAll(
+                'SELECT migration_id FROM _sqg_migrations WHERE project = $1', [projectName]
+            );
+            const applied = new Set(result.getRows().map((row) => row[0] as string));
+            const migrations: [string, string][] = [
+                {{#each migrations}}
+                ['{{{id}}}', {{{quote sqlQuery}}}],
+                {{/each}}
+            ];
+            for (const [id, sql] of migrations) {
+                if (!applied.has(id)) {
+                    await conn.run(sql);
+                    await conn.run(
+                        'INSERT INTO _sqg_migrations (project, migration_id) VALUES ($1, $2)',
+                        [projectName, id]
+                    );
+                }
+            }
+            await conn.run('COMMIT');
+        } catch (e) {
+            await conn.run('ROLLBACK');
+            throw e;
+        }
+    }
+{{/if}}
+
     static getQueryNames(): Map<string, keyof {{className}}> {
         return new Map([
             {{#each queries}} {{#unless skipGenerateFunction}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "bin": {
@@ -53,6 +53,7 @@
     "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",
     "yaml": "^2.8.2",
@@ -60,6 +61,8 @@
     "@modelcontextprotocol/sdk": "^1.0.4"
   },
   "devDependencies": {
+    "@libsql/client": "^0.17.0",
+    "@tursodatabase/database": "^0.4.3",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.16.0",