@depup/typeorm-extension 4.0.0-depup.0 → 4.2.0-depup.0

package/dist/index.mjs

@@ -5,13 +5,27 @@ import fs from "node:fs";
 import { Brackets, DataSource, InstanceChecker, MigrationExecutor, MssqlParameter, Repository, Table } from "typeorm";
 import { oneOf, read as read$1, readArray, readBool, readInt, toArray, toBool } from "envix";
 import { createMerger } from "smob";
+import { PlatformTools } from "typeorm/platform/PlatformTools.js";
 import { DriverFactory } from "typeorm/driver/DriverFactory.js";
-import { pascalCase } from "pascal-case";
-import process$1 from "node:process";
+import { CommandUtils } from "typeorm/commands/CommandUtils.js";
 import { MigrationGenerateCommand } from "typeorm/commands/MigrationGenerateCommand.js";
+import { pascalCase } from "pascal-case";
 //#region src/errors/base.ts
 var TypeormExtensionError = class extends Error {};
 //#endregion
+//#region src/errors/database-lock.ts
+var DatabaseLockError = class DatabaseLockError extends TypeormExtensionError {
+	static timeout(name, timeout) {
+		return new DatabaseLockError(`The database lock ${name} could not be acquired within ${timeout}ms.`);
+	}
+	static transactionActive(name) {
+		return new DatabaseLockError(`The database lock ${name} can not be taken inside a transaction, it would outlive a rollback.`);
+	}
+	static transactionLeftOpen(name) {
+		return new DatabaseLockError(`The callback of the database lock ${name} left a transaction open, which has been rolled back.`);
+	}
+};
+//#endregion
 //#region src/errors/driver.ts
 var DriverError = class DriverError extends TypeormExtensionError {
 	constructor(message) {
@@ -26,6 +40,9 @@ var DriverError = class DriverError extends TypeormExtensionError {
 	static schemaAlterationNotSupported(driverName) {
 		return new DriverError(`Schema alterations are not supported for the driver ${driverName}.`);
 	}
+	static lockNotSupported(driverName) {
+		return new DriverError(`Database locks are not supported for the driver ${driverName}.`);
+	}
 	static columnConversionExpressionNotSupported(driverName) {
 		return new DriverError(`A conversion expression (\`using\`) can not be expressed for the driver ${driverName}, which would convert the values on its own terms instead.`);
 	}
@@ -92,6 +109,12 @@ var OptionsError = class OptionsError extends TypeormExtensionError {
 	static notFound() {
 		return new OptionsError("The database options could not be located/loaded.");
 	}
+	static timezoneUnsupported(timezone) {
+		return new OptionsError(`The database timezone ${String(timezone)} is not supported, only UTC is.`);
+	}
+	static timezoneConflict(detail) {
+		return new OptionsError(`The database timezone can not be pinned: ${detail}`);
+	}
 	static databaseNotDefined() {
 		return new OptionsError("The database name to connect to is not defined.");
 	}
@@ -925,6 +948,8 @@ let EnvironmentVariableName = /* @__PURE__ */ function(EnvironmentVariableName)
 	EnvironmentVariableName["MAX_QUERY_EXECUTION_TIME_ALT"] = "TYPEORM_MAX_QUERY_EXECUTION_TIME";
 	EnvironmentVariableName["DEBUG"] = "DB_DEBUG";
 	EnvironmentVariableName["DEBUG_ALT"] = "TYPEORM_DEBUG";
+	EnvironmentVariableName["PIN_TIMEZONE"] = "DB_PIN_TIMEZONE";
+	EnvironmentVariableName["PIN_TIMEZONE_ALT"] = "TYPEORM_PIN_TIMEZONE";
 	EnvironmentVariableName["UUID_EXTENSION"] = "DB_UUID_EXTENSION";
 	EnvironmentVariableName["UUID_EXTENSION_ALT"] = "TYPEORM_UUID_EXTENSION";
 	EnvironmentVariableName["CACHE"] = "DB_CACHE";
@@ -1062,7 +1087,8 @@ function useEnv(key) {
 		maxQueryExecutionTime: oneOf([readInt("DB_MAX_QUERY_EXECUTION_TIME"), readInt("TYPEORM_MAX_QUERY_EXECUTION_TIME")]),
 		debug: oneOf([read$1("DB_DEBUG"), read$1("TYPEORM_DEBUG")]),
 		cache: transformCache(oneOf([read$1("DB_CACHE"), read$1("TYPEORM_CACHE")])),
-		uuidExtension: oneOf([read$1("DB_UUID_EXTENSION"), read$1("TYPEORM_UUID_EXTENSION")])
+		uuidExtension: oneOf([read$1("DB_UUID_EXTENSION"), read$1("TYPEORM_UUID_EXTENSION")]),
+		pinTimezone: oneOf([read$1("DB_PIN_TIMEZONE"), read$1("TYPEORM_PIN_TIMEZONE")])
 	};
 	if (output.extra) output.extra = JSON.parse(output.extra);
 	let type;
@@ -1093,12 +1119,726 @@ function mergeDataSourceOptions(target, source) {
 	return merge(target, source);
 }
 //#endregion
+//#region src/data-source/options/timezone/utils.ts
+function isDataSourceTimezone(input) {
+	return typeof input === "string" && input.toUpperCase() === "UTC";
+}
+function isDate(input) {
+	return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+}
+/**
+* Everything this module installs (wrapped drivers, clients, parsers,
+* session callbacks) is recorded here, so a second application recognises
+* the first one exactly instead of guessing from option values.
+*/
+const installed = /* @__PURE__ */ new WeakSet();
+function markInstalled(value) {
+	installed.add(value);
+	return value;
+}
+function isInstalled(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && installed.has(value);
+}
+/**
+* Whether the options carry a pin applied earlier, in any of the places a
+* dialect installs one.
+*/
+function hasInstalledTimezone(options) {
+	if (isInstalled(options.driver)) return true;
+	const extra = options.extra && typeof options.extra === "object" ? options.extra : {};
+	return isInstalled(extra.types) || isInstalled(extra.Client) || isInstalled(extra.sessionCallback);
+}
+//#endregion
+//#region src/data-source/options/timezone/mysql.ts
+const MYSQL_SESSION_TIMEZONE_SQL = "SET time_zone = '+00:00'";
+/**
+* The mysql2 `timezone` values meaning UTC.
+*/
+const MYSQL_UTC_TIMEZONE = /^(?:z|[+-]00:00)$/i;
+/**
+* Wrap a `mysql2` module so every pool pins its connections to UTC. The pool
+* emits `connection` synchronously, before it hands a new connection out, and
+* a connection runs its queries in order, so the `SET` is the first statement
+* every connection executes. A connection whose `SET` fails is destroyed
+* rather than left running in another zone.
+*/
+function createMysqlUTCDriver(driver) {
+	return markInstalled({
+		...driver,
+		createPool(...args) {
+			const pool = driver.createPool(...args);
+			pool.on("connection", (connection) => {
+				connection.query(MYSQL_SESSION_TIMEZONE_SQL, (err) => {
+					if (err) connection.destroy();
+				});
+			});
+			return pool;
+		}
+	});
+}
+function readSetting(options, key) {
+	const extra = options.extra ?? {};
+	return typeof extra[key] !== "undefined" ? extra[key] : options[key];
+}
+/**
+* Pin a mysql / mariadb data source: the session runs `SET time_zone` on
+* every new pool connection, and mysql2 reads and writes DATETIME and
+* TIMESTAMP values as UTC (`timezone: 'Z'`). DATE values are returned as
+* strings (`dateStrings: ['DATE']`): a calendar date has no instant, and
+* mysql2 would otherwise hand it over as UTC midnight, which typeorm then
+* formats back in the process zone, a day early west of UTC.
+*
+* A `timezone` naming UTC and `dateStrings: ['DATE']` are accepted as they
+* are. Another `timezone`, other `dateStrings`, a custom `typeCast` or a
+* replication setup (a pool cluster has no per-connection hook) is a
+* conflict, and so is a pin altered after it was applied.
+*/
+function applyMysqlTimezone(options) {
+	if (isInstalled(options.driver)) {
+		const timezone = readSetting(options, "timezone");
+		const dateStrings = readSetting(options, "dateStrings");
+		if (timezone === "Z" && Array.isArray(dateStrings) && dateStrings.length === 1 && dateStrings[0] === "DATE" && typeof readSetting(options, "typeCast") === "undefined") return options;
+		throw OptionsError.timezoneConflict("the mysql pin was altered after it was applied.");
+	}
+	if (typeof options.replication !== "undefined") throw OptionsError.timezoneConflict("a mysql replication setup has no per-connection hook to pin the session with.");
+	const timezone = readSetting(options, "timezone");
+	if (typeof timezone !== "undefined" && !(typeof timezone === "string" && MYSQL_UTC_TIMEZONE.test(timezone))) throw OptionsError.timezoneConflict(`the mysql timezone is set to ${String(timezone)}.`);
+	const dateStrings = readSetting(options, "dateStrings");
+	if (typeof dateStrings !== "undefined" && dateStrings !== false && !(Array.isArray(dateStrings) && dateStrings.every((type) => type === "DATE"))) throw OptionsError.timezoneConflict("mysql dateStrings would hand DATETIME or TIMESTAMP values over as zone-less strings.");
+	if (typeof readSetting(options, "typeCast") !== "undefined") throw OptionsError.timezoneConflict("a custom mysql typeCast decides how date values are read.");
+	const driver = options.driver ?? PlatformTools.load("mysql2");
+	const extra = { ...options.extra ?? {} };
+	delete extra.timezone;
+	delete extra.dateStrings;
+	return {
+		...options,
+		extra,
+		timezone: "Z",
+		dateStrings: ["DATE"],
+		driver: createMysqlUTCDriver(driver)
+	};
+}
+//#endregion
+//#region src/data-source/options/timezone/oracle.ts
+const ORACLE_SESSION_TIMEZONE_SQL = "ALTER SESSION SET TIME_ZONE = '+00:00'";
+/**
+* Re-read the local fields of a Date as UTC. node-oracledb builds a zone-less
+* `TIMESTAMP` as a local Date from its fields, and offers no switch for it.
+*/
+function readLocalDateAsUTC(date) {
+	const output = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+	const year = date.getFullYear();
+	if (year >= 0 && year < 100) output.setUTCFullYear(year);
+	return output;
+}
+/**
+* The reverse: a local Date whose fields are the UTC fields of the given one.
+* node-oracledb binds a Date as a zone-less `TIMESTAMP` from its local
+* fields, so this sends the UTC wall clock with the column's own type, which
+* keeps an index on the column usable (a `TIMESTAMP WITH TIME ZONE` bind
+* would convert the column side of every comparison).
+*/
+function writeUTCAsLocalDate(date) {
+	const output = new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
+	const year = date.getUTCFullYear();
+	if (year >= 0 && year < 100) output.setFullYear(year);
+	return output;
+}
+/**
+* Proxy an object, replacing the named methods. Every function is bound to
+* the object itself, so its internals never re-enter the proxy, and cached,
+* so reading it twice gives the same function. A member carrying a
+* `prototype` which is not replaced (an exported class) passes through
+* untouched, which keeps `instanceof` and statics working.
+*/
+function proxyMethods(target, methods) {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy(target, { get(object, property) {
+		const value = Reflect.get(object, property, object);
+		if (typeof value !== "function") return value;
+		const cached = cache.get(property);
+		if (cached && cached.source === value) return cached.value;
+		const replace = typeof property === "string" ? methods[property] : void 0;
+		let output;
+		if (replace) output = replace(value.bind(object));
+		else if (Object.prototype.hasOwnProperty.call(value, "prototype")) output = value;
+		else output = value.bind(object);
+		cache.set(property, {
+			source: value,
+			value: output
+		});
+		return output;
+	} });
+}
+/**
+* Wrap a `node-oracledb` module so the connections it hands out (pooled or
+* standalone, the latter with the session pinned too) read a zone-less
+* `TIMESTAMP` as UTC, return `TIMESTAMP`
+* out-binds as UTC and send Date parameters as UTC wall clock. The module
+* exposes the read conversion only process-wide (`oracledb.fetchTypeHandler`)
+* or per `execute()` call, so the handler is added to every call a wrapped
+* connection makes. A handler the caller passes, or the process-wide one,
+* still decides first.
+*
+* In a process zone with daylight saving, a UTC wall clock falling into the
+* local spring-forward hour has no local Date to travel as: such a value is
+* read, and written, an hour late. A process running in UTC is exact.
+*/
+function createOracleUTCDriver(driver) {
+	const handleTimestamp = (metadata) => {
+		if (metadata.dbType !== driver.DB_TYPE_TIMESTAMP) return;
+		return { converter: (value) => isDate(value) ? readLocalDateAsUTC(value) : value };
+	};
+	const withHandler = (options) => {
+		const custom = options?.fetchTypeHandler ?? driver.fetchTypeHandler;
+		return {
+			...options ?? {},
+			fetchTypeHandler: (metadata) => {
+				const result = typeof custom === "function" ? custom(metadata) : void 0;
+				return typeof result === "undefined" ? handleTimestamp(metadata) : result;
+			}
+		};
+	};
+	const toBindValue = (value) => {
+		if (isDate(value)) return writeUTCAsLocalDate(value);
+		if (Array.isArray(value)) return value.map((element) => isDate(element) ? writeUTCAsLocalDate(element) : element);
+		return value;
+	};
+	const isZonelessType = (type) => typeof type === "undefined" || type === driver.DB_TYPE_TIMESTAMP;
+	const toBind = (value) => {
+		if (value && typeof value === "object" && !Array.isArray(value) && !isDate(value) && "val" in value) {
+			const definition = value;
+			return isZonelessType(definition.type) ? {
+				...definition,
+				val: toBindValue(definition.val)
+			} : definition;
+		}
+		return toBindValue(value);
+	};
+	/**
+	* A row of `executeMany` holds plain values whose types, if any, come from
+	* `bindDefs`: only a Date without one, or typed TIMESTAMP, is shifted.
+	*/
+	const toRow = (row, definitions) => {
+		const shift = (value, definition) => {
+			const type = definition && typeof definition === "object" ? definition.type : void 0;
+			return isZonelessType(type) ? toBindValue(value) : value;
+		};
+		if (Array.isArray(row)) return row.map((value, index) => shift(value, Array.isArray(definitions) ? definitions[index] : void 0));
+		if (row && typeof row === "object") {
+			const output = {};
+			const keys = Object.keys(row);
+			for (const key of keys) {
+				const definition = definitions && typeof definitions === "object" && !Array.isArray(definitions) ? definitions[key] : void 0;
+				output[key] = shift(row[key], definition);
+			}
+			return output;
+		}
+		return row;
+	};
+	const toBinds = (binds) => {
+		if (Array.isArray(binds)) return binds.map((value) => toBind(value));
+		if (binds && typeof binds === "object") {
+			const output = {};
+			const keys = Object.keys(binds);
+			for (const key of keys) output[key] = toBind(binds[key]);
+			return output;
+		}
+		return binds;
+	};
+	const isTimestampOut = (definition) => {
+		if (!definition || typeof definition !== "object" || isDate(definition)) return false;
+		const { type, dir, val } = definition;
+		if (dir !== driver.BIND_OUT && dir !== driver.BIND_INOUT) return false;
+		return type === driver.DB_TYPE_TIMESTAMP || typeof type === "undefined" && dir === driver.BIND_INOUT && isDate(val);
+	};
+	const readOut = (value) => {
+		if (isDate(value)) return readLocalDateAsUTC(value);
+		if (Array.isArray(value)) return value.map((element) => isDate(element) ? readLocalDateAsUTC(element) : element);
+		return value;
+	};
+	const convertOutBinds = (outBinds, definitions) => {
+		if (!outBinds || typeof outBinds !== "object" || !definitions || typeof definitions !== "object") return outBinds;
+		if (Array.isArray(definitions)) {
+			if (!Array.isArray(outBinds)) return outBinds;
+			const outs = definitions.filter((definition) => !!definition && typeof definition === "object" && !isDate(definition) && (definition.dir === driver.BIND_OUT || definition.dir === driver.BIND_INOUT));
+			return outBinds.map((value, index) => isTimestampOut(outs[index]) ? readOut(value) : value);
+		}
+		const output = { ...outBinds };
+		const keys = Object.keys(output);
+		for (const key of keys) if (isTimestampOut(definitions[key])) output[key] = readOut(output[key]);
+		return output;
+	};
+	const convertResult = (result, definitions) => {
+		if (result && typeof result === "object" && typeof result.outBinds !== "undefined") result.outBinds = convertOutBinds(result.outBinds, definitions);
+		return result;
+	};
+	const convertManyResult = (result, definitions) => {
+		if (result && typeof result === "object" && Array.isArray(result.outBinds)) result.outBinds = result.outBinds.map((row) => convertOutBinds(row, definitions));
+		return result;
+	};
+	const settle = (outcome, definitions, callback, convert) => {
+		if (typeof callback === "function") return outcome;
+		return outcome && typeof outcome.then === "function" ? outcome.then((result) => convert(result, definitions)) : outcome;
+	};
+	const wrapConnection = (connection) => proxyMethods(connection, {
+		execute: (original) => (sql, binds, options, callback) => {
+			if (typeof binds === "function") return original(sql, {}, withHandler(), binds);
+			const input = binds ?? {};
+			const optionsOrCallback = typeof options === "function" ? void 0 : options;
+			const done = typeof options === "function" ? options : callback;
+			if (typeof done === "function") return original(sql, toBinds(input), withHandler(optionsOrCallback), (err, result) => {
+				done(err, err ? result : convertResult(result, input));
+			});
+			return settle(original(sql, toBinds(input), withHandler(optionsOrCallback)), input, void 0, convertResult);
+		},
+		executeMany: (original) => (sql, binds, options, callback) => {
+			const optionsOrCallback = typeof options === "function" ? void 0 : options;
+			const done = typeof options === "function" ? options : callback;
+			const definitions = optionsOrCallback?.bindDefs;
+			const rows = Array.isArray(binds) ? binds.map((row) => toRow(row, definitions)) : binds;
+			if (typeof done === "function") return original(sql, rows, optionsOrCallback ?? {}, (err, result) => {
+				done(err, err ? result : convertManyResult(result, definitions));
+			});
+			return settle(original(sql, rows, optionsOrCallback ?? {}), definitions, void 0, convertManyResult);
+		},
+		queryStream: (original) => (sql, binds, options) => original(sql, toBinds(binds ?? {}), withHandler(options))
+	});
+	const wrapPool = (pool) => proxyMethods(pool, { getConnection: (original) => (...args) => {
+		const callback = args[args.length - 1];
+		if (typeof callback === "function") return original(...args.slice(0, -1), (err, connection, ...rest) => {
+			callback(err, connection ? wrapConnection(connection) : connection, ...rest);
+		});
+		return original(...args).then((connection) => wrapConnection(connection));
+	} });
+	const wrapFactory = (wrap) => (original) => (...args) => {
+		const callback = args[args.length - 1];
+		if (typeof callback === "function") return original(...args.slice(0, -1), (err, value) => {
+			callback(err, value ? wrap(value) : value);
+		});
+		const output = original(...args);
+		if (output && typeof output.then === "function") return output.then((value) => wrap(value));
+		return output ? wrap(output) : output;
+	};
+	const pinConnection = (connection) => Promise.resolve(connection.execute(ORACLE_SESSION_TIMEZONE_SQL)).then(() => wrapConnection(connection), (error) => Promise.resolve(connection.close()).catch(() => void 0).then(() => Promise.reject(error)));
+	return markInstalled(proxyMethods(driver, {
+		createPool: wrapFactory(wrapPool),
+		getPool: (original) => (...args) => {
+			const pool = original(...args);
+			return pool ? wrapPool(pool) : pool;
+		},
+		getConnection: (original) => (...args) => {
+			const callback = args[args.length - 1];
+			if (typeof callback === "function") return original(...args.slice(0, -1), (err, connection) => {
+				if (err || !connection) {
+					callback(err, connection);
+					return;
+				}
+				pinConnection(connection).then((value) => callback(null, value), (error) => callback(error));
+			});
+			return original(...args).then((connection) => pinConnection(connection));
+		}
+	}));
+}
+/**
+* Pin an oracle data source: a pool `sessionCallback` running
+* `ALTER SESSION SET TIME_ZONE`, and a driver whose connections read a
+* zone-less `TIMESTAMP` as UTC and send Date parameters as UTC wall clock.
+* A `sessionCallback` function the caller set runs after the pin; one naming
+* a PL/SQL procedure can not be combined and is a conflict.
+*/
+function applyOracleTimezone(options) {
+	if (isInstalled(options.driver)) {
+		if (isInstalled(options.extra?.sessionCallback)) return options;
+		throw OptionsError.timezoneConflict("the oracle pin was altered after it was applied.");
+	}
+	const existing = options.extra?.sessionCallback;
+	if (typeof existing !== "undefined" && typeof existing !== "function") throw OptionsError.timezoneConflict("the oracle sessionCallback names a PL/SQL procedure, which can not run after the session pin.");
+	const sessionCallback = markInstalled((connection, requestedTag, callback) => {
+		connection.execute(ORACLE_SESSION_TIMEZONE_SQL, (err) => {
+			if (err || typeof existing !== "function") {
+				callback(err ?? void 0);
+				return;
+			}
+			existing(connection, requestedTag, callback);
+		});
+	});
+	const driver = options.driver ?? PlatformTools.load("oracledb");
+	return {
+		...options,
+		driver: createOracleUTCDriver(driver),
+		extra: {
+			...options.extra ?? {},
+			sessionCallback
+		}
+	};
+}
+//#endregion
+//#region src/data-source/options/timezone/postgres.ts
+/**
+* `timestamp without time zone` and its array.
+*/
+const POSTGRES_TIMESTAMP_OID = 1114;
+const POSTGRES_TIMESTAMP_ARRAY_OID = 1115;
+/**
+* A `TimeZone` assignment among the postgres startup options, in either
+* spelling the server accepts (`-c TimeZone=...`, `--TimeZone=...`). The
+* name is matched whole: `log_timezone` sets something else entirely.
+*/
+const POSTGRES_TIMEZONE_OPTION = /(?:^|\s)(?:-c\s*|--)timezone=(\S+)/gi;
+const POSTGRES_UTC_ZONE = /^(?:utc|uct|etc\/utc|etc\/uct|universal|etc\/universal|zulu|etc\/zulu|z|gmt|gmt0|etc\/gmt|etc\/gmt0|etc\/gmt[+-]0|greenwich|etc\/greenwich|[+-]?0{1,2}(?::?00)?)$/i;
+/**
+* The text form of a `timestamp without time zone` (ISO DateStyle).
+*/
+const POSTGRES_TIMESTAMP = /^(\d{4,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d+)?( BC)?$/;
+/**
+* The exact form pg's `prepareValue` gives a Date (the process offset
+* included), which pg-cursor applies in its constructor, before a stream
+* reaches the client.
+*/
+const POSTGRES_LOCAL_DATE = /^(\d{4,})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})([+-])(\d{2}):(\d{2})( BC)?$/;
+/**
+* Serialize a Date as pg does with `parseInputDatesAsUTC`, which is only
+* available process-wide there: UTC fields, an explicit `+00:00`, and a
+* ` BC` suffix for years before 1.
+*/
+function serializePostgresDateAsUTC(date) {
+	let year = date.getUTCFullYear();
+	const isBCYear = year < 1;
+	if (isBCYear) year = Math.abs(year) + 1;
+	const pad = (value, length = 2) => String(value).padStart(length, "0");
+	let output = `${pad(year, 4)}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.${pad(date.getUTCMilliseconds(), 3)}+00:00`;
+	if (isBCYear) output += " BC";
+	return output;
+}
+/**
+* Re-serialize a Date which pg already turned into its local form (the
+* process offset included) as UTC. Any other value is returned unchanged.
+*/
+function reserializePostgresLocalDateAsUTC(value) {
+	if (typeof value !== "string") return value;
+	const match = POSTGRES_LOCAL_DATE.exec(value);
+	if (!match) return value;
+	const [, year, month, day, hour, minute, second, millisecond, sign, offsetHours, offsetMinutes, bc] = match;
+	let fullYear = Number(year);
+	if (bc) fullYear = 1 - fullYear;
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(fullYear, Number(month) - 1, Number(day));
+	date.setUTCHours(Number(hour), Number(minute), Number(second), Number(millisecond));
+	const offset = (Number(offsetHours) * 60 + Number(offsetMinutes)) * (sign === "-" ? -1 : 1);
+	date.setTime(date.getTime() - offset * 6e4);
+	return serializePostgresDateAsUTC(date);
+}
+function toPostgresUTCParameter(value) {
+	if (isDate(value)) return serializePostgresDateAsUTC(value);
+	if (Array.isArray(value)) return value.map((element) => toPostgresUTCParameter(element));
+	return value;
+}
+/**
+* A submittable (pg Query, pg-cursor, pg-query-stream) may already hold its
+* values in pg's prepared form: pg-cursor applies pg's `prepareValue` in its
+* constructor, before the client sees it.
+*/
+function toPostgresUTCSubmittedParameter(value) {
+	if (isDate(value)) return serializePostgresDateAsUTC(value);
+	return reserializePostgresLocalDateAsUTC(value);
+}
+/**
+* Parse the text form of a `timestamp without time zone` as UTC: the same
+* fields, BC years and `infinity` pg's own parser handles, read in UTC rather
+* than in the zone of the process. Another text form (a non-ISO DateStyle)
+* gives `null`, as it does there.
+*/
+function parsePostgresTimestampAsUTC(value) {
+	if (value === "infinity") return Infinity;
+	if (value === "-infinity") return -Infinity;
+	const match = POSTGRES_TIMESTAMP.exec(value);
+	if (!match) return null;
+	const [, year, month, day, hour, minute, second, fraction, bc] = match;
+	let fullYear = Number(year);
+	if (bc) fullYear = 1 - fullYear;
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(fullYear, Number(month) - 1, Number(day));
+	date.setUTCHours(Number(hour), Number(minute), Number(second), fraction ? Math.floor(Number(fraction) * 1e3) : 0);
+	return date;
+}
+/**
+* Parse the text form of a postgres array, handing each element to the given
+* parser. Covers what pg emits for a `timestamp[]`: quoted and unquoted
+* elements, `NULL` and nested arrays.
+*/
+function parsePostgresArray(value, parse) {
+	let position = 0;
+	const parseLevel = () => {
+		const output = [];
+		position++;
+		while (position < value.length) {
+			const char = value[position];
+			if (char === "}") {
+				position++;
+				return output;
+			}
+			if (char === ",") position++;
+			else if (char === "{") output.push(parseLevel());
+			else if (char === "\"") {
+				let element = "";
+				position++;
+				while (position < value.length && value[position] !== "\"") {
+					if (value[position] === "\\") position++;
+					element += value[position];
+					position++;
+				}
+				position++;
+				output.push(parse(element));
+			} else {
+				let element = "";
+				while (position < value.length && value[position] !== "," && value[position] !== "}") {
+					element += value[position];
+					position++;
+				}
+				output.push(element === "NULL" ? null : parse(element));
+			}
+		}
+		return output;
+	};
+	const brace = value.indexOf("{");
+	if (brace === -1) return [];
+	position = brace;
+	return parseLevel();
+}
+const parsePostgresTimestampArrayAsUTC = (value) => parsePostgresArray(value, parsePostgresTimestampAsUTC);
+/**
+* Build postgres type parsers which read `timestamp without time zone` (and
+* its array) as UTC and delegate every other type to the given registry.
+*/
+function createPostgresUTCTypes(types) {
+	return markInstalled({ getTypeParser(oid, format) {
+		if (format !== "binary") {
+			if (oid === POSTGRES_TIMESTAMP_OID) return parsePostgresTimestampAsUTC;
+			if (oid === POSTGRES_TIMESTAMP_ARRAY_OID) return parsePostgresTimestampArrayAsUTC;
+		}
+		return types.getTypeParser(oid, format);
+	} });
+}
+/**
+* Whether a registry still parses zone-less timestamps the way pg does by
+* default (a local Date), judged by behaviour: a custom parser registered for
+* them (strings, another date library) is a choice the pin would override.
+*/
+function isDefaultTimestampParsing(types) {
+	const expected = new Date(2e3, 0, 2, 3, 4, 5).getTime();
+	try {
+		const single = types.getTypeParser(POSTGRES_TIMESTAMP_OID)("2000-01-02 03:04:05");
+		const many = types.getTypeParser(POSTGRES_TIMESTAMP_ARRAY_OID)("{\"2000-01-02 03:04:05\"}");
+		return single instanceof Date && single.getTime() === expected && Array.isArray(many) && many[0] instanceof Date && many[0].getTime() === expected;
+	} catch {
+		return false;
+	}
+}
+/**
+* Derive a pg `Client` class which sends Date parameters as UTC. Left to pg,
+* a Date is sent with the offset of the Node process, which postgres drops
+* for a `timestamp without time zone`, storing the process's wall clock.
+* pg-pool takes the class through its `Client` option, so this stays scoped
+* to one pool.
+*
+* A stream (pg-query-stream / pg-cursor) prepares its values before the
+* client sees them, so those arrive in pg's local form and are re-serialized;
+* a Date inside an array value of a stream arrives as an array literal and is
+* not.
+*/
+function createPostgresUTCClient(Base) {
+	const Client = class extends Base {
+		query(config, values, callback) {
+			if (Array.isArray(values)) return super.query(config, values.map((value) => toPostgresUTCParameter(value)), callback);
+			if (config && typeof config === "object") {
+				if (config.cursor && Array.isArray(config.cursor.values)) config.cursor.values = config.cursor.values.map((value) => toPostgresUTCSubmittedParameter(value));
+				else if (Array.isArray(config.values)) {
+					if (typeof config.submit === "function") config.values = config.values.map((value) => toPostgresUTCSubmittedParameter(value));
+					else return super.query({
+						...config,
+						values: config.values.map((value) => toPostgresUTCParameter(value))
+					}, values, callback);
+				}
+			}
+			return super.query(config, values, callback);
+		}
+	};
+	return markInstalled(Client);
+}
+/**
+* The TimeZone a set of startup options assigns. Postgres applies them in
+* order, so the last assignment is the one in effect.
+*/
+function readTimezoneOption(options) {
+	if (typeof options !== "string") return;
+	let zone;
+	for (const match of options.matchAll(POSTGRES_TIMEZONE_OPTION)) [, zone] = match;
+	return typeof zone === "string" ? zone.replace(/^'(.*)'$/, "$1") : void 0;
+}
+function isUTCZone(zone) {
+	return POSTGRES_UTC_ZONE.test(zone);
+}
+/**
+* Add `-c TimeZone=UTC` to a set of startup options, or accept a TimeZone
+* already in effect there when it names UTC. Any other zone is a conflict.
+*/
+function pinTimezoneOption(options, source) {
+	const zone = readTimezoneOption(options);
+	if (typeof zone === "undefined") return `${options} -c TimeZone=UTC`.trim();
+	if (isUTCZone(zone)) return options;
+	throw OptionsError.timezoneConflict(`${source} sets the postgres TimeZone to ${zone}.`);
+}
+/**
+* Take the `options` parameter out of a connection string, leaving every
+* other byte of it as it was (re-encoding it can break a string pg would
+* have accepted). Postgres uses the last occurrence, and so does this.
+*/
+function extractPostgresUrlOptions(url) {
+	const index = url.indexOf("?");
+	if (index === -1) return { url };
+	const hash = url.indexOf("#", index);
+	const query = url.slice(index + 1, hash === -1 ? void 0 : hash);
+	const rest = hash === -1 ? "" : url.slice(hash);
+	let options;
+	const kept = [];
+	for (const segment of query.split("&")) {
+		const params = new URLSearchParams(segment);
+		if (params.has("options")) options = params.get("options") ?? "";
+		else if (segment.length > 0) kept.push(segment);
+	}
+	return {
+		url: url.slice(0, index) + (kept.length > 0 ? `?${kept.join("&")}` : "") + rest,
+		options
+	};
+}
+function isPostgresNativeInUse(nativeDriver, driver) {
+	try {
+		let native = nativeDriver;
+		if (native === null || typeof native === "undefined") native = PlatformTools.load("pg-native");
+		return !!(native && driver.native);
+	} catch {
+		return false;
+	}
+}
+/**
+* Pin a postgres data source: `-c TimeZone=UTC` for the session, parsers
+* reading `timestamp without time zone` (and its array) as UTC, and a client
+* sending Date parameters as UTC.
+*
+* pg takes the startup options from the connection string first, then
+* `extra.options`, then `PGOPTIONS`; the options in effect are moved into
+* `extra.options` (out of the connection string, byte for byte otherwise)
+* and the pin is added there. A user's `extra.types` (for other types) and
+* `extra.Client` are built upon. A foreign TimeZone in effect, timestamp
+* parsing customised process-wide or in `extra.types`, or a replication node
+* url carrying options (shared `extra` can not hold per-node options) is a
+* conflict, and so is a pin altered after it was applied.
+*/
+function applyPostgresTimezone(options) {
+	const extra = { ...options.extra ?? {} };
+	if (isInstalled(extra.types) || isInstalled(extra.Client)) {
+		const zone = readTimezoneOption(extra.options);
+		const nodes = options.replication ? [options.replication.master, ...options.replication.slaves] : [];
+		const urls = [
+			options.url,
+			extra.connectionString,
+			...nodes.map((node) => node.url)
+		].filter((url) => typeof url === "string");
+		if (isInstalled(extra.types) && isInstalled(extra.Client) && typeof zone === "string" && isUTCZone(zone) && urls.every((url) => typeof extractPostgresUrlOptions(url).options === "undefined")) return options;
+		throw OptionsError.timezoneConflict("the postgres pin was altered after it was applied.");
+	}
+	const driver = options.driver ?? PlatformTools.load("pg");
+	if (!isDefaultTimestampParsing(driver.types)) throw OptionsError.timezoneConflict("timestamp parsing is customised process-wide (pg.types.setTypeParser).");
+	const own = extra.types;
+	if (own && !isDefaultTimestampParsing(own)) throw OptionsError.timezoneConflict("extra.types customises timestamp parsing.");
+	const output = { ...options };
+	let fromUrl;
+	if (typeof options.url === "string") {
+		const extracted = extractPostgresUrlOptions(options.url);
+		output.url = extracted.url;
+		fromUrl = extracted.options;
+	}
+	if (typeof extra.connectionString === "string") {
+		const extracted = extractPostgresUrlOptions(extra.connectionString);
+		extra.connectionString = extracted.url;
+		fromUrl = extracted.options;
+	}
+	if (options.replication) {
+		if ([options.replication.master, ...options.replication.slaves].some((node) => typeof node.url === "string" && typeof extractPostgresUrlOptions(node.url).options !== "undefined")) throw OptionsError.timezoneConflict("a replication node url carries startup options, which can not be combined with the pin.");
+	}
+	let source = "PGOPTIONS";
+	let base = process.env.PGOPTIONS ?? "";
+	if (typeof fromUrl === "string") {
+		source = "the connection url";
+		base = fromUrl;
+	} else if (typeof extra.options === "string") {
+		source = "extra.options";
+		base = extra.options;
+	}
+	extra.options = pinTimezoneOption(base, source);
+	extra.types = createPostgresUTCTypes(own ?? driver.types);
+	extra.Client = createPostgresUTCClient(extra.Client ?? (isPostgresNativeInUse(options.nativeDriver, driver) ? driver.native.Client : driver.Client));
+	output.extra = extra;
+	return output;
+}
+//#endregion
+//#region src/data-source/options/timezone/module.ts
+/**
+* Pin a data source to a timezone (only UTC) on EVERY side of a zone-less
+* date column: the database session that stamps it (`now()`,
+* `CURRENT_TIMESTAMP`), and the driver that reads it and serializes Date
+* parameters into it. Left alone, the database stamps in its own session
+* zone while the driver reads and writes in the zone of the Node process,
+* which agree only while both clocks do.
+*
+* Each driver lives in its own file (`postgres.ts`, `mysql.ts`, `oracle.ts`);
+* every other driver needs nothing and is returned unchanged. A setting the
+* caller already made is kept when it agrees with the pin (a UTC `timezone`,
+* a UTC `TimeZone`) or can be built upon (a pg `Client`, pg `types` leaving
+* timestamps alone, an oracle `sessionCallback` function), and throws an
+* `OptionsError` when it contradicts it: half a pin shifts values instead of
+* fixing them. Applying it twice returns the pinned options unchanged.
+*
+* Only values written from then on are affected: rows a database stamped in
+* another zone before keep that wall clock.
+*/
+function pinTimezone(options, timezone) {
+	if (!isDataSourceTimezone(timezone)) throw OptionsError.timezoneUnsupported(timezone);
+	switch (options.type) {
+		case "mysql":
+		case "mariadb": return applyMysqlTimezone(options);
+		case "postgres": return applyPostgresTimezone(options);
+		case "oracle": return applyOracleTimezone(options);
+		default: return options;
+	}
+}
+//#endregion
 //#region src/data-source/options/utils/env.ts
 function hasEnvDataSourceOptions() {
 	return !!useEnv("type");
 }
-/* istanbul ignore next */
+/**
+* Apply `DB_PIN_TIMEZONE`, when set, once the options are complete: applied
+* before a merge, a deep merge would reach into the wrapped driver module.
+* Options pinned in code are re-checked after the merge as well, so an
+* environment value undoing part of the pin (a `DB_DRIVER_EXTRA`
+* timezone, say)
+* fails instead of leaving it half applied.
+*/
+function applyEnvTimezone(options) {
+	const timezone = useEnv("pinTimezone");
+	if (typeof timezone === "undefined" || timezone === "") return hasInstalledTimezone(options) ? pinTimezone(options, "UTC") : options;
+	if (!isDataSourceTimezone(timezone)) throw OptionsError.timezoneUnsupported(timezone);
+	return pinTimezone(options, "UTC");
+}
 function readDataSourceOptionsFromEnv() {
+	const options = readRawDataSourceOptionsFromEnv();
+	if (!options) return;
+	return applyEnvTimezone(options);
+}
+/* istanbul ignore next */
+function readRawDataSourceOptionsFromEnv() {
 	if (!hasEnvDataSourceOptions()) return;
 	const base = {
 		type: useEnv("type"),
@@ -1167,9 +1907,9 @@ function readDataSourceOptionsFromEnv() {
 	};
 }
 function mergeDataSourceOptionsWithEnv(options) {
-	const env = readDataSourceOptionsFromEnv();
-	if (!env) return options;
-	return mergeDataSourceOptions(env, options);
+	const env = readRawDataSourceOptionsFromEnv();
+	if (!env) return applyEnvTimezone(options);
+	return applyEnvTimezone(mergeDataSourceOptions(env, options));
 }
 //#endregion
 //#region src/data-source/options/module.ts
@@ -1232,7 +1972,8 @@ async function useDataSource(alias) {
 			if (!existing.isInitialized) await existing.initialize();
 			return existing;
 		}
-		const dataSource = new DataSource(await useDataSourceOptions(key));
+		const options = await useDataSourceOptions(key);
+		const dataSource = new DataSource(options);
 		await dataSource.initialize();
 		return dataSource;
 	});
@@ -1814,7 +2555,7 @@ function matchesColumnType(column, input, describer) {
 	const { normalizeType, describeType } = describer;
 	if (normalizeType(input.type).toLowerCase() !== normalizeType(column.type).toLowerCase()) return false;
 	if (typeof input.length !== "undefined" && describeType(input.type, input.length).toLowerCase() !== describeType(column.type, column.length).toLowerCase()) return false;
-	return !(typeof input.nullable === "boolean" && input.nullable !== column.isNullable);
+	return typeof input.nullable !== "boolean" || input.nullable === column.isNullable;
 }
 //#endregion
 //#region src/database/schema/alter/checks.ts
@@ -2434,73 +3175,44 @@ async function dropDatabase(input = {}) {
 }
 //#endregion
 //#region src/database/utils/migration.ts
+/**
+* typeorm keeps the statement escaping, the query-parameter formatting and both file
+* templates as protected statics on its migration:generate command. Subclassing is the
+* only way to reach them, and reusing them keeps the generated file byte-identical to
+* the output of `typeorm migration:generate`.
+*/
 var GenerateCommand = class extends MigrationGenerateCommand {
-	static prettify(query) {
-		return this.prettifyQuery(query);
+	static buildStatement(query, parameters, prettify) {
+		const statement = prettify ? this.prettifyQuery(query) : query;
+		return `await queryRunner.query(\`${this.escapeTemplateLiteral(statement)}\`${this.queryParams(parameters)});`;
+	}
+	static buildContent(context, up, down) {
+		const upStatements = up.map((statement) => `        ${statement}`);
+		const downStatements = down.map((statement) => `        ${statement}`);
+		if (context.language === "js") return this.getJavascriptTemplate(context.name, context.timestamp, upStatements, downStatements, context.esm);
+		return this.getTemplate(context.name, context.timestamp, upStatements, downStatements);
 	}
 };
-function queryParams(parameters) {
-	if (!parameters || !parameters.length) return "";
-	return `, ${JSON.stringify(parameters)}`;
-}
-function buildTemplate(name, timestamp, upStatements, downStatements) {
-	const migrationName = `${pascalCase(name)}${timestamp}`;
-	const up = upStatements.map((statement) => `        ${statement}`);
-	const down = downStatements.map((statement) => `        ${statement}`);
-	return `import type { MigrationInterface, QueryRunner } from 'typeorm';
-
-export class ${migrationName} implements MigrationInterface {
-    name = '${migrationName}';
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-${up.join(`
-`)}
-    }
-    public async down(queryRunner: QueryRunner): Promise<void> {
-${down.join(`
-`)}
-    }
-}
-`;
-}
 async function generateMigration(context) {
-	context.name = context.name || "Default";
-	const timestamp = context.timestamp || (/* @__PURE__ */ new Date()).getTime();
-	const fileName = `${timestamp}-${context.name}.ts`;
-	const { dataSource } = context;
-	const up = [];
-	const down = [];
-	const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
-	if (context.prettify) {
-		sqlInMemory.upQueries.forEach((upQuery) => {
-			upQuery.query = GenerateCommand.prettify(upQuery.query);
-		});
-		sqlInMemory.downQueries.forEach((downQuery) => {
-			downQuery.query = GenerateCommand.prettify(downQuery.query);
-		});
-	}
-	sqlInMemory.upQueries.forEach((upQuery) => {
-		up.push(`await queryRunner.query(\`${upQuery.query.replace(/`/g, "\\`")}\`${queryParams(upQuery.parameters)});`);
-	});
-	sqlInMemory.downQueries.forEach((downQuery) => {
-		down.push(`await queryRunner.query(\`${downQuery.query.replace(/`/g, "\\`")}\`${queryParams(downQuery.parameters)});`);
-	});
+	const name = context.name || "Default";
+	const timestamp = context.timestamp ?? Date.now();
+	const language = context.language || "ts";
+	const sqlInMemory = await context.dataSource.driver.createSchemaBuilder().log();
+	const up = sqlInMemory.upQueries.map((query) => GenerateCommand.buildStatement(query.query, query.parameters, context.prettify));
+	const down = sqlInMemory.downQueries.map((query) => GenerateCommand.buildStatement(query.query, query.parameters, context.prettify)).reverse();
 	if (up.length === 0 && down.length === 0) return {
 		up,
 		down
 	};
-	const content = buildTemplate(context.name, timestamp, up, down.reverse());
+	const content = GenerateCommand.buildContent({
+		name,
+		timestamp,
+		language,
+		esm: context.esm || false
+	}, up, down);
 	if (!context.preview) {
-		let directoryPath;
-		if (context.directoryPath) if (!path.isAbsolute(context.directoryPath)) directoryPath = path.join(process$1.cwd(), context.directoryPath);
-		else directoryPath = context.directoryPath;
-		else directoryPath = path.join(process$1.cwd(), "migrations");
-		try {
-			await fs.promises.access(directoryPath, fs.constants.R_OK | fs.constants.W_OK);
-		} catch {
-			await fs.promises.mkdir(directoryPath, { recursive: true });
-		}
-		await fs.promises.writeFile(path.join(directoryPath, fileName), content, { encoding: "utf-8" });
+		const directoryPath = resolveFilePath(context.directoryPath || "migrations");
+		await CommandUtils.createFile(path.join(directoryPath, `${timestamp}-${name}.${language}`), content);
 	}
 	return {
 		up,
@@ -2612,6 +3324,95 @@ async function dropSQLiteDatabase(input = {}) {
 	return executeDatabaseDrop("better-sqlite3", await buildDatabaseDropContext(input));
 }
 //#endregion
+//#region src/database/lock/module.ts
+const MYSQL_LOCK_STATEMENTS = {
+	acquire: "SELECT GET_LOCK(SHA2(CONCAT(COALESCE(DATABASE(), ''), ':', ?), 256), 0) AS `acquired`",
+	release: "SELECT RELEASE_LOCK(SHA2(CONCAT(COALESCE(DATABASE(), ''), ':', ?), 256)) AS `released`"
+};
+/**
+* cockroachdb accepts the postgres advisory lock functions, but they do not
+* lock anything, so it is deliberately missing.
+*/
+const statements = /* @__PURE__ */ new Map([
+	["postgres", {
+		acquire: "SELECT pg_try_advisory_lock(hashtextextended($1, 0)) AS \"acquired\"",
+		release: "SELECT pg_advisory_unlock(hashtextextended($1, 0)) AS \"released\""
+	}],
+	["mysql", MYSQL_LOCK_STATEMENTS],
+	["mariadb", MYSQL_LOCK_STATEMENTS]
+]);
+const POLL_INTERVAL = 100;
+/**
+* pg answers with a boolean, mysql with the string '1' / '0', mariadb with
+* the number 1 / 0 (either may be NULL). A truthiness check would read '0'
+* as acquired.
+*/
+function isDatabaseLockAcquired(rows) {
+	if (!Array.isArray(rows) || rows.length === 0) return false;
+	const value = Object.values(rows[0] ?? {})[0];
+	return value === true || value === 1 || value === "1";
+}
+/**
+* Run a callback while holding a named advisory lock, so that only one
+* session at a time (across processes) runs it. The lock is released
+* afterwards, also when the callback throws. A transaction the callback
+* leaves open on the query runner is rolled back first.
+*
+* The lock is session scoped: the query runner must stay on one connection
+* for the whole call, which a typeorm QueryRunner does until it is released.
+* Nested calls with the same name on the same query runner do not block.
+*
+* Supported for postgres, mysql and mariadb.
+*
+* @throws DriverError on any other driver, unless `strict` is false.
+* @throws DatabaseLockError if the lock can not be acquired within `timeout`,
+* the query runner is in a transaction, or the callback left one open.
+*/
+async function withDatabaseLock(queryRunner, name, fn, options = {}) {
+	const { type } = queryRunner.dataSource.options;
+	const statement = statements.get(type);
+	if (!statement) {
+		if (options.strict === false) return fn();
+		throw DriverError.lockNotSupported(type);
+	}
+	if (queryRunner.isTransactionActive) throw DatabaseLockError.transactionActive(name);
+	const timeout = options.timeout ?? Infinity;
+	const deadline = Date.now() + timeout;
+	while (!isDatabaseLockAcquired(await queryRunner.query(statement.acquire, [name]))) {
+		const remaining = deadline - Date.now();
+		if (!(remaining > 0)) throw DatabaseLockError.timeout(name, timeout);
+		await new Promise((resolve) => {
+			setTimeout(resolve, Math.min(POLL_INTERVAL, remaining));
+		});
+	}
+	let output;
+	try {
+		output = await fn();
+	} catch (e) {
+		await rollbackTransaction(queryRunner);
+		await queryRunner.query(statement.release, [name]).catch(() => void 0);
+		throw e;
+	}
+	const transactionLeftOpen = await rollbackTransaction(queryRunner);
+	await queryRunner.query(statement.release, [name]);
+	if (transactionLeftOpen) throw DatabaseLockError.transactionLeftOpen(name);
+	return output;
+}
+/**
+* A transaction the callback left open (or postgres aborted) would make
+* postgres refuse the release, and the lock would go back to the pool held.
+*
+* Nested transactions are savepoints in typeorm: one rollback only unwinds
+* the innermost, so repeat until the outer one is gone (or a rollback fails).
+*/
+async function rollbackTransaction(queryRunner) {
+	if (!queryRunner.isTransactionActive) return false;
+	try {
+		while (queryRunner.isTransactionActive) await queryRunner.rollbackTransaction();
+	} catch {}
+	return true;
+}
+//#endregion
 //#region src/helpers/entity/name.ts
 function getEntityName(entity) {
 	if (typeof entity === "string") return entity;
@@ -2889,7 +3690,10 @@ var SeederEntity = class {
 		this.id = ctx.id;
 		this.timestamp = ctx.timestamp;
 		this.name = ctx.name;
-		if (ctx.constructor) this.instance = new ctx.constructor();
+		if (ctx.constructor) {
+			const SeederClass = ctx.constructor;
+			this.instance = new SeederClass();
+		}
 		this.fileName = ctx.fileName;
 		this.filePath = ctx.filePath;
 	}
@@ -3282,6 +4086,6 @@ async function runSeeders(dataSource, options) {
 	return new SeederExecutor(dataSource).execute(options);
 }
 //#endregion
-export { CockroachDBDialect, CodeTransformation, DriverError, EntityMetadataError, EntityRelationLookupError, EnvironmentName, EnvironmentVariableName, MYSQL_FOREIGN_KEY_CHECKS_OFF, MYSQL_FOREIGN_KEY_CHECKS_ON, MYSQL_FOREIGN_KEY_CHECKS_SELECT, MongoDBDialect, MsSQLDialect, MySQLDialect, OptionsError, OracleDialect, PathResolver, PathResolverMode, PostgresDialect, SQLiteDialect, SchemaAlterationError, SchemaDriftError, SeederEntity, SeederExecutor, SeederFactory, SeederFactoryManager, TypeormExtensionError, adjustFilePath, adjustFilePaths, assertSchemaMatchesMetadata, buildCockroachDBCreateDatabaseQuery, buildCockroachDBDropDatabaseQuery, buildConnectionParams, buildDataSourceOptions, buildDatabaseCreateContext, buildDatabaseDropContext, buildMongoDBConnectionUri, buildMongoDBDropDatabaseCommand, buildMsSQLCreateDatabaseQuery, buildMsSQLDropDatabaseQuery, buildMySQLCreateDatabaseQuery, buildMySQLDropDatabaseQuery, buildOracleConnectString, buildOracleCreateDatabaseQuery, buildPostgresCreateDatabaseQuery, buildPostgresCreateSchemaQuery, buildPostgresDatabaseExistsQuery, buildPostgresDropDatabaseQuery, buildSeederFileName, buildSeederFileTemplate, canReplaceWindowsSeparator, changeColumnType, checkDatabase, createCockroachDBDatabase, createDatabase, createMongoDBDatabase, createMsSQLDatabase, createMySQLDatabase, createOracleDatabase, createPathResolver, createPostgresDatabase, createSQLiteDatabase, deriveMySQLCharacterSet, detectCodeTransformation, dropCockroachDBDatabase, dropDatabase, dropMongoDBDatabase, dropMsSQLDatabase, dropMySQLDatabase, dropOracleDatabase, dropPostgresDatabase, dropSQLiteDatabase, existsQuery, extendObject, findDataSource, generateMigration, getEntityMetadata, getEntityName, getEntityPropertyNames, getSchemaDrift, hasDataSource, hasDataSourceOptions, hasEnvDataSourceOptions, hasOwnProperty, hasResultRows, hasStringProperty, hasTrailingSlash, isCodeTransformation, isDirectory, isEntityUnique, isObject, isPromise, mergeDataSourceOptions, mergeDataSourceOptionsWithEnv, parseFilePath, pickRecord, prepareSeederFactories, prepareSeederSeeds, readDataSourceOptionsFromEnv, readTSConfig, renameForeignKey, renameIndex, replaceWindowSeparator, resetEnv, resetSeederFactoryManager, resolveFilePath, resolveFilePaths, resolveFilePatterns, resolveSQLiteDatabaseDirectory, resolveSQLiteDatabasePath, resolveSeederConfig, runSeeder, runSeeders, safeReplaceWindowsSeparator, setDataSource, setDataSourceOptions, setSeederFactory, synchronizeDatabaseSchema, transformFilePath, unsetDataSource, useDataSource, useDataSourceOptions, useEnv, useSeederFactory, useSeederFactoryManager, validateEntityJoinColumns, withForeignKeyChecksDisabled, withoutTrailingSlash };
+export { CockroachDBDialect, CodeTransformation, DatabaseLockError, DriverError, EntityMetadataError, EntityRelationLookupError, EnvironmentName, EnvironmentVariableName, MYSQL_FOREIGN_KEY_CHECKS_OFF, MYSQL_FOREIGN_KEY_CHECKS_ON, MYSQL_FOREIGN_KEY_CHECKS_SELECT, MongoDBDialect, MsSQLDialect, MySQLDialect, OptionsError, OracleDialect, PathResolver, PathResolverMode, PostgresDialect, SQLiteDialect, SchemaAlterationError, SchemaDriftError, SeederEntity, SeederExecutor, SeederFactory, SeederFactoryManager, TypeormExtensionError, adjustFilePath, adjustFilePaths, assertSchemaMatchesMetadata, buildCockroachDBCreateDatabaseQuery, buildCockroachDBDropDatabaseQuery, buildConnectionParams, buildDataSourceOptions, buildDatabaseCreateContext, buildDatabaseDropContext, buildMongoDBConnectionUri, buildMongoDBDropDatabaseCommand, buildMsSQLCreateDatabaseQuery, buildMsSQLDropDatabaseQuery, buildMySQLCreateDatabaseQuery, buildMySQLDropDatabaseQuery, buildOracleConnectString, buildOracleCreateDatabaseQuery, buildPostgresCreateDatabaseQuery, buildPostgresCreateSchemaQuery, buildPostgresDatabaseExistsQuery, buildPostgresDropDatabaseQuery, buildSeederFileName, buildSeederFileTemplate, canReplaceWindowsSeparator, changeColumnType, checkDatabase, createCockroachDBDatabase, createDatabase, createMongoDBDatabase, createMsSQLDatabase, createMySQLDatabase, createOracleDatabase, createPathResolver, createPostgresDatabase, createSQLiteDatabase, deriveMySQLCharacterSet, detectCodeTransformation, dropCockroachDBDatabase, dropDatabase, dropMongoDBDatabase, dropMsSQLDatabase, dropMySQLDatabase, dropOracleDatabase, dropPostgresDatabase, dropSQLiteDatabase, existsQuery, extendObject, findDataSource, generateMigration, getEntityMetadata, getEntityName, getEntityPropertyNames, getSchemaDrift, hasDataSource, hasDataSourceOptions, hasEnvDataSourceOptions, hasOwnProperty, hasResultRows, hasStringProperty, hasTrailingSlash, isCodeTransformation, isDirectory, isEntityUnique, isObject, isPromise, mergeDataSourceOptions, mergeDataSourceOptionsWithEnv, parseFilePath, pickRecord, pinTimezone, prepareSeederFactories, prepareSeederSeeds, readDataSourceOptionsFromEnv, readTSConfig, renameForeignKey, renameIndex, replaceWindowSeparator, resetEnv, resetSeederFactoryManager, resolveFilePath, resolveFilePaths, resolveFilePatterns, resolveSQLiteDatabaseDirectory, resolveSQLiteDatabasePath, resolveSeederConfig, runSeeder, runSeeders, safeReplaceWindowsSeparator, setDataSource, setDataSourceOptions, setSeederFactory, synchronizeDatabaseSchema, transformFilePath, unsetDataSource, useDataSource, useDataSourceOptions, useEnv, useSeederFactory, useSeederFactoryManager, validateEntityJoinColumns, withDatabaseLock, withForeignKeyChecksDisabled, withoutTrailingSlash };
 
 //# sourceMappingURL=index.mjs.map