driftsql 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/index.js

@@ -1 +1,1568 @@
-import{t as e}from"./postgres-9C7eE0wB.js";import{A as t,C as n,D as r,E as i,F as a,I as o,L as s,M as c,N as l,O as u,P as d,R as f,S as p,T as m,_ as h,a as g,b as _,c as v,d as y,f as b,g as x,h as S,i as C,j as w,k as T,l as E,m as D,n as O,o as k,p as A,r as j,s as M,t as N,u as P,v as F,w as I,x as L,y as R,z}from"./src-B1L6LdRV.js";import{n as B,t as V}from"./type-generator-CpqI7vBb.js";export{D as Column,N as DriftSQLClient,v as MigrationBuilder,M as MigrationRunner,y as MySQLGenerator,f as PostgresDriver,e as PostgresGenerator,O as SQLClient,P as SQLiteGenerator,C as SchemaDiffer,j as SnapshotManager,b as Table,V as TypeGenerator,S as bigint,x as bigserial,h as boolean,F as bytea,R as char,E as createMigration,s as createMySQLHelpers,z as createPostgresHelpers,o as createSQLiteHelpers,A as createTable,_ as date,L as decimal,g as detectChanges,p as doublePrecision,k as generateMigrationFromChanges,B as generateTypesFromSchema,n as integer,I as json,m as jsonb,i as numeric,r as real,u as serial,T as smallint,t as text,w as time,c as timestamp,l as timestamptz,d as uuid,a as varchar};
+import { a as __export, i as __esm, n as init_postgres, o as __toCommonJS, r as postgres_exports, t as PostgresGenerator } from "./postgres-CjYq8GvL.js";
+import { n as generateTypesFromSchema, t as TypeGenerator } from "./type-generator-Ba8bgnMm.js";
+import { Command } from "commander";
+import consola from "consola";
+import fs from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import postgres from "postgres";
+
+//#region src/schema/runner.ts
+var MigrationRunner = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async ensureMigrationsTable() {
+		await this.client.query(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        version VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+	}
+	async getAppliedMigrations() {
+		await this.ensureMigrationsTable();
+		return (await this.client.query("SELECT version FROM _migrations ORDER BY version")).rows.map((row) => row.version);
+	}
+	async up(migration) {
+		if ((await this.getAppliedMigrations()).includes(migration.version)) {
+			consola.info(`Migration ${migration.version} (${migration.name}) already applied`);
+			return;
+		}
+		consola.start(`Running migration ${migration.version} (${migration.name})`);
+		for (const statement of migration.up) await this.client.query(statement);
+		await this.client.query("INSERT INTO _migrations (version, name) VALUES ($1, $2)", [migration.version, migration.name]);
+		consola.success(`Migration ${migration.version} (${migration.name}) applied successfully`);
+	}
+	async down(migration) {
+		if (!(await this.getAppliedMigrations()).includes(migration.version)) {
+			consola.info(`Migration ${migration.version} (${migration.name}) not applied`);
+			return;
+		}
+		consola.start(`Rolling back migration ${migration.version} (${migration.name})`);
+		for (const statement of migration.down) await this.client.query(statement);
+		await this.client.query("DELETE FROM _migrations WHERE version = $1", [migration.version]);
+		consola.success(`Migration ${migration.version} (${migration.name}) rolled back successfully`);
+	}
+	async upAll(migrations) {
+		const applied = await this.getAppliedMigrations();
+		const pending = migrations.filter((m) => !applied.includes(m.version));
+		if (pending.length === 0) {
+			consola.info("No pending migrations");
+			return;
+		}
+		consola.info(`Found ${pending.length} pending migrations`);
+		for (const migration of pending) await this.up(migration);
+	}
+	async downAll(migrations) {
+		const applied = await this.getAppliedMigrations();
+		const toRollback = migrations.filter((m) => applied.includes(m.version)).reverse();
+		if (toRollback.length === 0) {
+			consola.info("No migrations to rollback");
+			return;
+		}
+		consola.info(`Rolling back ${toRollback.length} migrations`);
+		for (const migration of toRollback) await this.down(migration);
+	}
+	async reset(migrations) {
+		await this.downAll(migrations);
+		await this.upAll(migrations);
+	}
+};
+
+//#endregion
+//#region src/schema/snapshot.ts
+var SnapshotManager = class {
+	snapshotPath;
+	constructor(snapshotPath = "./.driftsql/snapshot.json") {
+		this.snapshotPath = snapshotPath;
+	}
+	async save(tables) {
+		const snapshot = {
+			version: "1",
+			timestamp: Date.now(),
+			tables
+		};
+		const dir = path.dirname(this.snapshotPath);
+		await fs.mkdir(dir, { recursive: true });
+		await fs.writeFile(this.snapshotPath, JSON.stringify(snapshot, null, 2), "utf8");
+	}
+	async load() {
+		try {
+			const content = await fs.readFile(this.snapshotPath, "utf8");
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	}
+	async exists() {
+		try {
+			await fs.access(this.snapshotPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region src/schema/generators/mysql.ts
+var mysql_exports = /* @__PURE__ */ __export({ MySQLGenerator: () => MySQLGenerator });
+var MySQLGenerator;
+var init_mysql = __esm({ "src/schema/generators/mysql.ts": (() => {
+	MySQLGenerator = class {
+		generateCreateTable(table) {
+			const lines = [];
+			lines.push(`CREATE TABLE \`${table.name}\` (`);
+			const columnDefs = [];
+			for (const column of table.columns) columnDefs.push("  " + this.generateColumnDefinition(column));
+			if (table.primaryKey && table.primaryKey.length > 0) {
+				const pkColumns = table.primaryKey.map((col) => `\`${col}\``).join(", ");
+				columnDefs.push(`  PRIMARY KEY (${pkColumns})`);
+			}
+			if (table.checks && table.checks.length > 0) for (const check of table.checks) columnDefs.push(`  CONSTRAINT \`${check.name}\` CHECK (${check.expression})`);
+			lines.push(columnDefs.join(",\n"));
+			lines.push(") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;");
+			const sql = [lines.join("\n")];
+			if (table.indexes && table.indexes.length > 0) for (const index of table.indexes) sql.push(this.generateIndex(table.name, index));
+			return sql.join("\n\n");
+		}
+		generateDropTable(tableName) {
+			return `DROP TABLE IF EXISTS \`${tableName}\`;`;
+		}
+		generateColumnDefinition(column) {
+			const parts = [`\`${column.name}\``];
+			parts.push(this.getColumnType(column));
+			if (column.notNull && !column.primaryKey && column.type !== "serial" && column.type !== "bigserial") parts.push("NOT NULL");
+			if (column.unique) parts.push("UNIQUE");
+			if (column.type === "serial" || column.type === "bigserial") parts.push("AUTO_INCREMENT");
+			if (column.default !== void 0) parts.push(`DEFAULT ${this.formatDefault(column.default)}`);
+			if (column.references) {
+				const ref = column.references;
+				parts.push(`REFERENCES \`${ref.table}\`(\`${ref.column}\`)`);
+				if (ref.onDelete) parts.push(`ON DELETE ${ref.onDelete}`);
+				if (ref.onUpdate) parts.push(`ON UPDATE ${ref.onUpdate}`);
+			}
+			if (column.check) parts.push(`CHECK (${column.check})`);
+			return parts.join(" ");
+		}
+		getColumnType(column) {
+			let typeStr = column.type;
+			if (typeStr === "serial") return "INT";
+			if (typeStr === "bigserial") return "BIGINT";
+			if (typeStr === "timestamptz") return "TIMESTAMP";
+			if (typeStr === "jsonb") return "JSON";
+			if (typeStr === "bytea") return "BLOB";
+			if (typeStr === "double precision") return "DOUBLE";
+			let result = typeStr.toUpperCase();
+			if (column.length) result += `(${column.length})`;
+			else if (column.precision) if (column.scale !== void 0) result += `(${column.precision}, ${column.scale})`;
+			else result += `(${column.precision})`;
+			return result;
+		}
+		formatDefault(value) {
+			if (typeof value === "string") {
+				if (value.toUpperCase() === "NOW()" || value.toUpperCase() === "CURRENT_TIMESTAMP") return "CURRENT_TIMESTAMP";
+				return `'${value}'`;
+			}
+			if (typeof value === "boolean") return value ? "1" : "0";
+			return String(value);
+		}
+		generateIndex(tableName, index) {
+			const unique = index.unique ? "UNIQUE " : "";
+			const type = index.type && index.type !== "btree" ? ` USING ${index.type.toUpperCase()}` : "";
+			const columns = index.columns.map((col) => `\`${col}\``).join(", ");
+			return `CREATE ${unique}INDEX \`${index.name}\` ON \`${tableName}\`${type} (${columns});`;
+		}
+	};
+}) });
+
+//#endregion
+//#region src/schema/generators/sqlite.ts
+var sqlite_exports = /* @__PURE__ */ __export({ SQLiteGenerator: () => SQLiteGenerator });
+var SQLiteGenerator;
+var init_sqlite = __esm({ "src/schema/generators/sqlite.ts": (() => {
+	SQLiteGenerator = class {
+		generateCreateTable(table) {
+			const lines = [];
+			lines.push(`CREATE TABLE "${table.name}" (`);
+			const columnDefs = [];
+			for (const column of table.columns) columnDefs.push("  " + this.generateColumnDefinition(column));
+			if (table.primaryKey && table.primaryKey.length > 0) {
+				const pkColumns = table.primaryKey.map((col) => `"${col}"`).join(", ");
+				columnDefs.push(`  PRIMARY KEY (${pkColumns})`);
+			}
+			if (table.checks && table.checks.length > 0) for (const check of table.checks) columnDefs.push(`  CONSTRAINT "${check.name}" CHECK (${check.expression})`);
+			lines.push(columnDefs.join(",\n"));
+			lines.push(");");
+			const sql = [lines.join("\n")];
+			if (table.indexes && table.indexes.length > 0) for (const index of table.indexes) sql.push(this.generateIndex(table.name, index));
+			return sql.join("\n\n");
+		}
+		generateDropTable(tableName) {
+			return `DROP TABLE IF EXISTS "${tableName}";`;
+		}
+		generateColumnDefinition(column) {
+			const parts = [`"${column.name}"`];
+			parts.push(this.getColumnType(column));
+			if (column.primaryKey) {
+				parts.push("PRIMARY KEY");
+				if (column.type === "serial" || column.type === "bigserial") parts.push("AUTOINCREMENT");
+			}
+			if (column.notNull && !column.primaryKey) parts.push("NOT NULL");
+			if (column.unique) parts.push("UNIQUE");
+			if (column.default !== void 0) parts.push(`DEFAULT ${this.formatDefault(column.default)}`);
+			if (column.references) {
+				const ref = column.references;
+				parts.push(`REFERENCES "${ref.table}"("${ref.column}")`);
+				if (ref.onDelete) parts.push(`ON DELETE ${ref.onDelete}`);
+				if (ref.onUpdate) parts.push(`ON UPDATE ${ref.onUpdate}`);
+			}
+			if (column.check) parts.push(`CHECK (${column.check})`);
+			return parts.join(" ");
+		}
+		getColumnType(column) {
+			let type = column.type;
+			if (type === "serial" || type === "bigserial") return "INTEGER";
+			if (type === "bigint") return "INTEGER";
+			if (type === "smallint") return "INTEGER";
+			if (type === "varchar" || type === "char") return "TEXT";
+			if (type === "timestamptz") return "TEXT";
+			if (type === "timestamp") return "TEXT";
+			if (type === "date") return "TEXT";
+			if (type === "time") return "TEXT";
+			if (type === "uuid") return "TEXT";
+			if (type === "json" || type === "jsonb") return "TEXT";
+			if (type === "bytea") return "BLOB";
+			if (type === "decimal" || type === "numeric") return "REAL";
+			if (type === "real" || type === "double precision") return "REAL";
+			if (type === "boolean") return "INTEGER";
+			return type.toUpperCase();
+		}
+		formatDefault(value) {
+			if (typeof value === "string") {
+				if (value.toUpperCase() === "NOW()" || value.toUpperCase() === "CURRENT_TIMESTAMP") return "CURRENT_TIMESTAMP";
+				return `'${value}'`;
+			}
+			if (typeof value === "boolean") return value ? "1" : "0";
+			return String(value);
+		}
+		generateIndex(tableName, index) {
+			const unique = index.unique ? "UNIQUE " : "";
+			const columns = index.columns.map((col) => `"${col}"`).join(", ");
+			return `CREATE ${unique}INDEX "${index.name}" ON "${tableName}" (${columns});`;
+		}
+	};
+}) });
+
+//#endregion
+//#region src/schema/migration.ts
+init_postgres();
+init_mysql();
+init_sqlite();
+var MigrationBuilder = class {
+	upStatements = [];
+	downStatements = [];
+	dialect;
+	constructor(dialect = "postgres") {
+		this.dialect = dialect;
+	}
+	createTable(table) {
+		const tableDef = table.getDefinition();
+		const generator = this.getGenerator();
+		this.upStatements.push(generator.generateCreateTable(tableDef));
+		this.downStatements.unshift(generator.generateDropTable(tableDef.name));
+		return this;
+	}
+	dropTable(tableName) {
+		const generator = this.getGenerator();
+		this.upStatements.push(generator.generateDropTable(tableName));
+		return this;
+	}
+	addColumn(tableName, columnSql) {
+		this.upStatements.push(`ALTER TABLE "${tableName}" ADD COLUMN ${columnSql};`);
+		return this;
+	}
+	dropColumn(tableName, columnName) {
+		this.upStatements.push(`ALTER TABLE "${tableName}" DROP COLUMN "${columnName}";`);
+		return this;
+	}
+	renameTable(oldName, newName) {
+		if (this.dialect === "postgres") this.upStatements.push(`ALTER TABLE "${oldName}" RENAME TO "${newName}";`);
+		else if (this.dialect === "mysql") this.upStatements.push(`RENAME TABLE \`${oldName}\` TO \`${newName}\`;`);
+		else this.upStatements.push(`ALTER TABLE "${oldName}" RENAME TO "${newName}";`);
+		return this;
+	}
+	raw(sql, downSql) {
+		this.upStatements.push(sql);
+		if (downSql) this.downStatements.unshift(downSql);
+		return this;
+	}
+	build(version, name) {
+		return {
+			version,
+			name,
+			up: this.upStatements,
+			down: this.downStatements
+		};
+	}
+	getGenerator() {
+		switch (this.dialect) {
+			case "postgres": return new PostgresGenerator();
+			case "mysql": return new MySQLGenerator();
+			case "sqlite": return new SQLiteGenerator();
+			default: return new PostgresGenerator();
+		}
+	}
+};
+function createMigration(dialect = "postgres") {
+	return new MigrationBuilder(dialect);
+}
+
+//#endregion
+//#region src/schema/differ.ts
+var SchemaDiffer = class {
+	dialect;
+	constructor(dialect = "postgres") {
+		this.dialect = dialect;
+	}
+	detectChanges(oldSchema, newSchema) {
+		const changes = [];
+		const oldTables = new Map(oldSchema.map((t) => [t.name, t]));
+		const newTables = new Map(newSchema.map((t) => [t.name, t]));
+		for (const [tableName, newTable] of newTables) {
+			const oldTable = oldTables.get(tableName);
+			if (!oldTable) changes.push({
+				type: "create_table",
+				table: tableName,
+				details: newTable
+			});
+			else {
+				changes.push(...this.detectColumnChanges(oldTable, newTable));
+				changes.push(...this.detectIndexChanges(oldTable, newTable));
+			}
+		}
+		for (const [tableName] of oldTables) if (!newTables.has(tableName)) changes.push({
+			type: "drop_table",
+			table: tableName
+		});
+		return changes;
+	}
+	detectColumnChanges(oldTable, newTable) {
+		const changes = [];
+		const oldColumns = new Map(oldTable.columns.map((c) => [c.name, c]));
+		const newColumns = new Map(newTable.columns.map((c) => [c.name, c]));
+		for (const [colName, newCol] of newColumns) {
+			const oldCol = oldColumns.get(colName);
+			if (!oldCol) changes.push({
+				type: "add_column",
+				table: newTable.name,
+				details: newCol
+			});
+			else if (this.hasColumnChanged(oldCol, newCol)) changes.push({
+				type: "modify_column",
+				table: newTable.name,
+				details: {
+					old: oldCol,
+					new: newCol
+				}
+			});
+		}
+		for (const [colName] of oldColumns) if (!newColumns.has(colName)) changes.push({
+			type: "drop_column",
+			table: newTable.name,
+			details: { name: colName }
+		});
+		return changes;
+	}
+	detectIndexChanges(oldTable, newTable) {
+		const changes = [];
+		const oldIndexes = new Map((oldTable.indexes || []).map((i) => [i.name, i]));
+		const newIndexes = new Map((newTable.indexes || []).map((i) => [i.name, i]));
+		for (const [idxName, newIdx] of newIndexes) if (!oldIndexes.has(idxName)) changes.push({
+			type: "create_index",
+			table: newTable.name,
+			details: newIdx
+		});
+		for (const [idxName] of oldIndexes) if (!newIndexes.has(idxName)) changes.push({
+			type: "drop_index",
+			table: newTable.name,
+			details: { name: idxName }
+		});
+		return changes;
+	}
+	hasColumnChanged(oldCol, newCol) {
+		return oldCol.type !== newCol.type || oldCol.length !== newCol.length || oldCol.precision !== newCol.precision || oldCol.scale !== newCol.scale || oldCol.notNull !== newCol.notNull || oldCol.unique !== newCol.unique || oldCol.default !== newCol.default || JSON.stringify(oldCol.references) !== JSON.stringify(newCol.references);
+	}
+	generateMigration(changes, version, name) {
+		const migration = new MigrationBuilder(this.dialect);
+		for (const change of changes) switch (change.type) {
+			case "create_table": {
+				const tableDef = change.details;
+				const generator = this.getGenerator();
+				const sql = generator.generateCreateTable(tableDef);
+				migration.raw(sql, generator.generateDropTable(tableDef.name));
+				break;
+			}
+			case "drop_table": {
+				const generator = this.getGenerator();
+				migration.raw(generator.generateDropTable(change.table));
+				break;
+			}
+			case "add_column": {
+				const col = change.details;
+				const colSql = this.generateColumnSQL(col);
+				migration.raw(`ALTER TABLE "${change.table}" ADD COLUMN ${colSql};`, `ALTER TABLE "${change.table}" DROP COLUMN "${col.name}";`);
+				break;
+			}
+			case "drop_column": {
+				const colName = change.details.name;
+				migration.raw(`ALTER TABLE "${change.table}" DROP COLUMN "${colName}";`);
+				break;
+			}
+			case "create_index": {
+				const idx = change.details;
+				const sql = this.generateIndexSQL(change.table, idx);
+				migration.raw(sql, `DROP INDEX "${idx.name}";`);
+				break;
+			}
+			case "drop_index": {
+				const idxName = change.details.name;
+				migration.raw(`DROP INDEX "${idxName}";`);
+				break;
+			}
+		}
+		return migration;
+	}
+	generateColumnSQL(col) {
+		const parts = [`"${col.name}"`];
+		parts.push(col.type.toUpperCase());
+		if (col.length) parts[1] += `(${col.length})`;
+		if (col.notNull) parts.push("NOT NULL");
+		if (col.unique) parts.push("UNIQUE");
+		if (col.default !== void 0) parts.push(`DEFAULT ${this.formatDefault(col.default)}`);
+		return parts.join(" ");
+	}
+	generateIndexSQL(tableName, idx) {
+		const unique = idx.unique ? "UNIQUE " : "";
+		const columns = idx.columns.map((col) => `"${col}"`).join(", ");
+		return `CREATE ${unique}INDEX "${idx.name}" ON "${tableName}" (${columns});`;
+	}
+	formatDefault(value) {
+		if (typeof value === "string") {
+			if (value.toUpperCase() === "NOW()" || value.toUpperCase() === "CURRENT_TIMESTAMP") return value.toUpperCase();
+			return `'${value}'`;
+		}
+		if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+		return String(value);
+	}
+	getGenerator() {
+		const { PostgresGenerator: PostgresGenerator$1 } = (init_postgres(), __toCommonJS(postgres_exports));
+		const { MySQLGenerator: MySQLGenerator$1 } = (init_mysql(), __toCommonJS(mysql_exports));
+		const { SQLiteGenerator: SQLiteGenerator$1 } = (init_sqlite(), __toCommonJS(sqlite_exports));
+		switch (this.dialect) {
+			case "postgres": return new PostgresGenerator$1();
+			case "mysql": return new MySQLGenerator$1();
+			case "sqlite": return new SQLiteGenerator$1();
+			default: return new PostgresGenerator$1();
+		}
+	}
+};
+function detectChanges(oldSchema, newSchema, dialect = "postgres") {
+	return new SchemaDiffer(dialect).detectChanges(oldSchema, newSchema);
+}
+function generateMigrationFromChanges(changes, version, name, dialect = "postgres") {
+	return new SchemaDiffer(dialect).generateMigration(changes, version, name);
+}
+
+//#endregion
+//#region src/cli/index.ts
+const program = new Command();
+program.name("driftsql").description("DriftSQL CLI - Database migrations and schema management").version("0.0.1");
+program.command("migrate:up").description("Run all pending migrations").option("-d, --dir <directory>", "Migrations directory", "./migrations").option("-c, --config <path>", "Config file path", "./driftsql.config.ts").action(async (options) => {
+	try {
+		const { client, migrations } = await loadMigrations(options.dir, options.config);
+		await new MigrationRunner(client).upAll(migrations);
+		await client.close();
+		consola.success("All migrations applied successfully");
+	} catch (error) {
+		consola.error("Migration failed:", error);
+		process.exit(1);
+	}
+});
+program.command("migrate:down").description("Rollback the last migration").option("-d, --dir <directory>", "Migrations directory", "./migrations").option("-c, --config <path>", "Config file path", "./driftsql.config.ts").action(async (options) => {
+	try {
+		const { client, migrations } = await loadMigrations(options.dir, options.config);
+		const runner = new MigrationRunner(client);
+		const applied = await runner.getAppliedMigrations();
+		const lastMigration = migrations.find((m) => m.version === applied[applied.length - 1]);
+		if (lastMigration) await runner.down(lastMigration);
+		else consola.info("No migrations to rollback");
+		await client.close();
+	} catch (error) {
+		consola.error("Rollback failed:", error);
+		process.exit(1);
+	}
+});
+program.command("migrate:reset").description("Reset all migrations (down then up)").option("-d, --dir <directory>", "Migrations directory", "./migrations").option("-c, --config <path>", "Config file path", "./driftsql.config.ts").action(async (options) => {
+	try {
+		const { client, migrations } = await loadMigrations(options.dir, options.config);
+		await new MigrationRunner(client).reset(migrations);
+		await client.close();
+		consola.success("All migrations reset successfully");
+	} catch (error) {
+		consola.error("Reset failed:", error);
+		process.exit(1);
+	}
+});
+program.command("migrate:status").description("Show migration status").option("-d, --dir <directory>", "Migrations directory", "./migrations").option("-c, --config <path>", "Config file path", "./driftsql.config.ts").action(async (options) => {
+	try {
+		const { client, migrations } = await loadMigrations(options.dir, options.config);
+		const applied = await new MigrationRunner(client).getAppliedMigrations();
+		consola.info("Migration Status:\n");
+		for (const migration of migrations) {
+			const status = applied.includes(migration.version) ? "✓ Applied" : "✗ Pending";
+			consola.log(`${status} - ${migration.version} (${migration.name})`);
+		}
+		await client.close();
+	} catch (error) {
+		consola.error("Failed to get status:", error);
+		process.exit(1);
+	}
+});
+program.command("migrate:create <name>").description("Create a new migration file").option("-d, --dir <directory>", "Migrations directory", "./migrations").action(async (name, options) => {
+	try {
+		const version = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.]/g, "").slice(0, 14);
+		const fileName = `${version}_${name}.ts`;
+		const filePath = path.join(options.dir, fileName);
+		await fs.mkdir(options.dir, { recursive: true });
+		const template = `import { createMigration } from 'driftsql'
+
+export const migration = createMigration('postgres')
+  .raw('-- Add your migration SQL here')
+  .build('${version}', '${name}')
+`;
+		await fs.writeFile(filePath, template, "utf8");
+		consola.success(`Created migration: ${fileName}`);
+	} catch (error) {
+		consola.error("Failed to create migration:", error);
+		process.exit(1);
+	}
+});
+program.command("migrate:generate [name]").description("Automatically generate migration from schema changes").option("-s, --schema <path>", "Schema file path", "./schema.ts").option("-d, --dir <directory>", "Migrations directory", "./migrations").action(async (name, options) => {
+	try {
+		const snapshotManager = new SnapshotManager();
+		const schemaPath = path.resolve(process.cwd(), options.schema);
+		consola.start("Loading schema...");
+		const schemaModule = await import(schemaPath);
+		const schema = schemaModule.default || schemaModule.schema;
+		if (!schema || !Array.isArray(schema)) {
+			consola.error("Schema file must export default or named \"schema\" as an array of table definitions");
+			consola.info("Example: export default [usersTable.getDefinition(), postsTable.getDefinition()]");
+			process.exit(1);
+		}
+		const currentSchema = schema;
+		const snapshot = await snapshotManager.load();
+		if (!snapshot) {
+			consola.info("No previous schema snapshot found, creating initial migration...");
+			const version$1 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.]/g, "").slice(0, 14);
+			const migrationName$1 = name || "initial";
+			const fileName$1 = `${version$1}_${migrationName$1}.ts`;
+			const filePath$1 = path.join(options.dir, fileName$1);
+			await fs.mkdir(options.dir, { recursive: true });
+			const { PostgresGenerator: PostgresGenerator$1 } = await import("./postgres-CFQEP3ft.js");
+			const generator = new PostgresGenerator$1();
+			const upSQL$1 = currentSchema.map((table) => generator.generateCreateTable(table)).map((sql) => `  .raw(\`${sql.replace(/`/g, "\\`")}\`)`).join("\n");
+			const migrationContent$1 = `import { createMigration } from 'driftsql'
+
+// Initial migration - automatically generated
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+export const migration = createMigration('postgres')
+${upSQL$1}
+  .build('${version$1}', '${migrationName$1}')
+`;
+			await fs.writeFile(filePath$1, migrationContent$1, "utf8");
+			await snapshotManager.save(currentSchema);
+			const { generateTypesFromSchema: generateTypesFromSchema$2 } = await import("./type-generator-DbcqBk-4.js");
+			await generateTypesFromSchema$2(currentSchema, path.join(process.cwd(), "db-types.ts"));
+			consola.success(`\nCreated initial migration: ${fileName$1}`);
+			consola.success(`Generated TypeScript types: db-types.ts`);
+			consola.info("Snapshot saved. Run \"driftsql migrate:up\" to apply changes.");
+			return;
+		}
+		consola.info("Detecting changes...");
+		const changes = detectChanges(snapshot.tables, currentSchema, "postgres");
+		if (changes.length === 0) {
+			consola.success("No schema changes detected!");
+			return;
+		}
+		consola.info(`Found ${changes.length} change(s):`);
+		changes.forEach((change, idx) => {
+			consola.log(`  ${idx + 1}. ${change.type} - ${change.table}`);
+		});
+		const version = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.]/g, "").slice(0, 14);
+		const migrationName = name || "auto_migration";
+		const fileName = `${version}_${migrationName}.ts`;
+		const filePath = path.join(options.dir, fileName);
+		await fs.mkdir(options.dir, { recursive: true });
+		const upSQL = generateMigrationFromChanges(changes, version, migrationName).build(version, migrationName).up.map((sql) => `  .raw(\`${sql.replace(/`/g, "\\`")}\``).join("\n");
+		const migrationContent = `import { createMigration } from 'driftsql'
+
+// This migration was automatically generated
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// Changes: ${changes.length}
+
+export const migration = createMigration('postgres')
+${upSQL}
+  .build('${version}', '${migrationName}')
+`;
+		await fs.writeFile(filePath, migrationContent, "utf8");
+		await snapshotManager.save(currentSchema);
+		const { generateTypesFromSchema: generateTypesFromSchema$1 } = await import("./type-generator-DbcqBk-4.js");
+		await generateTypesFromSchema$1(currentSchema, path.join(process.cwd(), "db-types.ts"));
+		consola.success(`\nGenerated migration: ${fileName}`);
+		consola.success(`Updated TypeScript types: db-types.ts`);
+		consola.info("Snapshot updated. Run \"driftsql migrate:up\" to apply changes.");
+	} catch (error) {
+		consola.error("Failed to generate migration:", error);
+		process.exit(1);
+	}
+});
+program.command("db:inspect").description("Inspect database and generate TypeScript types").option("-c, --config <path>", "Config file path", "./driftsql.config.ts").option("-o, --output <path>", "Output file path", "./db-types.ts").action(async (options) => {
+	try {
+		const client = await loadClient(options.config);
+		await client.inspectDB({
+			driver: client.getDriver(),
+			outputFile: options.output
+		});
+		await client.close();
+	} catch (error) {
+		consola.error("Inspection failed:", error);
+		process.exit(1);
+	}
+});
+program.command("generate:types").description("Generate TypeScript types from schema file").option("-s, --schema <path>", "Schema file path", "./schema.ts").option("-o, --output <path>", "Output file path", "./db-types.ts").action(async (options) => {
+	try {
+		const schemaPath = path.resolve(process.cwd(), options.schema);
+		const outputPath = path.resolve(process.cwd(), options.output);
+		consola.start("Loading schema...");
+		const schemaModule = await import(schemaPath);
+		const schema = schemaModule.default || schemaModule.schema;
+		if (!schema || !Array.isArray(schema)) {
+			consola.error("Schema file must export default or named \"schema\" as an array of table definitions");
+			process.exit(1);
+		}
+		const { generateTypesFromSchema: generateTypesFromSchema$1 } = await import("./type-generator-DbcqBk-4.js");
+		await generateTypesFromSchema$1(schema, outputPath);
+		consola.success(`TypeScript types generated: ${options.output}`);
+	} catch (error) {
+		consola.error("Type generation failed:", error);
+		process.exit(1);
+	}
+});
+program.command("init").description("Initialize DriftSQL with a basic notes schema").option("-d, --dir <directory>", "Migrations directory", "./migrations").action(async (options) => {
+	try {
+		await fs.mkdir(options.dir, { recursive: true });
+		const configContent = `import { SQLClient, PostgresDriver } from 'driftsql'
+
+export default new SQLClient({
+  driver: new PostgresDriver({
+    connectionString: process.env.DATABASE_URL!,
+  }),
+})
+`;
+		const schemaContent = `import { createTable, serial, varchar, text, timestamp, boolean } from 'driftsql'
+
+const notesTable = createTable('notes', (table) => {
+  table
+    .column(serial('id').primaryKey())
+    .column(varchar('title', 255).notNull())
+    .column(text('content'))
+    .column(boolean('is_archived').default(false).notNull())
+    .column(timestamp('created_at').default('CURRENT_TIMESTAMP').notNull())
+    .column(timestamp('updated_at').default('CURRENT_TIMESTAMP').notNull())
+    .index('idx_notes_archived', ['is_archived'])
+    .index('idx_notes_created_at', ['created_at'])
+})
+
+// Export array of table definitions
+export default [notesTable.getDefinition()]
+`;
+		const envContent = `DATABASE_URL=postgresql://user:password@localhost:5432/mydb
+`;
+		const gitignoreContent = `.driftsql/
+.env
+`;
+		const configPath = path.join(process.cwd(), "driftsql.config.ts");
+		const schemaPath = path.join(process.cwd(), "schema.ts");
+		const envPath = path.join(process.cwd(), ".env.example");
+		const gitignorePath = path.join(process.cwd(), ".gitignore");
+		const filesToCreate = [
+			{
+				path: configPath,
+				content: configContent,
+				name: "driftsql.config.ts"
+			},
+			{
+				path: schemaPath,
+				content: schemaContent,
+				name: "schema.ts"
+			},
+			{
+				path: envPath,
+				content: envContent,
+				name: ".env.example"
+			}
+		];
+		for (const file of filesToCreate) try {
+			await fs.access(file.path);
+			consola.warn(`${file.name} already exists, skipping...`);
+		} catch {
+			await fs.writeFile(file.path, file.content, "utf8");
+			consola.success(`Created ${file.name}`);
+		}
+		try {
+			if (!(await fs.readFile(gitignorePath, "utf8")).includes(".driftsql/")) {
+				await fs.appendFile(gitignorePath, "\n" + gitignoreContent);
+				consola.success("Updated .gitignore");
+			}
+		} catch {
+			await fs.writeFile(gitignorePath, gitignoreContent, "utf8");
+			consola.success("Created .gitignore");
+		}
+		consola.success("\n✨ DriftSQL initialized successfully!\n");
+		consola.info("Next steps:");
+		consola.info("1. Copy .env.example to .env and update DATABASE_URL");
+		consola.info("2. Run: driftsql migrate:generate initial  (generates migration + types)");
+		consola.info("3. Run: driftsql migrate:up");
+		consola.info("4. Import Database type from db-types.ts for type safety");
+		consola.info("5. Edit schema.ts and run migrate:generate to auto-detect changes!\n");
+	} catch (error) {
+		consola.error("Initialization failed:", error);
+		process.exit(1);
+	}
+});
+async function loadClient(configPath) {
+	try {
+		const config = await import(path.resolve(process.cwd(), configPath));
+		return config.default || config.client;
+	} catch (error) {
+		consola.error(`Failed to load config from ${configPath}`);
+		throw error;
+	}
+}
+async function loadMigrations(migrationDir, configPath) {
+	const client = await loadClient(configPath);
+	const migrations = [];
+	try {
+		const dir = path.resolve(process.cwd(), migrationDir);
+		const tsFiles = (await fs.readdir(dir)).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+		for (const file of tsFiles) {
+			const module = await import(path.join(dir, file));
+			const migration = module.migration || module.default;
+			if (migration) migrations.push(migration);
+		}
+		return {
+			client,
+			migrations
+		};
+	} catch (error) {
+		consola.error(`Failed to load migrations from ${migrationDir}`);
+		throw error;
+	}
+}
+program.parse();
+
+//#endregion
+//#region src/types.ts
+function hasTransactionSupport(driver) {
+	return "transaction" in driver && typeof driver.transaction === "function";
+}
+function hasPreparedStatementSupport(driver) {
+	return "prepare" in driver && typeof driver.prepare === "function";
+}
+var DatabaseError = class extends Error {
+	constructor(message, driverType, originalError) {
+		super(message);
+		this.driverType = driverType;
+		this.originalError = originalError;
+		this.name = "DatabaseError";
+	}
+};
+var QueryError = class extends DatabaseError {
+	constructor(driverType, sql, originalError) {
+		super(`Query failed: ${sql}`, driverType, originalError);
+		this.name = "QueryError";
+	}
+};
+
+//#endregion
+//#region src/utils/inspect.ts
+const withTimeout = (promise, timeoutMs = 3e4) => {
+	return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Query timeout after ${timeoutMs}ms`)), timeoutMs))]);
+};
+const retryQuery = async (queryFn, maxRetries = 3, baseDelay = 1e3) => {
+	for (let attempt = 1; attempt <= maxRetries; attempt++) try {
+		return await queryFn();
+	} catch (error) {
+		if (attempt === maxRetries) throw error;
+		const delay = baseDelay * Math.pow(2, attempt - 1);
+		consola.warn(`Query attempt ${attempt} failed, retrying in ${delay}ms...`, error);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	throw new Error("Max retries exceeded");
+};
+const mapDatabaseTypeToTypeScript = (dataType, isNullable = false, driverType = "postgres") => {
+	const nullable = isNullable ? " | null" : "";
+	switch (dataType.toLowerCase()) {
+		case "uuid": return `string${nullable}`;
+		case "character varying":
+		case "varchar":
+		case "text":
+		case "char":
+		case "character":
+		case "longtext":
+		case "mediumtext":
+		case "tinytext": return `string${nullable}`;
+		case "integer":
+		case "int":
+		case "int4":
+		case "smallint":
+		case "int2":
+		case "bigint":
+		case "int8":
+		case "serial":
+		case "bigserial":
+		case "numeric":
+		case "decimal":
+		case "real":
+		case "float4":
+		case "double precision":
+		case "float8":
+		case "tinyint":
+		case "mediumint":
+		case "float":
+		case "double": return `number${nullable}`;
+		case "boolean":
+		case "bool":
+		case "bit": return `boolean${nullable}`;
+		case "timestamp":
+		case "timestamp with time zone":
+		case "timestamp without time zone":
+		case "timestamptz":
+		case "date":
+		case "time":
+		case "time with time zone":
+		case "time without time zone":
+		case "timetz":
+		case "interval":
+		case "datetime":
+		case "year": return `Date${nullable}`;
+		case "json":
+		case "jsonb": return `any${nullable}`;
+		case "array": return `any[]${nullable}`;
+		case "bytea":
+		case "binary":
+		case "varbinary":
+		case "blob":
+		case "longblob":
+		case "mediumblob":
+		case "tinyblob": return `Buffer${nullable}`;
+		case "enum":
+		case "set": return `string${nullable}`;
+		default:
+			consola.warn(`Unknown ${driverType} type: ${dataType}, defaulting to 'any'`);
+			return `any${nullable}`;
+	}
+};
+const getDriverType = (driver) => {
+	return `${driver.constructor.name || "unknown driver"}`;
+};
+const inspectDB = async (options) => {
+	consola.warn("inspectDB is experimental and may make mistakes when inspecting your database. However it will not destroy your database.");
+	const { driver, outputFile = "db-types.ts" } = options;
+	const driverType = getDriverType(driver);
+	consola.start(`Inspecting database using ${driverType} driver`);
+	const client = new SQLClient({ driver });
+	let generatedTypes = "";
+	try {
+		let tablesQuery;
+		let tableSchemaFilter;
+		if (driverType === "mysql") {
+			const currentDatabase = (await withTimeout(retryQuery(() => client.query("SELECT DATABASE() as `database`", [])), 1e4)).rows[0]?.database;
+			if (!currentDatabase) throw new Error("Could not determine current MySQL database name");
+			consola.success(`Using MySQL database: ${currentDatabase}`);
+			tablesQuery = `SELECT TABLE_NAME as table_name
+                   FROM information_schema.tables
+                   WHERE TABLE_SCHEMA = ?
+                   AND TABLE_TYPE = 'BASE TABLE'
+                   ORDER BY TABLE_NAME`;
+			tableSchemaFilter = currentDatabase;
+		} else if (driverType === "postgres" || driverType === "neon") {
+			tablesQuery = `SELECT table_name
+                   FROM information_schema.tables
+                   WHERE table_schema = $1
+                   AND table_type = 'BASE TABLE'
+                   ORDER BY table_name`;
+			tableSchemaFilter = "public";
+		} else if (driverType === "libsql" || driverType === "sqlite" || driverType === "sqlitecloud") {
+			tablesQuery = `SELECT name as table_name
+                   FROM sqlite_master
+                   WHERE type = 'table'
+                   ORDER BY name`;
+			tableSchemaFilter = void 0;
+		} else throw new Error(`Unsupported driver type: ${driverType}`);
+		const tables = await withTimeout(retryQuery(() => client.query(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : [])), 3e4);
+		consola.info("Tables in the database:", tables.rows.map((t) => t.table_name).join(", "));
+		let processedTables = 0;
+		const totalTables = tables.rows.length;
+		for (const table of tables.rows) {
+			const tableName = table.table_name;
+			if (tableName.startsWith("sqlite_sequence") || tableName.startsWith("_prisma_migrations")) continue;
+			processedTables++;
+			consola.info(`[${processedTables}/${totalTables}] Inspecting table: ${tableName}`);
+			try {
+				let columnsQuery;
+				let queryParams;
+				if (driverType === "mysql") {
+					columnsQuery = `
+          SELECT
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default
+          FROM information_schema.columns
+          WHERE TABLE_NAME = ?
+          AND TABLE_SCHEMA = ?
+          ORDER BY ORDINAL_POSITION
+        `;
+					queryParams = [tableName, tableSchemaFilter];
+				} else if (driverType === "postgres" || driverType === "neon") {
+					columnsQuery = `
+          SELECT
+            column_name,
+            data_type,
+            is_nullable,
+            column_default
+          FROM information_schema.columns
+          WHERE table_name = $1
+          AND table_schema = $2
+          ORDER BY ordinal_position
+        `;
+					queryParams = [tableName, tableSchemaFilter];
+				} else {
+					columnsQuery = `
+          SELECT
+            name as column_name,
+            type as data_type,
+            CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
+            dflt_value as column_default
+          FROM pragma_table_info(?)
+          ORDER BY cid
+        `;
+					queryParams = [tableName];
+				}
+				const columns = await withTimeout(retryQuery(() => client.query(columnsQuery, queryParams)), 15e3);
+				if (columns.rows.length === 0) {
+					consola.info(`No columns found for table: ${tableName}`);
+					continue;
+				}
+				consola.info(`Columns in '${tableName}'`);
+				columns.rows.forEach((c) => {
+					const typeDisplay = c.data_type + (c.is_nullable === "YES" ? " (nullable)" : "");
+					consola.info(`  > ${chalk.bold.yellow(typeDisplay)} > ${c.column_name}`);
+				});
+				const uniqueColumns = /* @__PURE__ */ new Map();
+				columns.rows.forEach((col) => {
+					if (!uniqueColumns.has(col.column_name)) uniqueColumns.set(col.column_name, col);
+				});
+				generatedTypes += `export interface ${tableName.charAt(0).toUpperCase() + tableName.slice(1)} {\n`;
+				for (const col of uniqueColumns.values()) {
+					const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === "YES", driverType);
+					generatedTypes += `  ${col.column_name}: ${tsType};\n`;
+				}
+				generatedTypes += "}\n\n";
+			} catch (error) {
+				consola.error(`Failed to process table ${tableName}:`, error);
+				consola.info(`Skipping table ${tableName} and continuing...`);
+				continue;
+			}
+		}
+		generatedTypes += "export interface Database {\n";
+		for (const table of tables.rows) {
+			if (table.table_name.startsWith("sqlite_sequence") || table.table_name.startsWith("_prisma_migrations")) continue;
+			const interfaceName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
+			generatedTypes += `  ${table.table_name}: ${interfaceName};\n`;
+		}
+		generatedTypes += "}\n\n";
+		await fs.writeFile(outputFile, generatedTypes, "utf8");
+		consola.success(`TypeScript types written to ${outputFile}`);
+		consola.success(`Successfully processed ${processedTables} tables`);
+	} catch (error) {
+		consola.error("Fatal error during database inspection:", error);
+		throw error;
+	} finally {
+		await client.close().catch((error) => consola.error("Error closing client:", error));
+	}
+};
+var inspect_default = inspectDB;
+
+//#endregion
+//#region src/drivers/helpers/postgres.ts
+function createPostgresHelpers(driver) {
+	return {
+		async findFirst(table, where) {
+			const conditions = [];
+			const params = [];
+			let paramIndex = 1;
+			if (where) for (const [key, value] of Object.entries(where)) {
+				conditions.push(`"${key}" = $${paramIndex}`);
+				params.push(value);
+				paramIndex++;
+			}
+			const sql = `SELECT * FROM "${table}" ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""} LIMIT 1`;
+			return await driver.query(sql, params);
+		},
+		async findMany(table, options) {
+			const conditions = [];
+			const params = [];
+			let paramIndex = 1;
+			if (options?.where) for (const [key, value] of Object.entries(options.where)) {
+				conditions.push(`"${key}" = $${paramIndex}`);
+				params.push(value);
+				paramIndex++;
+			}
+			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+			const limitClause = options?.limit ? `LIMIT $${paramIndex++}` : "";
+			const offsetClause = options?.offset ? `OFFSET $${paramIndex++}` : "";
+			if (options?.limit) params.push(options.limit);
+			if (options?.offset) params.push(options.offset);
+			const sql = `SELECT * FROM "${table}" ${whereClause} ${limitClause} ${offsetClause}`.trim();
+			return await driver.query(sql, params);
+		},
+		async insert(table, data) {
+			const keys = Object.keys(data);
+			const values = Object.values(data);
+			const sql = `INSERT INTO "${table}" (${keys.map((k) => `"${k}"`).join(", ")}) VALUES (${keys.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING *`;
+			return await driver.query(sql, values);
+		},
+		async update(table, data, where) {
+			const setEntries = Object.entries(data);
+			const whereEntries = Object.entries(where);
+			const params = [];
+			let paramIndex = 1;
+			const setClauses = setEntries.map(([key, value]) => {
+				params.push(value);
+				return `"${key}" = $${paramIndex++}`;
+			});
+			const whereClauses = whereEntries.map(([key, value]) => {
+				params.push(value);
+				return `"${key}" = $${paramIndex++}`;
+			});
+			const sql = `UPDATE "${table}" SET ${setClauses.join(", ")} WHERE ${whereClauses.join(" AND ")} RETURNING *`;
+			return await driver.query(sql, params);
+		},
+		async delete(table, where) {
+			const conditions = [];
+			const params = [];
+			let paramIndex = 1;
+			for (const [key, value] of Object.entries(where)) {
+				conditions.push(`"${key}" = $${paramIndex}`);
+				params.push(value);
+				paramIndex++;
+			}
+			const sql = `DELETE FROM "${table}" WHERE ${conditions.join(" AND ")}`;
+			return (await driver.query(sql, params)).rowCount;
+		}
+	};
+}
+
+//#endregion
+//#region src/drivers/postgres.ts
+var PostgresDriver = class {
+	client;
+	findFirst;
+	findMany;
+	insert;
+	update;
+	delete;
+	constructor(config) {
+		this.client = postgres(config.connectionString, {
+			max: config.max ?? 10,
+			idle_timeout: config.idle_timeout ?? 30,
+			connect_timeout: config.connect_timeout ?? 10,
+			prepare: false,
+			transform: { undefined: null }
+		});
+		const helpers = createPostgresHelpers(this);
+		this.findFirst = helpers.findFirst;
+		this.findMany = helpers.findMany;
+		this.insert = helpers.insert;
+		this.update = helpers.update;
+		this.delete = helpers.delete;
+	}
+	async query(sql, params) {
+		try {
+			const result = await this.client.unsafe(sql, params || []);
+			const rows = Array.isArray(result) ? [...result] : [];
+			return {
+				rows,
+				rowCount: rows.length,
+				command: result.command
+			};
+		} catch (error) {
+			throw new QueryError("postgres", sql, error);
+		}
+	}
+	async close() {
+		await this.client.end();
+	}
+};
+
+//#endregion
+//#region src/drivers/helpers/mysql.ts
+function createMySQLHelpers(driver) {
+	return {
+		async findFirst(table, where) {
+			const conditions = [];
+			const params = [];
+			if (where) for (const [key, value] of Object.entries(where)) {
+				conditions.push(`\`${key}\` = ?`);
+				params.push(value);
+			}
+			const sql = `SELECT * FROM \`${table}\` ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""} LIMIT 1`;
+			return await driver.query(sql, params);
+		},
+		async findMany(table, options) {
+			const conditions = [];
+			const params = [];
+			if (options?.where) for (const [key, value] of Object.entries(options.where)) {
+				conditions.push(`\`${key}\` = ?`);
+				params.push(value);
+			}
+			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+			const limitClause = options?.limit ? `LIMIT ?` : "";
+			const offsetClause = options?.offset ? `OFFSET ?` : "";
+			if (options?.limit) params.push(options.limit);
+			if (options?.offset) params.push(options.offset);
+			const sql = `SELECT * FROM \`${table}\` ${whereClause} ${limitClause} ${offsetClause}`.trim();
+			return await driver.query(sql, params);
+		},
+		async insert(table, data) {
+			const keys = Object.keys(data);
+			const values = Object.values(data);
+			const sql = `INSERT INTO \`${table}\` (${keys.map((k) => `\`${k}\``).join(", ")}) VALUES (${keys.map(() => "?").join(", ")})`;
+			await driver.query(sql, values);
+			const selectSql = `SELECT * FROM \`${table}\` WHERE id = LAST_INSERT_ID()`;
+			return await driver.query(selectSql);
+		},
+		async update(table, data, where) {
+			const setEntries = Object.entries(data);
+			const whereEntries = Object.entries(where);
+			const params = [];
+			const setClauses = setEntries.map(([key, value]) => {
+				params.push(value);
+				return `\`${key}\` = ?`;
+			});
+			const whereClauses = whereEntries.map(([key, value]) => {
+				params.push(value);
+				return `\`${key}\` = ?`;
+			});
+			const sql = `UPDATE \`${table}\` SET ${setClauses.join(", ")} WHERE ${whereClauses.join(" AND ")}`;
+			await driver.query(sql, params);
+			const selectParams = Object.values(where);
+			const selectSql = `SELECT * FROM \`${table}\` WHERE ${Object.keys(where).map((k) => `\`${k}\` = ?`).join(" AND ")}`;
+			return await driver.query(selectSql, selectParams);
+		},
+		async delete(table, where) {
+			const conditions = [];
+			const params = [];
+			for (const [key, value] of Object.entries(where)) {
+				conditions.push(`\`${key}\` = ?`);
+				params.push(value);
+			}
+			const sql = `DELETE FROM \`${table}\` WHERE ${conditions.join(" AND ")}`;
+			return (await driver.query(sql, params)).rowCount;
+		}
+	};
+}
+
+//#endregion
+//#region src/drivers/helpers/sqlite.ts
+function createSQLiteHelpers(driver) {
+	return {
+		async findFirst(table, where) {
+			const conditions = [];
+			const params = [];
+			if (where) for (const [key, value] of Object.entries(where)) {
+				conditions.push(`"${key}" = ?`);
+				params.push(value);
+			}
+			const sql = `SELECT * FROM "${table}" ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""} LIMIT 1`;
+			return await driver.query(sql, params);
+		},
+		async findMany(table, options) {
+			const conditions = [];
+			const params = [];
+			if (options?.where) for (const [key, value] of Object.entries(options.where)) {
+				conditions.push(`"${key}" = ?`);
+				params.push(value);
+			}
+			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+			const limitClause = options?.limit ? `LIMIT ?` : "";
+			const offsetClause = options?.offset ? `OFFSET ?` : "";
+			if (options?.limit) params.push(options.limit);
+			if (options?.offset) params.push(options.offset);
+			const sql = `SELECT * FROM "${table}" ${whereClause} ${limitClause} ${offsetClause}`.trim();
+			return await driver.query(sql, params);
+		},
+		async insert(table, data) {
+			const keys = Object.keys(data);
+			const values = Object.values(data);
+			const sql = `INSERT INTO "${table}" (${keys.map((k) => `"${k}"`).join(", ")}) VALUES (${keys.map(() => "?").join(", ")}) RETURNING *`;
+			return await driver.query(sql, values);
+		},
+		async update(table, data, where) {
+			const setEntries = Object.entries(data);
+			const whereEntries = Object.entries(where);
+			const params = [];
+			const setClauses = setEntries.map(([key, value]) => {
+				params.push(value);
+				return `"${key}" = ?`;
+			});
+			const whereClauses = whereEntries.map(([key, value]) => {
+				params.push(value);
+				return `"${key}" = ?`;
+			});
+			const sql = `UPDATE "${table}" SET ${setClauses.join(", ")} WHERE ${whereClauses.join(" AND ")} RETURNING *`;
+			return await driver.query(sql, params);
+		},
+		async delete(table, where) {
+			const conditions = [];
+			const params = [];
+			for (const [key, value] of Object.entries(where)) {
+				conditions.push(`"${key}" = ?`);
+				params.push(value);
+			}
+			const sql = `DELETE FROM "${table}" WHERE ${conditions.join(" AND ")}`;
+			return (await driver.query(sql, params)).rowCount;
+		}
+	};
+}
+
+//#endregion
+//#region src/schema/column.ts
+var Column = class {
+	definition;
+	constructor(name, type) {
+		this.definition = {
+			name,
+			type
+		};
+	}
+	length(len) {
+		this.definition.length = len;
+		return this;
+	}
+	precision(p, s) {
+		this.definition.precision = p;
+		if (s !== void 0) this.definition.scale = s;
+		return this;
+	}
+	primaryKey() {
+		this.definition.primaryKey = true;
+		this.definition.notNull = true;
+		return this;
+	}
+	notNull() {
+		this.definition.notNull = true;
+		return this;
+	}
+	unique() {
+		this.definition.unique = true;
+		return this;
+	}
+	default(value) {
+		this.definition.default = value;
+		return this;
+	}
+	references(table, column = "id") {
+		this.definition.references = {
+			table,
+			column
+		};
+		return this;
+	}
+	onDelete(action) {
+		if (this.definition.references) this.definition.references.onDelete = action;
+		return this;
+	}
+	onUpdate(action) {
+		if (this.definition.references) this.definition.references.onUpdate = action;
+		return this;
+	}
+	check(expression) {
+		this.definition.check = expression;
+		return this;
+	}
+	getDefinition() {
+		return this.definition;
+	}
+};
+function serial(name) {
+	return new Column(name, "serial");
+}
+function bigserial(name) {
+	return new Column(name, "bigserial");
+}
+function integer(name) {
+	return new Column(name, "integer");
+}
+function bigint(name) {
+	return new Column(name, "bigint");
+}
+function smallint(name) {
+	return new Column(name, "smallint");
+}
+function text(name) {
+	return new Column(name, "text");
+}
+function varchar(name, length) {
+	const col = new Column(name, "varchar");
+	if (length) col.length(length);
+	return col;
+}
+function char(name, length) {
+	const col = new Column(name, "char");
+	if (length) col.length(length);
+	return col;
+}
+function boolean(name) {
+	return new Column(name, "boolean");
+}
+function timestamp(name) {
+	return new Column(name, "timestamp");
+}
+function timestamptz(name) {
+	return new Column(name, "timestamptz");
+}
+function date(name) {
+	return new Column(name, "date");
+}
+function time(name) {
+	return new Column(name, "time");
+}
+function json(name) {
+	return new Column(name, "json");
+}
+function jsonb(name) {
+	return new Column(name, "jsonb");
+}
+function uuid(name) {
+	return new Column(name, "uuid");
+}
+function decimal(name, precision, scale) {
+	const col = new Column(name, "decimal");
+	if (precision) col.precision(precision, scale);
+	return col;
+}
+function numeric(name, precision, scale) {
+	const col = new Column(name, "numeric");
+	if (precision) col.precision(precision, scale);
+	return col;
+}
+function real(name) {
+	return new Column(name, "real");
+}
+function doublePrecision(name) {
+	return new Column(name, "double precision");
+}
+function bytea(name) {
+	return new Column(name, "bytea");
+}
+
+//#endregion
+//#region src/schema/table.ts
+var Table = class {
+	definition;
+	constructor(name) {
+		this.definition = {
+			name,
+			columns: [],
+			indexes: [],
+			checks: []
+		};
+	}
+	column(column) {
+		this.definition.columns.push(column.getDefinition());
+		return this;
+	}
+	primaryKey(...columns) {
+		this.definition.primaryKey = columns;
+		return this;
+	}
+	index(name, columns, options) {
+		const index = {
+			name,
+			columns,
+			unique: options?.unique,
+			type: options?.type
+		};
+		this.definition.indexes?.push(index);
+		return this;
+	}
+	unique(name, ...columns) {
+		return this.index(name, columns, { unique: true });
+	}
+	check(name, expression) {
+		this.definition.checks?.push({
+			name,
+			expression
+		});
+		return this;
+	}
+	getDefinition() {
+		return this.definition;
+	}
+};
+function createTable(name, callback) {
+	const table = new Table(name);
+	callback(table);
+	return table;
+}
+
+//#endregion
+//#region src/schema/index.ts
+init_postgres();
+init_mysql();
+init_sqlite();
+
+//#endregion
+//#region src/index.ts
+var SQLClient = class SQLClient {
+	primaryDriver;
+	fallbackDrivers;
+	queryCache;
+	cacheTTL;
+	maxCacheSize = 100;
+	constructor(options) {
+		this.primaryDriver = options.driver;
+		this.fallbackDrivers = options.fallbackDrivers || [];
+		this.queryCache = /* @__PURE__ */ new Map();
+		this.cacheTTL = options.cacheTTL ?? 5e3;
+	}
+	isCacheValid(entry) {
+		return Date.now() - entry.timestamp < this.cacheTTL;
+	}
+	getCacheKey(sql, params) {
+		return JSON.stringify({
+			sql,
+			params
+		});
+	}
+	maintainCacheSize() {
+		if (this.queryCache.size > this.maxCacheSize) {
+			const firstKey = this.queryCache.keys().next().value;
+			if (firstKey !== void 0) this.queryCache.delete(firstKey);
+		}
+	}
+	cacheResult(cacheKey, result) {
+		this.queryCache.set(cacheKey, {
+			result,
+			timestamp: Date.now()
+		});
+		this.maintainCacheSize();
+	}
+	async tryFallbackDrivers(sql, params) {
+		consola.warn(`Query failed with ${this.primaryDriver.constructor.name}, trying fallbacks`);
+		let lastError;
+		for (const driver of this.fallbackDrivers) try {
+			return await driver.query(sql, params);
+		} catch (error) {
+			lastError = error;
+		}
+		throw lastError || new DatabaseError("All drivers failed to execute query", "unknown");
+	}
+	async query(sql, params) {
+		const cacheKey = this.getCacheKey(sql, params);
+		const cached = this.queryCache.get(cacheKey);
+		if (cached && this.isCacheValid(cached)) return cached.result;
+		try {
+			const result = await this.primaryDriver.query(sql, params);
+			this.cacheResult(cacheKey, result);
+			return result;
+		} catch (primaryError) {
+			if (this.fallbackDrivers.length === 0) throw primaryError;
+			return await this.tryFallbackDrivers(sql, params);
+		}
+	}
+	async transaction(callback) {
+		if (!hasTransactionSupport(this.primaryDriver)) throw new DatabaseError("Primary driver does not support transactions", this.primaryDriver.constructor.name);
+		return await this.primaryDriver.transaction(async (transactionDriver) => {
+			return await callback(new SQLClient({
+				driver: transactionDriver,
+				fallbackDrivers: []
+			}));
+		});
+	}
+	async prepare(sql) {
+		if (!hasPreparedStatementSupport(this.primaryDriver)) throw new DatabaseError("Primary driver does not support prepared statements", this.primaryDriver.constructor.name);
+		return await this.primaryDriver.prepare(sql);
+	}
+	async findFirst(table, where) {
+		if (!this.primaryDriver.findFirst) throw new DatabaseError("Primary driver does not support findFirst", this.primaryDriver.constructor.name);
+		return (await this.primaryDriver.findFirst(table, where))?.rows[0] || null;
+	}
+	async findMany(table, options) {
+		if (!this.primaryDriver.findMany) throw new DatabaseError("Primary driver does not support findMany", this.primaryDriver.constructor.name);
+		return (await this.primaryDriver.findMany(table, options)).rows;
+	}
+	async insert(table, data) {
+		if (!this.primaryDriver.insert) throw new DatabaseError("Primary driver does not support insert", this.primaryDriver.constructor.name);
+		return (await this.primaryDriver.insert(table, data)).rows[0];
+	}
+	async update(table, data, where) {
+		if (!this.primaryDriver.update) throw new DatabaseError("Primary driver does not support update", this.primaryDriver.constructor.name);
+		return (await this.primaryDriver.update(table, data, where)).rows[0] || null;
+	}
+	async delete(table, where) {
+		if (!this.primaryDriver.delete) throw new DatabaseError("Primary driver does not support delete", this.primaryDriver.constructor.name);
+		return await this.primaryDriver.delete(table, where);
+	}
+	getDriver() {
+		return this.primaryDriver;
+	}
+	async inspectDB(options) {
+		return await inspect_default({
+			driver: this.getDriver(),
+			...options
+		});
+	}
+	supportsTransactions() {
+		return hasTransactionSupport(this.primaryDriver);
+	}
+	supportsPreparedStatements() {
+		return hasPreparedStatementSupport(this.primaryDriver);
+	}
+	clearCache() {
+		this.queryCache.clear();
+	}
+	getCacheStats() {
+		return {
+			size: this.queryCache.size,
+			ttl: this.cacheTTL
+		};
+	}
+	async close() {
+		this.queryCache.clear();
+		const closePromises = [this.primaryDriver, ...this.fallbackDrivers].map((driver) => driver.close().catch((err) => consola.warn(`Error closing ${driver.constructor.name}:`, err)));
+		await Promise.all(closePromises);
+	}
+};
+const DriftSQLClient = SQLClient;
+
+//#endregion
+export { Column, DriftSQLClient, MigrationBuilder, MigrationRunner, MySQLGenerator, PostgresDriver, PostgresGenerator, SQLClient, SQLiteGenerator, SchemaDiffer, SnapshotManager, Table, TypeGenerator, bigint, bigserial, boolean, bytea, char, createMigration, createMySQLHelpers, createPostgresHelpers, createSQLiteHelpers, createTable, date, decimal, detectChanges, doublePrecision, generateMigrationFromChanges, generateTypesFromSchema, integer, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar };