driftsql 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/index.js

@@ -1,52 +1,680 @@
-import{a as e,i as t,n,o as r,r as i,t as a}from"./postgres-9C7eE0wB.js";import{n as o,t as s}from"./type-generator-Ba8bgnMm.js";import{Command as c}from"commander";import l from"consola";import u from"node:fs/promises";import d from"node:path";import f from"chalk";import p from"postgres";var m=class{client;constructor(e){this.client=e}async ensureMigrationsTable(){await this.client.query(`
+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(){return await this.ensureMigrationsTable(),(await this.client.query(`SELECT version FROM _migrations ORDER BY version`)).rows.map(e=>e.version)}async up(e){if((await this.getAppliedMigrations()).includes(e.version)){l.info(`Migration ${e.version} (${e.name}) already applied`);return}l.start(`Running migration ${e.version} (${e.name})`);for(let t of e.up)await this.client.query(t);await this.client.query(`INSERT INTO _migrations (version, name) VALUES ($1, $2)`,[e.version,e.name]),l.success(`Migration ${e.version} (${e.name}) applied successfully`)}async down(e){if(!(await this.getAppliedMigrations()).includes(e.version)){l.info(`Migration ${e.version} (${e.name}) not applied`);return}l.start(`Rolling back migration ${e.version} (${e.name})`);for(let t of e.down)await this.client.query(t);await this.client.query(`DELETE FROM _migrations WHERE version = $1`,[e.version]),l.success(`Migration ${e.version} (${e.name}) rolled back successfully`)}async upAll(e){let t=await this.getAppliedMigrations(),n=e.filter(e=>!t.includes(e.version));if(n.length===0){l.info(`No pending migrations`);return}l.info(`Found ${n.length} pending migrations`);for(let e of n)await this.up(e)}async downAll(e){let t=await this.getAppliedMigrations(),n=e.filter(e=>t.includes(e.version)).reverse();if(n.length===0){l.info(`No migrations to rollback`);return}l.info(`Rolling back ${n.length} migrations`);for(let e of n)await this.down(e)}async reset(e){await this.downAll(e),await this.upAll(e)}},h=class{snapshotPath;constructor(e=`./.driftsql/snapshot.json`){this.snapshotPath=e}async save(e){let t={version:`1`,timestamp:Date.now(),tables:e},n=d.dirname(this.snapshotPath);await u.mkdir(n,{recursive:!0}),await u.writeFile(this.snapshotPath,JSON.stringify(t,null,2),`utf8`)}async load(){try{let e=await u.readFile(this.snapshotPath,`utf8`);return JSON.parse(e)}catch{return null}}async exists(){try{return await u.access(this.snapshotPath),!0}catch{return!1}}},g=e({MySQLGenerator:()=>_}),_,v=t((()=>{_=class{generateCreateTable(e){let t=[];t.push(`CREATE TABLE \`${e.name}\` (`);let n=[];for(let t of e.columns)n.push(`  `+this.generateColumnDefinition(t));if(e.primaryKey&&e.primaryKey.length>0){let t=e.primaryKey.map(e=>`\`${e}\``).join(`, `);n.push(`  PRIMARY KEY (${t})`)}if(e.checks&&e.checks.length>0)for(let t of e.checks)n.push(`  CONSTRAINT \`${t.name}\` CHECK (${t.expression})`);t.push(n.join(`,
-`)),t.push(`) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`);let r=[t.join(`
-`)];if(e.indexes&&e.indexes.length>0)for(let t of e.indexes)r.push(this.generateIndex(e.name,t));return r.join(`
+    `);
+	}
+	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});`;
+		}
+	};
+}) });
 
-`)}generateDropTable(e){return`DROP TABLE IF EXISTS \`${e}\`;`}generateColumnDefinition(e){let t=[`\`${e.name}\``];if(t.push(this.getColumnType(e)),e.notNull&&!e.primaryKey&&e.type!==`serial`&&e.type!==`bigserial`&&t.push(`NOT NULL`),e.unique&&t.push(`UNIQUE`),(e.type===`serial`||e.type===`bigserial`)&&t.push(`AUTO_INCREMENT`),e.default!==void 0&&t.push(`DEFAULT ${this.formatDefault(e.default)}`),e.references){let n=e.references;t.push(`REFERENCES \`${n.table}\`(\`${n.column}\`)`),n.onDelete&&t.push(`ON DELETE ${n.onDelete}`),n.onUpdate&&t.push(`ON UPDATE ${n.onUpdate}`)}return e.check&&t.push(`CHECK (${e.check})`),t.join(` `)}getColumnType(e){let t=e.type;if(t===`serial`)return`INT`;if(t===`bigserial`)return`BIGINT`;if(t===`timestamptz`)return`TIMESTAMP`;if(t===`jsonb`)return`JSON`;if(t===`bytea`)return`BLOB`;if(t===`double precision`)return`DOUBLE`;let n=t.toUpperCase();return e.length?n+=`(${e.length})`:e.precision&&(e.scale===void 0?n+=`(${e.precision})`:n+=`(${e.precision}, ${e.scale})`),n}formatDefault(e){return typeof e==`string`?e.toUpperCase()===`NOW()`||e.toUpperCase()===`CURRENT_TIMESTAMP`?`CURRENT_TIMESTAMP`:`'${e}'`:typeof e==`boolean`?e?`1`:`0`:String(e)}generateIndex(e,t){let n=t.unique?`UNIQUE `:``,r=t.type&&t.type!==`btree`?` USING ${t.type.toUpperCase()}`:``,i=t.columns.map(e=>`\`${e}\``).join(`, `);return`CREATE ${n}INDEX \`${t.name}\` ON \`${e}\`${r} (${i});`}}})),y=e({SQLiteGenerator:()=>b}),b,x=t((()=>{b=class{generateCreateTable(e){let t=[];t.push(`CREATE TABLE "${e.name}" (`);let n=[];for(let t of e.columns)n.push(`  `+this.generateColumnDefinition(t));if(e.primaryKey&&e.primaryKey.length>0){let t=e.primaryKey.map(e=>`"${e}"`).join(`, `);n.push(`  PRIMARY KEY (${t})`)}if(e.checks&&e.checks.length>0)for(let t of e.checks)n.push(`  CONSTRAINT "${t.name}" CHECK (${t.expression})`);t.push(n.join(`,
-`)),t.push(`);`);let r=[t.join(`
-`)];if(e.indexes&&e.indexes.length>0)for(let t of e.indexes)r.push(this.generateIndex(e.name,t));return r.join(`
+//#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);
+}
 
-`)}generateDropTable(e){return`DROP TABLE IF EXISTS "${e}";`}generateColumnDefinition(e){let t=[`"${e.name}"`];if(t.push(this.getColumnType(e)),e.primaryKey&&(t.push(`PRIMARY KEY`),(e.type===`serial`||e.type===`bigserial`)&&t.push(`AUTOINCREMENT`)),e.notNull&&!e.primaryKey&&t.push(`NOT NULL`),e.unique&&t.push(`UNIQUE`),e.default!==void 0&&t.push(`DEFAULT ${this.formatDefault(e.default)}`),e.references){let n=e.references;t.push(`REFERENCES "${n.table}"("${n.column}")`),n.onDelete&&t.push(`ON DELETE ${n.onDelete}`),n.onUpdate&&t.push(`ON UPDATE ${n.onUpdate}`)}return e.check&&t.push(`CHECK (${e.check})`),t.join(` `)}getColumnType(e){let t=e.type;return t===`serial`||t===`bigserial`||t===`bigint`||t===`smallint`?`INTEGER`:t===`varchar`||t===`char`||t===`timestamptz`||t===`timestamp`||t===`date`||t===`time`||t===`uuid`||t===`json`||t===`jsonb`?`TEXT`:t===`bytea`?`BLOB`:t===`decimal`||t===`numeric`||t===`real`||t===`double precision`?`REAL`:t===`boolean`?`INTEGER`:t.toUpperCase()}formatDefault(e){return typeof e==`string`?e.toUpperCase()===`NOW()`||e.toUpperCase()===`CURRENT_TIMESTAMP`?`CURRENT_TIMESTAMP`:`'${e}'`:typeof e==`boolean`?e?`1`:`0`:String(e)}generateIndex(e,t){let n=t.unique?`UNIQUE `:``,r=t.columns.map(e=>`"${e}"`).join(`, `);return`CREATE ${n}INDEX "${t.name}" ON "${e}" (${r});`}}}));n(),v(),x();var S=class{upStatements=[];downStatements=[];dialect;constructor(e=`postgres`){this.dialect=e}createTable(e){let t=e.getDefinition(),n=this.getGenerator();return this.upStatements.push(n.generateCreateTable(t)),this.downStatements.unshift(n.generateDropTable(t.name)),this}dropTable(e){let t=this.getGenerator();return this.upStatements.push(t.generateDropTable(e)),this}addColumn(e,t){return this.upStatements.push(`ALTER TABLE "${e}" ADD COLUMN ${t};`),this}dropColumn(e,t){return this.upStatements.push(`ALTER TABLE "${e}" DROP COLUMN "${t}";`),this}renameTable(e,t){return this.dialect===`postgres`?this.upStatements.push(`ALTER TABLE "${e}" RENAME TO "${t}";`):this.dialect===`mysql`?this.upStatements.push(`RENAME TABLE \`${e}\` TO \`${t}\`;`):this.upStatements.push(`ALTER TABLE "${e}" RENAME TO "${t}";`),this}raw(e,t){return this.upStatements.push(e),t&&this.downStatements.unshift(t),this}build(e,t){return{version:e,name:t,up:this.upStatements,down:this.downStatements}}getGenerator(){switch(this.dialect){case`postgres`:return new a;case`mysql`:return new _;case`sqlite`:return new b;default:return new a}}};function ee(e=`postgres`){return new S(e)}var C=class{dialect;constructor(e=`postgres`){this.dialect=e}detectChanges(e,t){let n=[],r=new Map(e.map(e=>[e.name,e])),i=new Map(t.map(e=>[e.name,e]));for(let[e,t]of i){let i=r.get(e);i?(n.push(...this.detectColumnChanges(i,t)),n.push(...this.detectIndexChanges(i,t))):n.push({type:`create_table`,table:e,details:t})}for(let[e]of r)i.has(e)||n.push({type:`drop_table`,table:e});return n}detectColumnChanges(e,t){let n=[],r=new Map(e.columns.map(e=>[e.name,e])),i=new Map(t.columns.map(e=>[e.name,e]));for(let[e,a]of i){let i=r.get(e);i?this.hasColumnChanged(i,a)&&n.push({type:`modify_column`,table:t.name,details:{old:i,new:a}}):n.push({type:`add_column`,table:t.name,details:a})}for(let[e]of r)i.has(e)||n.push({type:`drop_column`,table:t.name,details:{name:e}});return n}detectIndexChanges(e,t){let n=[],r=new Map((e.indexes||[]).map(e=>[e.name,e])),i=new Map((t.indexes||[]).map(e=>[e.name,e]));for(let[e,a]of i)r.has(e)||n.push({type:`create_index`,table:t.name,details:a});for(let[e]of r)i.has(e)||n.push({type:`drop_index`,table:t.name,details:{name:e}});return n}hasColumnChanged(e,t){return e.type!==t.type||e.length!==t.length||e.precision!==t.precision||e.scale!==t.scale||e.notNull!==t.notNull||e.unique!==t.unique||e.default!==t.default||JSON.stringify(e.references)!==JSON.stringify(t.references)}generateMigration(e,t,n){let r=new S(this.dialect);for(let t of e)switch(t.type){case`create_table`:{let e=t.details,n=this.getGenerator(),i=n.generateCreateTable(e);r.raw(i,n.generateDropTable(e.name));break}case`drop_table`:{let e=this.getGenerator();r.raw(e.generateDropTable(t.table));break}case`add_column`:{let e=t.details,n=this.generateColumnSQL(e);r.raw(`ALTER TABLE "${t.table}" ADD COLUMN ${n};`,`ALTER TABLE "${t.table}" DROP COLUMN "${e.name}";`);break}case`drop_column`:{let e=t.details.name;r.raw(`ALTER TABLE "${t.table}" DROP COLUMN "${e}";`);break}case`create_index`:{let e=t.details,n=this.generateIndexSQL(t.table,e);r.raw(n,`DROP INDEX "${e.name}";`);break}case`drop_index`:{let e=t.details.name;r.raw(`DROP INDEX "${e}";`);break}}return r}generateColumnSQL(e){let t=[`"${e.name}"`];return t.push(e.type.toUpperCase()),e.length&&(t[1]+=`(${e.length})`),e.notNull&&t.push(`NOT NULL`),e.unique&&t.push(`UNIQUE`),e.default!==void 0&&t.push(`DEFAULT ${this.formatDefault(e.default)}`),t.join(` `)}generateIndexSQL(e,t){let n=t.unique?`UNIQUE `:``,r=t.columns.map(e=>`"${e}"`).join(`, `);return`CREATE ${n}INDEX "${t.name}" ON "${e}" (${r});`}formatDefault(e){return typeof e==`string`?e.toUpperCase()===`NOW()`||e.toUpperCase()===`CURRENT_TIMESTAMP`?e.toUpperCase():`'${e}'`:typeof e==`boolean`?e?`TRUE`:`FALSE`:String(e)}getGenerator(){let{PostgresGenerator:e}=(n(),r(i)),{MySQLGenerator:t}=(v(),r(g)),{SQLiteGenerator:a}=(x(),r(y));switch(this.dialect){case`postgres`:return new e;case`mysql`:return new t;case`sqlite`:return new a;default:return new e}}};function w(e,t,n=`postgres`){return new C(n).detectChanges(e,t)}function T(e,t,n,r=`postgres`){return new C(r).generateMigration(e,t,n)}const E=new c;E.name(`driftsql`).description(`DriftSQL CLI - Database migrations and schema management`).version(`0.0.1`),E.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 e=>{try{let{client:t,migrations:n}=await O(e.dir,e.config);await new m(t).upAll(n),await t.close(),l.success(`All migrations applied successfully`)}catch(e){l.error(`Migration failed:`,e),process.exit(1)}}),E.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 e=>{try{let{client:t,migrations:n}=await O(e.dir,e.config),r=new m(t),i=await r.getAppliedMigrations(),a=n.find(e=>e.version===i[i.length-1]);a?await r.down(a):l.info(`No migrations to rollback`),await t.close()}catch(e){l.error(`Rollback failed:`,e),process.exit(1)}}),E.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 e=>{try{let{client:t,migrations:n}=await O(e.dir,e.config);await new m(t).reset(n),await t.close(),l.success(`All migrations reset successfully`)}catch(e){l.error(`Reset failed:`,e),process.exit(1)}}),E.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 e=>{try{let{client:t,migrations:n}=await O(e.dir,e.config),r=await new m(t).getAppliedMigrations();l.info(`Migration Status:
-`);for(let e of n){let t=r.includes(e.version)?`✓ Applied`:`✗ Pending`;l.log(`${t} - ${e.version} (${e.name})`)}await t.close()}catch(e){l.error(`Failed to get status:`,e),process.exit(1)}}),E.command(`migrate:create <name>`).description(`Create a new migration file`).option(`-d, --dir <directory>`,`Migrations directory`,`./migrations`).action(async(e,t)=>{try{let n=new Date().toISOString().replace(/[-:T.]/g,``).slice(0,14),r=`${n}_${e}.ts`,i=d.join(t.dir,r);await u.mkdir(t.dir,{recursive:!0});let a=`import { createMigration } from 'driftsql'
+//#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('${n}', '${e}')
-`;await u.writeFile(i,a,`utf8`),l.success(`Created migration: ${r}`)}catch(e){l.error(`Failed to create migration:`,e),process.exit(1)}}),E.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(e,t)=>{try{let n=new h,r=d.resolve(process.cwd(),t.schema);l.start(`Loading schema...`);let i=await import(r),a=i.default||i.schema;(!a||!Array.isArray(a))&&(l.error(`Schema file must export default or named "schema" as an array of table definitions`),l.info(`Example: export default [usersTable.getDefinition(), postsTable.getDefinition()]`),process.exit(1));let o=a,s=await n.load();if(!s){l.info(`No previous schema snapshot found, creating initial migration...`);let r=new Date().toISOString().replace(/[-:T.]/g,``).slice(0,14),i=e||`initial`,a=`${r}_${i}.ts`,s=d.join(t.dir,a);await u.mkdir(t.dir,{recursive:!0});let{PostgresGenerator:c}=await import(`./postgres-DWtAqXNK.js`),f=new c,p=o.map(e=>f.generateCreateTable(e)).map(e=>`  .raw(\`${e.replace(/`/g,"\\`")}\`)`).join(`
-`),m=`import { createMigration } from 'driftsql'
+  .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: ${new Date().toISOString()}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
 
 export const migration = createMigration('postgres')
-${p}
-  .build('${r}', '${i}')
-`;await u.writeFile(s,m,`utf8`),await n.save(o);let{generateTypesFromSchema:h}=await import(`./type-generator-DbcqBk-4.js`);await h(o,d.join(process.cwd(),`db-types.ts`)),l.success(`\nCreated initial migration: ${a}`),l.success(`Generated TypeScript types: db-types.ts`),l.info(`Snapshot saved. Run "driftsql migrate:up" to apply changes.`);return}l.info(`Detecting changes...`);let c=w(s.tables,o,`postgres`);if(c.length===0){l.success(`No schema changes detected!`);return}l.info(`Found ${c.length} change(s):`),c.forEach((e,t)=>{l.log(`  ${t+1}. ${e.type} - ${e.table}`)});let f=new Date().toISOString().replace(/[-:T.]/g,``).slice(0,14),p=e||`auto_migration`,m=`${f}_${p}.ts`,g=d.join(t.dir,m);await u.mkdir(t.dir,{recursive:!0});let _=T(c,f,p).build(f,p).up.map(e=>`  .raw(\`${e.replace(/`/g,"\\`")}\``).join(`
-`),v=`import { createMigration } from 'driftsql'
+${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: ${new Date().toISOString()}
-// Changes: ${c.length}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// Changes: ${changes.length}
 
 export const migration = createMigration('postgres')
-${_}
-  .build('${f}', '${p}')
-`;await u.writeFile(g,v,`utf8`),await n.save(o);let{generateTypesFromSchema:y}=await import(`./type-generator-DbcqBk-4.js`);await y(o,d.join(process.cwd(),`db-types.ts`)),l.success(`\nGenerated migration: ${m}`),l.success(`Updated TypeScript types: db-types.ts`),l.info(`Snapshot updated. Run "driftsql migrate:up" to apply changes.`)}catch(e){l.error(`Failed to generate migration:`,e),process.exit(1)}}),E.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 e=>{try{let t=await D(e.config);await t.inspectDB({driver:t.getDriver(),outputFile:e.output}),await t.close()}catch(e){l.error(`Inspection failed:`,e),process.exit(1)}}),E.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 e=>{try{let t=d.resolve(process.cwd(),e.schema),n=d.resolve(process.cwd(),e.output);l.start(`Loading schema...`);let r=await import(t),i=r.default||r.schema;(!i||!Array.isArray(i))&&(l.error(`Schema file must export default or named "schema" as an array of table definitions`),process.exit(1));let{generateTypesFromSchema:a}=await import(`./type-generator-DbcqBk-4.js`);await a(i,n),l.success(`TypeScript types generated: ${e.output}`)}catch(e){l.error(`Type generation failed:`,e),process.exit(1)}}),E.command(`init`).description(`Initialize DriftSQL with a basic notes schema`).option(`-d, --dir <directory>`,`Migrations directory`,`./migrations`).action(async e=>{try{await u.mkdir(e.dir,{recursive:!0});let t=`.driftsql/
-.env
-`,n=d.join(process.cwd(),`driftsql.config.ts`),r=d.join(process.cwd(),`schema.ts`),i=d.join(process.cwd(),`.env.example`),a=d.join(process.cwd(),`.gitignore`),o=[{path:n,content:`import { SQLClient, PostgresDriver } from 'driftsql'
+${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!,
   }),
 })
-`,name:`driftsql.config.ts`},{path:r,content:`import { createTable, serial, varchar, text, timestamp, boolean } from 'driftsql'
+`;
+		const schemaContent = `import { createTable, serial, varchar, text, timestamp, boolean } from 'driftsql'
 
 const notesTable = createTable('notes', (table) => {
   table
@@ -62,23 +690,245 @@ const notesTable = createTable('notes', (table) => {
 
 // Export array of table definitions
 export default [notesTable.getDefinition()]
-`,name:`schema.ts`},{path:i,content:`DATABASE_URL=postgresql://user:password@localhost:5432/mydb
-`,name:`.env.example`}];for(let e of o)try{await u.access(e.path),l.warn(`${e.name} already exists, skipping...`)}catch{await u.writeFile(e.path,e.content,`utf8`),l.success(`Created ${e.name}`)}try{(await u.readFile(a,`utf8`)).includes(`.driftsql/`)||(await u.appendFile(a,`
-`+t),l.success(`Updated .gitignore`))}catch{await u.writeFile(a,t,`utf8`),l.success(`Created .gitignore`)}l.success(`
-✨ DriftSQL initialized successfully!
-`),l.info(`Next steps:`),l.info(`1. Copy .env.example to .env and update DATABASE_URL`),l.info(`2. Run: driftsql migrate:generate initial  (generates migration + types)`),l.info(`3. Run: driftsql migrate:up`),l.info(`4. Import Database type from db-types.ts for type safety`),l.info(`5. Edit schema.ts and run migrate:generate to auto-detect changes!
-`)}catch(e){l.error(`Initialization failed:`,e),process.exit(1)}});async function D(e){try{let t=await import(d.resolve(process.cwd(),e));return t.default||t.client}catch(t){throw l.error(`Failed to load config from ${e}`),t}}async function O(e,t){let n=await D(t),r=[];try{let t=d.resolve(process.cwd(),e),i=(await u.readdir(t)).filter(e=>e.endsWith(`.ts`)||e.endsWith(`.js`)).sort();for(let e of i){let n=await import(d.join(t,e)),i=n.migration||n.default;i&&r.push(i)}return{client:n,migrations:r}}catch(t){throw l.error(`Failed to load migrations from ${e}`),t}}E.parse();function k(e){return`transaction`in e&&typeof e.transaction==`function`}function A(e){return`prepare`in e&&typeof e.prepare==`function`}var j=class extends Error{constructor(e,t,n){super(e),this.driverType=t,this.originalError=n,this.name=`DatabaseError`}},M=class extends j{constructor(e,t,n){super(`Query failed: ${t}`,e,n),this.name=`QueryError`}};const N=(e,t=3e4)=>Promise.race([e,new Promise((e,n)=>setTimeout(()=>n(Error(`Query timeout after ${t}ms`)),t))]),P=async(e,t=3,n=1e3)=>{for(let r=1;r<=t;r++)try{return await e()}catch(e){if(r===t)throw e;let i=n*2**(r-1);l.warn(`Query attempt ${r} failed, retrying in ${i}ms...`,e),await new Promise(e=>setTimeout(e,i))}throw Error(`Max retries exceeded`)},F=(e,t=!1,n=`postgres`)=>{let r=t?` | null`:``;switch(e.toLowerCase()){case`uuid`:return`string${r}`;case`character varying`:case`varchar`:case`text`:case`char`:case`character`:case`longtext`:case`mediumtext`:case`tinytext`:return`string${r}`;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${r}`;case`boolean`:case`bool`:case`bit`:return`boolean${r}`;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${r}`;case`json`:case`jsonb`:return`any${r}`;case`array`:return`any[]${r}`;case`bytea`:case`binary`:case`varbinary`:case`blob`:case`longblob`:case`mediumblob`:case`tinyblob`:return`Buffer${r}`;case`enum`:case`set`:return`string${r}`;default:return l.warn(`Unknown ${n} type: ${e}, defaulting to 'any'`),`any${r}`}},te=e=>`${e.constructor.name||`unknown driver`}`;var ne=async e=>{l.warn(`inspectDB is experimental and may make mistakes when inspecting your database. However it will not destroy your database.`);let{driver:t,outputFile:n=`db-types.ts`}=e,r=te(t);l.start(`Inspecting database using ${r} driver`);let i=new $({driver:t}),a=``;try{let e,t;if(r===`mysql`){let n=(await N(P(()=>i.query("SELECT DATABASE() as `database`",[])),1e4)).rows[0]?.database;if(!n)throw Error(`Could not determine current MySQL database name`);l.success(`Using MySQL database: ${n}`),e=`SELECT TABLE_NAME as table_name
+`;
+		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`,t=n}else if(r===`postgres`||r===`neon`)e=`SELECT table_name
+                   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`,t=`public`;else if(r===`libsql`||r===`sqlite`||r===`sqlitecloud`)e=`SELECT name as table_name
+                   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`,t=void 0;else throw Error(`Unsupported driver type: ${r}`);let o=await N(P(()=>i.query(e,t?[t]:[])),3e4);l.info(`Tables in the database:`,o.rows.map(e=>e.table_name).join(`, `));let s=0,c=o.rows.length;for(let e of o.rows){let n=e.table_name;if(!(n.startsWith(`sqlite_sequence`)||n.startsWith(`_prisma_migrations`))){s++,l.info(`[${s}/${c}] Inspecting table: ${n}`);try{let e,o;r===`mysql`?(e=`
+                   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,
@@ -88,7 +938,10 @@ export default [notesTable.getDefinition()]
           WHERE TABLE_NAME = ?
           AND TABLE_SCHEMA = ?
           ORDER BY ORDINAL_POSITION
-        `,o=[n,t]):r===`postgres`||r===`neon`?(e=`
+        `;
+					queryParams = [tableName, tableSchemaFilter];
+				} else if (driverType === "postgres" || driverType === "neon") {
+					columnsQuery = `
           SELECT
             column_name,
             data_type,
@@ -98,7 +951,10 @@ export default [notesTable.getDefinition()]
           WHERE table_name = $1
           AND table_schema = $2
           ORDER BY ordinal_position
-        `,o=[n,t]):(e=`
+        `;
+					queryParams = [tableName, tableSchemaFilter];
+				} else {
+					columnsQuery = `
           SELECT
             name as column_name,
             type as data_type,
@@ -106,9 +962,607 @@ export default [notesTable.getDefinition()]
             dflt_value as column_default
           FROM pragma_table_info(?)
           ORDER BY cid
-        `,o=[n]);let s=await N(P(()=>i.query(e,o)),15e3);if(s.rows.length===0){l.info(`No columns found for table: ${n}`);continue}l.info(`Columns in '${n}'`),s.rows.forEach(e=>{let t=e.data_type+(e.is_nullable===`YES`?` (nullable)`:``);l.info(`  > ${f.bold.yellow(t)} > ${e.column_name}`)});let c=new Map;s.rows.forEach(e=>{c.has(e.column_name)||c.set(e.column_name,e)}),a+=`export interface ${n.charAt(0).toUpperCase()+n.slice(1)} {\n`;for(let e of c.values()){let t=F(e.data_type,e.is_nullable===`YES`,r);a+=`  ${e.column_name}: ${t};\n`}a+=`}
+        `;
+					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();
 
-`}catch(e){l.error(`Failed to process table ${n}:`,e),l.info(`Skipping table ${n} and continuing...`);continue}}}a+=`export interface Database {
-`;for(let e of o.rows){if(e.table_name.startsWith(`sqlite_sequence`)||e.table_name.startsWith(`_prisma_migrations`))continue;let t=e.table_name.charAt(0).toUpperCase()+e.table_name.slice(1);a+=`  ${e.table_name}: ${t};\n`}a+=`}
+//#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;
 
-`,await u.writeFile(n,a,`utf8`),l.success(`TypeScript types written to ${n}`),l.success(`Successfully processed ${s} tables`)}catch(e){throw l.error(`Fatal error during database inspection:`,e),e}finally{await i.close().catch(e=>l.error(`Error closing client:`,e))}};function I(e){return{async findFirst(t,n){let r=[],i=[],a=1;if(n)for(let[e,t]of Object.entries(n))r.push(`"${e}" = $${a}`),i.push(t),a++;let o=`SELECT * FROM "${t}" ${r.length>0?`WHERE ${r.join(` AND `)}`:``} LIMIT 1`;return await e.query(o,i)},async findMany(t,n){let r=[],i=[],a=1;if(n?.where)for(let[e,t]of Object.entries(n.where))r.push(`"${e}" = $${a}`),i.push(t),a++;let o=r.length>0?`WHERE ${r.join(` AND `)}`:``,s=n?.limit?`LIMIT $${a++}`:``,c=n?.offset?`OFFSET $${a++}`:``;n?.limit&&i.push(n.limit),n?.offset&&i.push(n.offset);let l=`SELECT * FROM "${t}" ${o} ${s} ${c}`.trim();return await e.query(l,i)},async insert(t,n){let r=Object.keys(n),i=Object.values(n),a=`INSERT INTO "${t}" (${r.map(e=>`"${e}"`).join(`, `)}) VALUES (${r.map((e,t)=>`$${t+1}`).join(`, `)}) RETURNING *`;return await e.query(a,i)},async update(t,n,r){let i=Object.entries(n),a=Object.entries(r),o=[],s=1,c=i.map(([e,t])=>(o.push(t),`"${e}" = $${s++}`)),l=a.map(([e,t])=>(o.push(t),`"${e}" = $${s++}`)),u=`UPDATE "${t}" SET ${c.join(`, `)} WHERE ${l.join(` AND `)} RETURNING *`;return await e.query(u,o)},async delete(t,n){let r=[],i=[],a=1;for(let[e,t]of Object.entries(n))r.push(`"${e}" = $${a}`),i.push(t),a++;let o=`DELETE FROM "${t}" WHERE ${r.join(` AND `)}`;return(await e.query(o,i)).rowCount}}}var L=class{client;findFirst;findMany;insert;update;delete;constructor(e){this.client=p(e.connectionString,{max:e.max??10,idle_timeout:e.idle_timeout??30,connect_timeout:e.connect_timeout??10,prepare:!1,transform:{undefined:null}});let t=I(this);this.findFirst=t.findFirst,this.findMany=t.findMany,this.insert=t.insert,this.update=t.update,this.delete=t.delete}async query(e,t){try{let n=await this.client.unsafe(e,t||[]),r=Array.isArray(n)?[...n]:[];return{rows:r,rowCount:r.length,command:n.command}}catch(t){throw new M(`postgres`,e,t)}}async close(){await this.client.end()}};function R(e){return{async findFirst(t,n){let r=[],i=[];if(n)for(let[e,t]of Object.entries(n))r.push(`\`${e}\` = ?`),i.push(t);let a=`SELECT * FROM \`${t}\` ${r.length>0?`WHERE ${r.join(` AND `)}`:``} LIMIT 1`;return await e.query(a,i)},async findMany(t,n){let r=[],i=[];if(n?.where)for(let[e,t]of Object.entries(n.where))r.push(`\`${e}\` = ?`),i.push(t);let a=r.length>0?`WHERE ${r.join(` AND `)}`:``,o=n?.limit?`LIMIT ?`:``,s=n?.offset?`OFFSET ?`:``;n?.limit&&i.push(n.limit),n?.offset&&i.push(n.offset);let c=`SELECT * FROM \`${t}\` ${a} ${o} ${s}`.trim();return await e.query(c,i)},async insert(t,n){let r=Object.keys(n),i=Object.values(n),a=`INSERT INTO \`${t}\` (${r.map(e=>`\`${e}\``).join(`, `)}) VALUES (${r.map(()=>`?`).join(`, `)})`;await e.query(a,i);let o=`SELECT * FROM \`${t}\` WHERE id = LAST_INSERT_ID()`;return await e.query(o)},async update(t,n,r){let i=Object.entries(n),a=Object.entries(r),o=[],s=i.map(([e,t])=>(o.push(t),`\`${e}\` = ?`)),c=a.map(([e,t])=>(o.push(t),`\`${e}\` = ?`)),l=`UPDATE \`${t}\` SET ${s.join(`, `)} WHERE ${c.join(` AND `)}`;await e.query(l,o);let u=Object.values(r),d=`SELECT * FROM \`${t}\` WHERE ${Object.keys(r).map(e=>`\`${e}\` = ?`).join(` AND `)}`;return await e.query(d,u)},async delete(t,n){let r=[],i=[];for(let[e,t]of Object.entries(n))r.push(`\`${e}\` = ?`),i.push(t);let a=`DELETE FROM \`${t}\` WHERE ${r.join(` AND `)}`;return(await e.query(a,i)).rowCount}}}function z(e){return{async findFirst(t,n){let r=[],i=[];if(n)for(let[e,t]of Object.entries(n))r.push(`"${e}" = ?`),i.push(t);let a=`SELECT * FROM "${t}" ${r.length>0?`WHERE ${r.join(` AND `)}`:``} LIMIT 1`;return await e.query(a,i)},async findMany(t,n){let r=[],i=[];if(n?.where)for(let[e,t]of Object.entries(n.where))r.push(`"${e}" = ?`),i.push(t);let a=r.length>0?`WHERE ${r.join(` AND `)}`:``,o=n?.limit?`LIMIT ?`:``,s=n?.offset?`OFFSET ?`:``;n?.limit&&i.push(n.limit),n?.offset&&i.push(n.offset);let c=`SELECT * FROM "${t}" ${a} ${o} ${s}`.trim();return await e.query(c,i)},async insert(t,n){let r=Object.keys(n),i=Object.values(n),a=`INSERT INTO "${t}" (${r.map(e=>`"${e}"`).join(`, `)}) VALUES (${r.map(()=>`?`).join(`, `)}) RETURNING *`;return await e.query(a,i)},async update(t,n,r){let i=Object.entries(n),a=Object.entries(r),o=[],s=i.map(([e,t])=>(o.push(t),`"${e}" = ?`)),c=a.map(([e,t])=>(o.push(t),`"${e}" = ?`)),l=`UPDATE "${t}" SET ${s.join(`, `)} WHERE ${c.join(` AND `)} RETURNING *`;return await e.query(l,o)},async delete(t,n){let r=[],i=[];for(let[e,t]of Object.entries(n))r.push(`"${e}" = ?`),i.push(t);let a=`DELETE FROM "${t}" WHERE ${r.join(` AND `)}`;return(await e.query(a,i)).rowCount}}}var B=class{definition;constructor(e,t){this.definition={name:e,type:t}}length(e){return this.definition.length=e,this}precision(e,t){return this.definition.precision=e,t!==void 0&&(this.definition.scale=t),this}primaryKey(){return this.definition.primaryKey=!0,this.definition.notNull=!0,this}notNull(){return this.definition.notNull=!0,this}unique(){return this.definition.unique=!0,this}default(e){return this.definition.default=e,this}references(e,t=`id`){return this.definition.references={table:e,column:t},this}onDelete(e){return this.definition.references&&(this.definition.references.onDelete=e),this}onUpdate(e){return this.definition.references&&(this.definition.references.onUpdate=e),this}check(e){return this.definition.check=e,this}getDefinition(){return this.definition}};function V(e){return new B(e,`serial`)}function H(e){return new B(e,`bigserial`)}function U(e){return new B(e,`integer`)}function W(e){return new B(e,`bigint`)}function G(e){return new B(e,`smallint`)}function K(e){return new B(e,`text`)}function q(e,t){let n=new B(e,`varchar`);return t&&n.length(t),n}function J(e,t){let n=new B(e,`char`);return t&&n.length(t),n}function Y(e){return new B(e,`boolean`)}function X(e){return new B(e,`timestamp`)}function re(e){return new B(e,`timestamptz`)}function ie(e){return new B(e,`date`)}function ae(e){return new B(e,`time`)}function oe(e){return new B(e,`json`)}function Z(e){return new B(e,`jsonb`)}function se(e){return new B(e,`uuid`)}function ce(e,t,n){let r=new B(e,`decimal`);return t&&r.precision(t,n),r}function le(e,t,n){let r=new B(e,`numeric`);return t&&r.precision(t,n),r}function ue(e){return new B(e,`real`)}function de(e){return new B(e,`double precision`)}function fe(e){return new B(e,`bytea`)}var Q=class{definition;constructor(e){this.definition={name:e,columns:[],indexes:[],checks:[]}}column(e){return this.definition.columns.push(e.getDefinition()),this}primaryKey(...e){return this.definition.primaryKey=e,this}index(e,t,n){let r={name:e,columns:t,unique:n?.unique,type:n?.type};return this.definition.indexes?.push(r),this}unique(e,...t){return this.index(e,t,{unique:!0})}check(e,t){return this.definition.checks?.push({name:e,expression:t}),this}getDefinition(){return this.definition}};function pe(e,t){let n=new Q(e);return t(n),n}n(),v(),x();var $=class e{primaryDriver;fallbackDrivers;queryCache;cacheTTL;maxCacheSize=100;constructor(e){this.primaryDriver=e.driver,this.fallbackDrivers=e.fallbackDrivers||[],this.queryCache=new Map,this.cacheTTL=e.cacheTTL??5e3}isCacheValid(e){return Date.now()-e.timestamp<this.cacheTTL}getCacheKey(e,t){return JSON.stringify({sql:e,params:t})}maintainCacheSize(){if(this.queryCache.size>this.maxCacheSize){let e=this.queryCache.keys().next().value;e!==void 0&&this.queryCache.delete(e)}}cacheResult(e,t){this.queryCache.set(e,{result:t,timestamp:Date.now()}),this.maintainCacheSize()}async tryFallbackDrivers(e,t){l.warn(`Query failed with ${this.primaryDriver.constructor.name}, trying fallbacks`);let n;for(let r of this.fallbackDrivers)try{return await r.query(e,t)}catch(e){n=e}throw n||new j(`All drivers failed to execute query`,`unknown`)}async query(e,t){let n=this.getCacheKey(e,t),r=this.queryCache.get(n);if(r&&this.isCacheValid(r))return r.result;try{let r=await this.primaryDriver.query(e,t);return this.cacheResult(n,r),r}catch(n){if(this.fallbackDrivers.length===0)throw n;return await this.tryFallbackDrivers(e,t)}}async transaction(t){if(!k(this.primaryDriver))throw new j(`Primary driver does not support transactions`,this.primaryDriver.constructor.name);return await this.primaryDriver.transaction(async n=>await t(new e({driver:n,fallbackDrivers:[]})))}async prepare(e){if(!A(this.primaryDriver))throw new j(`Primary driver does not support prepared statements`,this.primaryDriver.constructor.name);return await this.primaryDriver.prepare(e)}async findFirst(e,t){if(!this.primaryDriver.findFirst)throw new j(`Primary driver does not support findFirst`,this.primaryDriver.constructor.name);return(await this.primaryDriver.findFirst(e,t))?.rows[0]||null}async findMany(e,t){if(!this.primaryDriver.findMany)throw new j(`Primary driver does not support findMany`,this.primaryDriver.constructor.name);return(await this.primaryDriver.findMany(e,t)).rows}async insert(e,t){if(!this.primaryDriver.insert)throw new j(`Primary driver does not support insert`,this.primaryDriver.constructor.name);return(await this.primaryDriver.insert(e,t)).rows[0]}async update(e,t,n){if(!this.primaryDriver.update)throw new j(`Primary driver does not support update`,this.primaryDriver.constructor.name);return(await this.primaryDriver.update(e,t,n)).rows[0]||null}async delete(e,t){if(!this.primaryDriver.delete)throw new j(`Primary driver does not support delete`,this.primaryDriver.constructor.name);return await this.primaryDriver.delete(e,t)}getDriver(){return this.primaryDriver}async inspectDB(e){return await ne({driver:this.getDriver(),...e})}supportsTransactions(){return k(this.primaryDriver)}supportsPreparedStatements(){return A(this.primaryDriver)}clearCache(){this.queryCache.clear()}getCacheStats(){return{size:this.queryCache.size,ttl:this.cacheTTL}}async close(){this.queryCache.clear();let e=[this.primaryDriver,...this.fallbackDrivers].map(e=>e.close().catch(t=>l.warn(`Error closing ${e.constructor.name}:`,t)));await Promise.all(e)}};const me=$;export{B as Column,me as DriftSQLClient,S as MigrationBuilder,m as MigrationRunner,_ as MySQLGenerator,L as PostgresDriver,a as PostgresGenerator,$ as SQLClient,b as SQLiteGenerator,C as SchemaDiffer,h as SnapshotManager,Q as Table,s as TypeGenerator,W as bigint,H as bigserial,Y as boolean,fe as bytea,J as char,ee as createMigration,R as createMySQLHelpers,I as createPostgresHelpers,z as createSQLiteHelpers,pe as createTable,ie as date,ce as decimal,w as detectChanges,de as doublePrecision,T as generateMigrationFromChanges,o as generateTypesFromSchema,U as integer,oe as json,Z as jsonb,le as numeric,ue as real,V as serial,G as smallint,K as text,ae as time,X as timestamp,re as timestamptz,se as uuid,q as varchar};
+//#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 };