@h3ravel/arquebus 0.3.6 → 0.4.1

package/dist/index.cjs

@@ -239,6 +239,7 @@ const tap = (instance, callback) => {
 	return result instanceof Promise ? result.then(() => instance) : instance;
 };
 const { compose } = mixin_exports;
+const flatten = (arr) => arr.flat();
 const flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
 const kebabCase = (str) => (0, radashi.trim)((0, radashi.dash)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
 const snakeCase = (str) => (0, radashi.trim)((0, radashi.snake)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
@@ -3557,13 +3558,1430 @@ var MigrationRepository = class {
 		return this.getConnection().table(this.table);
 	}
 	getConnection() {
-		return this.resolver.connection(this.connection);
+		return this.resolver.fire(this.connection);
 	}
 	setSource(name) {
 		this.connection = name;
 	}
 };
 
+//#endregion
+//#region src/inspector/utils/strip-quotes.ts
+/**
+* Strip leading/trailing quotes from a string and handle null values.
+*/
+function stripQuotes(value) {
+	if (value === null || value === void 0) return null;
+	const trimmed = value.trim();
+	if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+	return value;
+}
+
+//#endregion
+//#region src/inspector/dialects/cockroachdb.ts
+/**
+* Converts CockroachDB default value to JS
+* Eg `'example'::character varying` => `example`
+*/
+function parseDefaultValue$5(value) {
+	if (value === null) return null;
+	if (value.startsWith("nextval(")) return value;
+	value = value.split("::")[0];
+	return stripQuotes(value);
+}
+var CockroachDB = class {
+	knex;
+	schema;
+	explodedSchema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+		const config = knex$1.client.config;
+		if (!config.searchPath) {
+			this.schema = "public";
+			this.explodedSchema = [this.schema];
+		} else if (typeof config.searchPath === "string") {
+			this.schema = config.searchPath;
+			this.explodedSchema = [config.searchPath];
+		} else {
+			this.schema = config.searchPath[0];
+			this.explodedSchema = config.searchPath;
+		}
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		this.explodedSchema = [this.schema];
+		return this;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("tablename").from("pg_catalog.pg_tables").whereIn("schemaname", this.explodedSchema)).map(({ tablename }) => tablename);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("table_name", "table_schema", this.knex.select(this.knex.raw("obj_description(oid)")).from("pg_class").where({ relkind: "r" }).andWhere({ relname: "table_name" }).as("table_comment")).from("information_schema.tables").whereIn("table_schema", this.explodedSchema).andWhereRaw("\"table_catalog\" = current_database()").andWhere({ table_type: "BASE TABLE" }).orderBy("table_name", "asc");
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).limit(1).first();
+			return {
+				name: rawTable.table_name,
+				schema: rawTable.table_schema,
+				comment: rawTable.table_comment
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.table_name,
+				schema: rawTable.table_schema,
+				comment: rawTable.table_comment
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const subquery = this.knex.select().from("information_schema.tables").whereIn("table_schema", this.explodedSchema).andWhere({ table_name: table });
+		const record = await this.knex.select(this.knex.raw("exists (?)", [subquery])).first();
+		return (record === null || record === void 0 ? void 0 : record.exists) || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("table_name", "column_name").from("information_schema.columns").whereIn("table_schema", this.explodedSchema);
+		if (table) query.andWhere({ table_name: table });
+		return (await query).map(({ table_name, column_name }) => ({
+			table: table_name,
+			column: column_name
+		}));
+	}
+	async columnInfo(table, column) {
+		const { knex: knex$1 } = this;
+		const bindings = [];
+		if (table) bindings.push(table);
+		if (column) bindings.push(column);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const [columns, constraints] = await Promise.all([knex$1.raw(`
+         SELECT *, CASE WHEN res.is_generated THEN (
+          SELECT
+            generation_expression
+          FROM
+            information_schema.columns
+          WHERE
+            table_schema = res.schema 
+            AND table_name = res.table 
+            AND column_name = res.name
+          ) ELSE NULL END AS generation_expression
+         FROM (
+         SELECT
+           att.attname AS name,
+           rel.relname AS table,
+           rel.relnamespace::regnamespace::text AS schema,
+           format_type(att.atttypid, null) AS data_type,
+           NOT att.attnotnull AS is_nullable,
+           CASE WHEN att.attgenerated = '' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS default_value,
+           att.attgenerated = 's' AS is_generated,
+           CASE
+             WHEN att.atttypid IN (1042, 1043) THEN (att.atttypmod - 4)::int4
+             WHEN att.atttypid IN (1560, 1562) THEN (att.atttypmod)::int4
+             ELSE NULL
+           END AS max_length,
+           des.description AS comment,
+           CASE att.atttypid
+             WHEN 21 THEN 16
+             WHEN 23 THEN 32
+             WHEN 20 THEN 64
+             WHEN 1700 THEN
+               CASE WHEN atttypmod = -1 THEN NULL
+                 ELSE (((atttypmod - 4) >> 16) & 65535)::int4
+               END
+             WHEN 700 THEN 24
+             WHEN 701 THEN 53
+             ELSE NULL
+           END AS numeric_precision,
+           CASE
+             WHEN atttypid IN (21, 23, 20) THEN 0
+             WHEN atttypid = 1700 THEN
+               CASE
+                 WHEN atttypmod = -1 THEN NULL
+                 ELSE ((atttypmod - 4) & 65535)::int4
+               END
+             ELSE null
+           END AS numeric_scale
+         FROM
+           pg_attribute att
+           LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+           LEFT JOIN pg_attrdef ad ON (att.attrelid, att.attnum) = (ad.adrelid, ad.adnum)
+           LEFT JOIN pg_description des ON (att.attrelid, att.attnum) = (des.objoid, des.objsubid)
+         WHERE
+           rel.relnamespace IN (${schemaIn})
+           ${table ? "AND rel.relname = ?" : ""}
+           ${column ? "AND att.attname = ?" : ""}
+           AND rel.relkind = 'r'
+           AND att.attnum > 0
+           AND NOT att.attisdropped
+         ORDER BY rel.relname, att.attnum) res;
+       `, bindings), knex$1.raw(`
+         SELECT
+           con.contype AS type,
+           rel.relname AS table,
+           att.attname AS column,
+           frel.relnamespace::regnamespace::text AS foreign_key_schema,
+           frel.relname AS foreign_key_table,
+           fatt.attname AS foreign_key_column
+         FROM
+           pg_constraint con
+         LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+         LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+         LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+         LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+         WHERE con.connamespace IN (${schemaIn})
+           AND array_length(con.conkey, 1) <= 1
+           AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+           ${table ? "AND rel.relname = ?" : ""}
+           ${column ? "AND att.attname = ?" : ""}
+         `, bindings)]);
+		const parsedColumms = columns.rows.map((col) => {
+			var _col$default_value;
+			const constraintsForColumn = constraints.rows.filter((constraint) => constraint.table === col.table && constraint.column === col.name);
+			const foreignKeyConstraint = constraintsForColumn.find((constraint) => constraint.type === "f");
+			return {
+				...col,
+				is_unique: constraintsForColumn.some((constraint) => ["u", "p"].includes(constraint.type)),
+				is_primary_key: constraintsForColumn.some((constraint) => constraint.type === "p"),
+				has_auto_increment: ["integer", "bigint"].includes(col.data_type) && (((_col$default_value = col.default_value) === null || _col$default_value === void 0 ? void 0 : _col$default_value.startsWith("nextval(")) ?? false),
+				default_value: parseDefaultValue$5(col.default_value),
+				foreign_key_schema: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_schema) ?? null,
+				foreign_key_table: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_table) ?? null,
+				foreign_key_column: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_column) ?? null
+			};
+		});
+		if (table && column) return parsedColumms[0];
+		return parsedColumms;
+	}
+	/**
+	* Check if the given table contains the given column
+	*/
+	async hasColumn(table, column) {
+		const subquery = this.knex.select().from("information_schema.columns").whereIn("table_schema", this.explodedSchema).andWhere({
+			table_name: table,
+			column_name: column
+		});
+		const record = await this.knex.select(this.knex.raw("exists (?)", [subquery])).first();
+		return (record === null || record === void 0 ? void 0 : record.exists) || false;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const result = await this.knex.select("information_schema.key_column_usage.column_name").from("information_schema.key_column_usage").leftJoin("information_schema.table_constraints", function() {
+			this.on("information_schema.table_constraints.constraint_name", "=", "information_schema.key_column_usage.constraint_name").andOn("information_schema.table_constraints.table_name", "=", "information_schema.key_column_usage.table_name");
+		}).whereIn("information_schema.table_constraints.table_schema", this.explodedSchema).andWhere({
+			"information_schema.table_constraints.constraint_type": "PRIMARY KEY",
+			"information_schema.table_constraints.table_name": table
+		});
+		return result.length > 0 ? result.length === 1 ? result[0].column_name : result.map((r) => r.column_name) : null;
+	}
+	async foreignKeys(table) {
+		const rowsWithoutQuotes = (await this.knex.raw(`
+      SELECT
+        c.conrelid::regclass::text AS "table",
+        (
+          SELECT
+            STRING_AGG(a.attname, ','
+            ORDER BY
+              t.seq)
+          FROM (
+            SELECT
+              ROW_NUMBER() OVER (ROWS UNBOUNDED PRECEDING) AS seq,
+              attnum
+            FROM
+              UNNEST(c.conkey) AS t (attnum)) AS t
+          INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid
+            AND a.attnum = t.attnum) AS "column",
+        tt.name AS foreign_key_table,
+        (
+          SELECT
+            STRING_AGG(QUOTE_IDENT(a.attname), ','
+            ORDER BY
+              t.seq)
+          FROM (
+            SELECT
+              ROW_NUMBER() OVER (ROWS UNBOUNDED PRECEDING) AS seq,
+              attnum
+            FROM
+              UNNEST(c.confkey) AS t (attnum)) AS t
+        INNER JOIN pg_attribute AS a ON a.attrelid = c.confrelid
+          AND a.attnum = t.attnum) AS foreign_key_column,
+        tt.schema AS foreign_key_schema,
+        c.conname AS constraint_name,
+        CASE confupdtype
+        WHEN 'r' THEN
+          'RESTRICT'
+        WHEN 'c' THEN
+          'CASCADE'
+        WHEN 'n' THEN
+          'SET NULL'
+        WHEN 'd' THEN
+          'SET DEFAULT'
+        WHEN 'a' THEN
+          'NO ACTION'
+        ELSE
+          NULL
+        END AS on_update,
+        CASE confdeltype
+        WHEN 'r' THEN
+          'RESTRICT'
+        WHEN 'c' THEN
+          'CASCADE'
+        WHEN 'n' THEN
+          'SET NULL'
+        WHEN 'd' THEN
+          'SET DEFAULT'
+        WHEN 'a' THEN
+          'NO ACTION'
+        ELSE
+          NULL
+        END AS
+        on_delete
+      FROM
+        pg_catalog.pg_constraint AS c
+        INNER JOIN (
+          SELECT
+            pg_class.oid,
+            QUOTE_IDENT(pg_namespace.nspname) AS SCHEMA,
+            QUOTE_IDENT(pg_class.relname) AS name
+          FROM
+            pg_class
+            INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid) AS tf ON tf.oid = c.conrelid
+        INNER JOIN (
+          SELECT
+            pg_class.oid,
+            QUOTE_IDENT(pg_namespace.nspname) AS SCHEMA,
+            QUOTE_IDENT(pg_class.relname) AS name
+          FROM
+            pg_class
+            INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid) AS tt ON tt.oid = c.confrelid
+      WHERE
+        c.contype = 'f';
+    `)).rows.map(stripRowQuotes);
+		if (table) return rowsWithoutQuotes.filter((row) => row.table === table);
+		return rowsWithoutQuotes;
+		function stripRowQuotes(row) {
+			return Object.fromEntries(Object.entries(row).map(([key, value]) => {
+				return [key, stripQuotes(value)];
+			}));
+		}
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/mssql.ts
+function rawColumnToColumn$2(rawColumn) {
+	return {
+		...rawColumn,
+		default_value: parseDefaultValue$4(rawColumn.default_value),
+		generation_expression: rawColumn.generation_expression || null,
+		is_generated: !!rawColumn.is_generated,
+		is_unique: rawColumn.is_unique === true,
+		is_primary_key: rawColumn.is_primary_key === true,
+		is_nullable: rawColumn.is_nullable === "YES",
+		has_auto_increment: rawColumn.has_auto_increment === "YES",
+		numeric_precision: rawColumn.numeric_precision || null,
+		numeric_scale: rawColumn.numeric_scale || null,
+		max_length: parseMaxLength(rawColumn)
+	};
+	function parseMaxLength(rawColumn$1) {
+		const max_length = Number(rawColumn$1.max_length);
+		if (Number.isNaN(max_length) || rawColumn$1.max_length === null || rawColumn$1.max_length === void 0) return null;
+		if ([
+			"nvarchar",
+			"nchar",
+			"ntext"
+		].includes(rawColumn$1.data_type)) return max_length === -1 ? max_length : max_length / 2;
+		return max_length;
+	}
+}
+function parseDefaultValue$4(value) {
+	if (value === null) return null;
+	while (value.startsWith("(") && value.endsWith(")")) value = value.slice(1, -1);
+	if (value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var MSSQL = class {
+	knex;
+	_schema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		return this;
+	}
+	get schema() {
+		return this._schema || "dbo";
+	}
+	set schema(value) {
+		this._schema = value;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("TABLE_NAME").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_SCHEMA: this.schema
+		})).map(({ TABLE_NAME }) => TABLE_NAME);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("TABLE_NAME", "TABLE_SCHEMA", "TABLE_CATALOG", "TABLE_TYPE").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_SCHEMA: this.schema
+		});
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).first();
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				catalog: rawTable.TABLE_CATALOG
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				catalog: rawTable.TABLE_CATALOG
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.count({ count: "*" }).from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			table_name: table,
+			TABLE_SCHEMA: this.schema
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("TABLE_NAME", "COLUMN_NAME").from("INFORMATION_SCHEMA.COLUMNS").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_SCHEMA: this.schema
+		});
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return (await query).map(({ TABLE_NAME, COLUMN_NAME }) => ({
+			table: TABLE_NAME,
+			column: COLUMN_NAME
+		}));
+	}
+	async columnInfo(table, column) {
+		const dbName = this.knex.client.database();
+		const query = this.knex.select(this.knex.raw(`
+        [o].[name] AS [table],
+        [c].[name] AS [name],
+        [t].[name] AS [data_type],
+        [c].[max_length] AS [max_length],
+        [c].[precision] AS [numeric_precision],
+        [c].[scale] AS [numeric_scale],
+        CASE WHEN [c].[is_nullable] = 0 THEN
+          'NO'
+        ELSE
+          'YES'
+        END AS [is_nullable],
+        object_definition ([c].[default_object_id]) AS [default_value],
+        [i].[is_primary_key],
+        [i].[is_unique],
+        CASE [c].[is_identity]
+        WHEN 1 THEN
+          'YES'
+        ELSE
+          'NO'
+        END AS [has_auto_increment],
+        OBJECT_NAME ([fk].[referenced_object_id]) AS [foreign_key_table],
+        COL_NAME ([fk].[referenced_object_id],
+          [fk].[referenced_column_id]) AS [foreign_key_column],
+        [cc].[is_computed] as [is_generated],
+        [cc].[definition] as [generation_expression]`)).from(this.knex.raw("??.[sys].[columns] [c]", [dbName])).joinRaw("JOIN [sys].[types] [t] ON [c].[user_type_id] = [t].[user_type_id]").joinRaw("JOIN [sys].[tables] [o] ON [o].[object_id] = [c].[object_id]").joinRaw("JOIN [sys].[schemas] [s] ON [s].[schema_id] = [o].[schema_id]").joinRaw("LEFT JOIN [sys].[computed_columns] AS [cc] ON [cc].[object_id] = [c].[object_id] AND [cc].[column_id] = [c].[column_id]").joinRaw("LEFT JOIN [sys].[foreign_key_columns] AS [fk] ON [fk].[parent_object_id] = [c].[object_id] AND [fk].[parent_column_id] = [c].[column_id]").joinRaw(`LEFT JOIN (
+          SELECT
+            [ic].[object_id],
+            [ic].[column_id],
+            [ix].[is_unique],
+            [ix].[is_primary_key],
+            MAX([ic].[index_column_id]) OVER(partition by [ic].[index_id], [ic].[object_id]) AS index_column_count,
+            ROW_NUMBER() OVER (
+              PARTITION BY [ic].[object_id], [ic].[column_id]
+              ORDER BY [ix].[is_primary_key] DESC, [ix].[is_unique] DESC
+            ) AS index_priority
+          FROM
+            [sys].[index_columns] [ic]
+          JOIN [sys].[indexes] AS [ix] ON [ix].[object_id] = [ic].[object_id]
+            AND [ix].[index_id] = [ic].[index_id]
+        ) AS [i]
+        ON [i].[object_id] = [c].[object_id]
+        AND [i].[column_id] = [c].[column_id]
+        AND ISNULL([i].[index_column_count], 1) = 1
+        AND ISNULL([i].[index_priority], 1) = 1`).where({ "s.name": this.schema });
+		if (table) query.andWhere({ "o.name": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.name": column }).first();
+			return rawColumnToColumn$2(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn$2);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.count({ count: "*" }).from("INFORMATION_SCHEMA.COLUMNS").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_NAME: table,
+			COLUMN_NAME: column,
+			TABLE_SCHEMA: this.schema
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const results = await this.knex.raw(`SELECT
+         Col.Column_Name
+       FROM
+         INFORMATION_SCHEMA.TABLE_CONSTRAINTS Tab,
+         INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE Col
+       WHERE
+         Col.Constraint_Name = Tab.Constraint_Name
+         AND Col.Table_Name = Tab.Table_Name
+         AND Constraint_Type = 'PRIMARY KEY'
+         AND Col.Table_Name = ?
+         AND Tab.CONSTRAINT_SCHEMA = ?`, [table, this.schema]);
+		return results.length > 0 ? results.length === 1 ? results[0]["Column_Name"] : results.map((row) => row["Column_Name"]) : null;
+	}
+	async foreignKeys(table) {
+		const result = await this.knex.raw(`
+      SELECT
+        OBJECT_NAME (fc.parent_object_id) AS "table",
+          COL_NAME (fc.parent_object_id, fc.parent_column_id) AS "column",
+          OBJECT_SCHEMA_NAME (f.referenced_object_id) AS foreign_key_schema,
+          OBJECT_NAME (f.referenced_object_id) AS foreign_key_table,
+          COL_NAME (fc.referenced_object_id, fc.referenced_column_id) AS foreign_key_column,
+          f.name AS constraint_name,
+          REPLACE(f.update_referential_action_desc, '_', ' ') AS on_update,
+          REPLACE(f.delete_referential_action_desc, '_', ' ') AS on_delete
+      FROM
+        sys.foreign_keys AS f
+        INNER JOIN sys.foreign_key_columns AS fc ON f.OBJECT_ID = fc.constraint_object_id
+      WHERE
+        OBJECT_SCHEMA_NAME (f.parent_object_id) = ?;
+    `, [this.schema]);
+		if (table) return result === null || result === void 0 ? void 0 : result.filter((row) => row.table === table);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/mysql.ts
+function rawColumnToColumn$1(rawColumn) {
+	var _rawColumn$EXTRA;
+	let dataType = rawColumn.COLUMN_TYPE.replace(/\(.*?\)/, "");
+	if (rawColumn.COLUMN_TYPE.startsWith("tinyint(1)")) dataType = "boolean";
+	return {
+		name: rawColumn.COLUMN_NAME,
+		table: rawColumn.TABLE_NAME,
+		collation: rawColumn.COLLATION_NAME,
+		data_type: dataType,
+		default_value: parseDefaultValue$3(rawColumn.COLUMN_DEFAULT),
+		generation_expression: rawColumn.GENERATION_EXPRESSION || null,
+		max_length: rawColumn.CHARACTER_MAXIMUM_LENGTH,
+		numeric_precision: rawColumn.NUMERIC_PRECISION,
+		numeric_scale: rawColumn.NUMERIC_SCALE,
+		is_generated: !!((_rawColumn$EXTRA = rawColumn.EXTRA) === null || _rawColumn$EXTRA === void 0 ? void 0 : _rawColumn$EXTRA.endsWith("GENERATED")),
+		is_nullable: rawColumn.IS_NULLABLE === "YES",
+		is_unique: rawColumn.COLUMN_KEY === "UNI",
+		is_primary_key: rawColumn.CONSTRAINT_NAME === "PRIMARY" || rawColumn.COLUMN_KEY === "PRI",
+		has_auto_increment: rawColumn.EXTRA === "auto_increment",
+		foreign_key_column: rawColumn.REFERENCED_COLUMN_NAME,
+		foreign_key_table: rawColumn.REFERENCED_TABLE_NAME,
+		comment: rawColumn.COLUMN_COMMENT
+	};
+}
+function parseDefaultValue$3(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var MySQL = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("TABLE_NAME").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_SCHEMA: this.knex.client.database()
+		})).map(({ TABLE_NAME }) => TABLE_NAME);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("TABLE_NAME", "ENGINE", "TABLE_SCHEMA", "TABLE_COLLATION", "TABLE_COMMENT").from("information_schema.tables").where({
+			table_schema: this.knex.client.database(),
+			table_type: "BASE TABLE"
+		});
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).first();
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				comment: rawTable.TABLE_COMMENT,
+				collation: rawTable.TABLE_COLLATION,
+				engine: rawTable.ENGINE
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				comment: rawTable.TABLE_COMMENT,
+				collation: rawTable.TABLE_COLLATION,
+				engine: rawTable.ENGINE
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.count({ count: "*" }).from("information_schema.tables").where({
+			table_schema: this.knex.client.database(),
+			table_name: table
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("TABLE_NAME", "COLUMN_NAME").from("INFORMATION_SCHEMA.COLUMNS").where({ TABLE_SCHEMA: this.knex.client.database() });
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return (await query).map(({ TABLE_NAME, COLUMN_NAME }) => ({
+			table: TABLE_NAME,
+			column: COLUMN_NAME
+		}));
+	}
+	async columnInfo(table, column) {
+		const query = this.knex.select("c.TABLE_NAME", "c.COLUMN_NAME", "c.COLUMN_DEFAULT", "c.COLUMN_TYPE", "c.CHARACTER_MAXIMUM_LENGTH", "c.IS_NULLABLE", "c.COLUMN_KEY", "c.EXTRA", "c.COLLATION_NAME", "c.COLUMN_COMMENT", "c.NUMERIC_PRECISION", "c.NUMERIC_SCALE", "c.GENERATION_EXPRESSION", "fk.REFERENCED_TABLE_NAME", "fk.REFERENCED_COLUMN_NAME", "fk.CONSTRAINT_NAME", "rc.UPDATE_RULE", "rc.DELETE_RULE", "rc.MATCH_OPTION").from("INFORMATION_SCHEMA.COLUMNS as c").leftJoin("INFORMATION_SCHEMA.KEY_COLUMN_USAGE as fk", function() {
+			this.on("c.TABLE_NAME", "=", "fk.TABLE_NAME").andOn("fk.COLUMN_NAME", "=", "c.COLUMN_NAME").andOn("fk.CONSTRAINT_SCHEMA", "=", "c.TABLE_SCHEMA");
+		}).leftJoin("INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS as rc", function() {
+			this.on("rc.TABLE_NAME", "=", "fk.TABLE_NAME").andOn("rc.CONSTRAINT_NAME", "=", "fk.CONSTRAINT_NAME").andOn("rc.CONSTRAINT_SCHEMA", "=", "fk.CONSTRAINT_SCHEMA");
+		}).where({ "c.TABLE_SCHEMA": this.knex.client.database() });
+		if (table) query.andWhere({ "c.TABLE_NAME": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.column_name": column }).first();
+			return rawColumnToColumn$1(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn$1).sort((column$1) => +!column$1.foreign_key_column).filter((column$1, index, records) => {
+			return records.findIndex((_column) => {
+				return column$1.name === _column.name && column$1.table === _column.table;
+			}) === index;
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.count("*", { as: "count" }).from("information_schema.columns").where({
+			table_schema: this.knex.client.database(),
+			table_name: table,
+			column_name: column
+		}).first();
+		return !!(result && result.count);
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const results = await this.knex.raw("SHOW KEYS FROM ?? WHERE Key_name = 'PRIMARY'", table);
+		if (results && results.length && results[0].length) {
+			if (results[0].length === 1) return results[0][0]["Column_name"];
+			return results[0].map((row) => row["Column_name"]);
+		}
+		return null;
+	}
+	async foreignKeys(table) {
+		const query = this.knex.select("rc.TABLE_NAME AS table", "kcu.COLUMN_NAME AS column", "rc.REFERENCED_TABLE_NAME AS foreign_key_table", "kcu.REFERENCED_COLUMN_NAME AS foreign_key_column", "rc.CONSTRAINT_NAME AS constraint_name", "rc.UPDATE_RULE AS on_update", "rc.DELETE_RULE AS on_delete").from("information_schema.referential_constraints AS rc").leftJoin("information_schema.key_column_usage AS kcu ", function() {
+			this.on("rc.CONSTRAINT_NAME", "=", "kcu.CONSTRAINT_NAME").andOn("kcu.CONSTRAINT_SCHEMA", "=", "rc.CONSTRAINT_SCHEMA");
+		}).where({ "rc.CONSTRAINT_SCHEMA": this.knex.client.database() });
+		if (table) query.andWhere({ "rc.TABLE_NAME": table });
+		return await query;
+	}
+	async uniqueConstraints(table) {
+		const { knex: knex$1 } = this;
+		const query = knex$1.select("stat.table_name AS table_name", "stat.index_name AS constraint_name", knex$1.raw("group_concat(stat.column_name ORDER BY stat.seq_in_index separator ', ') AS columns")).from("information_schema.statistics stat").join("information_schema.table_constraints tco", function() {
+			this.on("stat.table_schema", "=", "tco.table_schema").andOn("stat.table_name", "=", "tco.table_name").andOn("stat.index_name", "=", "tco.constraint_name");
+		}).where("stat.non_unique", "=", 0).andWhere("tco.constraint_type", "=", "UNIQUE").andWhere("stat.table_schema", knex$1.client.database()).groupBy([
+			"stat.table_name",
+			"stat.index_name",
+			"tco.constraint_type"
+		]);
+		if (table) query.andWhere("stat.table_name", "=", table);
+		return (await query).map((v) => ({
+			table: v.table_name,
+			constraint_name: v.constraint_name,
+			columns: v.columns
+		}));
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/oracledb.ts
+/**
+* NOTE: Use previous optimizer for better data dictionary performance.
+*/
+const OPTIMIZER_FEATURES = "11.2.0.4";
+function rawColumnToColumn(rawColumn) {
+	const is_generated = rawColumn.VIRTUAL_COLUMN === "YES";
+	const default_value = parseDefaultValue$2(rawColumn.DATA_DEFAULT);
+	return {
+		name: rawColumn.COLUMN_NAME,
+		table: rawColumn.TABLE_NAME,
+		data_type: rawColumn.DATA_TYPE,
+		default_value: !is_generated ? default_value : null,
+		generation_expression: is_generated ? default_value : null,
+		max_length: rawColumn.DATA_LENGTH,
+		numeric_precision: rawColumn.DATA_PRECISION,
+		numeric_scale: rawColumn.DATA_SCALE,
+		is_generated: rawColumn.VIRTUAL_COLUMN === "YES",
+		is_nullable: rawColumn.NULLABLE === "Y",
+		is_unique: rawColumn.CONSTRAINT_TYPE === "U",
+		is_primary_key: rawColumn.CONSTRAINT_TYPE === "P",
+		has_auto_increment: rawColumn.IDENTITY_COLUMN === "YES",
+		foreign_key_column: rawColumn.REFERENCED_COLUMN_NAME,
+		foreign_key_table: rawColumn.REFERENCED_TABLE_NAME,
+		comment: rawColumn.COLUMN_COMMENT
+	};
+}
+function parseDefaultValue$2(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	if (value === "CURRENT_TIMESTAMP ") return "CURRENT_TIMESTAMP";
+	return stripQuotes(value);
+}
+var oracleDB = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "TABLE_NAME" "name"
+        `)).from("USER_TABLES")).map(({ name }) => name);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "TABLE_NAME" "name"
+        `)).from("USER_TABLES");
+		if (table) return await query.andWhere({ TABLE_NAME: table }).first();
+		return await query;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            COUNT(*) "count"
+        `)).from("USER_TABLES").where({ TABLE_NAME: table }).first();
+		return !!(result === null || result === void 0 ? void 0 : result.count);
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') NO_QUERY_TRANSFORMATION */
+            "TABLE_NAME" "table",
+            "COLUMN_NAME" "column"
+        `)).from("USER_TAB_COLS").where({ HIDDEN_COLUMN: "NO" });
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return await query;
+	}
+	async columnInfo(table, column) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const query = this.knex.with("uc", this.knex.raw(`
+          SELECT /*+ MATERIALIZE */
+            "uc"."TABLE_NAME",
+            "ucc"."COLUMN_NAME",
+            "uc"."CONSTRAINT_NAME",
+            "uc"."CONSTRAINT_TYPE",
+            "uc"."R_CONSTRAINT_NAME",
+            COUNT(*) OVER(
+              PARTITION BY
+                "uc"."CONSTRAINT_NAME"
+            ) "CONSTRAINT_COUNT", 
+            ROW_NUMBER() OVER(
+              PARTITION BY
+                "uc"."TABLE_NAME", 
+                "ucc"."COLUMN_NAME" 
+              ORDER BY 
+                "uc"."CONSTRAINT_TYPE"
+            ) "CONSTRAINT_PRIORITY"
+          FROM "USER_CONSTRAINTS" "uc"
+          INNER JOIN "USER_CONS_COLUMNS" "ucc"
+            ON "uc"."CONSTRAINT_NAME" = "ucc"."CONSTRAINT_NAME"
+          WHERE "uc"."CONSTRAINT_TYPE" IN ('P', 'U', 'R')
+      `)).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "c"."TABLE_NAME", 
+            "c"."COLUMN_NAME", 
+            "c"."DATA_DEFAULT", 
+            "c"."DATA_TYPE", 
+            "c"."DATA_LENGTH", 
+            "c"."DATA_PRECISION", 
+            "c"."DATA_SCALE", 
+            "c"."NULLABLE", 
+            "c"."IDENTITY_COLUMN", 
+            "c"."VIRTUAL_COLUMN", 
+            "cm"."COMMENTS" "COLUMN_COMMENT", 
+            "ct"."CONSTRAINT_TYPE",
+            "fk"."TABLE_NAME" "REFERENCED_TABLE_NAME",
+            "fk"."COLUMN_NAME" "REFERENCED_COLUMN_NAME"
+          FROM "USER_TAB_COLS" "c" 
+          LEFT JOIN "USER_COL_COMMENTS" "cm"
+            ON "c"."TABLE_NAME" = "cm"."TABLE_NAME" 
+            AND "c"."COLUMN_NAME" = "cm"."COLUMN_NAME" 
+          LEFT JOIN "uc" "ct"
+            ON "c"."TABLE_NAME" = "ct"."TABLE_NAME" 
+            AND "c"."COLUMN_NAME" = "ct"."COLUMN_NAME"
+            AND "ct"."CONSTRAINT_COUNT" = 1 
+            AND "ct"."CONSTRAINT_PRIORITY" = 1
+          LEFT JOIN "uc" "fk"
+            ON "ct"."R_CONSTRAINT_NAME" = "fk"."CONSTRAINT_NAME"
+        `)).where({ "c.HIDDEN_COLUMN": "NO" });
+		if (table) query.andWhere({ "c.TABLE_NAME": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.COLUMN_NAME": column }).first();
+			return rawColumnToColumn(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') NO_QUERY_TRANSFORMATION */
+            COUNT(*) "count"
+        `)).from("USER_TAB_COLS").where({
+			TABLE_NAME: table,
+			COLUMN_NAME: column,
+			HIDDEN_COLUMN: "NO"
+		}).first();
+		return !!(result === null || result === void 0 ? void 0 : result.count);
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const result = await this.knex.with("uc", this.knex.select(this.knex.raw("/*+ MATERIALIZE */ \"CONSTRAINT_NAME\"")).from("USER_CONSTRAINTS").where({
+			TABLE_NAME: table,
+			CONSTRAINT_TYPE: "P"
+		})).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "ucc"."COLUMN_NAME"
+          FROM "USER_CONS_COLUMNS" "ucc"
+          INNER JOIN "uc" "pk"
+            ON "ucc"."CONSTRAINT_NAME" = "pk"."CONSTRAINT_NAME"
+        `));
+		return result.length > 0 ? result.length === 1 ? result[0].COLUMN_NAME : result.map((r) => r.COLUMN_NAME) : null;
+	}
+	async foreignKeys(table) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const query = this.knex.with("ucc", this.knex.raw(`
+          SELECT /*+ MATERIALIZE */
+            "TABLE_NAME",
+            "COLUMN_NAME",
+            "CONSTRAINT_NAME"
+          FROM "USER_CONS_COLUMNS"
+        `)).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "uc"."TABLE_NAME" "table", 
+            "fcc"."COLUMN_NAME" "column", 
+            "rcc"."TABLE_NAME" AS "foreign_key_table",
+            "rcc"."COLUMN_NAME" AS "foreign_key_column",
+            "uc"."CONSTRAINT_NAME" "constraint_name", 
+            NULL as "on_update", 
+            "uc"."DELETE_RULE" "on_delete" 
+          FROM "USER_CONSTRAINTS" "uc" 
+          INNER JOIN "ucc" "fcc"
+            ON "uc"."CONSTRAINT_NAME" = "fcc"."CONSTRAINT_NAME"
+          INNER JOIN "ucc" "rcc"
+            ON "uc"."R_CONSTRAINT_NAME" = "rcc"."CONSTRAINT_NAME"
+      `)).where({ "uc.CONSTRAINT_TYPE": "R" });
+		if (table) query.andWhere({ "uc.TABLE_NAME": table });
+		return await query;
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/postgres.ts
+/**
+* Converts Postgres default value to JS
+* Eg `'example'::character varying` => `example`
+*/
+function parseDefaultValue$1(value) {
+	if (value === null) return null;
+	if (value.startsWith("nextval(")) return value;
+	value = value.split("::")[0];
+	if (value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var Postgres = class {
+	knex;
+	schema;
+	explodedSchema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+		const config = knex$1.client.config;
+		if (!config.searchPath) {
+			this.schema = "public";
+			this.explodedSchema = [this.schema];
+		} else if (typeof config.searchPath === "string") {
+			this.schema = config.searchPath;
+			this.explodedSchema = [config.searchPath];
+		} else {
+			this.schema = config.searchPath[0];
+			this.explodedSchema = config.searchPath;
+		}
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		this.explodedSchema = [this.schema];
+		return this;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        rel.relname AS name
+      FROM
+        pg_class rel
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relkind = 'r'
+      ORDER BY rel.relname
+    `)).rows.map((row) => row.name);
+	}
+	async tableInfo(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		const result = await this.knex.raw(`
+      SELECT
+        rel.relnamespace::regnamespace::text AS schema,
+        rel.relname AS name,
+        des.description AS comment
+      FROM
+        pg_class rel
+      LEFT JOIN pg_description des ON rel.oid = des.objoid AND des.objsubid = 0
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+        AND rel.relkind = 'r'
+      ORDER BY rel.relname
+    `, bindings);
+		if (table) return result.rows[0];
+		return result.rows;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        rel.relname AS name
+      FROM
+        pg_class rel
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relkind = 'r'
+        AND rel.relname = ?
+      ORDER BY rel.relname
+    `, [table])).rows.length > 0;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const bindings = [];
+		if (table) bindings.push(table);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        att.attname AS column,
+        rel.relname AS table
+      FROM
+        pg_attribute att
+        LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+        AND rel.relkind = 'r'
+        AND att.attnum > 0
+        AND NOT att.attisdropped;
+    `, bindings)).rows;
+	}
+	async columnInfo(table, column) {
+		var _versionResponse$rows;
+		const { knex: knex$1 } = this;
+		const bindings = [];
+		if (table) bindings.push(table);
+		if (column) bindings.push(column);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const majorVersion = ((_versionResponse$rows = (await this.knex.raw("SHOW server_version")).rows) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows[0]) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows.server_version) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows.split(".")) === null || _versionResponse$rows === void 0 ? void 0 : _versionResponse$rows[0]) ?? 10;
+		let generationSelect = `
+      NULL AS generation_expression,
+      pg_get_expr(ad.adbin, ad.adrelid) AS default_value,
+      FALSE AS is_generated,
+    `;
+		if (Number(majorVersion) >= 12) generationSelect = `
+        CASE WHEN att.attgenerated = 's' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS generation_expression,
+        CASE WHEN att.attgenerated = '' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS default_value,
+        att.attgenerated = 's' AS is_generated,
+      `;
+		const [columns, constraints] = await Promise.all([knex$1.raw(`
+        SELECT
+        	att.attname AS name,
+          rel.relname AS table,
+          rel.relnamespace::regnamespace::text as schema,
+          att.atttypid::regtype::text AS data_type,
+          NOT att.attnotnull AS is_nullable,
+          ${generationSelect}
+          CASE
+            WHEN att.atttypid IN (1042, 1043) THEN (att.atttypmod - 4)::int4
+            WHEN att.atttypid IN (1560, 1562) THEN (att.atttypmod)::int4
+            ELSE NULL
+          END AS max_length,
+          des.description AS comment,
+          CASE att.atttypid
+            WHEN 21 THEN 16
+            WHEN 23 THEN 32
+            WHEN 20 THEN 64
+            WHEN 1700 THEN
+              CASE WHEN atttypmod = -1 THEN NULL
+                ELSE (((atttypmod - 4) >> 16) & 65535)::int4
+              END
+            WHEN 700 THEN 24
+            WHEN 701 THEN 53
+            ELSE NULL
+          END AS numeric_precision,
+          CASE
+            WHEN atttypid IN (21, 23, 20) THEN 0
+            WHEN atttypid = 1700 THEN
+              CASE
+                WHEN atttypmod = -1 THEN NULL
+                ELSE ((atttypmod - 4) & 65535)::int4
+              END
+            ELSE null
+          END AS numeric_scale
+        FROM
+          pg_attribute att
+          LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+          LEFT JOIN pg_attrdef ad ON (att.attrelid, att.attnum) = (ad.adrelid, ad.adnum)
+          LEFT JOIN pg_description des ON (att.attrelid, att.attnum) = (des.objoid, des.objsubid)
+        WHERE
+          rel.relnamespace IN (${schemaIn})
+          ${table ? "AND rel.relname = ?" : ""}
+          ${column ? "AND att.attname = ?" : ""}
+          AND rel.relkind = 'r'
+          AND att.attnum > 0
+          AND NOT att.attisdropped
+        ORDER BY rel.relname, att.attnum;
+      `, bindings), knex$1.raw(`
+        SELECT
+          con.contype AS type,
+          rel.relname AS table,
+          att.attname AS column,
+          frel.relnamespace::regnamespace::text AS foreign_key_schema,
+          frel.relname AS foreign_key_table,
+          fatt.attname AS foreign_key_column,
+          CASE
+            WHEN con.contype = 'p' THEN pg_get_serial_sequence(att.attrelid::regclass::text, att.attname) != ''
+            ELSE NULL
+          END AS has_auto_increment
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+        LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+        WHERE con.connamespace IN (${schemaIn})
+          AND array_length(con.conkey, 1) <= 1
+          AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+          ${table ? "AND rel.relname = ?" : ""}
+          ${column ? "AND att.attname = ?" : ""}
+        `, bindings)]);
+		const parsedColumms = columns.rows.map((col) => {
+			const constraintsForColumn = constraints.rows.filter((constraint) => constraint.table === col.table && constraint.column === col.name);
+			const foreignKeyConstraint = constraintsForColumn.find((constraint) => constraint.type === "f");
+			return {
+				...col,
+				is_unique: constraintsForColumn.some((constraint) => ["u", "p"].includes(constraint.type)),
+				is_primary_key: constraintsForColumn.some((constraint) => constraint.type === "p"),
+				has_auto_increment: constraintsForColumn.some((constraint) => constraint.has_auto_increment),
+				default_value: parseDefaultValue$1(col.default_value),
+				foreign_key_schema: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_schema) ?? null,
+				foreign_key_table: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_table) ?? null,
+				foreign_key_column: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_column) ?? null
+			};
+		});
+		if (table && column) return parsedColumms[0];
+		return parsedColumms;
+	}
+	/**
+	* Check if the given table contains the given column
+	*/
+	async hasColumn(table, column) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        att.attname AS column,
+        rel.relname AS table
+      FROM
+        pg_attribute att
+        LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relname = ?
+        AND att.attname = ?
+        AND rel.relkind = 'r'
+        AND att.attnum > 0
+        AND NOT att.attisdropped;
+    `, [table, column])).rows;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const result = await this.knex.raw(`
+      SELECT
+          att.attname AS column
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ANY(con.conkey)
+        WHERE con.connamespace IN (${schemaIn})
+          AND con.contype = 'p'
+          AND rel.relname = ?
+    `, [table]);
+		return result.rows.length !== 0 ? result.rows.length === 1 ? result.rows[0].column : result.rows.map((r) => r.column) : null;
+	}
+	async foreignKeys(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		return (await this.knex.raw(`
+       SELECT
+          con.conname AS constraint_name,
+          rel.relname AS table,
+          att.attname AS column,
+          frel.relnamespace::regnamespace::text AS foreign_key_schema,
+          frel.relname AS foreign_key_table,
+          fatt.attname AS foreign_key_column,
+          CASE con.confupdtype
+            WHEN 'r' THEN
+              'RESTRICT'
+            WHEN 'c' THEN
+              'CASCADE'
+            WHEN 'n' THEN
+              'SET NULL'
+            WHEN 'd' THEN
+              'SET DEFAULT'
+            WHEN 'a' THEN
+              'NO ACTION'
+            ELSE
+              NULL
+          END AS on_update,
+          CASE con.confdeltype
+            WHEN 'r' THEN
+              'RESTRICT'
+            WHEN 'c' THEN
+              'CASCADE'
+            WHEN 'n' THEN
+              'SET NULL'
+            WHEN 'd' THEN
+              'SET DEFAULT'
+            WHEN 'a' THEN
+              'NO ACTION'
+            ELSE
+              NULL
+          END AS on_delete
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+        LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+        WHERE con.connamespace IN (${schemaIn})
+          AND array_length(con.conkey, 1) <= 1
+          AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+          AND con.contype = 'f'
+          ${table ? "AND rel.relname = ?" : ""}
+    `, bindings)).rows;
+	}
+	async uniqueConstraints(table) {
+		const { knex: knex$1 } = this;
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		return (await knex$1.raw(`
+      SELECT
+        con.conrelid::regclass AS table_name,
+        con.conname AS constraint_name,
+        array_agg(a.attname ORDER BY k.n) AS columns
+      FROM
+        pg_constraint AS con
+      CROSS JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(con,n)
+      LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+      JOIN pg_attribute AS a ON a.attnum = k.con AND a.attrelid = con.conrelid
+      WHERE con.contype = 'u'
+        AND con.connamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+      GROUP BY con.oid, con.conrelid, con.conname;
+      `, bindings)).rows.map((v) => {
+			const columns = Array.isArray(v.columns) ? v.columns : v.columns.substring(1, v.columns.length - 1).split(",");
+			return {
+				table: v.table_name,
+				constraint_name: v.constraint_name,
+				columns
+			};
+		});
+	}
+};
+
+//#endregion
+//#region src/inspector/utils/extract-max-length.ts
+/**
+* Extracts the length value out of a given datatype
+* For example: `varchar(32)` => 32
+*/
+function extractMaxLength(type) {
+	const matches = /\(([^)]+)\)/.exec(type);
+	if (matches && matches.length > 0 && matches[1]) return Number(matches[1]);
+	return null;
+}
+
+//#endregion
+//#region src/inspector/utils/extract-type.ts
+/**
+* Extracts the type out of a given datatype
+* For example: `varchar(32)` => varchar
+*/
+function extractType(type) {
+	return type.replace(/[^a-zA-Z]/g, "").toLowerCase();
+}
+
+//#endregion
+//#region src/inspector/dialects/sqlite.ts
+function parseDefaultValue(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var SQLite = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("name").from("sqlite_master").whereRaw("type = 'table' AND name NOT LIKE 'sqlite_%'")).map(({ name }) => name);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("name", "sql").from("sqlite_master").where({ type: "table" }).andWhereRaw("name NOT LIKE 'sqlite_%'");
+		if (table) query.andWhere({ name: table });
+		let records = await query;
+		records = records.map((table$1) => ({
+			name: table$1.name,
+			sql: table$1.sql
+		}));
+		if (table) return records[0];
+		return records;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		return (await this.knex.select(1).from("sqlite_master").where({
+			type: "table",
+			name: table
+		})).length > 0;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		if (table) return (await this.knex.raw("PRAGMA table_xinfo(??)", table)).map((column) => ({
+			table,
+			column: column.name
+		}));
+		const tables = await this.tables();
+		const columnsPerTable = await Promise.all(tables.map(async (table$1) => await this.columns(table$1)));
+		return flatten(columnsPerTable);
+	}
+	async columnInfo(table, column) {
+		const getColumnsForTable = async (table$1) => {
+			const tablesWithAutoIncrementPrimaryKeys = (await this.knex.select("name").from("sqlite_master").whereRaw("sql LIKE '%AUTOINCREMENT%'")).map(({ name }) => name);
+			const columns = await this.knex.raw("PRAGMA table_xinfo(??)", table$1);
+			const foreignKeys = await this.knex.raw("PRAGMA foreign_key_list(??)", table$1);
+			const indexList = await this.knex.raw("PRAGMA index_list(??)", table$1);
+			const indexInfoList = await Promise.all(indexList.map((index) => this.knex.raw("PRAGMA index_info(??)", index.name)));
+			return columns.map((raw) => {
+				const foreignKey = foreignKeys.find((fk) => fk.from === raw.name);
+				const indexIndex = indexInfoList.findIndex((list) => list.find((fk) => fk.name === raw.name));
+				const index = indexList[indexIndex];
+				const indexInfo = indexInfoList[indexIndex];
+				return {
+					name: raw.name,
+					table: table$1,
+					data_type: extractType(raw.type),
+					default_value: parseDefaultValue(raw.dflt_value),
+					max_length: extractMaxLength(raw.type),
+					numeric_precision: null,
+					numeric_scale: null,
+					is_generated: raw.hidden !== 0,
+					generation_expression: null,
+					is_nullable: raw.notnull === 0,
+					is_unique: !!(index === null || index === void 0 ? void 0 : index.unique) && (indexInfo === null || indexInfo === void 0 ? void 0 : indexInfo.length) === 1,
+					is_primary_key: raw.pk === 1,
+					has_auto_increment: raw.pk === 1 && tablesWithAutoIncrementPrimaryKeys.includes(table$1),
+					foreign_key_column: (foreignKey === null || foreignKey === void 0 ? void 0 : foreignKey.to) || null,
+					foreign_key_table: (foreignKey === null || foreignKey === void 0 ? void 0 : foreignKey.table) || null
+				};
+			});
+		};
+		if (!table) {
+			const tables = await this.tables();
+			const columnsPerTable = await Promise.all(tables.map(async (table$1) => await getColumnsForTable(table$1)));
+			return flatten(columnsPerTable);
+		}
+		if (table && !column) return await getColumnsForTable(table);
+		return (await getColumnsForTable(table)).find((columnInfo) => columnInfo.name === column);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		let isColumn = false;
+		if ((await this.knex.raw(`SELECT COUNT(*) AS ct FROM pragma_table_xinfo('${table}') WHERE name='${column}'`))[0]["ct"] !== 0) isColumn = true;
+		return isColumn;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const pkColumns = (await this.knex.raw("PRAGMA table_xinfo(??)", table)).filter((col) => col.pk !== 0);
+		return pkColumns.length > 0 ? pkColumns.length === 1 ? pkColumns[0].name : pkColumns.map((col) => col.name) : null;
+	}
+	async foreignKeys(table) {
+		if (table) return (await this.knex.raw("PRAGMA foreign_key_list(??)", table)).map((key) => ({
+			table,
+			column: key.from,
+			foreign_key_table: key.table,
+			foreign_key_column: key.to,
+			on_update: key.on_update,
+			on_delete: key.on_delete,
+			constraint_name: null
+		}));
+		const tables = await this.tables();
+		const keysPerTable = await Promise.all(tables.map(async (table$1) => await this.foreignKeys(table$1)));
+		return flatten(keysPerTable);
+	}
+	async uniqueConstraints(table) {
+		if (table) {
+			const indexList = await this.knex.raw("PRAGMA index_list(??)", table);
+			const indexInfoList = await Promise.all(indexList.map((index) => this.knex.raw("PRAGMA index_info(??)", index.name)));
+			return indexList.filter((i) => i.unique).map((index, i) => {
+				const info = indexInfoList[i];
+				return {
+					table,
+					constraint_name: index.name,
+					columns: info.map((c) => c.name)
+				};
+			});
+		}
+		const tables = await this.tables();
+		const constraintsPerTable = await Promise.all(tables.map(async (table$1) => await this.uniqueConstraints(table$1)));
+		return flatten(constraintsPerTable);
+	}
+};
+
+//#endregion
+//#region src/inspector/index.ts
+var SchemaInspector = class {
+	static inspect(knex$1) {
+		let constructor;
+		switch (knex$1.client.constructor.name) {
+			case "Client_MySQL":
+			case "Client_MySQL2":
+				constructor = MySQL;
+				break;
+			case "Client_PG":
+				constructor = Postgres;
+				break;
+			case "Client_CockroachDB":
+				constructor = CockroachDB;
+				break;
+			case "Client_SQLite3":
+			case "Client_BetterSQLite3":
+				constructor = SQLite;
+				break;
+			case "Client_Oracledb":
+			case "Client_Oracle":
+				constructor = oracleDB;
+				break;
+			case "Client_MSSQL":
+				constructor = MSSQL;
+				break;
+			default: throw Error("Unsupported driver used: " + knex$1.client.constructor.name);
+		}
+		return new constructor(knex$1);
+	}
+};
+
 //#endregion
 //#region src/migrations/migrator.ts
 async function glob(folderPath) {
@@ -3605,14 +5023,14 @@ var Migrator = class {
 		return Object.values(files).filter((file) => !ran.includes(this.getMigrationName(file)));
 	}
 	async runPending(migrations, options = {}) {
-		if (migrations.length === 0) {
-			this.write("Nothing to migrate");
+		if (migrations.length === 0 && !options.quiet) {
+			__h3ravel_shared.Logger.info("INFO: Nothing to migrate.");
 			return;
 		}
 		let batch = await this.repository.getNextBatchNumber();
 		const pretend = options.pretend || false;
 		const step = options.step || false;
-		this.write("Running migrations.");
+		__h3ravel_shared.Logger.info("INFO: Running migrations...");
 		for (const file of migrations) {
 			await this.runUp(file, batch, pretend);
 			if (step) batch++;
@@ -3621,19 +5039,19 @@ var Migrator = class {
 	async runUp(file, batch, _pretend) {
 		const migration = await this.resolvePath(file);
 		const name = this.getMigrationName(file);
-		await this.writeTask(name, () => this.runMigration(migration, "up"));
+		await __h3ravel_shared.TaskManager.taskRunner(name, () => this.runMigration(migration, "up"));
 		await this.repository.log(name, batch);
 	}
 	async runDown(file, migration, _pretend) {
 		const instance = await this.resolvePath(file);
 		const name = this.getMigrationName(file);
-		await this.writeTask(name, () => this.runMigration(instance, "down"));
+		await __h3ravel_shared.TaskManager.taskRunner(name, () => this.runMigration(instance, "down"));
 		await this.repository.delete(migration);
 	}
 	async rollback(paths = [], options = {}) {
 		const migrations = await this.getMigrationsForRollback(options);
 		if (migrations.length === 0) {
-			this.write("Nothing to rollback.");
+			__h3ravel_shared.Logger.info("INFO: Nothing to rollback");
 			return [];
 		}
 		return await this.rollbackMigrations(migrations, paths, options);
@@ -3646,7 +5064,7 @@ var Migrator = class {
 	async rollbackMigrations(migrations, paths, options) {
 		const rolledBack = [];
 		const files = await this.getMigrationFiles(paths);
-		this.write("Rolling back migrations.");
+		__h3ravel_shared.Logger.info("INFO: Rolling back migrations...");
 		for (const migration of migrations) {
 			const file = files[migration.migration];
 			if (!file) {
@@ -3658,11 +5076,35 @@ var Migrator = class {
 		}
 		return rolledBack;
 	}
-	reset(_paths = [], _pretend = false) {
-		this.repository.getRan().then((r) => r.reverse());
-		return [];
+	async reset(paths = [], options, pretend = false) {
+		const migrations = await this.repository.getRan().then((r) => r.map((e) => ({ migration: e })).reverse());
+		if (migrations.length === 0) {
+			if (!options.quiet) __h3ravel_shared.Logger.info("INFO: Nothing to reset.");
+			return [];
+		}
+		return this.resetMigrations(migrations, paths, pretend);
 	}
-	resetMigrations(migrations, paths, pretend = false) {
+	/**
+	* Drop all tables and re-run all migrations
+	* 
+	* @param paths 
+	* @param options 
+	*/
+	async fresh(paths, options) {
+		/** Initialise connections */
+		const connection = this.repository.getConnection().connector;
+		const inspector = SchemaInspector.inspect(connection);
+		await connection.raw("SET foreign_key_checks = 0");
+		/** Drop all existing tables */
+		for (const table of await inspector.tables()) await __h3ravel_shared.TaskManager.taskRunner(`Dropping ${__h3ravel_shared.Logger.parse([[table, "grey"]], "", false)} table`, () => connection.schema.dropTableIfExists(table));
+		await connection.raw("SET foreign_key_checks = 1");
+		/** Create the migration repository */
+		await this.repository.createRepository();
+		console.log();
+		/** Run fresh migrations */
+		await this.run(paths, options);
+	}
+	async resetMigrations(migrations, paths, pretend = false) {
 		return this.rollbackMigrations(migrations, paths, { pretend });
 	}
 	async runMigration(migration, method) {
@@ -3713,7 +5155,7 @@ var Migrator = class {
 		return this.connection;
 	}
 	resolveConnection(connection) {
-		return this.resolver.connection(connection || this.connection);
+		return this.resolver.fire(connection || this.connection);
 	}
 	getRepository() {
 		return this.repository;
@@ -3735,17 +5177,6 @@ var Migrator = class {
 	write(...args) {
 		if (this.output) console.log(...args);
 	}
-	async writeTask(description, task) {
-		const startTime = process.hrtime();
-		let result = false;
-		try {
-			result = await (task || (() => true))();
-		} finally {
-			const endTime = process.hrtime(startTime);
-			const duration = (endTime[0] * 1e9 + endTime[1]) / 1e6;
-			__h3ravel_shared.Logger.twoColumnLog(__h3ravel_shared.Logger.parse([[description, "green"]], "", false), [__h3ravel_shared.Logger.parse([[`${Math.floor(duration)}ms`, "gray"]], "", false), __h3ravel_shared.Logger.parse([[result !== false ? "✔" : "✘", result !== false ? "green" : "red"]], "", false)].join(" "));
-		}
-	}
 };
 var migrator_default = Migrator;
 
@@ -3846,6 +5277,49 @@ var Migrate = class {
 		if (destroyAll) await arquebus$1.destroyAll();
 	}
 	/**
+	* Rollback all database migrations
+	* 
+	* @param config 
+	* @param options 
+	* @param destroyAll 
+	*/
+	async reset(config, options = {}, destroyAll = false) {
+		const { arquebus: arquebus$1, migrator } = await this.setupConnection(config);
+		const paths = await Utils.getMigrationPaths(this.basePath ?? process.cwd(), migrator, config.migrations.path, options.path);
+		await migrator.setOutput(true).reset(paths, {
+			step: options.step || 0,
+			pretend: options.pretend,
+			batch: options.batch || 0,
+			quiet: options.quiet || false
+		});
+		if (destroyAll) await arquebus$1.destroyAll();
+	}
+	/**
+	* Reset and re-run all migrations
+	* 
+	* @param config 
+	* @param options 
+	* @param destroyAll 
+	*/
+	async refresh(config, options = {}, destroyAll = false) {
+		await this.reset(config, Object.assign({}, options, { quiet: true }), false);
+		console.log("");
+		await this.run(config, options, destroyAll);
+	}
+	/**
+	* Drop all tables and re-run all migrations
+	* 
+	* @param config 
+	* @param options 
+	* @param destroyAll 
+	*/
+	async fresh(config, options = {}, destroyAll = false) {
+		const { arquebus: arquebus$1, migrator } = await this.setupConnection(config);
+		const paths = await Utils.getMigrationPaths(this.basePath ?? process.cwd(), migrator, config.migrations.path, options.path);
+		await migrator.setOutput(true).fresh(paths, { pretend: options.pretend });
+		if (destroyAll) await arquebus$1.destroyAll();
+	}
+	/**
 	* Prepares the database for migration
 	* 
 	* @param migrator 
@@ -4122,6 +5596,7 @@ exports.SoftDeletes = soft_deletes_default;
 exports.arquebus = arquebus_default;
 exports.compose = compose;
 exports.defineConfig = defineConfig;
+exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.getAttrMethod = getAttrMethod;
 exports.getAttrName = getAttrName;