@tsqx/kit 0.0.4

package/dist/index.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _tsqx_core = require("@tsqx/core");
+//#region src/config.ts
+function defineConfig(config) {
+	const result = (0, _tsqx_core.parseConfig)(config);
+	if (result.isErr()) throw result.error;
+	return result.value;
+}
+//#endregion
+exports.defineConfig = defineConfig;

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+import { Config, ConfigInput } from "@tsqx/core";
+
+//#region src/config.d.ts
+declare function defineConfig(config: ConfigInput): Config;
+//#endregion
+export { type Config, type ConfigInput, defineConfig };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { Config, ConfigInput } from "@tsqx/core";
+
+//#region src/config.d.ts
+declare function defineConfig(config: ConfigInput): Config;
+//#endregion
+export { type Config, type ConfigInput, defineConfig };

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import { parseConfig } from "@tsqx/core";
+//#region src/config.ts
+function defineConfig(config) {
+	const result = parseConfig(config);
+	if (result.isErr()) throw result.error;
+	return result.value;
+}
+//#endregion
+export { defineConfig };

package/dist/postgres/pg/index.cjs

@@ -0,0 +1,425 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _tsqx_core = require("@tsqx/core");
+let neverthrow = require("neverthrow");
+//#region src/postgres/pg/parser.ts
+function stripComments(sql) {
+	sql = sql.replace(/\/\*[\s\S]*?\*\//g, "");
+	sql = sql.replace(/--.*$/gm, "");
+	return sql;
+}
+function parseColumnDef(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const match = trimmed.match(/^("(\w+)"|(\w+))\s+(.+)$/is);
+	if (!match) return null;
+	const name = match[2] ?? match[3].toLowerCase();
+	const rest = match[4].trim();
+	const typeMatch = rest.match(/^(\w+(?:\s+(?:PRECISION|VARYING|ZONE|WITHOUT|WITH(?:\s+TIME\s+ZONE)?))?(?:\(\s*\d+(?:\s*,\s*\d+)?\s*\))?(?:\[\])?)/i);
+	if (!typeMatch) return null;
+	const type = typeMatch[1].toUpperCase();
+	const modifiers = rest.slice(typeMatch[0].length).trim().toUpperCase();
+	const nullable = !modifiers.includes("NOT NULL");
+	const primaryKey = modifiers.includes("PRIMARY KEY");
+	const unique = modifiers.includes("UNIQUE");
+	let defaultValue;
+	const defaultMatch = rest.slice(typeMatch[0].length).match(/DEFAULT\s+(.+?)(?:\s+(?:NOT\s+NULL|NULL|PRIMARY\s+KEY|UNIQUE|REFERENCES|CHECK|CONSTRAINT)|\s*$)/i);
+	if (defaultMatch) defaultValue = defaultMatch[1].trim();
+	let references;
+	const restModifiers = rest.slice(typeMatch[0].length).trim();
+	const refMatch = restModifiers.match(/REFERENCES\s+"?(\w+)"?\s*\(\s*"?(\w+)"?\s*\)/i);
+	if (refMatch) references = {
+		table: restModifiers.includes(`"${refMatch[1]}"`) ? refMatch[1] : refMatch[1].toLowerCase(),
+		column: restModifiers.includes(`"${refMatch[2]}"`) ? refMatch[2] : refMatch[2].toLowerCase()
+	};
+	return {
+		name,
+		type,
+		nullable: primaryKey ? false : nullable,
+		...defaultValue !== void 0 && { default: defaultValue },
+		primaryKey,
+		unique,
+		...references && { references }
+	};
+}
+function isTableConstraint(line) {
+	const upper = line.trim().toUpperCase();
+	return upper.startsWith("PRIMARY KEY") || upper.startsWith("UNIQUE") || upper.startsWith("FOREIGN KEY") || upper.startsWith("CONSTRAINT") || upper.startsWith("CHECK");
+}
+function parseTableConstraint(raw) {
+	let working = raw.trim().toUpperCase();
+	let name;
+	const constraintMatch = raw.trim().match(/^CONSTRAINT\s+"?(\w+)"?\s+(.+)$/is);
+	if (constraintMatch) {
+		name = constraintMatch[1].toLowerCase();
+		working = constraintMatch[2].trim().toUpperCase();
+	}
+	const colsMatch = working.match(/\(\s*(.+?)\s*\)/);
+	if (!colsMatch) return null;
+	const columns = colsMatch[1].split(",").map((c) => {
+		const trimmed = c.trim();
+		if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+		return trimmed.replace(/"/g, "").toLowerCase();
+	});
+	if (working.startsWith("PRIMARY KEY")) return {
+		type: "primary_key",
+		...name && { name },
+		columns
+	};
+	if (working.startsWith("UNIQUE")) return {
+		type: "unique",
+		...name && { name },
+		columns
+	};
+	if (working.startsWith("FOREIGN KEY")) {
+		const refMatch = working.match(/REFERENCES\s+"?(\w+)"?\s*\(\s*(.+?)\s*\)/i);
+		if (!refMatch) return null;
+		const refColumns = refMatch[2].split(",").map((c) => {
+			const trimmed = c.trim();
+			if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+			return trimmed.replace(/"/g, "").toLowerCase();
+		});
+		return {
+			type: "foreign_key",
+			...name && { name },
+			columns,
+			references: {
+				table: refMatch[1].toLowerCase(),
+				columns: refColumns
+			}
+		};
+	}
+	return null;
+}
+function parseCreateTable(sql) {
+	const tableMatch = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?("(\w+)"|(\w+))\s*\(([\s\S]+)\)/i);
+	if (!tableMatch) return (0, neverthrow.err)(new _tsqx_core.SchemaError(`Failed to parse CREATE TABLE statement`));
+	const tableName = tableMatch[2] ?? tableMatch[3].toLowerCase();
+	const body = tableMatch[4];
+	const lines = [];
+	let depth = 0;
+	let current = "";
+	for (const char of body) {
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		if (char === "," && depth === 0) {
+			lines.push(current.trim());
+			current = "";
+		} else current += char;
+	}
+	if (current.trim()) lines.push(current.trim());
+	const columns = [];
+	const constraints = [];
+	for (const line of lines) if (isTableConstraint(line)) {
+		const constraint = parseTableConstraint(line);
+		if (constraint) constraints.push(constraint);
+	} else {
+		const column = parseColumnDef(line);
+		if (column) columns.push(column);
+	}
+	const pkConstraint = constraints.find((c) => c.type === "primary_key");
+	if (pkConstraint) {
+		for (const col of columns) if (pkConstraint.columns.includes(col.name)) {
+			col.primaryKey = true;
+			col.nullable = false;
+		}
+	}
+	return (0, neverthrow.ok)({
+		name: tableName,
+		columns,
+		constraints
+	});
+}
+function parseSchemaFiles(files) {
+	const snapshot = {};
+	for (const file of files) {
+		const matches = stripComments(file.content).match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"?\w+"?\s*\([\s\S]*?\);/gi);
+		if (!matches) continue;
+		for (const statement of matches) {
+			const result = parseCreateTable(statement);
+			if (result.isErr()) return (0, neverthrow.err)(new _tsqx_core.SchemaError(`Error in ${file.filename}: ${result.error.message}`));
+			const table = result.value;
+			if (snapshot[table.name]) return (0, neverthrow.err)(new _tsqx_core.SchemaError(`Duplicate table "${table.name}" found in ${file.filename}`));
+			snapshot[table.name] = table;
+		}
+	}
+	return (0, neverthrow.ok)(snapshot);
+}
+//#endregion
+//#region src/postgres/pg/generator.ts
+function quoteIdent(name) {
+	if (name !== name.toLowerCase()) return `"${name}"`;
+	return name;
+}
+function columnToSQL(col) {
+	const parts = [quoteIdent(col.name), col.type];
+	if (col.primaryKey) parts.push("PRIMARY KEY");
+	if (!col.nullable && !col.primaryKey) parts.push("NOT NULL");
+	if (col.unique) parts.push("UNIQUE");
+	if (col.default !== void 0) parts.push(`DEFAULT ${col.default}`);
+	if (col.references) parts.push(`REFERENCES ${quoteIdent(col.references.table)}(${quoteIdent(col.references.column)})`);
+	return parts.join(" ");
+}
+function createTableSQL(table) {
+	const cols = table.columns.map((c) => `  ${columnToSQL(c)}`);
+	for (const constraint of table.constraints) {
+		const name = constraint.name ? `CONSTRAINT ${constraint.name} ` : "";
+		if (constraint.type === "primary_key") {
+			if (constraint.columns.length > 1) cols.push(`  ${name}PRIMARY KEY (${constraint.columns.map(quoteIdent).join(", ")})`);
+		} else if (constraint.type === "unique") {
+			if (constraint.columns.length > 1) cols.push(`  ${name}UNIQUE (${constraint.columns.map(quoteIdent).join(", ")})`);
+		} else if (constraint.type === "foreign_key" && constraint.references) cols.push(`  ${name}FOREIGN KEY (${constraint.columns.map(quoteIdent).join(", ")}) REFERENCES ${quoteIdent(constraint.references.table)}(${constraint.references.columns.map(quoteIdent).join(", ")})`);
+	}
+	return `CREATE TABLE ${quoteIdent(table.name)} (\n${cols.join(",\n")}\n);`;
+}
+function operationToSQL(op) {
+	switch (op.type) {
+		case "create_table": return createTableSQL(op.table);
+		case "drop_table": return `DROP TABLE IF EXISTS ${quoteIdent(op.tableName)};`;
+		case "add_column": return `ALTER TABLE ${quoteIdent(op.tableName)} ADD COLUMN ${columnToSQL(op.column)};`;
+		case "drop_column": return `ALTER TABLE ${quoteIdent(op.tableName)} DROP COLUMN ${quoteIdent(op.columnName)};`;
+		case "alter_column": {
+			const stmts = [];
+			const { tableName, columnName, from, to } = op;
+			const qt = quoteIdent(tableName);
+			const qc = quoteIdent(columnName);
+			if (from.type !== to.type) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET DATA TYPE ${to.type};`);
+			if (from.nullable && !to.nullable) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET NOT NULL;`);
+			else if (!from.nullable && to.nullable) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} DROP NOT NULL;`);
+			if (from.default !== to.default) if (to.default !== void 0) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET DEFAULT ${to.default};`);
+			else stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} DROP DEFAULT;`);
+			if (!from.unique && to.unique) stmts.push(`ALTER TABLE ${qt} ADD CONSTRAINT ${tableName}_${columnName}_unique UNIQUE (${qc});`);
+			else if (from.unique && !to.unique) stmts.push(`ALTER TABLE ${qt} DROP CONSTRAINT ${tableName}_${columnName}_unique;`);
+			return stmts.join("\n");
+		}
+	}
+}
+function generateSQL(operations) {
+	if (operations.length === 0) return "";
+	return `BEGIN;\n\n${operations.map(operationToSQL).filter(Boolean).join("\n\n")}\n\nCOMMIT;\n`;
+}
+//#endregion
+//#region src/postgres/pg/types.ts
+function sqlTypeToJsonSchema(sqlType) {
+	switch (sqlType.toUpperCase().replace(/\(.+\)/, "").trim()) {
+		case "SERIAL":
+		case "BIGSERIAL":
+		case "INTEGER":
+		case "INT":
+		case "INT4":
+		case "SMALLINT":
+		case "INT2":
+		case "BIGINT":
+		case "INT8": return { type: "integer" };
+		case "REAL":
+		case "FLOAT4":
+		case "DOUBLE PRECISION":
+		case "FLOAT8":
+		case "NUMERIC":
+		case "DECIMAL": return { type: "number" };
+		case "BOOLEAN":
+		case "BOOL": return { type: "boolean" };
+		case "TEXT": return { type: "string" };
+		case "VARCHAR":
+		case "CHARACTER VARYING": {
+			const lenMatch = sqlType.match(/\((\d+)\)/);
+			return lenMatch ? {
+				type: "string",
+				maxLength: parseInt(lenMatch[1], 10)
+			} : { type: "string" };
+		}
+		case "CHAR":
+		case "CHARACTER": {
+			const lenMatch = sqlType.match(/\((\d+)\)/);
+			return lenMatch ? {
+				type: "string",
+				maxLength: parseInt(lenMatch[1], 10)
+			} : { type: "string" };
+		}
+		case "UUID": return {
+			type: "string",
+			format: "uuid"
+		};
+		case "DATE": return {
+			type: "string",
+			format: "date"
+		};
+		case "TIMESTAMP":
+		case "TIMESTAMP WITHOUT TIME ZONE":
+		case "TIMESTAMP WITH TIME ZONE":
+		case "TIMESTAMPTZ": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "TIME":
+		case "TIME WITHOUT TIME ZONE":
+		case "TIME WITH TIME ZONE":
+		case "TIMETZ": return {
+			type: "string",
+			format: "time"
+		};
+		case "JSON":
+		case "JSONB": return { type: "object" };
+		case "BYTEA": return {
+			type: "string",
+			format: "byte"
+		};
+		default: return { type: "string" };
+	}
+}
+function sqlTypeToTsType(sqlType) {
+	switch (sqlType.toUpperCase().replace(/\(.+\)/, "").trim()) {
+		case "SERIAL":
+		case "BIGSERIAL":
+		case "INTEGER":
+		case "INT":
+		case "INT4":
+		case "SMALLINT":
+		case "INT2":
+		case "BIGINT":
+		case "INT8":
+		case "REAL":
+		case "FLOAT4":
+		case "DOUBLE PRECISION":
+		case "FLOAT8":
+		case "NUMERIC":
+		case "DECIMAL": return "number";
+		case "BOOLEAN":
+		case "BOOL": return "boolean";
+		case "JSON":
+		case "JSONB": return "unknown";
+		case "BYTEA": return "Buffer";
+		default: return "string";
+	}
+}
+//#endregion
+//#region src/postgres/pg/query-codegen.ts
+function camelCase(str) {
+	return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateParamInterface(query) {
+	if (query.params.length === 0) return null;
+	return `export interface ${`${(0, _tsqx_core.pascalCase)(query.name)}Params`} {\n${query.params.map((p) => {
+		const base = sqlTypeToTsType(p.sqlType);
+		const type = p.nullable ? `${base} | null` : base;
+		return `  ${p.name}: ${type};`;
+	}).join("\n")}\n}`;
+}
+function generateParamSchema(query) {
+	if (query.params.length === 0) return null;
+	const name = `${(0, _tsqx_core.pascalCase)(query.name)}ParamsSchema`;
+	const properties = {};
+	const required = [];
+	for (const param of query.params) {
+		const jsonType = sqlTypeToJsonSchema(param.sqlType);
+		if (param.nullable) properties[param.name] = {
+			...jsonType,
+			type: Array.isArray(jsonType.type) ? [...jsonType.type, "null"] : [jsonType.type, "null"]
+		};
+		else {
+			properties[param.name] = jsonType;
+			required.push(param.name);
+		}
+	}
+	const schema = {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: `${(0, _tsqx_core.pascalCase)(query.name)}Params`,
+		type: "object",
+		properties,
+		required,
+		additionalProperties: false
+	};
+	return `export const ${name} = ${JSON.stringify(schema, null, 2)} as const;`;
+}
+function generateResultType(query, snapshot) {
+	if (query.command === "exec" || query.command === "execrows" || query.command === "execresult") return null;
+	if (!query.returnsTable || !snapshot[query.returnsTable]) return null;
+	const table = snapshot[query.returnsTable];
+	const typeName = (0, _tsqx_core.pascalCase)(query.returnsTable);
+	if (query.returnsColumns.length === table.columns.length && query.returnsColumns.every((c) => table.columns.some((tc) => tc.name === c))) return typeName;
+	return `Pick<${typeName}, ${query.returnsColumns.map((c) => `"${c}"`).join(" | ")}>`;
+}
+function generateReturnType(query, resultType) {
+	switch (query.command) {
+		case "one": return `Promise<${resultType ?? "unknown"} | null>`;
+		case "many": return `Promise<${resultType ?? "unknown"}[]>`;
+		case "exec": return "Promise<void>";
+		case "execrows": return "Promise<number>";
+		case "execresult": return "Promise<QueryResult>";
+		default: return "Promise<void>";
+	}
+}
+function generateFunctionBody(query) {
+	const paramArgs = query.params.map((p) => `params.${p.name}`).join(", ");
+	const queryArgs = query.params.length > 0 ? `sql, [${paramArgs}]` : "sql";
+	switch (query.command) {
+		case "one": return `  const result = await client.query(${queryArgs});\n  return result.rows[0] ?? null;`;
+		case "many": return `  const result = await client.query(${queryArgs});\n  return result.rows;`;
+		case "exec": return `  await client.query(${queryArgs});`;
+		case "execrows": return `  const result = await client.query(${queryArgs});\n  return result.rowCount ?? 0;`;
+		case "execresult": return `  return await client.query(${queryArgs});`;
+		default: return `  await client.query(${queryArgs});`;
+	}
+}
+function generateFunction(query, snapshot) {
+	const fnName = camelCase(query.name);
+	const returnType = generateReturnType(query, generateResultType(query, snapshot));
+	const hasParams = query.params.length > 0;
+	const paramsType = hasParams ? `${(0, _tsqx_core.pascalCase)(query.name)}Params` : null;
+	const args = hasParams ? `client: Client | Pool, params: ${paramsType}` : "client: Client | Pool";
+	const sql = query.expandedSql.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+	const lines = [];
+	lines.push(`export async function ${fnName}(${args}): ${returnType} {`);
+	lines.push(`  const sql = '${sql}';`);
+	lines.push(generateFunctionBody(query));
+	lines.push("}");
+	return lines.join("\n");
+}
+function generateQueryFiles(queries, snapshot) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const query of queries) {
+		const key = query.sourceFile.replace(/\.sql$/, "");
+		if (!grouped.has(key)) grouped.set(key, []);
+		grouped.get(key).push(query);
+	}
+	const files = {};
+	for (const [basename, fileQueries] of grouped) {
+		const lines = ["// This file is auto-generated by tsqx. Do not edit manually.", "import type { Client, Pool, QueryResult } from \"pg\";"];
+		const tableImports = /* @__PURE__ */ new Set();
+		for (const query of fileQueries) if (query.returnsTable && snapshot[query.returnsTable]) tableImports.add(query.returnsTable);
+		if (tableImports.size > 0) {
+			const imports = [...tableImports].map((t) => `type ${(0, _tsqx_core.pascalCase)(t)}`).join(", ");
+			lines.push(`import { ${imports} } from "../../generated";`);
+		}
+		lines.push("");
+		for (const query of fileQueries) {
+			const paramInterface = generateParamInterface(query);
+			if (paramInterface) {
+				lines.push(paramInterface);
+				lines.push("");
+			}
+			const paramSchema = generateParamSchema(query);
+			if (paramSchema) {
+				lines.push(paramSchema);
+				lines.push("");
+			}
+			lines.push(generateFunction(query, snapshot));
+			lines.push("");
+		}
+		files[`${basename}.ts`] = lines.join("\n");
+	}
+	return files;
+}
+//#endregion
+//#region src/postgres/pg/index.ts
+function pgDialect() {
+	return {
+		name: "pg",
+		parseSchema: parseSchemaFiles,
+		generateSQL,
+		sqlTypeToJsonSchema,
+		sqlTypeToTsType,
+		generateQueryCode: generateQueryFiles
+	};
+}
+//#endregion
+exports.pgDialect = pgDialect;

package/dist/postgres/pg/index.d.cts

@@ -0,0 +1,6 @@
+import { Dialect } from "@tsqx/core";
+
+//#region src/postgres/pg/index.d.ts
+declare function pgDialect(): Dialect;
+//#endregion
+export { pgDialect };

package/dist/postgres/pg/index.d.mts

@@ -0,0 +1,6 @@
+import { Dialect } from "@tsqx/core";
+
+//#region src/postgres/pg/index.d.ts
+declare function pgDialect(): Dialect;
+//#endregion
+export { pgDialect };

package/dist/postgres/pg/index.mjs

@@ -0,0 +1,424 @@
+import { SchemaError, pascalCase } from "@tsqx/core";
+import { err, ok } from "neverthrow";
+//#region src/postgres/pg/parser.ts
+function stripComments(sql) {
+	sql = sql.replace(/\/\*[\s\S]*?\*\//g, "");
+	sql = sql.replace(/--.*$/gm, "");
+	return sql;
+}
+function parseColumnDef(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const match = trimmed.match(/^("(\w+)"|(\w+))\s+(.+)$/is);
+	if (!match) return null;
+	const name = match[2] ?? match[3].toLowerCase();
+	const rest = match[4].trim();
+	const typeMatch = rest.match(/^(\w+(?:\s+(?:PRECISION|VARYING|ZONE|WITHOUT|WITH(?:\s+TIME\s+ZONE)?))?(?:\(\s*\d+(?:\s*,\s*\d+)?\s*\))?(?:\[\])?)/i);
+	if (!typeMatch) return null;
+	const type = typeMatch[1].toUpperCase();
+	const modifiers = rest.slice(typeMatch[0].length).trim().toUpperCase();
+	const nullable = !modifiers.includes("NOT NULL");
+	const primaryKey = modifiers.includes("PRIMARY KEY");
+	const unique = modifiers.includes("UNIQUE");
+	let defaultValue;
+	const defaultMatch = rest.slice(typeMatch[0].length).match(/DEFAULT\s+(.+?)(?:\s+(?:NOT\s+NULL|NULL|PRIMARY\s+KEY|UNIQUE|REFERENCES|CHECK|CONSTRAINT)|\s*$)/i);
+	if (defaultMatch) defaultValue = defaultMatch[1].trim();
+	let references;
+	const restModifiers = rest.slice(typeMatch[0].length).trim();
+	const refMatch = restModifiers.match(/REFERENCES\s+"?(\w+)"?\s*\(\s*"?(\w+)"?\s*\)/i);
+	if (refMatch) references = {
+		table: restModifiers.includes(`"${refMatch[1]}"`) ? refMatch[1] : refMatch[1].toLowerCase(),
+		column: restModifiers.includes(`"${refMatch[2]}"`) ? refMatch[2] : refMatch[2].toLowerCase()
+	};
+	return {
+		name,
+		type,
+		nullable: primaryKey ? false : nullable,
+		...defaultValue !== void 0 && { default: defaultValue },
+		primaryKey,
+		unique,
+		...references && { references }
+	};
+}
+function isTableConstraint(line) {
+	const upper = line.trim().toUpperCase();
+	return upper.startsWith("PRIMARY KEY") || upper.startsWith("UNIQUE") || upper.startsWith("FOREIGN KEY") || upper.startsWith("CONSTRAINT") || upper.startsWith("CHECK");
+}
+function parseTableConstraint(raw) {
+	let working = raw.trim().toUpperCase();
+	let name;
+	const constraintMatch = raw.trim().match(/^CONSTRAINT\s+"?(\w+)"?\s+(.+)$/is);
+	if (constraintMatch) {
+		name = constraintMatch[1].toLowerCase();
+		working = constraintMatch[2].trim().toUpperCase();
+	}
+	const colsMatch = working.match(/\(\s*(.+?)\s*\)/);
+	if (!colsMatch) return null;
+	const columns = colsMatch[1].split(",").map((c) => {
+		const trimmed = c.trim();
+		if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+		return trimmed.replace(/"/g, "").toLowerCase();
+	});
+	if (working.startsWith("PRIMARY KEY")) return {
+		type: "primary_key",
+		...name && { name },
+		columns
+	};
+	if (working.startsWith("UNIQUE")) return {
+		type: "unique",
+		...name && { name },
+		columns
+	};
+	if (working.startsWith("FOREIGN KEY")) {
+		const refMatch = working.match(/REFERENCES\s+"?(\w+)"?\s*\(\s*(.+?)\s*\)/i);
+		if (!refMatch) return null;
+		const refColumns = refMatch[2].split(",").map((c) => {
+			const trimmed = c.trim();
+			if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+			return trimmed.replace(/"/g, "").toLowerCase();
+		});
+		return {
+			type: "foreign_key",
+			...name && { name },
+			columns,
+			references: {
+				table: refMatch[1].toLowerCase(),
+				columns: refColumns
+			}
+		};
+	}
+	return null;
+}
+function parseCreateTable(sql) {
+	const tableMatch = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?("(\w+)"|(\w+))\s*\(([\s\S]+)\)/i);
+	if (!tableMatch) return err(new SchemaError(`Failed to parse CREATE TABLE statement`));
+	const tableName = tableMatch[2] ?? tableMatch[3].toLowerCase();
+	const body = tableMatch[4];
+	const lines = [];
+	let depth = 0;
+	let current = "";
+	for (const char of body) {
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		if (char === "," && depth === 0) {
+			lines.push(current.trim());
+			current = "";
+		} else current += char;
+	}
+	if (current.trim()) lines.push(current.trim());
+	const columns = [];
+	const constraints = [];
+	for (const line of lines) if (isTableConstraint(line)) {
+		const constraint = parseTableConstraint(line);
+		if (constraint) constraints.push(constraint);
+	} else {
+		const column = parseColumnDef(line);
+		if (column) columns.push(column);
+	}
+	const pkConstraint = constraints.find((c) => c.type === "primary_key");
+	if (pkConstraint) {
+		for (const col of columns) if (pkConstraint.columns.includes(col.name)) {
+			col.primaryKey = true;
+			col.nullable = false;
+		}
+	}
+	return ok({
+		name: tableName,
+		columns,
+		constraints
+	});
+}
+function parseSchemaFiles(files) {
+	const snapshot = {};
+	for (const file of files) {
+		const matches = stripComments(file.content).match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"?\w+"?\s*\([\s\S]*?\);/gi);
+		if (!matches) continue;
+		for (const statement of matches) {
+			const result = parseCreateTable(statement);
+			if (result.isErr()) return err(new SchemaError(`Error in ${file.filename}: ${result.error.message}`));
+			const table = result.value;
+			if (snapshot[table.name]) return err(new SchemaError(`Duplicate table "${table.name}" found in ${file.filename}`));
+			snapshot[table.name] = table;
+		}
+	}
+	return ok(snapshot);
+}
+//#endregion
+//#region src/postgres/pg/generator.ts
+function quoteIdent(name) {
+	if (name !== name.toLowerCase()) return `"${name}"`;
+	return name;
+}
+function columnToSQL(col) {
+	const parts = [quoteIdent(col.name), col.type];
+	if (col.primaryKey) parts.push("PRIMARY KEY");
+	if (!col.nullable && !col.primaryKey) parts.push("NOT NULL");
+	if (col.unique) parts.push("UNIQUE");
+	if (col.default !== void 0) parts.push(`DEFAULT ${col.default}`);
+	if (col.references) parts.push(`REFERENCES ${quoteIdent(col.references.table)}(${quoteIdent(col.references.column)})`);
+	return parts.join(" ");
+}
+function createTableSQL(table) {
+	const cols = table.columns.map((c) => `  ${columnToSQL(c)}`);
+	for (const constraint of table.constraints) {
+		const name = constraint.name ? `CONSTRAINT ${constraint.name} ` : "";
+		if (constraint.type === "primary_key") {
+			if (constraint.columns.length > 1) cols.push(`  ${name}PRIMARY KEY (${constraint.columns.map(quoteIdent).join(", ")})`);
+		} else if (constraint.type === "unique") {
+			if (constraint.columns.length > 1) cols.push(`  ${name}UNIQUE (${constraint.columns.map(quoteIdent).join(", ")})`);
+		} else if (constraint.type === "foreign_key" && constraint.references) cols.push(`  ${name}FOREIGN KEY (${constraint.columns.map(quoteIdent).join(", ")}) REFERENCES ${quoteIdent(constraint.references.table)}(${constraint.references.columns.map(quoteIdent).join(", ")})`);
+	}
+	return `CREATE TABLE ${quoteIdent(table.name)} (\n${cols.join(",\n")}\n);`;
+}
+function operationToSQL(op) {
+	switch (op.type) {
+		case "create_table": return createTableSQL(op.table);
+		case "drop_table": return `DROP TABLE IF EXISTS ${quoteIdent(op.tableName)};`;
+		case "add_column": return `ALTER TABLE ${quoteIdent(op.tableName)} ADD COLUMN ${columnToSQL(op.column)};`;
+		case "drop_column": return `ALTER TABLE ${quoteIdent(op.tableName)} DROP COLUMN ${quoteIdent(op.columnName)};`;
+		case "alter_column": {
+			const stmts = [];
+			const { tableName, columnName, from, to } = op;
+			const qt = quoteIdent(tableName);
+			const qc = quoteIdent(columnName);
+			if (from.type !== to.type) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET DATA TYPE ${to.type};`);
+			if (from.nullable && !to.nullable) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET NOT NULL;`);
+			else if (!from.nullable && to.nullable) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} DROP NOT NULL;`);
+			if (from.default !== to.default) if (to.default !== void 0) stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} SET DEFAULT ${to.default};`);
+			else stmts.push(`ALTER TABLE ${qt} ALTER COLUMN ${qc} DROP DEFAULT;`);
+			if (!from.unique && to.unique) stmts.push(`ALTER TABLE ${qt} ADD CONSTRAINT ${tableName}_${columnName}_unique UNIQUE (${qc});`);
+			else if (from.unique && !to.unique) stmts.push(`ALTER TABLE ${qt} DROP CONSTRAINT ${tableName}_${columnName}_unique;`);
+			return stmts.join("\n");
+		}
+	}
+}
+function generateSQL(operations) {
+	if (operations.length === 0) return "";
+	return `BEGIN;\n\n${operations.map(operationToSQL).filter(Boolean).join("\n\n")}\n\nCOMMIT;\n`;
+}
+//#endregion
+//#region src/postgres/pg/types.ts
+function sqlTypeToJsonSchema(sqlType) {
+	switch (sqlType.toUpperCase().replace(/\(.+\)/, "").trim()) {
+		case "SERIAL":
+		case "BIGSERIAL":
+		case "INTEGER":
+		case "INT":
+		case "INT4":
+		case "SMALLINT":
+		case "INT2":
+		case "BIGINT":
+		case "INT8": return { type: "integer" };
+		case "REAL":
+		case "FLOAT4":
+		case "DOUBLE PRECISION":
+		case "FLOAT8":
+		case "NUMERIC":
+		case "DECIMAL": return { type: "number" };
+		case "BOOLEAN":
+		case "BOOL": return { type: "boolean" };
+		case "TEXT": return { type: "string" };
+		case "VARCHAR":
+		case "CHARACTER VARYING": {
+			const lenMatch = sqlType.match(/\((\d+)\)/);
+			return lenMatch ? {
+				type: "string",
+				maxLength: parseInt(lenMatch[1], 10)
+			} : { type: "string" };
+		}
+		case "CHAR":
+		case "CHARACTER": {
+			const lenMatch = sqlType.match(/\((\d+)\)/);
+			return lenMatch ? {
+				type: "string",
+				maxLength: parseInt(lenMatch[1], 10)
+			} : { type: "string" };
+		}
+		case "UUID": return {
+			type: "string",
+			format: "uuid"
+		};
+		case "DATE": return {
+			type: "string",
+			format: "date"
+		};
+		case "TIMESTAMP":
+		case "TIMESTAMP WITHOUT TIME ZONE":
+		case "TIMESTAMP WITH TIME ZONE":
+		case "TIMESTAMPTZ": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "TIME":
+		case "TIME WITHOUT TIME ZONE":
+		case "TIME WITH TIME ZONE":
+		case "TIMETZ": return {
+			type: "string",
+			format: "time"
+		};
+		case "JSON":
+		case "JSONB": return { type: "object" };
+		case "BYTEA": return {
+			type: "string",
+			format: "byte"
+		};
+		default: return { type: "string" };
+	}
+}
+function sqlTypeToTsType(sqlType) {
+	switch (sqlType.toUpperCase().replace(/\(.+\)/, "").trim()) {
+		case "SERIAL":
+		case "BIGSERIAL":
+		case "INTEGER":
+		case "INT":
+		case "INT4":
+		case "SMALLINT":
+		case "INT2":
+		case "BIGINT":
+		case "INT8":
+		case "REAL":
+		case "FLOAT4":
+		case "DOUBLE PRECISION":
+		case "FLOAT8":
+		case "NUMERIC":
+		case "DECIMAL": return "number";
+		case "BOOLEAN":
+		case "BOOL": return "boolean";
+		case "JSON":
+		case "JSONB": return "unknown";
+		case "BYTEA": return "Buffer";
+		default: return "string";
+	}
+}
+//#endregion
+//#region src/postgres/pg/query-codegen.ts
+function camelCase(str) {
+	return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateParamInterface(query) {
+	if (query.params.length === 0) return null;
+	return `export interface ${`${pascalCase(query.name)}Params`} {\n${query.params.map((p) => {
+		const base = sqlTypeToTsType(p.sqlType);
+		const type = p.nullable ? `${base} | null` : base;
+		return `  ${p.name}: ${type};`;
+	}).join("\n")}\n}`;
+}
+function generateParamSchema(query) {
+	if (query.params.length === 0) return null;
+	const name = `${pascalCase(query.name)}ParamsSchema`;
+	const properties = {};
+	const required = [];
+	for (const param of query.params) {
+		const jsonType = sqlTypeToJsonSchema(param.sqlType);
+		if (param.nullable) properties[param.name] = {
+			...jsonType,
+			type: Array.isArray(jsonType.type) ? [...jsonType.type, "null"] : [jsonType.type, "null"]
+		};
+		else {
+			properties[param.name] = jsonType;
+			required.push(param.name);
+		}
+	}
+	const schema = {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: `${pascalCase(query.name)}Params`,
+		type: "object",
+		properties,
+		required,
+		additionalProperties: false
+	};
+	return `export const ${name} = ${JSON.stringify(schema, null, 2)} as const;`;
+}
+function generateResultType(query, snapshot) {
+	if (query.command === "exec" || query.command === "execrows" || query.command === "execresult") return null;
+	if (!query.returnsTable || !snapshot[query.returnsTable]) return null;
+	const table = snapshot[query.returnsTable];
+	const typeName = pascalCase(query.returnsTable);
+	if (query.returnsColumns.length === table.columns.length && query.returnsColumns.every((c) => table.columns.some((tc) => tc.name === c))) return typeName;
+	return `Pick<${typeName}, ${query.returnsColumns.map((c) => `"${c}"`).join(" | ")}>`;
+}
+function generateReturnType(query, resultType) {
+	switch (query.command) {
+		case "one": return `Promise<${resultType ?? "unknown"} | null>`;
+		case "many": return `Promise<${resultType ?? "unknown"}[]>`;
+		case "exec": return "Promise<void>";
+		case "execrows": return "Promise<number>";
+		case "execresult": return "Promise<QueryResult>";
+		default: return "Promise<void>";
+	}
+}
+function generateFunctionBody(query) {
+	const paramArgs = query.params.map((p) => `params.${p.name}`).join(", ");
+	const queryArgs = query.params.length > 0 ? `sql, [${paramArgs}]` : "sql";
+	switch (query.command) {
+		case "one": return `  const result = await client.query(${queryArgs});\n  return result.rows[0] ?? null;`;
+		case "many": return `  const result = await client.query(${queryArgs});\n  return result.rows;`;
+		case "exec": return `  await client.query(${queryArgs});`;
+		case "execrows": return `  const result = await client.query(${queryArgs});\n  return result.rowCount ?? 0;`;
+		case "execresult": return `  return await client.query(${queryArgs});`;
+		default: return `  await client.query(${queryArgs});`;
+	}
+}
+function generateFunction(query, snapshot) {
+	const fnName = camelCase(query.name);
+	const returnType = generateReturnType(query, generateResultType(query, snapshot));
+	const hasParams = query.params.length > 0;
+	const paramsType = hasParams ? `${pascalCase(query.name)}Params` : null;
+	const args = hasParams ? `client: Client | Pool, params: ${paramsType}` : "client: Client | Pool";
+	const sql = query.expandedSql.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+	const lines = [];
+	lines.push(`export async function ${fnName}(${args}): ${returnType} {`);
+	lines.push(`  const sql = '${sql}';`);
+	lines.push(generateFunctionBody(query));
+	lines.push("}");
+	return lines.join("\n");
+}
+function generateQueryFiles(queries, snapshot) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const query of queries) {
+		const key = query.sourceFile.replace(/\.sql$/, "");
+		if (!grouped.has(key)) grouped.set(key, []);
+		grouped.get(key).push(query);
+	}
+	const files = {};
+	for (const [basename, fileQueries] of grouped) {
+		const lines = ["// This file is auto-generated by tsqx. Do not edit manually.", "import type { Client, Pool, QueryResult } from \"pg\";"];
+		const tableImports = /* @__PURE__ */ new Set();
+		for (const query of fileQueries) if (query.returnsTable && snapshot[query.returnsTable]) tableImports.add(query.returnsTable);
+		if (tableImports.size > 0) {
+			const imports = [...tableImports].map((t) => `type ${pascalCase(t)}`).join(", ");
+			lines.push(`import { ${imports} } from "../../generated";`);
+		}
+		lines.push("");
+		for (const query of fileQueries) {
+			const paramInterface = generateParamInterface(query);
+			if (paramInterface) {
+				lines.push(paramInterface);
+				lines.push("");
+			}
+			const paramSchema = generateParamSchema(query);
+			if (paramSchema) {
+				lines.push(paramSchema);
+				lines.push("");
+			}
+			lines.push(generateFunction(query, snapshot));
+			lines.push("");
+		}
+		files[`${basename}.ts`] = lines.join("\n");
+	}
+	return files;
+}
+//#endregion
+//#region src/postgres/pg/index.ts
+function pgDialect() {
+	return {
+		name: "pg",
+		parseSchema: parseSchemaFiles,
+		generateSQL,
+		sqlTypeToJsonSchema,
+		sqlTypeToTsType,
+		generateQueryCode: generateQueryFiles
+	};
+}
+//#endregion
+export { pgDialect };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@tsqx/kit",
+  "version": "0.0.4",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./postgres/pg": {
+      "import": "./dist/postgres/pg/index.mjs",
+      "require": "./dist/postgres/pg/index.cjs",
+      "types": "./dist/postgres/pg/index.d.ts"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "neverthrow": "^8.2.0",
+    "@tsqx/core": "^0.0.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chtushar/tsqx",
+    "directory": "packages/kit"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}