@sqg/sqg 0.3.0 → 0.5.0

package/dist/sqg.mjs

@@ -21,45 +21,128 @@ import typescriptPlugin from "prettier/parser-typescript";
 import estree from "prettier/plugins/estree";
 
 //#region src/constants.ts
-/**
-* SQG Constants - Centralized definitions for supported engines and generators
-* This file enables self-documenting CLI help and validation.
-*/
-/** Supported database engines */
-const SUPPORTED_ENGINES = [
-	"sqlite",
-	"duckdb",
-	"postgres"
-];
-/** Supported code generators with their descriptions */
-const SUPPORTED_GENERATORS = {
-	"typescript/better-sqlite3": {
+/** All supported generators with their full specification */
+const GENERATORS = {
+	"typescript/sqlite/better-sqlite3": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "better-sqlite3",
 		description: "TypeScript with better-sqlite3 driver",
-		compatibleEngines: ["sqlite"],
-		extension: ".ts"
+		extension: ".ts",
+		template: "better-sqlite3.hbs"
 	},
-	"typescript/duckdb": {
+	"typescript/duckdb/node-api": {
+		language: "typescript",
+		engine: "duckdb",
+		driver: "node-api",
 		description: "TypeScript with @duckdb/node-api driver",
-		compatibleEngines: ["duckdb"],
-		extension: ".ts"
+		extension: ".ts",
+		template: "typescript-duckdb.hbs"
+	},
+	"java/sqlite/jdbc": {
+		language: "java",
+		engine: "sqlite",
+		driver: "jdbc",
+		description: "Java with JDBC for SQLite",
+		extension: ".java",
+		template: "java-jdbc.hbs"
 	},
-	"java/jdbc": {
-		description: "Java with JDBC (SQLite, DuckDB, PostgreSQL)",
-		compatibleEngines: [
-			"sqlite",
-			"duckdb",
-			"postgres"
-		],
-		extension: ".java"
+	"java/duckdb/jdbc": {
+		language: "java",
+		engine: "duckdb",
+		driver: "jdbc",
+		description: "Java with JDBC for DuckDB",
+		extension: ".java",
+		template: "java-jdbc.hbs"
 	},
-	"java/duckdb-arrow": {
+	"java/duckdb/arrow": {
+		language: "java",
+		engine: "duckdb",
+		driver: "arrow",
 		description: "Java with DuckDB Arrow API",
-		compatibleEngines: ["duckdb"],
-		extension: ".java"
+		extension: ".java",
+		template: "java-duckdb-arrow.hbs"
+	},
+	"java/postgres/jdbc": {
+		language: "java",
+		engine: "postgres",
+		driver: "jdbc",
+		description: "Java with JDBC for PostgreSQL",
+		extension: ".java",
+		template: "java-jdbc.hbs"
 	}
 };
-/** List of all generator names for validation */
-const GENERATOR_NAMES = Object.keys(SUPPORTED_GENERATORS);
+/** Default drivers for language/engine combinations */
+const DEFAULT_DRIVERS = {
+	"typescript/sqlite": "better-sqlite3",
+	"typescript/duckdb": "node-api",
+	"java/sqlite": "jdbc",
+	"java/duckdb": "jdbc",
+	"java/postgres": "jdbc"
+};
+/** List of all full generator names */
+const GENERATOR_NAMES = Object.keys(GENERATORS);
+/** List of short generator names (language/engine) */
+const SHORT_GENERATOR_NAMES = Object.keys(DEFAULT_DRIVERS);
+/**
+* Resolve a generator string to its full form.
+* Accepts both short (language/engine) and full (language/engine/driver) formats.
+*/
+function resolveGenerator(generator) {
+	if (generator in GENERATORS) return generator;
+	if (generator in DEFAULT_DRIVERS) return `${generator}/${DEFAULT_DRIVERS[generator]}`;
+	return generator;
+}
+/**
+* Parse a generator string and return its info.
+* Throws if the generator is invalid.
+*/
+function parseGenerator(generator) {
+	const info = GENERATORS[resolveGenerator(generator)];
+	if (!info) throw new Error(`Invalid generator: ${generator}`);
+	return info;
+}
+/**
+* Check if a generator string is valid (either short or full form).
+*/
+function isValidGenerator(generator) {
+	return resolveGenerator(generator) in GENERATORS;
+}
+/**
+* Get the database engine for a generator.
+*/
+function getGeneratorEngine(generator) {
+	return parseGenerator(generator).engine;
+}
+/**
+* Find similar generator names for typo suggestions.
+*/
+function findSimilarGenerators(input) {
+	const normalized = input.toLowerCase();
+	return [...GENERATOR_NAMES, ...SHORT_GENERATOR_NAMES].filter((name) => {
+		const nameLower = name.toLowerCase();
+		if (nameLower.includes(normalized) || normalized.includes(nameLower)) return true;
+		return [
+			normalized.replace(/\//g, "-"),
+			normalized.replace(/-/g, "/"),
+			normalized.replace(/_/g, "/"),
+			normalized.replace(/_/g, "-")
+		].some((v) => nameLower.includes(v) || v.includes(nameLower));
+	});
+}
+/**
+* Format generators for CLI help output.
+*/
+function formatGeneratorsHelp() {
+	const lines = [];
+	for (const shortName of SHORT_GENERATOR_NAMES) {
+		const fullName = `${shortName}/${DEFAULT_DRIVERS[shortName]}`;
+		const info = GENERATORS[fullName];
+		lines.push(`  ${shortName.padEnd(24)} ${info.description} (default)`);
+		for (const [generatorName, generatorInfo] of Object.entries(GENERATORS)) if (generatorName.startsWith(`${shortName}/`) && generatorName !== fullName) lines.push(`  ${generatorName.padEnd(24)} ${generatorInfo.description}`);
+	}
+	return lines.join("\n");
+}
 /** SQL annotation syntax reference */
 const SQL_SYNTAX_REFERENCE = `
 SQL Annotation Syntax:
@@ -88,34 +171,6 @@ Example:
 
   -- TABLE users :appender
 `.trim();
-/**
-* Find similar generator names for typo suggestions
-*/
-function findSimilarGenerators(input) {
-	const normalized = input.toLowerCase();
-	return GENERATOR_NAMES.filter((name) => {
-		const nameLower = name.toLowerCase();
-		if (nameLower.includes(normalized) || normalized.includes(nameLower)) return true;
-		return [
-			normalized.replace("/", "-"),
-			normalized.replace("-", "/"),
-			normalized.replace("_", "/"),
-			normalized.replace("_", "-")
-		].some((v) => nameLower.includes(v) || v.includes(nameLower));
-	});
-}
-/**
-* Format generators for CLI help output
-*/
-function formatGeneratorsHelp() {
-	return Object.entries(SUPPORTED_GENERATORS).map(([name, info]) => `  ${name.padEnd(28)} ${info.description} (${info.compatibleEngines.join(", ")})`).join("\n");
-}
-/**
-* Format engines for CLI help output
-*/
-function formatEnginesHelp() {
-	return SUPPORTED_ENGINES.map((e) => `  ${e}`).join("\n");
-}
 
 //#endregion
 //#region src/errors.ts
@@ -174,41 +229,20 @@ var ConfigError = class extends SqgError {
 * Error for invalid generator names
 */
 var InvalidGeneratorError = class extends SqgError {
-	constructor(generatorName, validGenerators, suggestion) {
+	constructor(generatorName, validGenerators$1, suggestion) {
 		const similarMsg = suggestion ? ` Did you mean '${suggestion}'?` : "";
-		super(`Invalid generator '${generatorName}'.${similarMsg} Valid generators: ${validGenerators.join(", ")}`, "INVALID_GENERATOR", suggestion ? `Use '${suggestion}' instead` : `Choose from: ${validGenerators.join(", ")}`, { generator: generatorName });
+		super(`Invalid generator '${generatorName}'.${similarMsg} Valid generators: ${validGenerators$1.join(", ")}`, "INVALID_GENERATOR", suggestion ? `Use '${suggestion}' instead` : `Choose from: ${validGenerators$1.join(", ")}`, { generator: generatorName });
 		this.name = "InvalidGeneratorError";
 	}
 };
 /**
-* Error for invalid engine names
-*/
-var InvalidEngineError = class extends SqgError {
-	constructor(engineName, validEngines) {
-		super(`Invalid engine '${engineName}'. Valid engines: ${validEngines.join(", ")}`, "INVALID_ENGINE", `Choose from: ${validEngines.join(", ")}`, { engine: engineName });
-		this.name = "InvalidEngineError";
-	}
-};
-/**
-* Error for generator/engine compatibility
-*/
-var GeneratorEngineMismatchError = class extends SqgError {
-	constructor(generator, engine, compatibleEngines) {
-		super(`Generator '${generator}' is not compatible with engine '${engine}'`, "GENERATOR_ENGINE_MISMATCH", `Generator '${generator}' works with: ${compatibleEngines.join(", ")}`, {
-			generator,
-			engine
-		});
-		this.name = "GeneratorEngineMismatchError";
-	}
-};
-/**
 * Error for database initialization/connection issues
 */
 var DatabaseError = class extends SqgError {
 	constructor(message, engine, suggestion, context) {
 		super(message, "DATABASE_ERROR", suggestion, {
-			engine,
-			...context
+			...context,
+			engine
 		});
 		this.name = "DatabaseError";
 	}
@@ -406,11 +440,15 @@ function parseSQLQueries(filePath, extraVariables) {
 	const queries = [];
 	const tables = [];
 	const cursor = parser.parse(content).cursor();
+	function getLineNumber(position) {
+		return content.slice(0, position).split("\n").length;
+	}
 	function getStr(nodeName, optional = false) {
 		const node = cursor.node.getChild(nodeName);
 		if (!node) {
 			if (optional) return;
-			throw new Error(`${nodeName} not found`);
+			const lineNumber = getLineNumber(cursor.node.from);
+			throw new Error(`Node '${nodeName}' not found at line ${lineNumber}`);
 		}
 		return nodeStr(node);
 	}
@@ -1328,6 +1366,9 @@ var BaseGenerator = class {
 	isCompatibleWith(_engine) {
 		return true;
 	}
+	supportsAppenders(_engine) {
+		return false;
+	}
 	functionReturnType(query) {
 		if (query.isOne) return this.rowType(query);
 		return this.typeMapper.formatListType(this.rowType(query));
@@ -1351,6 +1392,9 @@ var JavaGenerator = class extends BaseGenerator {
 		super(template, new JavaTypeMapper());
 		this.template = template;
 	}
+	supportsAppenders(engine) {
+		return engine === "duckdb";
+	}
 	getFunctionName(id) {
 		return camelCase$1(id);
 	}
@@ -1447,14 +1491,17 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 		const name = `${gen.name}-jdbc`;
 		writeGeneratedFile(projectDir, {
 			name,
-			generator: "java/jdbc",
+			generator: "java/duckdb/jdbc",
 			output: gen.output,
 			config: gen.config
-		}, this.javaGenerator, name, q, tables);
+		}, this.javaGenerator, name, q, tables, "duckdb");
 	}
 	isCompatibleWith(engine) {
 		return engine === "duckdb";
 	}
+	supportsAppenders(_engine) {
+		return true;
+	}
 	getFilename(sqlFileName) {
 		return this.javaGenerator.getFilename(sqlFileName);
 	}
@@ -1462,25 +1509,28 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 		return this.javaGenerator.getClassName(name);
 	}
 	mapType(column) {
-		const { type, nullable } = column;
+		const { type } = column;
 		if (typeof type === "string") {
 			const mappedType = {
 				INTEGER: "IntVector",
+				BIGINT: "BigIntVector",
 				BOOLEAN: "BitVector",
 				DOUBLE: "Float8Vector",
 				FLOAT: "Float4Vector",
 				VARCHAR: "VarCharVector",
-				TEXT: "VarCharVector"
+				TEXT: "VarCharVector",
+				TIMESTAMP: "TimeStampVector",
+				DATE: "DateDayVector",
+				TIME: "TimeMicroVector"
 			}[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);
+		if (type instanceof ListType) return "ListVector";
+		if (type instanceof StructType) return "StructVector";
+		if (type instanceof MapType) return "MapVector";
+		consola.warn("(duckdb-arrow) Unknown complex type:", type);
+		return "Object";
 	}
 	mapParameterType(type, nullable) {
 		return this.typeMapper.getTypeName({
@@ -1688,6 +1738,9 @@ var TsDuckDBGenerator = class extends TsGenerator {
 	constructor(template) {
 		super(template);
 	}
+	supportsAppenders(_engine) {
+		return true;
+	}
 	async beforeGenerate(projectDir, gen, queries, tables) {
 		await super.beforeGenerate(projectDir, gen, queries, tables);
 		Handlebars.registerHelper("tsType", (column) => {
@@ -1735,22 +1788,31 @@ var TsDuckDBGenerator = class extends TsGenerator {
 
 //#endregion
 //#region src/generators/index.ts
+/**
+* Get a generator instance for the given generator.
+* Accepts both short (language/engine) and full (language/engine/driver) formats.
+*/
 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: {
-			const similar = findSimilarGenerators(generator);
-			throw new InvalidGeneratorError(generator, [...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
+	const fullGenerator = resolveGenerator(generator);
+	try {
+		const info = parseGenerator(generator);
+		const key = `${info.language}/${info.driver}`;
+		switch (key) {
+			case "typescript/better-sqlite3": 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}`);
+			default: throw new Error(`No generator class for ${key}`);
 		}
+	} catch {
+		const similar = findSimilarGenerators(generator);
+		throw new InvalidGeneratorError(fullGenerator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
 	}
 }
 
 //#endregion
 //#region src/sqltool.ts
-const GENERATED_FILE_COMMENT = "This file is generated by SQG. Do not edit manually.";
+const GENERATED_FILE_COMMENT = "This file is generated by SQG (https://sqg.dev). Do not edit manually.";
 const configSchema = z.object({ result: z.record(z.string(), z.string()).optional() });
 var Config = class Config {
 	constructor(result) {
@@ -1894,13 +1956,13 @@ var TableHelper = class {
 		return this.generator.typeMapper;
 	}
 };
-function generateSourceFile(name, queries, tables, templatePath, generator, config) {
+function generateSourceFile(name, queries, tables, templatePath, generator, engine, 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);
 	const migrations = queries.filter((q) => q.isMigrate).map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q)));
-	const tableHelpers = tables.filter((t) => !t.skipGenerateFunction).map((t) => new TableHelper(t, generator));
+	const tableHelpers = generator.supportsAppenders(engine) ? tables.filter((t) => !t.skipGenerateFunction).map((t) => new TableHelper(t, generator)) : [];
 	return template({
 		generatedComment: GENERATED_FILE_COMMENT,
 		migrations,
@@ -1913,6 +1975,8 @@ function generateSourceFile(name, queries, tables, templatePath, generator, conf
 		allowProtoMethodsByDefault: true
 	});
 }
+/** All valid generator strings for schema validation */
+const validGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
 /**
 * Project configuration schema with descriptions for validation messages
 */
@@ -1920,10 +1984,9 @@ const ProjectSchema = z.object({
 	version: z.number().describe("Configuration version (currently 1)"),
 	name: z.string().min(1, "Project name is required").describe("Project name used for generated class names"),
 	sql: z.array(z.object({
-		engine: z.enum(SUPPORTED_ENGINES).describe(`Database engine: ${SUPPORTED_ENGINES.join(", ")}`),
 		files: z.array(z.string().min(1)).min(1, "At least one SQL file is required").describe("SQL files to process"),
 		gen: z.array(z.object({
-			generator: z.enum(GENERATOR_NAMES).describe(`Code generator: ${GENERATOR_NAMES.join(", ")}`),
+			generator: z.string().refine((val) => isValidGenerator(val), { message: `Invalid generator. Valid generators: ${validGenerators.join(", ")}` }).describe(`Code generation generator: ${SHORT_GENERATOR_NAMES.join(", ")}`),
 			name: z.string().optional().describe("Override the generated class/module name"),
 			template: z.string().optional().describe("Custom Handlebars template path"),
 			output: z.string().min(1, "Output path is required").describe("Output file or directory path"),
@@ -1941,15 +2004,36 @@ var ExtraVariable = class {
 		this.value = value;
 	}
 };
-function createExtraVariables(sources) {
+function createExtraVariables(sources, suppressLogging = false) {
 	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);
+		if (!suppressLogging) consola.info("Extra variable:", varName, resolvedPath);
 		return new ExtraVariable(varName, `'${resolvedPath}'`);
 	});
 }
+function buildProjectFromCliOptions(options) {
+	if (!isValidGenerator(options.generator)) {
+		const similar = findSimilarGenerators(options.generator);
+		const allGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
+		throw new InvalidGeneratorError(options.generator, allGenerators, similar.length > 0 ? similar[0] : void 0);
+	}
+	const generatorInfo = parseGenerator(options.generator);
+	const genConfig = {
+		generator: options.generator,
+		output: options.output || "."
+	};
+	if (generatorInfo.language === "java") genConfig.config = { package: "generated" };
+	return {
+		version: 1,
+		name: options.name || "generated",
+		sql: [{
+			files: options.files,
+			gen: [genConfig]
+		}]
+	};
+}
 /**
 * Parse and validate project configuration with helpful error messages
 */
@@ -1971,12 +2055,12 @@ function parseProjectConfig(filePath) {
 		const obj = parsed;
 		if (obj.sql && Array.isArray(obj.sql)) for (let i = 0; i < obj.sql.length; i++) {
 			const sqlConfig = obj.sql[i];
-			if (sqlConfig.engine && !SUPPORTED_ENGINES.includes(sqlConfig.engine)) throw new InvalidEngineError(String(sqlConfig.engine), [...SUPPORTED_ENGINES]);
 			if (sqlConfig.gen && Array.isArray(sqlConfig.gen)) for (let j = 0; j < sqlConfig.gen.length; j++) {
 				const genConfig = sqlConfig.gen[j];
-				if (genConfig.generator && !GENERATOR_NAMES.includes(genConfig.generator)) {
+				if (genConfig.generator && !isValidGenerator(String(genConfig.generator))) {
 					const similar = findSimilarGenerators(String(genConfig.generator));
-					throw new InvalidGeneratorError(String(genConfig.generator), [...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
+					const allGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
+					throw new InvalidGeneratorError(String(genConfig.generator), allGenerators, similar.length > 0 ? similar[0] : void 0);
 				}
 			}
 		}
@@ -2020,11 +2104,16 @@ function validateQueries(queries) {
 		};
 	}
 }
-async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables = []) {
+async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false) {
 	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, gen.config);
+	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.config);
+	if (writeToStdout) {
+		process.stdout.write(sourceFile);
+		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
+		return null;
+	}
 	const outputPath = getOutputPath(projectDir, name, gen, generator);
 	writeFileSync(outputPath, sourceFile);
 	consola.success(`Generated ${outputPath}`);
@@ -2032,33 +2121,11 @@ async function writeGeneratedFile(projectDir, gen, generator, file, queries, tab
 	return outputPath;
 }
 /**
-* Validate project configuration without executing queries
+* Validate project configuration from a Project object without executing queries
 * Use this for pre-flight checks before generation
 */
-async function validateProject(projectPath) {
+async function validateProjectFromConfig(project, projectDir) {
 	const errors = [];
-	const projectDir = resolve(dirname(projectPath));
-	let project;
-	try {
-		project = parseProjectConfig(projectPath);
-	} catch (e) {
-		if (e instanceof SqgError) return {
-			valid: false,
-			errors: [{
-				code: e.code,
-				message: e.message,
-				suggestion: e.suggestion,
-				context: e.context
-			}]
-		};
-		return {
-			valid: false,
-			errors: [{
-				code: "UNKNOWN_ERROR",
-				message: String(e)
-			}]
-		};
-	}
 	const sqlFiles = [];
 	const generators = [];
 	for (const sql of project.sql) for (const sqlFile of sql.files) {
@@ -2072,15 +2139,15 @@ async function validateProject(projectPath) {
 		});
 		for (const gen of sql.gen) {
 			generators.push(gen.generator);
-			if (!SUPPORTED_GENERATORS[gen.generator].compatibleEngines.includes(sql.engine)) errors.push({
-				code: "GENERATOR_ENGINE_MISMATCH",
-				message: `Generator '${gen.generator}' is not compatible with engine '${sql.engine}'`,
-				suggestion: `For '${sql.engine}', use one of: ${Object.entries(SUPPORTED_GENERATORS).filter(([_, info]) => info.compatibleEngines.includes(sql.engine)).map(([name]) => name).join(", ")}`,
-				context: {
-					generator: gen.generator,
-					engine: sql.engine
-				}
-			});
+			if (!isValidGenerator(gen.generator)) {
+				const similar = findSimilarGenerators(gen.generator);
+				errors.push({
+					code: "INVALID_GENERATOR",
+					message: `Invalid generator '${gen.generator}'`,
+					suggestion: similar.length > 0 ? `Did you mean '${similar[0]}'?` : `Valid generators: ${SHORT_GENERATOR_NAMES.join(", ")}`,
+					context: { generator: gen.generator }
+				});
+			}
 		}
 	}
 	return {
@@ -2095,53 +2162,96 @@ async function validateProject(projectPath) {
 	};
 }
 /**
-* Process a project configuration and generate code
+* Validate project configuration from a YAML file without executing queries
+* Use this for pre-flight checks before generation
 */
-async function processProject(projectPath) {
+async function validateProject(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 gen of sql.gen) {
-			const generatorInfo = SUPPORTED_GENERATORS[gen.generator];
-			if (!generatorInfo.compatibleEngines.includes(sql.engine)) throw new GeneratorEngineMismatchError(gen.generator, sql.engine, generatorInfo.compatibleEngines);
-		}
-		for (const sqlFile of sql.files) {
-			const fullPath = join(projectDir, sqlFile);
-			if (!existsSync(fullPath)) throw new FileNotFoundError(fullPath, projectDir);
-			let queries;
-			let tables;
-			try {
-				const parseResult = parseSQLQueries(fullPath, extraVariables);
-				queries = parseResult.queries;
-				tables = parseResult.tables;
-			} catch (e) {
-				if (e instanceof SqgError) throw e;
-				throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
-			}
-			try {
-				const dbEngine = getDatabaseEngine(sql.engine);
-				await dbEngine.initializeDatabase(queries);
-				await dbEngine.executeQueries(queries);
-				if (tables.length > 0) await dbEngine.introspectTables(tables);
-				validateQueries(queries);
-				await dbEngine.close();
-			} catch (e) {
-				if (e instanceof SqgError) throw e;
-				throw new SqgError(`Database error processing ${sqlFile}: ${e.message}`, "DATABASE_ERROR", `Check that the SQL is valid for engine '${sql.engine}'`, {
-					file: sqlFile,
-					engine: sql.engine
-				});
-			}
+	let project;
+	try {
+		project = parseProjectConfig(projectPath);
+	} catch (e) {
+		if (e instanceof SqgError) return {
+			valid: false,
+			errors: [{
+				code: e.code,
+				message: e.message,
+				suggestion: e.suggestion,
+				context: e.context
+			}]
+		};
+		return {
+			valid: false,
+			errors: [{
+				code: "UNKNOWN_ERROR",
+				message: String(e)
+			}]
+		};
+	}
+	return await validateProjectFromConfig(project, projectDir);
+}
+/**
+* Process a project configuration and generate code from a Project object
+*/
+async function processProjectFromConfig(project, projectDir, writeToStdout = false) {
+	const originalLevel = consola.level;
+	if (writeToStdout) consola.level = LogLevels.silent;
+	try {
+		const extraVariables = createExtraVariables(project.sources ?? [], writeToStdout);
+		const files = [];
+		for (const sql of project.sql) {
+			const gensByEngine = /* @__PURE__ */ new Map();
 			for (const gen of sql.gen) {
-				const outputPath = await writeGeneratedFile(projectDir, gen, getGenerator(gen.generator), sqlFile, queries, tables);
-				files.push(outputPath);
+				const engine = getGeneratorEngine(gen.generator);
+				if (!gensByEngine.has(engine)) gensByEngine.set(engine, []);
+				gensByEngine.get(engine).push(gen);
+			}
+			for (const sqlFile of sql.files) {
+				const fullPath = join(projectDir, sqlFile);
+				if (!existsSync(fullPath)) throw new FileNotFoundError(fullPath, projectDir);
+				let queries;
+				let tables;
+				try {
+					const parseResult = parseSQLQueries(fullPath, extraVariables);
+					queries = parseResult.queries;
+					tables = parseResult.tables;
+				} catch (e) {
+					if (e instanceof SqgError) throw e;
+					throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
+				}
+				for (const [engine, gens] of gensByEngine) {
+					try {
+						const dbEngine = getDatabaseEngine(engine);
+						await dbEngine.initializeDatabase(queries);
+						await dbEngine.executeQueries(queries);
+						if (tables.length > 0) await dbEngine.introspectTables(tables);
+						validateQueries(queries);
+						await dbEngine.close();
+					} catch (e) {
+						if (e instanceof SqgError) throw e;
+						throw new SqgError(`Database error processing ${sqlFile}: ${e.message}`, "DATABASE_ERROR", `Check that the SQL is valid for engine '${engine}'`, {
+							file: sqlFile,
+							engine
+						});
+					}
+					for (const gen of gens) {
+						const outputPath = await writeGeneratedFile(projectDir, gen, getGenerator(gen.generator), sqlFile, queries, tables, engine, writeToStdout);
+						if (outputPath !== null) files.push(outputPath);
+					}
+				}
 			}
 		}
+		return files;
+	} finally {
+		if (writeToStdout) consola.level = originalLevel;
 	}
-	return files;
+}
+/**
+* Process a project configuration and generate code from a YAML file
+*/
+async function processProject(projectPath) {
+	const projectDir = resolve(dirname(projectPath));
+	return await processProjectFromConfig(parseProjectConfig(projectPath), projectDir, false);
 }
 
 //#endregion
@@ -2150,14 +2260,10 @@ async function processProject(projectPath) {
 * SQG Project Initialization - Creates new SQG projects with example files
 */
 /**
-* Get the default generator for an engine
+* Get the default generator for a language preference
 */
-function getDefaultGenerator(engine) {
-	return {
-		sqlite: "typescript/better-sqlite3",
-		duckdb: "typescript/duckdb",
-		postgres: "java/jdbc"
-	}[engine];
+function getDefaultGenerator() {
+	return "typescript/sqlite";
 }
 /**
 * Generate example SQL content based on engine
@@ -2355,21 +2461,8 @@ DELETE FROM posts WHERE id = \${id};
 /**
 * Generate sqg.yaml configuration
 */
-function getConfigYaml(engine, generator, output) {
-	SUPPORTED_GENERATORS[generator];
-	const config = {
-		version: 1,
-		name: "my-project",
-		sql: [{
-			engine,
-			files: ["queries.sql"],
-			gen: [{
-				generator,
-				output: output.endsWith("/") ? output : `${output}/`
-			}]
-		}]
-	};
-	if (generator.startsWith("java/")) config.sql[0].gen[0].config = { package: "generated" };
+function getConfigYaml(generator, output) {
+	const isJava = parseGenerator(generator).language === "java";
 	return `# SQG Configuration
 # Generated by: sqg init
 # Documentation: https://sqg.dev
@@ -2378,12 +2471,11 @@ version: 1
 name: my-project
 
 sql:
-  - engine: ${engine}
-    files:
+  - files:
       - queries.sql
     gen:
       - generator: ${generator}
-        output: ${output.endsWith("/") ? output : `${output}/`}${generator.startsWith("java/") ? `
+        output: ${output.endsWith("/") ? output : `${output}/`}${isJava ? `
         config:
           package: generated` : ""}
 `;
@@ -2392,18 +2484,13 @@ sql:
 * Initialize a new SQG project
 */
 async function initProject(options) {
-	const engine = options.engine || "sqlite";
+	const generator = options.generator || getDefaultGenerator();
 	const output = options.output || "./generated";
-	if (!SUPPORTED_ENGINES.includes(engine)) throw new InvalidEngineError(engine, [...SUPPORTED_ENGINES]);
-	let generator;
-	if (options.generator) {
-		if (!(options.generator in SUPPORTED_GENERATORS)) {
-			const similar = findSimilarGenerators(options.generator);
-			throw new InvalidGeneratorError(options.generator, Object.keys(SUPPORTED_GENERATORS), similar.length > 0 ? similar[0] : void 0);
-		}
-		generator = options.generator;
-		if (!SUPPORTED_GENERATORS[generator].compatibleEngines.includes(engine)) throw new SqgError(`Generator '${generator}' is not compatible with engine '${engine}'`, "GENERATOR_ENGINE_MISMATCH", `For '${engine}', use one of: ${Object.entries(SUPPORTED_GENERATORS).filter(([_, info]) => info.compatibleEngines.includes(engine)).map(([name]) => name).join(", ")}`);
-	} else generator = getDefaultGenerator(engine);
+	if (!isValidGenerator(generator)) {
+		const similar = findSimilarGenerators(generator);
+		throw new InvalidGeneratorError(generator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
+	}
+	const engine = parseGenerator(generator).engine;
 	const configPath = "sqg.yaml";
 	const sqlPath = "queries.sql";
 	if (!options.force) {
@@ -2414,16 +2501,16 @@ async function initProject(options) {
 		mkdirSync(output, { recursive: true });
 		consola.success(`Created output directory: ${output}`);
 	}
-	writeFileSync(configPath, getConfigYaml(engine, generator, output));
+	writeFileSync(configPath, getConfigYaml(generator, output));
 	consola.success(`Created ${configPath}`);
 	writeFileSync(sqlPath, getExampleSql(engine));
 	consola.success(`Created ${sqlPath}`);
 	consola.box(`
 SQG project initialized!
 
-Engine:    ${engine}
 Generator: ${generator}
-Output:    ${output}
+Engine: ${engine}
+Output: ${output}
 
 Next steps:
   1. Edit queries.sql to add your SQL queries
@@ -2436,46 +2523,81 @@ Documentation: https://sqg.dev
 
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.3.0";
+const version = process.env.npm_package_version ?? "0.5.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}
 
 Generate type-safe database access code from annotated SQL files.
 
-Supported Engines:
-${formatEnginesHelp()}
-
 Supported Generators:
-${formatGeneratorsHelp()}`).version(version, "-v, --version", "output the version number").option("--verbose", "Enable debug logging (shows SQL execution details)").option("--format <format>", "Output format: text (default) or json", "text").option("--validate", "Validate configuration without generating code").showHelpAfterError().showSuggestionAfterError();
-program.argument("<project>", "Path to the project YAML config (sqg.yaml)").hook("preAction", (thisCommand) => {
+${formatGeneratorsHelp()}`).version(version, "-v, --version", "output the version number").option("--verbose", "Enable debug logging (shows SQL execution details)").option("--format <format>", "Output format: text (default) or json", "text").option("--validate", "Validate configuration without generating code").option("--generator <generator>", `Code generation generator (${SHORT_GENERATOR_NAMES.join(", ")})`).option("--file <file>", "SQL file path (can be repeated)", (val, prev = []) => {
+	prev.push(val);
+	return prev;
+}).option("--output <path>", "Output file or directory path (optional, if omitted writes to stdout)").option("--name <name>", "Project name (optional, defaults to 'generated')").showHelpAfterError().showSuggestionAfterError();
+program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omit to use CLI options").hook("preAction", (thisCommand) => {
 	const opts = thisCommand.opts();
 	if (opts.verbose) consola.level = LogLevels.debug;
 	if (opts.format === "json") consola.level = LogLevels.silent;
 }).action(async (projectPath, options) => {
 	try {
-		if (options.validate) {
-			const result = await validateProject(projectPath);
-			if (options.format === "json") console.log(JSON.stringify(result, null, 2));
-			else if (result.valid) {
-				consola.success("Configuration is valid");
-				consola.info(`Project: ${result.project?.name}`);
-				consola.info(`SQL files: ${result.sqlFiles?.join(", ")}`);
-				consola.info(`Generators: ${result.generators?.join(", ")}`);
-			} else {
-				consola.error("Validation failed");
-				for (const error of result.errors || []) {
-					consola.error(`  ${error.message}`);
-					if (error.suggestion) consola.info(`    Suggestion: ${error.suggestion}`);
+		if (!projectPath) {
+			if (!options.generator) throw new SqgError("Missing required option: --generator", "CONFIG_VALIDATION_ERROR", `Specify a code generation generator: ${SHORT_GENERATOR_NAMES.join(", ")}`);
+			if (!options.file || options.file.length === 0) throw new SqgError("Missing required option: --file", "CONFIG_VALIDATION_ERROR", "Specify at least one SQL file with --file <path>");
+			const project = buildProjectFromCliOptions({
+				generator: options.generator,
+				files: options.file,
+				output: options.output,
+				name: options.name
+			});
+			const projectDir = process.cwd();
+			const writeToStdout = !options.output;
+			if (options.validate) {
+				const result = await validateProjectFromConfig(project, projectDir);
+				if (options.format === "json") console.log(JSON.stringify(result, null, 2));
+				else if (result.valid) {
+					consola.success("Configuration is valid");
+					consola.info(`Project: ${result.project?.name}`);
+					consola.info(`SQL files: ${result.sqlFiles?.join(", ")}`);
+					consola.info(`Generators: ${result.generators?.join(", ")}`);
+				} else {
+					consola.error("Validation failed");
+					for (const error of result.errors || []) {
+						consola.error(`  ${error.message}`);
+						if (error.suggestion) consola.info(`    Suggestion: ${error.suggestion}`);
+					}
 				}
+				exit(result.valid ? 0 : 1);
 			}
-			exit(result.valid ? 0 : 1);
+			const files = await processProjectFromConfig(project, projectDir, writeToStdout);
+			if (options.format === "json" && !writeToStdout) console.log(JSON.stringify({
+				status: "success",
+				generatedFiles: files
+			}));
+		} else {
+			if (options.validate) {
+				const result = await validateProject(projectPath);
+				if (options.format === "json") console.log(JSON.stringify(result, null, 2));
+				else if (result.valid) {
+					consola.success("Configuration is valid");
+					consola.info(`Project: ${result.project?.name}`);
+					consola.info(`SQL files: ${result.sqlFiles?.join(", ")}`);
+					consola.info(`Generators: ${result.generators?.join(", ")}`);
+				} else {
+					consola.error("Validation failed");
+					for (const error of result.errors || []) {
+						consola.error(`  ${error.message}`);
+						if (error.suggestion) consola.info(`    Suggestion: ${error.suggestion}`);
+					}
+				}
+				exit(result.valid ? 0 : 1);
+			}
+			const files = await processProject(projectPath);
+			if (options.format === "json") console.log(JSON.stringify({
+				status: "success",
+				generatedFiles: files
+			}));
 		}
-		const files = await processProject(projectPath);
-		if (options.format === "json") console.log(JSON.stringify({
-			status: "success",
-			generatedFiles: files
-		}));
 	} catch (err) {
 		if (options.format === "json") console.log(JSON.stringify(formatErrorForOutput(err)));
 		else if (err instanceof SqgError) {
@@ -2486,7 +2608,7 @@ program.argument("<project>", "Path to the project YAML config (sqg.yaml)").hook
 		exit(1);
 	}
 });
-program.command("init").description("Initialize a new SQG project with example configuration").option("-e, --engine <engine>", `Database engine (${SUPPORTED_ENGINES.join(", ")})`, "sqlite").option("-g, --generator <generator>", `Code generator (${GENERATOR_NAMES.join(", ")})`).option("-o, --output <dir>", "Output directory for generated files", "./generated").option("-f, --force", "Overwrite existing files").action(async (options) => {
+program.command("init").description("Initialize a new SQG project with example configuration").option("-t, --generator <generator>", `Code generation generator (${SHORT_GENERATOR_NAMES.join(", ")})`, "typescript/sqlite").option("-o, --output <dir>", "Output directory for generated files", "./generated").option("-f, --force", "Overwrite existing files").action(async (options) => {
 	const parentOpts = program.opts();
 	try {
 		await initProject(options);

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

@@ -69,7 +69,7 @@ public class {{className}} {
 public record {{rowType}}({{#each columns}}{{type}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
 {{else}}
 public record {{rowType}}(PreparedStatement statement, RootAllocator allocator, ArrowReader reader,
-{{#each columns}}{{mapType this}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) implements AutoCloseable {
+{{#each columns}}{{{mapType this}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) implements AutoCloseable {
     public boolean loadNextBatch() throws IOException {
         return reader.loadNextBatch();
     }
@@ -99,7 +99,7 @@ int
 {{#*inline "readVectors"}}
 var root = reader.getVectorSchemaRoot();
 
-return new {{rowType}}(stmt, allocator, reader, {{#each columns}}({{mapType this}})root.getVector("{{name}}"){{#unless @last}}, {{/unless}}{{/each}});
+return new {{rowType}}(stmt, allocator, reader, {{#each columns}}({{{mapType this}}})root.getVector("{{name}}"){{#unless @last}}, {{/unless}}{{/each}});
 
 {{/inline~}}
 

package/package.json

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